nodalis-compiler 1.0.18 → 1.0.19

package/CHANGELOG.md

@@ -1,5 +1,8 @@
 # Changelog
 
+## [1.0.19] 2026-03-03
+- Changed IEC parser to interpret Function Blocks that are actually standard functions to a formal function call.
+
 ## [1.0.17] 2026-02-25
 - Added support for compilation of multiple ST files as a single project.
 - Added support for formal parameters.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodalis-compiler",
-  "version": "1.0.18",
+  "version": "1.0.19",
   "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/iec-parser/parser.js

@@ -1845,6 +1845,35 @@ export class Rung extends Serializable {
         return this.Objects.find((v) => v.ID == id);
     }
 
+    /**
+     * Finds the object with the referenced output point ID.
+     * @param {string} refID The ID of the output point to use in searching for the object.
+     * @returns {FbdObject|LdObject} Returns the object with the output, or null if there is no object with that ID.
+     */
+    findObjectWithOutput(refID) {
+        return this.Objects.find(
+            /**
+             * 
+             * @param {FbdObject|LdObject|CommonObject} o 
+             */
+            (o) => {
+                if (o.Type === "Block") {
+                    const v = o.OutputVariables.Variables.find(
+                        /**
+                         * 
+                         * @param {OutputVariable} ov 
+                         */
+                        (ov) => {
+                            return ov.OutputPoint.ID === refID;
+                        });
+                    return typeof ov !== "undefined";
+                }
+                else if (o.Type !== "Comment") {
+                    return typeof o.Outputs.find(op => op.ID === refID) !== "undefined";
+                }
+            });
+    }
+
     /**
      * 
      * @param {LdObject | FbdObject} obj The ladder logic object from which to find connections.
@@ -2084,19 +2113,65 @@ export class Rung extends Serializable {
                 if(expression.length > 0){
                     expression += " OR ";
                 }
-                if(con instanceof FbdObject){
-                    var v = con.OutputVariables.Variables.find(iv => start.hasInput(iv.OutputPoint.ID));
-                    if(isValid(v)){
-                        expression += con.toST(v.ParameterName);
+                if (con instanceof FbdObject) {
+                    const sb = FbdObject.getStandardBlock(con.TypeName);
+                    if (sb && sb.Style === "F") { //this is a function, not a function block.
+                        let fcall = con.TypeName + "(";
+                        forEachElem(con.InputVariables.Variables,
+                            /**
+                             * 
+                             * @param {InputVariable} v 
+                             */
+                            (v) => {
+                                if (v.InputPoint.Connections.length > 0) {
+                                    let assign = "";
+                                    forEachElem(v.InputPoint.Connections,
+                                        /**
+                                         * 
+                                         * @param {Connection} c 
+                                         */
+                                        (c) => {
+                                            const o = this.findObjectWithOutput(c.RefID);
+                                            if (o) {
+                                                if (assign.length > 0) {
+                                                    assign += " OR ";
+                                                }
+                                                assign += this.#buildExpression(o);
+                                            }
+                                        }
+                                    );
+                                    if (v.Negated === "true") {
+                                        assign = "NOT " + assign;
+                                    }
+                                    if (!fcall.endsWith("(")) {
+                                        fcall += ", ";
+                                    }
+                                    fcall += `${v.ParameterName} := ${assign}`;
+                                }
+                            });
+                        expression += `${fcall})`;
                     }
+                    else {
+                        var v = con.OutputVariables.Variables.find(iv => start.hasInput(iv.OutputPoint.ID));
+                        if (isValid(v)) {
+                            expression += con.toST(v.ParameterName);
+                        }
+                    }
+
                 }
                 else if(con.Type !== "LeftPowerRail"){
                     expression += `(${this.#buildExpression(con)})`;
                 }
             }
         );
-        if(start.Type !== "Coil"){
-            expression = `${start.toST()}${expression.length > 0 ? " AND (" + expression + ")" : ""}`;
+        if (start.Type !== "Coil") {
+            if (start.Type === "DataSink") {
+                expression = start.toST("", expression);
+            }
+            else {
+
+                expression = `${start.toST()}${expression.length > 0 ? " AND (" + expression + ")" : ""}`;
+            }
         }
         return expression;  
     }
