nodalis-compiler 1.0.24 → 1.0.26

package/CHANGELOG.md

@@ -1,4 +1,10 @@
 # Changelog
+## [1.0.26] 2026-03-19
+- Improved error handling on programming.
+
+## [1.0.25] 2026-03-18
+- Added line number errors to compilers.
+- Changed bacnet to use remote address property in mapping as the instance number.
 
 ## [1.0.24] 2026-03-04
 - Added support for CONFIGURATION, RESOURCE, TASK, and PROGRAM (instance) keywords in ST.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodalis-compiler",
-  "version": "1.0.24",
+  "version": "1.0.26",
   "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/CPPCompiler.js

@@ -559,8 +559,8 @@ int main() {
             "windows-x64": " -lws2_32 -lcrypt32 -lwsock32 -lole32 -liphlpapi",
             "windows-arm64": " -lws2_32 -lcrypt32 -lwsock32 -lole32 -liphlpapi",
             "linux-x64": "",
-            "linux-arm64": "",
-            "linux-arm": "",
+            "linux-arm64": " -latomic",
+            "linux-arm": " -latomic",
             "macos-x64": "",
             "macos-arm64": "",
         }

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

@@ -179,13 +179,12 @@ function mapStatement(stmt){
         return [`${stmt.name}();`];
       }
         default:
-          return [`// unsupported: ${stmt.type}`];
+          throw createTranspileError(`Unsupported statement type '${stmt.type}'`, stmt);
       }
   }
   catch(e){
-    console.error(e + "\n" + JSON.stringify(stmt));
+    throw enrichTranspileError(e, stmt);
   }
