nodalis-compiler 1.0.19 → 1.0.21

package/CHANGELOG.md

@@ -1,7 +1,9 @@
 # Changelog
 
-## [1.0.19] 2026-03-03
+## [1.0.21] 2026-03-03
 - Changed IEC parser to interpret Function Blocks that are actually standard functions to a formal function call.
+- Fixed nodejs/jint compiles to put executables in a bin folder.
+- Fixed syntax errors with repeat.
 
 ## [1.0.17] 2026-02-25
 - Added support for compilation of multiple ST files as a single project.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodalis-compiler",
-  "version": "1.0.19",
+  "version": "1.0.21",
   "description": "Compiles IEC-61131-3/10 languages into code that can be used as a PLC on multiple platforms.",
   "icon": "nodalis.png",
   "main": "src/nodalis.js",

package/src/compilers/ArduinoCompiler.js

@@ -255,7 +255,7 @@ void loop() {
         fs.cpSync(path.join(supportDir, 'gpio.cpp'), path.join(outputPath, 'gpio.cpp'), { force: true });
         fs.cpSync(path.join(supportDir, 'json.hpp'), path.join(outputPath, 'json.hpp'), { force: true });
 
-        if (outputType === 'executable') {
+        if (this.isExecutableOutput()) {
             const arduinoCli = compilerConfig.arduino_cli || compilerConfig.arduinoCli || 'arduino-cli';
             const arduinoFqbn = this.resolveArduinoFqbn(target, compilerConfig);
             if (!arduinoFqbn) {
@@ -266,7 +266,7 @@ void loop() {
             this.ensureArduinoCoreInstalled(arduinoCli, arduinoFqbn);
 
             const buildDir = path.join(outputPath, 'build');
-            const binDir = path.join(outputPath, 'bin');
+            const binDir = this.getExecutableOutputPath();
             fs.mkdirSync(buildDir, { recursive: true });
             fs.mkdirSync(binDir, { recursive: true });
             const arduinoCompileCmd = `${arduinoCli} compile --fqbn "${arduinoFqbn}" "${outputPath}" --build-path "${buildDir}" --output-dir "${binDir}" --export-binaries`;

package/src/compilers/CPPCompiler.js

@@ -260,7 +260,7 @@ int main() {
         const pathTo = name => path.join(outputPath, name);
         const targetInfo = this.resolveTarget(target);
 
-        if (outputType === 'executable') {
+        if (this.isExecutableOutput()) {
             const requestedTarget = target ?? `${targetInfo.os}-${targetInfo.arch}`;
             const hostOs = this.getHostOS();
             const hostArch = this.getHostArch();
@@ -271,7 +271,7 @@ int main() {
             const archFlags = this.getArchFlags(targetInfo.os, targetInfo.arch, compiler);
             const formatFlags = (flags = []) => (flags.length ? `${flags.join(' ')} ` : '');
             const isWindowsTarget = targetInfo.os === 'windows';
-            const binDir = path.join(outputPath, 'bin');
+            const binDir = this.getExecutableOutputPath();
             fs.mkdirSync(binDir, { recursive: true });
 
             // Step 2: Compile open62541.c with C compiler

package/src/compilers/Compiler.js

@@ -14,6 +14,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+import path from 'path';
+
 export const IECLanguage = Object.freeze({
   LADDER_DIAGRAM: 'LD',
   STRUCTURED_TEXT: 'ST',
@@ -60,6 +62,14 @@ export class Compiler {
     this.options = options;
   }
 
+  isExecutableOutput() {
+    return this.options?.outputType === OutputType.EXECUTABLE;
+  }
+
+  getExecutableOutputPath() {
+    return path.join(this.options.outputPath, 'bin');
+  }
+
   /** @returns {string[]} */
   get supportedLanguages() {
     throw new Error('supportedLanguages must be implemented by subclass.');

package/src/compilers/JSCompiler.js

@@ -224,8 +224,8 @@ export function run(){
         }
         fs.mkdirSync(outputPath, { recursive: true });
         fs.writeFileSync(jsFile, jsCode);
-        const binDir = path.join(outputPath, 'bin');
-        if (outputType === 'executable') {
+        const binDir = this.getExecutableOutputPath();
+        if (this.isExecutableOutput()) {
             fs.mkdirSync(binDir, { recursive: true });
         }
         if(sourcePath.toLowerCase().endsWith(".iec") || sourcePath.toLowerCase().endsWith(".xml") || directoryBundleMode){
@@ -243,34 +243,37 @@ export function run(){
             ];
 
             let coreDir = path.resolve(__dirname + '/support/nodejs');
+            const runtimeOutputDir = this.isExecutableOutput() ? binDir : outputPath;
             
             for (const file of coreFiles) {
-                fs.copyFileSync(path.join(coreDir, file), path.join(outputPath, file));
+                fs.copyFileSync(path.join(coreDir, file), path.join(runtimeOutputDir, file));
             }
-            if (outputType === 'executable') {
-                fs.copyFileSync(jsFile, path.join(binDir, 'nodalisplc.js'));
+            if (this.isExecutableOutput()) {
+                fs.copyFileSync(jsFile, path.join(runtimeOutputDir, 'nodalisplc.js'));
             }
-            writePackageJson(outputPath, plcname);
-            installDependencies(outputPath);
+            writePackageJson(runtimeOutputDir, plcname);
+            installDependencies(runtimeOutputDir);
         }
         
 
-        if (target === "jint" && outputType === "executable") {
+        if (target === "jint" && this.isExecutableOutput()) {
             const supportDir = path.resolve(__dirname, "support/jint/Nodalis");
             const buildScript = os.platform() === "win32" ? "build.bat" : "build.sh";
+            const projectOutputDir = outputPath;
+            const runtimeOutputDir = binDir;
 
-            // 1. Copy all files from support/jint/nodalis to the output directory
-            fs.cpSync(supportDir, outputPath, { recursive: true });
+            // Keep the Jint project sources in the main output directory.
+            fs.cpSync(supportDir, projectOutputDir, { recursive: true, force: true });
 
-            // 2. Run the build script inside the output directory
-            const buildPath = path.resolve(path.join(outputPath, buildScript));
+            // Build from the main output directory, then move publish artifacts under bin.
+            const buildPath = path.resolve(path.join(projectOutputDir, buildScript));
             if(buildPath.endsWith(".sh")){
                 fs.chmodSync(buildPath, 0o755); // make executable
             }
-            execSync(buildPath, { cwd: path.resolve(outputPath), stdio: "inherit", shell: true });
+            execSync(buildPath, { cwd: path.resolve(projectOutputDir), stdio: "inherit", shell: true });
 
             // 3. Copy the generated JS file to each publish folder
-            const publishRoot = path.join(outputPath, "publish");
+            const publishRoot = path.join(projectOutputDir, "publish");
             
             const platforms = fs.readdirSync(publishRoot, { withFileTypes: true })
                 .filter(d => d.isDirectory())
@@ -301,7 +304,7 @@ export function run(){
 
             for (const platformDir of platforms) {
                 const platformName = path.basename(platformDir);
-                const platformBinDir = path.join(binDir, platformName);
+                const platformBinDir = path.join(runtimeOutputDir, platformName);
                 fs.mkdirSync(platformBinDir, { recursive: true });
                 fs.cpSync(platformDir, platformBinDir, { recursive: true, force: true });
             }

package/src/compilers/st-parser/expressionConverter.js

@@ -127,7 +127,7 @@ export function convertExpression(expr, isjsfb = false, jsfbVars = [], isjs=fals
     if (/^%[IQM][XBWDL]?\d+(\.\d+)?$/i.test(e)) return getReadAddressExpression(e);
 
     // Don't wrap literals or operators
-    if (/^(true|false|null|[+-]?\d+|[+-]?(?:(?:\d+\.\d*|\d*\.\d+)(?:[eE][+-]?\d+)?|\d+[eE][+-]?\d+)|0[bB][01]+|0[oO][0-7]+|0[xX][0-9a-f]+|!|&&|\|\||==|!=|[<>=+\-*/(),&|^])$/i.test(e)) return e;
+    if (/^(true|false|null|[+-]?\d+|[+-]?(?:(?:\d+\.\d*|\d*\.\d+)(?:[eE][+-]?\d+)?|\d+[eE][+-]?\d+)|0[bB][01]+|0[oO][0-7]+|0[xX][0-9a-f]+|!|&&|\|\||==|!=|>=|<=|>|<|=|\+|-|\*|\/|%|\(|\)|,|&|\||\^)$/i.test(e)) return e;
 
     // Don't wrap known function expressions (e.g., getBit)
     if (/^getBit\(/.test(e)) return e;

package/src/compilers/st-parser/parser.js

@@ -292,9 +292,10 @@ function parseStatementsUntil(endTokens) {
     const body = parseStatements('UNTIL');
     expect('UNTIL');
     const condition = [];
-    while (peek() && peek().value !== ';') {
+    while (peek() && peek().value.toUpperCase() !== 'END_REPEAT') {
       condition.push(consume().value);
     }
+    expect('END_REPEAT');
     if (peek()?.value === ';') consume();
     return { type: 'REPEAT', condition, body };
   }

package/src/compilers/st-parser/tokenizer.js

@@ -72,20 +72,25 @@ while ((match = regex.exec(code)) !== null) {
 }
 
 function normalizeNumericLiteral(value) {
-  const boolMatch = String(value).match(new RegExp(`^${BOOL_TYPE_PATTERN}#(TRUE|FALSE|1|0)$`, 'i'));
+  const literal = String(value);
+  const boolMatch = literal.match(new RegExp(`^${BOOL_TYPE_PATTERN}#(TRUE|FALSE|1|0)$`, 'i'));
   if (boolMatch) {
     const boolLiteral = boolMatch[1].toUpperCase();
     if (boolLiteral === 'TRUE' || boolLiteral === '1') return 'TRUE';
     return 'FALSE';
   }
 
-  const typedValue = String(value).replace(
+  const typedValue = literal.replace(
     new RegExp(`^(?:${INTEGER_TYPE_PATTERN}|${REAL_TYPE_PATTERN}|${BOOL_TYPE_PATTERN})#`, 'i'),
     ''
   );
 
   const match = typedValue.match(/^(2|8|16)#([0-9a-f_]+)$/i);
-  if (!match) return typedValue.replace(/_/g, '');
+  if (!match) {
+    const normalized = typedValue.replace(/_/g, '');
+    if (/^[+-]?\d+$/.test(normalized)) return normalizeDecimalIntegerLiteral(normalized);
+    return normalized;
+  }
   const radix = match[1];
   const digits = match[2].replace(/_/g, '');
   if (radix === '2') return `0b${digits}`;
@@ -93,6 +98,12 @@ function normalizeNumericLiteral(value) {
   return `0x${digits}`;
 }
 
+function normalizeDecimalIntegerLiteral(value) {
+  const sign = value.startsWith('-') ? '-' : '';
+  const digits = value.replace(/^[+-]?/, '').replace(/^0+(?=\d)/, '');
+  return `${sign}${digits || '0'}`;
+}
+
 function getTokenType(value) {
   const keywords = new Set([
     'PROGRAM', 'FUNCTION_BLOCK', 'FUNCTION', 'VAR_INPUT', 'VAR_OUTPUT', 'VAR', 'END_VAR',

package/src/programmers/utils.js

@@ -235,24 +235,41 @@ export async function inferEntryPoint(sourcePath, runtime = 'auto', providedEntr
   }
 
   const candidates = ['nodalisplc', 'nodalisplc.exe', 'nodalisplc.js'];
-  for (const candidate of candidates) {
-    if (await exists(path.join(sourcePath, candidate))) {
-      return candidate;
+  const candidateDirectories = ['bin', ''];
+  for (const directory of candidateDirectories) {
+    for (const candidate of candidates) {
+      const relativeCandidate = directory ? path.join(directory, candidate) : candidate;
+      if (await exists(path.join(sourcePath, relativeCandidate))) {
+        return toPosixPath(relativeCandidate);
+      }
     }
   }
 
+  const inferredRuntime = inferRuntime('', runtime);
+  if (inferredRuntime === 'node') {
+    const binNodeEntry = path.join('bin', 'nodalisplc.js');
+    if (await exists(path.join(sourcePath, binNodeEntry))) {
+      return toPosixPath(binNodeEntry);
+    }
+    return "nodalisplc.js"
+  }
+
   const entries = await fs.readdir(sourcePath, { withFileTypes: true });
   const files = entries.filter(entry => entry.isFile()).map(entry => entry.name);
-  if (files.length === 0) {
-    throw new Error(`Could not infer entry point for source directory: ${sourcePath}`);
+  if (files.length > 0) {
+    return files[0];
   }
 
-  const inferredRuntime = inferRuntime('', runtime);
-  if (inferredRuntime === 'node') {
-    return "nodalisplc.js"
+  const binEntriesPath = path.join(sourcePath, 'bin');
+  if (await exists(binEntriesPath)) {
+    const binEntries = await fs.readdir(binEntriesPath, { withFileTypes: true });
+    const binFiles = binEntries.filter(entry => entry.isFile()).map(entry => entry.name);
+    if (binFiles.length > 0) {
+      return toPosixPath(path.join('bin', binFiles[0]));
+    }
   }
 
-  return files[0];
+  throw new Error(`Could not infer entry point for source directory: ${sourcePath}`);
 }
 
 export function quoteForPosixSingle(value) {