nodalis-compiler 1.0.0

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

@@ -0,0 +1,155 @@
+/* eslint-disable curly */
+/* eslint-disable eqeqeq */
+// Copyright [2025] Nathan Skipper
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+/**
+ * @description Expression Converter
+ * @author Nathan Skipper, MTI
+ * @version 1.0.2
+ * @copyright Apache 2.0
+ */
+
+/**
+ * Converts an ST expression to be more understable to JS and C++
+ * @param {Array | string} expr An array of tokens or a string representing the expression.
+ * @param {boolean} isjsfb Expresses whether this expression is within a JS function block.
+ * @param {string[]} jsfbVars An array of variable names defined in the JS function block.
+ * @returns {string} Returns a converted expression.
+ */
+export function convertExpression(expr, isjsfb = false, jsfbVars = [], isjs=false) {
+  if (Array.isArray(expr)) {
+    if (!isjsfb) {
+      expr = expr.join(" ");
+    } else {
+      let jsexpr = "";
+      expr.forEach((e) => {
+        let ev = e.split(".")[0];
+        if (jsfbVars.includes(ev)) {
+          ev = "this." + e;
+        }
+        jsexpr += (jsexpr ? " " : "") + ev;
+      });
+      expr = jsexpr;//.replace(/([^\s])/g, ' $1 ').replace(/\s+/g, ' ').trim();  // ✨ ensure spacing
+    }
+  }
+
+  let results = expr
+    .replace(/\bAND\b/gi, '&&')
+    .replace(/\bOR\b/gi, '||')
+    .replace(/\bNOT\b/gi, '!')
+    .replace(/\bMOD\b/gi, '%')
+    .replace(/\bDIV\b/gi, '/')
+    .replace(/<>/g, '!=')
+    .replace(/:=/g, '=')
+    .replace(/\bTRUE\b/gi, 'true')
+    .replace(/\bFALSE\b/gi, 'false')
+    .replace(/\b(?<![><!])=(?!=)/g, '==');  // ✅ fix assignment/comparison
+
+    const tokens = results.split(/\s+/);
+  for (let i = 0; i < tokens.length; i++) {
+    if (tokens[i] === '=' &&
+        tokens[i - 1] !== '<' &&
+        tokens[i - 1] !== '>' &&
+        tokens[i - 1] !== '!' &&
+        tokens[i + 1] !== '='
+    ) {
+      tokens[i] = '==';
+    }
+  }
+  results = tokens.join(' ');
+  // Replace %I/Q/M references
+  const parts = results.split(/\s+/);
+  results = parts.map(e => {
+    // Don't touch raw address reads
+    if (/^%[IQM][XBWDL]?\d+(\.\d+)?$/i.test(e)) return getReadAddressExpression(e);
+
+    // Don't wrap literals or operators
+    if (/^(true|false|null|\d+|!|&&|\|\||==|!=|[<>=+\-*/()])$/i.test(e)) return e;
+
+    // Don't wrap known function expressions (e.g., getBit)
+    if (/^getBit\(/.test(e)) return e;
+
+    // Don't wrap dot-bit references already processed
+    if (/^&?[A-Za-z_]\w*\.\d+$/.test(e)) return e;
+
+    // Otherwise, wrap in resolve()
+    if(isjs)
+      return `resolve(${e})`;
+    else return e;
+  }).join(' ');
+  if (results.indexOf("read") === -1) {
+    results = results.replace(/\b(?!%)(([A-Za-z_]\w*)\.(\d+))\b/g, (_, full, base, bit) => {
+      return `getBit(&${base}, ${bit})`;
+    });
+  }
+  
+  return results;
+}
+
+
+/**
+ * 
+ * @param {string} addr 
+ * @returns 
+ */
+export function getReadAddressExpression(addr){
+  var result = `readDWord("${addr}")`;
+  try{
+    if(addr.indexOf(".")){
+      result = `readBit("${addr}")`;
+    }
+    else{
+      var width = addr.substring(2, 3).toUpperCase();
+      switch(width){
+        case "X":
+          result = `readByte("${addr}")`;
+        break;
+        case "W":
+          `readWord("${addr}")`;
+        break;
+      }
+    }
+  }
+  catch(e){
+    console.error(e);
+  }
+  return result;
+}
+
+export function getWriteAddressExpression(addr, value){
+  var result = `writeDWord("${addr}", ${value})`;
+  try{
+    if(addr.indexOf(".") > -1){
+      result = `writeBit("${addr}", ${value})`;
+    }
+    else{
+      var width = addr.substring(2, 3).toUpperCase();
+      switch(width){
+        case "X":
+          result = `writeByte("${addr}", ${value})`;
+        break;
+        case "W":
+          `writeWord("${addr}", ${value})`;
+        break;
+      }
+    }
+  }
+  catch(e){
+    console.error(e);
+  }
+  return result;
+}
+

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

@@ -0,0 +1,237 @@
+/* eslint-disable curly */
+/* eslint-disable eqeqeq */
+// Copyright [2025] Nathan Skipper
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+/**
+ * @description ANSI CPP Transpiler
+ * @author Nathan Skipper, MTI
+ * @version 1.0.2
+ * @copyright Apache 2.0
+ */
+
+import { convertExpression } from './expressionConverter.js';
+import { getWriteAddressExpression } from './expressionConverter.js';
+
+/**
+ * Converts the tokenized ST code to ANSCII C++.
+ * @param {{body: {type: string, name: string, varSections: [], statements: []}}[]} ast The tokenized code.
+ * @returns {string} The transpiled code.
+ */
+export function transpile(ast) {
+  const lines = [];
+
+  for (const block of ast.body) {
+    switch (block.type) {
+      case 'GlobalVars':
+        lines.push('// Global variable declarations');
+        lines.push(...declareVars(block.variables));
+        break;
+      case 'ProgramDeclaration':
+        lines.push(`void ${block.name}() { //PROGRAM:${block.name}`);
+        lines.push(...declareVars(block.varSections));
+        lines.push(...transpileStatements(block.statements));
+        lines.push('}');
+        break;
+
+      case 'FunctionDeclaration':
+        lines.push(`${mapType(block.returnType)} ${block.name}() { //FUNCTION:${block.name}`);
+        lines.push(...declareVars(block.varSections));
+        lines.push(...transpileStatements(block.statements));
+        lines.push('}');
+
+        for(var x = 0; x < lines.length; x++){
+            var l = lines[x];
+            if(l.indexOf(`${block.name} =`) > -1){
+                lines[x] = l.replace(`${block.name} =`, "return");
+            }
+        }
+
+        break;
+
+      case 'FunctionBlockDeclaration':
+        lines.push(`class ${block.name} {//FUNCTION_BLOCK:${block.name}`);
+        lines.push('public:');
+        //for (const v of block.varSections) {
+          lines.push(...declareVars(block.varSections));
+        //}
+        lines.push('  void operator()() {');
+        lines.push(...transpileStatements(block.statements).map(line => `    ${line}`));
+        lines.push('  }');
+        lines.push('};');
+        break;
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+/**
+ * Converts a single statement to C++
+ * @param {{type: string, left: string, right: string, condition:string[], elseIfBlocks: [], elseBlock: [], body: []}} stmt The tokenized statement to convert.
+ * @returns {string} the converted statement.
+ */
+function mapStatement(stmt){
+  try{
+    switch (stmt.type) {
+        case 'ASSIGN': {
+          const left = stmt.left;
+          const rightExpr = convertExpression(stmt.right);
+          if (isIOAddress(left)) {
+            return getWriteAddressExpression(left, rightExpr) + ";";
+          } else if (isBitSelector(left)) {
+            const [varName, bitIndex] = left.split('.');
+            return `setBit(&${varName}, ${bitIndex}, ${rightExpr});`;
+          }
+          return `${left} = ${rightExpr};`;
+        }
+
+        case 'IF': {
+          const cond = convertExpression(Array.isArray(stmt.condition) ? stmt.condition.join(' ') : stmt.condition);
+          const lines = [];
+
+          lines.push(`if (${cond}) {`);
+          lines.push(...transpileStatements(stmt.thenBlock).map(s => `  ${s}`));
+          lines.push(`}`);
+
+          if (stmt.elseIfBlocks && stmt.elseIfBlocks.length > 0) {
+            for (const elif of stmt.elseIfBlocks) {
+              const elifCond = convertExpression(Array.isArray(elif.condition) ? elif.condition.join(' ') : elif.condition);
+              lines.push(`else if (${elifCond}) {`);
+              lines.push(...transpileStatements(elif.block).map(s => `  ${s}`));
+              lines.push(`}`);
+            }
+          }
+
+          if (stmt.elseBlock && stmt.elseBlock.length > 0) {
+            lines.push(`else {`);
+            lines.push(...transpileStatements(stmt.elseBlock).map(s => `  ${s}`));
+            lines.push(`}`);
+          }
+
+          return lines;
+        }
+
+        case 'WHILE':
+          const wcond = convertExpression(Array.isArray(stmt.condition) ? stmt.condition.join(' ') : stmt.condition);
+          return [
+            `while (${wcond}) {`,
+            ...transpileStatements(stmt.body)?.map(s => `  ${s}`),
+            `}`
+          ];
+
+        case 'FOR':
+          return [
+            `for (int ${stmt.variable} = ${stmt.start}; ${stmt.variable} <= ${stmt.end}; ${stmt.variable} += ${stmt.step}) {`,
+            ...transpileStatements(stmt.body)?.map(s => `  ${s}`),
+            `}`
+          ];
+        case "CALL":
+          return [stmt.name + "();"];
+        default:
+          return [`// unsupported: ${stmt.type}`];
+      }
+  }
+  catch(e){
+    console.error(e + "\n" + JSON.stringify(stmt));
+  }
+  return "// uncompilable statement " + JSON.stringify(stmt);
+}
+
+/**
+ * Transpiles an array of statements.
+ * @param {{type: string, left: string, right: string, condition:string[], elseIfBlocks: [], elseBlock: [], body: []}[]} statements The statements to transpile.
+ * @returns {string[]} Returns an array of transpiled statements.
+ */
+function transpileStatements(statements) {
+  return statements?.flatMap(mapStatement);
+}
+
+/**
+ * Creates a transpiled section of declared variables.
+ * @param {{type: string, address: string, initialValue: string, sectionType: string}[]} varSections An array of variable tokens.
+ * @returns {string[]} An array of declaration statements.
+ */
+function declareVars(varSections) {
+  return varSections.map(v => {
+    var cleanedType = v.type.trim().toUpperCase();
+    var gv = "";
+    const isFunctionBlockType = !mapType(cleanedType) || mapType(cleanedType) === 'auto';
+    let init = "";
+    cleanedType = mapType(cleanedType);
+    if(v.address){
+      cleanedType = "RefVar<" + cleanedType + ">";
+      var addr = v.address;
+      if(!addr.startsWith("%")) addr = "%" + addr;
+      init = `("${addr}")`
+    }
+    else if (v.initialValue !== undefined && v.initialValue !== null) {
+      init = ` = ${v.initialValue}`;
+    }
+    if (v.sectionType==='VAR' && isFunctionBlockType) {
+      return `static ${v.type} ${v.name};`; // assume Function Block type
+    }
+    return `${cleanedType} ${v.name}${init};${gv}`;
+  });
+}
+
+/**
+ * Maps a structured text type to a C++ type.
+ * @param {string} type The ST type to map
+ * @returns {string} Returns a string representing the C++ equivalent for the structured text type.
+ */
+export function mapType(type) {
+  const types = {
+    'BOOL': 'bool',
+    'BYTE': 'uint8_t',
+    'WORD': 'uint16_t',
+    'DWORD': 'uint32_t',
+    'LWORD': 'uint64_t',
+    'SINT': 'int8_t',
+    'INT': 'int16_t',
+    'DINT': 'int32_t',
+    'LINT': 'int64_t',
+    'USINT': 'uint8_t',
+    'UINT': 'uint16_t',
+    'UDINT': 'uint32_t',
+    'ULINT': 'uint64_t',
+    'REAL': 'float',
+    'LREAL': 'double',
+    'TIME': 'uint32_t',
+    'DATE': 'std::string',
+    'TIME_OF_DAY': 'std::string',
+    'DATE_AND_TIME': 'std::string',
+    'STRING': 'std::string',
+    'WSTRING': 'std::wstring'
+  };
+  return types[type.trim().toUpperCase()] || 'auto';
+}
+
+/**
+ * Determins whether the expression is an address reference with a bit selector.
+ * @param {string} expr The expression to evaluate.
+ * @returns Returns true if the expression has a bit selector.
+ */
+function isBitSelector(expr) {
+  return typeof expr === 'string' && /^[A-Za-z_]\w*\.\d+$/.test(expr);
+}
+/**
+ * Determines whether the expression is an address reference.
+ * @param {string} expr The expression to evaluate.
+ * @returns Returns true if the expression is an address reference.
+ */
+function isIOAddress(expr) {
+  return typeof expr === 'string' && /^%[IQM]/i.test(expr);
+}

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

@@ -0,0 +1,254 @@
+/* eslint-disable curly */
+/* eslint-disable eqeqeq */
+// Copyright [2025] Nathan Skipper
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+
+/**
+ * @description Javascript Transpiler
+ * @author Nathan Skipper, MTI
+ * @version 1.0.2
+ * @copyright Apache 2.0
+ */
+
+import { convertExpression, getWriteAddressExpression } from './expressionConverter.js';
+let fbVars = [];
+let refVars = [];
+/**
+ * Converts the tokenized ST code to Javascript.
+ * @param {{body: {type: string, name: string, varSections: [], statements: []}}[]} ast The tokenized code.
+ * @returns {string} The transpiled code.
+ */
+export function transpile(ast) {
+  const lines = [];
+
+  for (const block of ast.body) {
+    switch (block.type) {
+      case 'GlobalVars':
+        lines.push('// Global variable declarations');
+        lines.push(...declareVars(block.variables));
+        break;
+
+      case 'ProgramDeclaration':
+        lines.push(`export function ${block.name}() { // PROGRAM:${block.name}`);
+        lines.push(...declareVars(block.varSections),false, block.name);
+        lines.push(...transpileStatements(block.statements));
+        lines.push('}');
+        break;
+
+      case 'FunctionDeclaration':
+        lines.push(`export function ${block.name}() { // FUNCTION:${block.name}`);
+        lines.push(...declareVars(block.varSections, false, block.name));
+        lines.push(...transpileStatements(block.statements));
+
+        for (let i = 0; i < lines.length; i++) {
+          if (lines[i].includes(`${block.name} =`)) {
+            lines[i] = lines[i].replace(`${block.name} =`, 'return');
+          }
+        }
+
+        lines.push('}');
+        break;
+
+      case 'FunctionBlockDeclaration':
+        lines.push(`export class ${block.name} { // FUNCTION_BLOCK:${block.name}`);
+        lines.push('  constructor() {');
+        lines.push(...declareVars(block.varSections, true, block.name).map(line => `    ${line}`));
+        lines.push('  }');
+        lines.push('  call() {');
+        lines.push(...transpileStatements(block.statements, true).map(line => `    ${line}`));
+        lines.push('  }');
+        lines.push('}');
+        break;
+    }
+  }
+  return lines.join('\n');
+}
+
+/**
+ * Converts a single statement to Javascript
+ * @param {{type: string, left: string, right: string, condition:string[], elseIfBlocks: [], elseBlock: [], body: []}} stmt The tokenized statement to convert.
+ * @returns {string} the converted statement.
+ */
+function mapStatement(stmt, infb = false) {
+  try {
+    switch (stmt.type) {
+      case 'ASSIGN': {
+        let left = stmt.left;
+        var e = left.split(".")[0];
+        if(infb && fbVars.includes(e)) {
+            left = "this." + left;
+        }
+            
+        const rightExpr = convertExpression(stmt.right, infb, fbVars, true);
+
+        if (isIOAddress(left)) {
+          return getWriteAddressExpression(left, rightExpr) + ";";
+        } else if (isBitSelector(left)) {
+          const [varName, bitIndex] = left.split('.');
+          return `setBit(${varName}, ${bitIndex}, ${rightExpr});`;
+        }
+
+        return `${left} = ${rightExpr};`;
+      }
+
+      case 'IF': {
+        const cond = convertExpression(stmt.condition, infb, fbVars,true);
+        const lines = [];
+
+        lines.push(`if (${cond}) {`);
+        lines.push(...transpileStatements(stmt.thenBlock, infb).map(s => `  ${s}`));
+        lines.push(`}`);
+
+        if (stmt.elseIfBlocks?.length) {
+          for (const elif of stmt.elseIfBlocks) {
+            const elifCond = convertExpression(elif.condition, infb, fbVars,true);
+            lines.push(`else if (${elifCond}) {`);
+            lines.push(...transpileStatements(elif.block, infb).map(s => `  ${s}`));
+            lines.push('}');
+          }
+        }
+
+        if (stmt.elseBlock?.length) {
+          lines.push('else {');
+          lines.push(...transpileStatements(stmt.elseBlock, infb).map(s => `  ${s}`));
+          lines.push('}');
+        }
+
+        return lines;
+      }
+
+      case 'WHILE': {
+        const cond = convertExpression(stmt.condition, infb, fbVars,true);
+        return [
+          `while (${cond}) {`,
+          ...transpileStatements(stmt.body, infb).map(s => `  ${s}`),
+          `}`
+        ];
+      }
+
+      case 'FOR':
+        return [
+          `for (let ${stmt.variable} = ${stmt.from}; ${stmt.variable} <= ${stmt.to}; ${stmt.variable} += ${stmt.step}) {`,
+          ...transpileStatements(stmt.body, infb).map(s => `  ${s}`),
+          `}`
+        ];
+
+      case 'REPEAT': {
+        const cond = convertExpression(stmt.condition, infb, fbVars,true);
+        return [
+          `do {`,
+          ...transpileStatements(stmt.body, infb).map(s => `  ${s}`),
+          `} while (!(${cond}));`
+        ];
+      }
+
+      case 'CALL':
+        let ext = "";
+        if(infb && fbVars.includes(stmt.name)){
+            ext = "this.";
+        }
+        return [`${ext}${stmt.name}.call();`];
+
+      default:
+        return [`// Unsupported statement type: ${stmt.type}`];
+    }
+  } catch (e) {
+    console.error("Error transpiling statement", stmt, e);
+    return [`// Failed to transpile: ${JSON.stringify(stmt)}`];
+  }
+}
+
+/**
+ * Transpiles an array of statements.
+ * @param {{type: string, left: string, right: string, condition:string[], elseIfBlocks: [], elseBlock: [], body: []}[]} statements The statements to transpile.
+ * @returns {string[]} Returns an array of transpiled statements.
+ */
+function transpileStatements(statements, infb=false) {
+  return statements?.flatMap((stmt) => mapStatement(stmt, infb));
+}
+
+/**
+ * Creates a transpiled section of declared variables.
+ * @param {{type: string, address: string, initialValue: string, sectionType: string}[]} varSections An array of variable tokens.
+ * @returns {string[]} An array of declaration statements.
+ */
+function declareVars(varSections, infb = false, blockName = "") {
+  if(infb){
+    fbVars = [];
+  }
+  return varSections.map(v => {
+    const isFunctionBlock = !mapType(v.type) || mapType(v.type) === 'any';
+    const decl = infb ? "this." : "let ";
+    if(infb) fbVars.push(v.name);
+    if (v.address) {
+      const addr = v.address.startsWith('%') ? v.address : '%' + v.address;
+      refVars.push(v.name);
+      return `${decl}${v.name} = createReference("${addr}");`;
+    }
+
+    const fullVarName = blockName ? `${blockName}.${v.name}` : v.name;
+
+    const initValue = (v.initialValue !== undefined && v.initialValue !== null)
+      ? ` = ${v.initialValue}`
+      : isFunctionBlock ? ` = newStatic("${fullVarName}", ${v.type})` : infb ? " = null" : "";
+
+    return `${decl}${v.name}${initValue};`;
+  });
+}
+
+/**
+ * Determines whether the expression is an address reference.
+ * @param {string} expr The expression to evaluate.
+ * @returns Returns true if the expression is an address reference.
+ */
+function isIOAddress(expr) {
+  return typeof expr === 'string' && /^%[IQM]/i.test(expr);
+}
+
+/**
+ * Determins whether the expression is an address reference with a bit selector.
+ * @param {string} expr The expression to evaluate.
+ * @returns Returns true if the expression has a bit selector.
+ */
+function isBitSelector(expr) {
+  return typeof expr === 'string' && /^[A-Za-z_]\w*\.\d+$/.test(expr);
+}
+
+function mapType(type) {
+  const jsTypes = {
+    'BOOL': 'boolean',
+    'BYTE': 'number',
+    'WORD': 'number',
+    'DWORD': 'number',
+    'LWORD': 'number',
+    'SINT': 'number',
+    'INT': 'number',
+    'DINT': 'number',
+    'LINT': 'number',
+    'USINT': 'number',
+    'UINT': 'number',
+    'UDINT': 'number',
+    'ULINT': 'number',
+    'REAL': 'number',
+    'LREAL': 'number',
+    'TIME': 'number',
+    'DATE': 'string',
+    'TIME_OF_DAY': 'string',
+    'DATE_AND_TIME': 'string',
+    'STRING': 'string',
+    'WSTRING': 'string'
+  };
+  return jsTypes[type?.trim().toUpperCase()] || 'any';
+}