-  return "// uncompilable statement " + JSON.stringify(stmt);
 }
 
 /**
@@ -197,6 +196,22 @@ function transpileStatements(statements) {
   return statements?.flatMap(mapStatement);
 }
 
+function createTranspileError(message, node) {
+  const line = node?.loc?.line ?? 1;
+  const column = node?.loc?.column ?? 1;
+  const error = new Error(`${message} at line ${line}, column ${column}`);
+  error.line = line;
+  error.column = column;
+  error.sourceLocation = { line, column };
+  return error;
+}
+
+function enrichTranspileError(error, node) {
+  if (error?.line) return error;
+  const message = error?.message || String(error);
+  return createTranspileError(message, node);
+}
+
 /**
  * Creates a transpiled section of declared variables.
  * @param {{type: string, address: string, initialValue: string, sectionType: string}[]} varSections An array of variable tokens.

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

@@ -196,11 +196,10 @@ function mapStatement(stmt, infb = false) {
         return [`${stmt.name}();`];
       }
       default:
-        return [`// Unsupported statement type: ${stmt.type}`];
+        throw createTranspileError(`Unsupported statement type '${stmt.type}'`, stmt);
     }
   } catch (e) {
-    console.error("Error transpiling statement", stmt, e);
-    return [`// Failed to transpile: ${JSON.stringify(stmt)}`];
+    throw enrichTranspileError(e, stmt);
   }
 }
 
@@ -213,6 +212,22 @@ function transpileStatements(statements, infb=false) {
   return statements?.flatMap((stmt) => mapStatement(stmt, infb));
 }
 
+function createTranspileError(message, node) {
+  const line = node?.loc?.line ?? 1;
+  const column = node?.loc?.column ?? 1;
+  const error = new Error(`${message} at line ${line}, column ${column}`);
+  error.line = line;
+  error.column = column;
+  error.sourceLocation = { line, column };
+  return error;
+}
+
+function enrichTranspileError(error, node) {
+  if (error?.line) return error;
+  const message = error?.message || String(error);
+  return createTranspileError(message, node);
+}
+
 /**
  * Creates a transpiled section of declared variables.
  * @param {{type: string, address: string, initialValue: string, sectionType: string}[]} varSections An array of variable tokens.

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

@@ -46,14 +46,33 @@ export function parseStructuredText(code) {
     return tokens[position + offset];
   }
 
+  function previous() {
+    return tokens[position - 1];
+  }
+
   function consume() {
     return tokens[position++];
   }
 
+  function withLoc(node, token) {
+    if (!node || !token) return node;
+    return { ...node, loc: { line: token.line, column: token.column } };
+  }
+
+  function createSourceError(message, token = peek() || previous()) {
+    const line = token?.line ?? 1;
+    const column = token?.column ?? 1;
+    const error = new Error(`${message} at line ${line}, column ${column}`);
+    error.line = line;
+    error.column = column;
+    error.sourceLocation = { line, column };
+    return error;
+  }
+
   function expect(value) {
     const token = consume();
     if (!token || token.value.toUpperCase() !== value.toUpperCase()) {
-      throw new Error(`Expected '${value}', but got '${token?.value}'`);
+      throw createSourceError(`Expected '${value}', but got '${token?.value ?? 'EOF'}'`, token || previous());
     }
     return token;
   }
@@ -129,7 +148,7 @@ export function parseStructuredText(code) {
     }
 
     if (peek()?.value === ';') consume();
-    return { type: 'TaskDeclaration', name, interval, priority };
+    return withLoc({ type: 'TaskDeclaration', name, interval, priority }, tokens[position - 1]);
   }
 
   function normalizeNumericString(value, fallback) {
@@ -173,7 +192,7 @@ export function parseStructuredText(code) {
         if (addrToken?.type === 'ADDRESS' || addrToken?.type === 'IDENTIFIER') {
           address = addrToken.value;
         } else {
-          throw new Error(`Expected address after AT, got '${addrToken?.value}'`);
+          throw createSourceError(`Expected address after AT, got '${addrToken?.value ?? 'EOF'}'`, addrToken || previous());
         }
       }
       expect(':');
@@ -188,12 +207,12 @@ export function parseStructuredText(code) {
         }
         initialValue = initTokens.join('');
       }
-      variables.push({ name, type, address, initialValue, sectionType: 'VAR_GLOBAL' });
+      variables.push(withLoc({ name, type, address, initialValue, sectionType: 'VAR_GLOBAL' }, tokens[position - 1]));
       if (peek()?.value === ';') consume();
     }
 
     expect('END_VAR');
-    return { type: 'GlobalVars', variables };
+    return withLoc({ type: 'GlobalVars', variables }, variables[0]?.loc ? { line: variables[0].loc.line, column: variables[0].loc.column } : previous());
   }
 
 
@@ -202,6 +221,7 @@ export function parseStructuredText(code) {
     const sectionType = consume().value.toUpperCase();
 
     while (peek() && peek().value.toUpperCase() !== 'END_VAR') {
+      const startToken = peek();
       const name = consume().value;
       expect(':');
       const type = consume().value;
@@ -215,7 +235,7 @@ export function parseStructuredText(code) {
         }
         initialValue = initTokens.join('');
       }
-      variables.push({ name, type, initialValue, sectionType });
+      variables.push(withLoc({ name, type, initialValue, sectionType }, startToken));
       if (peek()?.value === ';') consume();
     }
     expect('END_VAR');
@@ -234,6 +254,10 @@ export function parseStructuredText(code) {
 function parseStatement() {
   const token = peek();
   if (!token) return null;
+  if (token.value === ';') {
+    consume();
+    return null;
+  }
 
   if (token.value.toUpperCase() === 'IF') return parseIf();
   if (token.value.toUpperCase() === 'WHILE') return parseWhile();
@@ -261,7 +285,7 @@ function parseStatement() {
     // optional semicolon
     if (peek()?.value === ';') consume();
 
-    return { type: 'CALL', name, args };
+    return withLoc({ type: 'CALL', name, args }, token);
   }
 
   // Assignment: x := y;
@@ -280,16 +304,15 @@ if (peek(i)?.value === ':=') {
     right.push(consume().value);
   }
   if (peek()?.value === ';') consume();
-  return { type: 'ASSIGN', left: lhs, right };
+  return withLoc({ type: 'ASSIGN', left: lhs, right }, lhsTokens[0]);
 }
 
-  consume(); // Skip unknown
-  return null;
+  throw createSourceError(`Unexpected token '${token.value}'`, token);
 }
 
 
 function parseIf() {
-  consume(); // IF
+  const startToken = consume(); // IF
 
   // Collect condition tokens until THEN
   const conditionTokens = [];
@@ -322,13 +345,13 @@ function parseIf() {
     consume(); // END_IF
   }
 
-  return {
+  return withLoc({
     type: 'IF',
     condition: conditionTokens,
     thenBlock,
     elseIfBlocks,
     elseBlock
-  };
+  }, startToken);
 }
 
 
@@ -349,7 +372,7 @@ function parseStatementsUntil(endTokens) {
 
 
   function parseWhile() {
-    consume(); // WHILE
+    const startToken = consume(); // WHILE
     const condition = [];
     while (peek() && peek().value.toUpperCase() !== 'DO') {
       condition.push(consume().value);
@@ -357,11 +380,11 @@ function parseStatementsUntil(endTokens) {
     expect('DO');
     const body = parseStatements('END_WHILE');
     expect('END_WHILE');
-    return { type: 'WHILE', condition, body };
+    return withLoc({ type: 'WHILE', condition, body }, startToken);
   }
 
   function parseFor() {
-    consume(); // FOR
+    const startToken = consume(); // FOR
     const variable = consume().value;
     expect(':=');
     const from = consume().value;
@@ -375,11 +398,11 @@ function parseStatementsUntil(endTokens) {
     expect('DO');
     const body = parseStatements('END_FOR');
     expect('END_FOR');
-    return { type: 'FOR', variable, from, to, step, body };
+    return withLoc({ type: 'FOR', variable, from, to, step, body }, startToken);
   }
 
   function parseRepeat() {
-    consume(); // REPEAT
+    const startToken = consume(); // REPEAT
     const body = parseStatements('UNTIL');
     expect('UNTIL');
     const condition = [];
@@ -388,11 +411,11 @@ function parseStatementsUntil(endTokens) {
     }
     expect('END_REPEAT');
     if (peek()?.value === ';') consume();
-    return { type: 'REPEAT', condition, body };
+    return withLoc({ type: 'REPEAT', condition, body }, startToken);
   }
 
   function parseCase() {
-    consume(); // CASE
+    const startToken = consume(); // CASE
     const expression = [];
     while (peek() && peek().value.toUpperCase() !== 'OF') {
       expression.push(consume().value);
@@ -411,7 +434,7 @@ function parseStatementsUntil(endTokens) {
         const stmt = parseStatement();
         if (stmt) body.push(stmt);
       }
-      branches.push({ label: labels.join(','), body });
+      branches.push(withLoc({ label: labels.join(','), body }, peek(-1)));
     }
     let elseBlock = null;
     if (peek()?.value.toUpperCase() === 'ELSE') {
@@ -423,7 +446,7 @@ function parseStatementsUntil(endTokens) {
       }
     }
     expect('END_CASE');
-    return { type: 'CASE', expression, branches, elseBlock };
+    return withLoc({ type: 'CASE', expression, branches, elseBlock }, startToken);
   }
 
   function isCaseBranchBoundary(token) {
@@ -434,7 +457,7 @@ function parseStatementsUntil(endTokens) {
   }
 
   function parseProgramOrInstance() {
-    expect('PROGRAM');
+    const startToken = expect('PROGRAM');
     const name = consume().value;
 
     if (peek()?.value?.toUpperCase() === 'WITH' || peek()?.value === ':') {
@@ -446,7 +469,7 @@ function parseStatementsUntil(endTokens) {
       expect(':');
       const typeName = consume().value;
       if (peek()?.value === ';') consume();
-      return { type: 'ProgramInstanceDeclaration', name, typeName, associatedTaskName };
+      return withLoc({ type: 'ProgramInstanceDeclaration', name, typeName, associatedTaskName }, startToken);
     }
 
     const vars = [];
@@ -459,11 +482,11 @@ function parseStatementsUntil(endTokens) {
     stmts.push(...parseStatements('END_PROGRAM'));
     expect('END_PROGRAM');
 
-    return { type: 'ProgramDeclaration', name, varSections: vars, statements: stmts };
+    return withLoc({ type: 'ProgramDeclaration', name, varSections: vars, statements: stmts }, startToken);
   }
 
   function parseFunction() {
-    expect('FUNCTION');
+    const startToken = expect('FUNCTION');
     const name = consume().value;
     expect(':');
     const returnType = consume().value;
@@ -477,11 +500,11 @@ function parseStatementsUntil(endTokens) {
     stmts.push(...parseStatements('END_FUNCTION'));
     expect('END_FUNCTION');
 
-    return { type: 'FunctionDeclaration', name, returnType, varSections: vars, statements: stmts };
+    return withLoc({ type: 'FunctionDeclaration', name, returnType, varSections: vars, statements: stmts }, startToken);
   }
 
   function parseFunctionBlock() {
-    expect('FUNCTION_BLOCK');
+    const startToken = expect('FUNCTION_BLOCK');
     const name = consume().value;
     const vars = [];
     const stmts = [];
@@ -493,7 +516,7 @@ function parseStatementsUntil(endTokens) {
     stmts.push(...parseStatements('END_FUNCTION_BLOCK'));
     expect('END_FUNCTION_BLOCK');
 
-    return { type: 'FunctionBlockDeclaration', name, varSections: vars, statements: stmts };
+    return withLoc({ type: 'FunctionBlockDeclaration', name, varSections: vars, statements: stmts }, startToken);
   }
 
   const body = [];

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

@@ -24,7 +24,7 @@
 /**
  * Tokenizes a block of structured text into their types and values.
  * @param {string} code A block of structured text code.
- * @returns {{type: string, value: string}[]} An array of tokens.
+ * @returns {{type: string, value: string, line: number, column: number}[]} An array of tokens.
  */
 const INTEGER_TYPE_PATTERN = '(?:BYTE|WORD|DWORD|LWORD|SINT|INT|DINT|LINT|USINT|UINT|UDINT|ULINT)';
 const REAL_TYPE_PATTERN = '(?:REAL|LREAL)';