@@ -2124,6 +2199,34 @@ export class Rung extends Serializable {
                 (block) => {
                     if(done.includes(block.ID)) return;
                     done.push(block.ID);
+                    const sb = FbdObject.getStandardBlock(block.TypeName);
+                    if (typeof sb !== "undefined" && sb.Style === "F") {
+                        //if this is a function and connects with standard ladder logic, then we wait and deal with this in the next step.
+                        //If it doesn't connect with the rest of the rung, then we need to deal with it here.
+                        if (this.findConnections(block, true).find(o => o.Type === "Contact" || o.Type === "CompareContact" || o.Type === "Coil" || o.Type === "RightPowerRail")) {
+                            return;
+                        }
+                        else {
+                            forEachElem(block.OutputVariables.Variables,
+                                /**
+                             * 
+                             * @param {OutputVariable} outvar 
+                             */
+                                (outvar) => {
+
+
+                                    var inobj = this.Objects.find(o => o.hasInput(outvar.OutputPoint.ID));
+                                    if (isValid(inobj)) {
+                                        if (inobj.Type === "DataSink") {
+                                            st += this.#buildExpression(inobj) + ";\n";
+                                        }
+                                    }
+
+                                }
+                            );
+                            return;
+                        }
+                    }
                     forEachElem(block.InputVariables.Variables, 
                         /**
                          * 
@@ -2898,7 +3001,7 @@ export class Connection extends Serializable{
 export class FbdObject extends Serializable {
 
     /**
-     * @type {{TypeName: string, InputVariables: string[], OutputVariables: string[]}[]}
+     * @type {{TypeName: string, InputVariables: string[], OutputVariables: string[], Style: string}[]}
      */
     static StandardBlocks = [
         {

package/src/nodalis.js

@@ -128,11 +128,7 @@ export class Nodalis {
     outputPath,
     resourceName,
     sourcePath,
-    language,
-    codesysCommand,
-    codesysCommandTemplate,
-    codesysProjectFile,
-    codesysPouName
+    language
   }) {
     validateFileExtension(language, sourcePath, resourceName);
 
@@ -147,11 +143,7 @@ export class Nodalis {
       resourceName,
       target,
       outputType,
-      language,
-      codesysCommand,
-      codesysCommandTemplate,
-      codesysProjectFile,
-      codesysPouName
+      language
     };
 
     await compiler.compile();
@@ -203,6 +195,9 @@ Usage:
 Actions:
   --action list-compilers
       Lists all available compilers and their supported targets, languages, protocols, and versions.
+  
+  --action list-programmers
+      Lists all available programmers and their supported targets.
 
   --action compile
       Required options:
@@ -212,10 +207,6 @@ Actions:
         --resourceName  Resource name (used for .iec projects)
         --sourcePath    Path to source file (.st or .iec)
         --language      st (Structured Text) or ld (Ladder Diagram)
-        --codesysCommand Optional CODESYS executable/command for --target codesys
-        --codesysCommandTemplate Optional shell template for --target codesys executable builds
-        --codesysProjectFile Optional .project path for CODESYS automation (defaults to <output>/<resource>.project)
-        --codesysPouName Optional POU name to create/update in CODESYS project
 
   --action deploy  Programs a device based on a protocol.
     --target        The device/protocol targeted for programming.
@@ -261,6 +252,11 @@ Examples:
       console.log(JSON.stringify(list, null, 2));
       break;
     }
+    case 'list-programmers': {
+      const list = app.listProgrammers();
+      console.log(JSON.stringify(list, null, 2));
+      break;
+    }
 
     case 'compile': {
       app.compile({
@@ -269,11 +265,7 @@ Examples:
         outputPath: argMap.outputPath,
         resourceName: argMap.resourceName,
         sourcePath: argMap.sourcePath,
-        language: argMap.language,
-        codesysCommand: argMap.codesysCommand,
-        codesysCommandTemplate: argMap.codesysCommandTemplate,
-        codesysProjectFile: argMap.codesysProjectFile,
-        codesysPouName: argMap.codesysPouName
+        language: argMap.language
       }).then(() => {
         console.log('Compilation completed.');
       }).catch(err => {
@@ -306,7 +298,7 @@ Examples:
 
     default: {
       console.error(`Unknown or missing action: ${argMap.action}`);
-      console.error(`Valid actions: list-compilers, compile, deploy`);
+      console.error(`Valid actions: list-compilers, list-programmers, compile, deploy`);
       break;
     }
   }