nodalis-compiler 1.0.23 → 1.0.25

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [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.
+- Added "required" arrays to programmers for communicating required parameters beyond the base params when calling program.
+
 ## [1.0.23] 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodalis-compiler",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "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

@@ -21,7 +21,7 @@ import { fileURLToPath } from 'node:url';
 import { dirname } from 'node:path';
 import { Compiler, IECLanguage, OutputType, CommunicationProtocol } from './Compiler.js';
 import * as iec from './iec-parser/parser.js';
-import { parseStructuredText } from './st-parser/parser.js';
+import { parseStructuredText, buildCompilerMetadataDirectives } from './st-parser/parser.js';
 import { transpile } from './st-parser/gcctranspiler.js';
 import { DEFAULT_ARDUINO_FQBN } from './arduinoDefaults.js';
 import { getManagedArduinoCliPath, getManagedArduinoCliExecOptions } from '../toolchains.js';
@@ -161,7 +161,9 @@ export class ArduinoCompiler extends Compiler {
         let taskCode = '';
         let mapCode = '';
 
-        const lines = sourceCode.split('\n');
+        const metadataDirectives = buildCompilerMetadataDirectives(parsed);
+        const metadataAwareSource = metadataDirectives.length > 0 ? `${metadataDirectives}${sourceCode}` : sourceCode;
+        const lines = metadataAwareSource.split('\n');
         lines.forEach((line) => {
             if (line.trim().startsWith('//Task=')) {
                 const task = JSON.parse(line.substring(line.indexOf('=') + 1).trim());

package/src/compilers/CPPCompiler.js

@@ -20,7 +20,7 @@ import fs from 'fs';
 import path from "path";
 import { Compiler, IECLanguage, OutputType, CommunicationProtocol } from './Compiler.js';
 import * as iec from "./iec-parser/parser.js";
-import { parseStructuredText } from './st-parser/parser.js';
+import { parseStructuredText, buildCompilerMetadataDirectives } from './st-parser/parser.js';
 import { transpile } from './st-parser/gcctranspiler.js';
 import { fileURLToPath } from 'node:url';
 import { dirname } from 'node:path';
@@ -146,7 +146,9 @@ export class CPPCompiler extends Compiler {
         if(typeof resourceName !== "undefined" && resourceName !== null){
             plcname = resourceName;
         }
-        const lines = sourceCode.split("\n");
+        const metadataDirectives = buildCompilerMetadataDirectives(parsed);
+        const metadataAwareSource = metadataDirectives.length > 0 ? `${metadataDirectives}${sourceCode}` : sourceCode;
+        const lines = metadataAwareSource.split("\n");
         lines.forEach((line) => {
             if(line.trim().startsWith("//Task=")){
                 var task = JSON.parse(line.substring(line.indexOf("=") + 1).trim());
@@ -557,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/JSCompiler.js

@@ -19,7 +19,7 @@ import os from "os";
 import path from "path";
 import { Compiler, IECLanguage, OutputType, CommunicationProtocol } from './Compiler.js';
 import * as iec from "./iec-parser/parser.js";
-import { parseStructuredText } from './st-parser/parser.js';
+import { parseStructuredText, buildCompilerMetadataDirectives } from './st-parser/parser.js';
 import { transpile } from './st-parser/jstranspiler.js';
 import which from "which";
 import { fileURLToPath } from "url";
@@ -114,7 +114,9 @@ export class JSCompiler extends Compiler {
         if(typeof resourceName !== "undefined" && resourceName !== null){
             plcname = resourceName;
         }
-        const lines = sourceCode.split("\n");
+        const metadataDirectives = buildCompilerMetadataDirectives(parsed);
+        const metadataAwareSource = metadataDirectives.length > 0 ? `${metadataDirectives}${sourceCode}` : sourceCode;
+        const lines = metadataAwareSource.split("\n");
         lines.forEach((line) => {
             if(line.trim().startsWith("//Task=")){
                 var task = JSON.parse(line.substring(line.indexOf("=") + 1).trim());

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

@@ -32,19 +32,47 @@ import { tokenize } from './tokenizer.js';
 export function parseStructuredText(code) {
   const tokens = tokenize(code);
   let position = 0;
+  const TOP_LEVEL_STARTERS = new Set([
+    'PROGRAM',
+    'FUNCTION',
+    'FUNCTION_BLOCK',
+    'VAR_GLOBAL',
+    'CONFIGURATION',
+    'RESOURCE',
+    'TASK'
+  ]);
 
   function peek(offset = 0) {
     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;
   }
@@ -55,19 +83,101 @@ export function parseStructuredText(code) {
 
     switch (token.value.toUpperCase()) {
       case 'PROGRAM':
-        return parseProgram();
+        return parseProgramOrInstance();
       case 'FUNCTION':
         return parseFunction();
       case 'FUNCTION_BLOCK':
         return parseFunctionBlock();
       case 'VAR_GLOBAL':
         return parseGlobalVarSection();
+      case 'TASK':
+        return parseTask();
+      case 'CONFIGURATION':
+        return parseContainer('CONFIGURATION', 'END_CONFIGURATION');
+      case 'RESOURCE':
+        return parseContainer('RESOURCE', 'END_RESOURCE');
       default:
         consume();
         return null;
     }
   }
 
+  function parseContainer(startKeyword, endKeyword) {
+    expect(startKeyword);
+    const blocks = [];
+
+    while (peek() && peek().value.toUpperCase() !== endKeyword) {
+      const upper = peek().value.toUpperCase();
+      if (TOP_LEVEL_STARTERS.has(upper)) {
+        const block = parseBlock();
+        if (Array.isArray(block)) blocks.push(...block);
+        else if (block) blocks.push(block);
+      } else {
+        consume();
+      }
+    }
+
+    expect(endKeyword);
+    return blocks;
+  }
+
+  function parseTask() {
+    expect('TASK');
+    const name = consume().value;
+    let interval = '1000';
+    let priority = '1';
+
+    if (peek()?.value === '(') {
+      consume();
+      while (peek() && peek().value !== ')') {
+        const key = consume().value.toUpperCase();
+        if (peek()?.value === ':=') consume();
+
+        const valueTokens = [];
+        while (peek() && peek().value !== ',' && peek().value !== ')') {
+          valueTokens.push(consume().value);
+        }
+        const value = valueTokens.join('');
+
+        if (key === 'INTERVAL') interval = normalizeTaskInterval(value);
+        else if (key === 'PRIORITY') priority = normalizeNumericString(value, '1');
+
+        if (peek()?.value === ',') consume();
+      }
+      expect(')');
+    }
+
+    if (peek()?.value === ';') consume();
+    return withLoc({ type: 'TaskDeclaration', name, interval, priority }, tokens[position - 1]);
+  }
+
+  function normalizeNumericString(value, fallback) {
+    const match = String(value || '').match(/-?\d+/);
+    return match ? match[0] : fallback;
+  }
+
+  function normalizeTaskInterval(value) {
+    const text = String(value || '').trim();
+    if (!text) return '1000';
+
+    if (/^-?\d+$/.test(text)) return text;
+
+    const duration = text.match(/^T#?([+-]?\d+(?:\.\d+)?)(MS|S|M|H|D)?$/i);
+    if (!duration) return normalizeNumericString(text, '1000');
+
+    const amount = Number(duration[1]);
+    const unit = (duration[2] || 'MS').toUpperCase();
+    const multipliers = {
+      MS: 1,
+      S: 1000,
+      M: 60000,
+      H: 3600000,
+      D: 86400000
+    };
+    const ms = Math.round(amount * (multipliers[unit] || 1));
+    return String(ms);
+  }
+
   function parseGlobalVarSection() {
     expect('VAR_GLOBAL');
     const variables = [];
@@ -82,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(':');
@@ -97,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());
   }
 
 
@@ -111,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;
@@ -124,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');
@@ -143,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();
@@ -170,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;
@@ -189,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 = [];
@@ -231,13 +345,13 @@ function parseIf() {
     consume(); // END_IF
   }
 
-  return {
+  return withLoc({
     type: 'IF',
     condition: conditionTokens,
     thenBlock,
     elseIfBlocks,
     elseBlock
-  };
+  }, startToken);
 }
 
 
@@ -258,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);
@@ -266,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;
@@ -284,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 = [];
@@ -297,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);
@@ -320,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') {
@@ -332,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) {
@@ -342,9 +456,22 @@ function parseStatementsUntil(endTokens) {
     return peek(1)?.value === ':' || peek(1)?.value === ',';
   }
 
-  function parseProgram() {
-    expect('PROGRAM');
+  function parseProgramOrInstance() {
+    const startToken = expect('PROGRAM');
     const name = consume().value;
+
+    if (peek()?.value?.toUpperCase() === 'WITH' || peek()?.value === ':') {
+      let associatedTaskName = '';
+      if (peek()?.value?.toUpperCase() === 'WITH') {
+        consume();
+        associatedTaskName = consume().value;
+      }
+      expect(':');
+      const typeName = consume().value;
+      if (peek()?.value === ';') consume();
+      return withLoc({ type: 'ProgramInstanceDeclaration', name, typeName, associatedTaskName }, startToken);
+    }
+
     const vars = [];
     const stmts = [];
 
@@ -355,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;
@@ -373,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 = [];
@@ -389,14 +516,27 @@ 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 = [];
   while (position < tokens.length) {
     const block = parseBlock();
-    if (block) body.push(block);
+    if (Array.isArray(block)) body.push(...block);
+    else if (block) body.push(block);
   }
 
   return { type: 'Program', body };
 }
+
+export function buildCompilerMetadataDirectives(ast) {
+  const lines = [];
+  for (const block of ast?.body || []) {
+    if (block?.type === 'TaskDeclaration') {
+      lines.push(`//Task={"Name":"${block.name}", "Interval":"${block.interval}", "Priority":"${block.priority}"}`);
+    } else if (block?.type === 'ProgramInstanceDeclaration') {
+      lines.push(`//Instance={"TypeName":"${block.typeName}", "Name":"${block.name}", "AssociatedTaskName":"${block.associatedTaskName || ''}"}`);
+    }
+  }
+  return lines.join('\n') + (lines.length > 0 ? '\n' : '');
+}

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/nodalis.js

@@ -104,7 +104,8 @@ export class Nodalis {
   listProgrammers() {
     return this.programmers.map(p => ({
       name: p.name,
-      target: p.target
+      target: p.target,
+      required: p.required
     }));
   }
 

package/src/programmers/ArduinoProgrammer.js

@@ -23,6 +23,7 @@ export class ArduinoProgrammer extends Programmer {
     super(options);
     this.name = 'ArduinoProgrammer';
     this.target = 'arduino';
+    this.required = ["fqbn"];
   }
 
   async program() {

package/src/programmers/FileProgrammer.js

@@ -32,6 +32,7 @@ export class FileProgrammer extends Programmer {
     super(options);
     this.name = 'FileProgrammer';
     this.target = 'FILE';
+    this.required = [];
   }
 
   async program() {

package/src/programmers/MTIProgrammer.js

@@ -26,6 +26,7 @@ export class MTIProgrammer extends Programmer {
         super(options);
         this.name = "MTIProgrammer";
         this.target = "MTI";
+        this.required = [];
     }
 
     async program() {

package/src/programmers/SSHProgrammer.js

@@ -37,6 +37,7 @@ export class SSHProgrammer extends Programmer {
     super(options);
     this.name = 'SSHProgrammer';
     this.target = 'SSH';
+    this.required = ["username", "password"];
   }
 
   async program() {