@@ -40,37 +40,66 @@ const NUMBER_TOKEN_PATTERN = `(?:${TYPED_INTEGER_LITERAL_PATTERN}|${TYPED_REAL_L
 export function tokenize(code) {
   const tokens = [];
   let match;
-  // Remove single-line comments (//...)
-  code = code.replace(/\/\/.*$/gm, '');
-
-  // Remove multi-line comments ((*...*))
-  code = code.replace(/\(\*[\s\S]*?\*\)/g, '');
+  const sanitizedCode = stripCommentsPreservePositions(code);
+  const lineStarts = buildLineStarts(sanitizedCode);
 
   //const regex = /(%[IQM][A-Z]?[0-9]+(?:\.[0-9]+)?)|(:=)|([A-Za-z_]\w*\.\d+)|([A-Za-z_]\w*\.\w+)|([A-Za-z_]\w*)|(\d+)|([:;()<>+\-*/=])/g;
   const regex = new RegExp(`(%[IQM][A-Z]*\\d+(?:\\.\\d+)?)|(:=|=>|>=|<=|<>|!=|\\*\\*)|([A-Za-z_]\\w*\\.\\d+)|([A-Za-z_]\\w*\\.\\w+)|(${NUMBER_TOKEN_PATTERN})|([A-Za-z_]\\w*)|([<>+\\-*/=;():,&|^])`, 'gi');
 
-while ((match = regex.exec(code)) !== null) {
+while ((match = regex.exec(sanitizedCode)) !== null) {
   const [_, address, compoundSymbol, bitIdentifier, propIdentifier, number, identifier, symbol] = match;
+  const location = getLineColumn(lineStarts, match.index);
 
   if (address) 
-    tokens.push({ type: 'ADDRESS', value: address });
+    tokens.push({ type: 'ADDRESS', value: address, ...location });
   else if (compoundSymbol)
-    tokens.push({ type: 'SYMBOL', value: compoundSymbol });
+    tokens.push({ type: 'SYMBOL', value: compoundSymbol, ...location });
   else if (bitIdentifier)
-    tokens.push({ type: 'IDENTIFIER', value: bitIdentifier });
+    tokens.push({ type: 'IDENTIFIER', value: bitIdentifier, ...location });
   else if (propIdentifier)
-    tokens.push({ type: 'IDENTIFIER', value: propIdentifier });
+    tokens.push({ type: 'IDENTIFIER', value: propIdentifier, ...location });
   else if (identifier)
-    tokens.push({ type: 'IDENTIFIER', value: identifier });
+    tokens.push({ type: 'IDENTIFIER', value: identifier, ...location });
   else if (number)
-    tokens.push({ type: 'NUMBER', value: normalizeNumericLiteral(number) });
+    tokens.push({ type: 'NUMBER', value: normalizeNumericLiteral(number), ...location });
   else if (symbol)
-    tokens.push({ type: 'SYMBOL', value: symbol });
+    tokens.push({ type: 'SYMBOL', value: symbol, ...location });
 
   }
   return tokens;
 }
 
+function stripCommentsPreservePositions(code) {
+  return String(code || '')
+    .replace(/\/\/.*$/gm, (comment) => ' '.repeat(comment.length))
+    .replace(/\(\*[\s\S]*?\*\)/g, (comment) => comment.replace(/[^\n]/g, ' '));
+}
+
+function buildLineStarts(text) {
+  const starts = [0];
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] === '\n') starts.push(i + 1);
+  }
+  return starts;
+}
+
+function getLineColumn(lineStarts, index) {
+  let low = 0;
+  let high = lineStarts.length - 1;
+
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    if (lineStarts[mid] <= index) low = mid + 1;
+    else high = mid - 1;
+  }
+
+  const lineIndex = Math.max(0, high);
+  return {
+    line: lineIndex + 1,
+    column: (index - lineStarts[lineIndex]) + 1
+  };
+}
+
 function normalizeNumericLiteral(value) {
   const literal = String(value);
   const boolMatch = literal.match(new RegExp(`^${BOOL_TYPE_PATTERN}#(TRUE|FALSE|1|0)$`, 'i'));

package/src/compilers/support/generic/bacnet.cpp

@@ -428,6 +428,7 @@ bool BACNETClient::resolveRemote(const std::string& remote, BACnetRemotePoint& p
 bool BACNETClient::parseRemoteDefinition(const IOMap &map, BACnetRemotePoint &point)
 {
     json config = nullptr;
+    point.objectInstance = static_cast<uint32_t>(std::stoll(map.remoteAddress));
     if (map.additionalProperties.is_string())
     {
         std::cout << "BACNET-IP Additional Properties is a string.\n";
@@ -438,6 +439,7 @@ bool BACNETClient::parseRemoteDefinition(const IOMap &map, BACnetRemotePoint &po
         config = map.additionalProperties;
         std::cout << "BACNET-IP Additional Properties is an object.\n";
     }
+
     if (parseJsonRemote(config, point))
     {
         return true;
@@ -465,10 +467,6 @@ bool BACNETClient::parseJsonRemote(const json& config, BACnetRemotePoint& point)
         extractNumber(config, "ObjectInstance", instance)) {
         point.objectInstance = instance;
     }
-    else
-    {
-        std::cout << "BACNET-IP no object instance\n";
-    }
 
     auto propertyToken = extractString(config, "propertyId");
     if (!propertyToken) {

package/src/compilers/support/jint/nodalis/NodalisEngine/BacnetClient.cs

@@ -226,12 +226,13 @@ namespace Nodalis
             // Required numeric fields.
             if (!TryGetUInt(props, "objectType", out var objType) && !TryGetUInt(props, "ObjectType", out objType))
                 return false;
-            if (!TryGetUInt(props, "objectInstance", out var objInst) && !TryGetUInt(props, "ObjectInstance", out objInst))
-                return false;
             if (!TryGetUInt(props, "propertyId", out var propId) && !TryGetUInt(props, "PropertyId", out propId))
                 return false;
+            if (!uint.TryParse(remoteAddress, out var objInst))
+                return false;
 
             point.ObjectType = (BacnetObjectTypes)objType;
+
             point.ObjectInstance = objInst;
             point.PropertyId = (BacnetPropertyIds)propId;
 

package/src/compilers/support/nodejs/bacnet.js

@@ -253,13 +253,12 @@ export class BacnetClient extends IOClient {
     const stringRemote = parseRemoteString(map.remoteAddress);
 
     const objectTypeRaw = config.objectType ?? config.ObjectType ?? stringRemote?.objectType ?? 0;
-    const objectInstanceRaw = config.objectInstance ?? config.ObjectInstance ?? stringRemote?.objectInstance ?? 0;
     const propertyIdRaw = config.propertyId ?? config.PropertyId ?? stringRemote?.propertyId ?? 85;
     const arrayIndexRaw = config.arrayIndex ?? config.ArrayIndex ?? stringRemote?.arrayIndex ?? null;
     const valueType = String(config.valueType ?? config.ValueType ?? "e").toLowerCase();
 
     const objectType = resolveEnumValue(this.bacnet?.enum?.ObjectType, objectTypeRaw, parseInteger(objectTypeRaw, 0));
-    const objectInstance = parseInteger(objectInstanceRaw, 0);
+    const objectInstance = parseInteger(map.remoteAddress, null);
     const propertyId = resolveEnumValue(this.bacnet?.enum?.PropertyIdentifier, propertyIdRaw, parseInteger(propertyIdRaw, 85));
     const arrayIndex = parseInteger(arrayIndexRaw, null);
 

package/src/programmers/MTIProgrammer.js

@@ -32,7 +32,7 @@ export class MTIProgrammer extends Programmer {
     async program() {
         let result = true;
         try {
-            runMticp([
+            await runMticp([
                 "action=sendxml",
                 `src=${this.options.source}`,
                 `dst=${this.options.destination}`
@@ -43,6 +43,7 @@ export class MTIProgrammer extends Programmer {
             })
             .catch(err => {
                 // Print any error from the binary and exit non-zero
+                result = false;
                 console.error(err.message || err);
             });
         }