nodalis-compiler 1.0.30 → 1.0.32

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [1.0.32] 2026-06-05
+- Fixed problems with writing registers to Modbus.
+
+## [1.0.31] 2026-04-28
+- Added an "exports.json" file that can be used to designate exported local variables in
+programs when compiling a folder of ST files.
+
 ## [1.0.30] 2026-03-30
 - Fixed issue with boolean assignments in C++
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nodalis-compiler",
-  "version": "1.0.30",
+  "version": "1.0.32",
   "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",
@@ -16,6 +16,9 @@
   },
   "files": [
     "src/",
+    "!src/compilers/support/jint/nodalis/NodalisPLC/bin/",
+    "!src/compilers/support/jint/nodalis/NodalisPLC/obj/",
+    "!src/compilers/support/jint/nodalis/publish/",
     "README.md",
     "LICENSE",
     "package.json",

package/src/compilers/CPPCompiler.js

@@ -45,6 +45,163 @@ export class CPPCompiler extends Compiler {
         this.name = 'CPPCompiler';
     }
 
+    loadStructuredTextBundle(sourcePath, resourceName) {
+        const exports = this.loadStructuredTextBundleExports(sourcePath, resourceName);
+        const stFiles = this.listStructuredTextBundleFiles(sourcePath);
+
+        if (stFiles.length === 0) {
+            throw new Error(`No .st files found in source directory "${sourcePath}".`);
+        }
+
+        const normalizedResource = String(resourceName || '').trim();
+        const candidateNames = new Set([
+            normalizedResource,
+            normalizedResource.toLowerCase(),
+            normalizedResource.toLowerCase().endsWith('.st') ? normalizedResource.toLowerCase() : `${normalizedResource.toLowerCase()}.st`
+        ]);
+
+        const entryFile = stFiles.find((file) => {
+            const lower = file.toLowerCase();
+            return candidateNames.has(file) || candidateNames.has(lower);
+        });
+
+        if (!entryFile) {
+            throw new Error(`resourceName "${resourceName}" is not an .st file in "${sourcePath}".`);
+        }
+
+        const orderedFiles = [
+            ...stFiles.filter((file) => file !== entryFile).sort((a, b) => a.localeCompare(b)),
+            entryFile
+        ];
+
+        let combinedSource = this.buildStructuredTextExportGlobals(exports);
+        let currentLine = combinedSource.length > 0 ? combinedSource.split('\n').length + 2 : 1;
+        const fileLineMappings = [];
+
+        for (const file of orderedFiles) {
+            const originalSource = fs.readFileSync(path.join(sourcePath, file), 'utf-8');
+            const fileSource = (file === entryFile
+                ? this.addStructuredTextExportAssignments(originalSource, exports)
+                : originalSource).trim();
+            if (fileSource.length === 0) continue;
+
+            if (combinedSource.length > 0) {
+                combinedSource += '\n\n';
+            }
+
+            const lineCount = fileSource.split('\n').length;
+            fileLineMappings.push({
+                file,
+                startLine: currentLine,
+                endLine: currentLine + lineCount - 1
+            });
+            combinedSource += fileSource;
+            currentLine += lineCount + 1;
+        }
+
+        const entrySource = fs.readFileSync(path.join(sourcePath, entryFile), 'utf-8');
+        const entryProgramName = this.extractFirstProgramName(entrySource) || path.basename(entryFile, path.extname(entryFile));
+
+        return { combinedSource, entryProgramName, fileLineMappings };
+    }
+
+    loadStructuredTextBundleExports(sourcePath, resourceName) {
+        const exportsPath = path.join(sourcePath, 'exports.json');
+        const resourceKey = this.getStructuredTextExportResourceKey(resourceName);
+        const defaultExports = {
+            T_MAIN: [{ global: 'Result', type: 'BOOL', address: '%MX0.0', variable: 'bResult' }]
+        };
+
+        if (!fs.existsSync(exportsPath)) {
+            fs.writeFileSync(exportsPath, JSON.stringify(defaultExports, null, 4));
+            return resourceKey === this.getStructuredTextExportResourceKey('T_MAIN') ? defaultExports.T_MAIN : [];
+        }
+
+        let exportConfig;
+        try {
+            exportConfig = JSON.parse(fs.readFileSync(exportsPath, 'utf-8'));
+        } catch (err) {
+            throw new Error(`Failed to load exports.json from ${exportsPath}: ${err.message}`);
+        }
+
+        if (typeof exportConfig !== 'object' || exportConfig === null || Array.isArray(exportConfig)) {
+            throw new Error(`exports.json in ${sourcePath} must be an object keyed by resource name.`);
+        }
+
+        const matchedKey = Object.keys(exportConfig).find((key) => this.getStructuredTextExportResourceKey(key) === resourceKey);
+        if (!matchedKey) return [];
+
+        const exports = exportConfig[matchedKey];
+        if (!Array.isArray(exports)) {
+            throw new Error(`exports.json entry for resource "${matchedKey}" must be an array.`);
+        }
+        return exports.map((entry, index) => this.validateStructuredTextBundleExport(entry, index, exportsPath));
+    }
+
+    getStructuredTextExportResourceKey(resourceName) {
+        return this.getStructuredTextExportResourceName(resourceName).toLowerCase();
+    }
+
+    getStructuredTextExportResourceName(resourceName) {
+        const normalized = String(resourceName || '').trim();
+        return path.basename(normalized, path.extname(normalized));
+    }
+
+    validateStructuredTextBundleExport(entry, index, exportsPath) {
+        if (typeof entry !== 'object' || entry === null || Array.isArray(entry)) {
+            throw new Error(`Invalid export at ${exportsPath}[${index}]: expected an object.`);
+        }
+
+        const global = String(entry.global || '').trim();
+        const type = String(entry.type || 'BOOL').trim();
+        const address = String(entry.address || '').trim();
+        const variable = String(entry.variable || '').trim();
+        const identifierPattern = /^[A-Za-z_]\w*$/;
+        const variablePattern = /^[A-Za-z_]\w*(?:\.\w+)?$/;
+        const addressPattern = /^%[IQM][A-Z]*\d+(?:\.\d+)?$/i;
+
+        if (!identifierPattern.test(global)) {
+            throw new Error(`Invalid export global at ${exportsPath}[${index}]: "${entry.global}" is not a valid ST identifier.`);
+        }
+        if (!identifierPattern.test(type)) {
+            throw new Error(`Invalid export type at ${exportsPath}[${index}]: "${entry.type}" is not a valid ST type identifier.`);
+        }
+        if (!addressPattern.test(address)) {
+            throw new Error(`Invalid export address at ${exportsPath}[${index}]: "${entry.address}" is not a valid ST address.`);
+        }
+        if (!variablePattern.test(variable)) {
+            throw new Error(`Invalid export variable at ${exportsPath}[${index}]: "${entry.variable}" is not a valid ST variable reference.`);
+        }
+
+        return { global, type, address, variable };
+    }
+
+    buildStructuredTextExportGlobals(exports) {
+        if (!Array.isArray(exports) || exports.length === 0) return '';
+
+        return [
+            'VAR_GLOBAL',
+            ...exports.flatMap((entry) => [
+                `    ${entry.global} AT ${entry.address} : ${entry.type};`,
+                `//Global=${JSON.stringify({ Name: entry.global, Address: entry.address })}`
+            ]),
+            'END_VAR'
+        ].join('\n');
+    }
+
+    addStructuredTextExportAssignments(entrySource, exports) {
+        if (!Array.isArray(exports) || exports.length === 0) return entrySource;
+
+        const assignmentBlock = exports.map((entry) => `${entry.global} := ${entry.variable};`).join('\n');
+        const endProgramPattern = /^(\s*END_PROGRAM\b[^\r\n]*)/im;
+
+        if (!endProgramPattern.test(entrySource)) {
+            throw new Error('Entry program does not contain END_PROGRAM; cannot add exports.json assignments.');
+        }
+
+        return entrySource.replace(endProgramPattern, `${assignmentBlock}\n$1`);
+    }
+
     get supportedLanguages() {
         return [IECLanguage.STRUCTURED_TEXT, IECLanguage.LADDER_DIAGRAM];
     }
@@ -301,18 +458,22 @@ int main() {
 
             inputs.push(`"${open62541o}"`);
             inputs.push(`"${bacneta}"`);
+            const debugFlags = this.getDebugCompileFlags(compiler);
 
             if (compiler === 'cl.exe') {
                 const cppFlagSegment = formatFlags(archFlags.cpp);
-                cppCompileCmd = `cl.exe /I${bacneti} /I${bacneti}/ports/${isWindowsTarget ? "win32" : "linux"} ${cppFlagSegment}/EHsc /std:c++17 /Fe:"${exeFile}" ` +
+                cppCompileCmd = `cl.exe /I${bacneti} /I${bacneti}/ports/${isWindowsTarget ? "win32" : "linux"} ${cppFlagSegment}${debugFlags} /EHsc /std:c++17 /Fe:"${exeFile}" ` +
                     `"${cppFile}" "${pathTo('nodalis.cpp')}" "${pathTo('modbus.cpp')}" "${pathTo('opcua.cpp')}" "${pathTo('bacnet.cpp')}" "${pathTo('gpio.cpp')}"`; //"${pathTo('open62541.obj')}"`;
             } else {
                 const cppFlagSegment = formatFlags(archFlags.cpp);
-                cppCompileCmd = `${compiler} ${cppFlagSegment}-std=c++17 -I${bacneti} -I${bacneti}/ports/${isWindowsTarget ? "win32" : "linux"} -o "${exeFile}" ${inputs.join(' ')} ${archFlags.linker}`;
+                cppCompileCmd = `${compiler} ${cppFlagSegment}${debugFlags} -std=c++17 -I${bacneti} -I${bacneti}/ports/${isWindowsTarget ? "win32" : "linux"} -o "${exeFile}" ${inputs.join(' ')} ${archFlags.linker}`;
             }
 
             try {
                 execSync(cppCompileCmd, { stdio: 'pipe' });
+                if (targetInfo.os === 'macos') {
+                    this.generateMacOSDebugSymbols(exeFile);
+                }
                 if (isWindowsTarget) {
                     this.copyWindowsRuntimeDependencies(compiler, binDir);
                 }
@@ -326,6 +487,19 @@ int main() {
         }
     }
 
+    getDebugCompileFlags(compiler) {
+        if (compiler === 'cl.exe') return '/Zi /Od';
+        return '-g -O0';
+    }
+
+    generateMacOSDebugSymbols(exeFile) {
+        try {
+            execSync(`dsymutil "${exeFile}"`, { stdio: 'pipe' });
+        } catch {
+            // Debug symbols are best-effort; the executable is still usable without a dSYM.
+        }
+    }
+
     copyWindowsRuntimeDependencies(compiler, binDir) {
         const compilerName = String(compiler || '').toLowerCase();
         const isMingwToolchain = compilerName.includes('mingw') || compilerName.includes('w64');

package/src/compilers/JSCompiler.js

@@ -114,6 +114,7 @@ export class JSCompiler extends Compiler {
         let tasks = [];
         let programs = [];
         let globals = [];
+        let csharpGlobals = [];
         let taskCode = "";
         let mapCode = "";
         let plcname = "NodalisPLC";
@@ -143,6 +144,7 @@ export class JSCompiler extends Compiler {
             else if(line.indexOf("//Global=") > -1){
                 let global = JSON.parse(line.substring(line.indexOf("=") + 1).trim());
                 globals.push(`opcServer.mapVariable("${global.Name}", "${global.Address}");`)
+                csharpGlobals.push(`opcServer.MapVariable(${toCSharpStringLiteral(global.Name)}, ${toCSharpStringLiteral(global.Address)});`)
 
             }
             else if(line.trim().startsWith("PROGRAM")){
@@ -273,6 +275,7 @@ export function run(){
 
             // Keep the Jint project sources in the main output directory.
             fs.cpSync(supportDir, projectOutputDir, { recursive: true, force: true });
+            patchJintProgramOpcMappings(projectOutputDir, csharpGlobals);
 
             // Build from the main output directory, then move publish artifacts under bin.
             const buildPath = path.resolve(path.join(projectOutputDir, buildScript));
@@ -347,3 +350,15 @@ function installDependencies(outputDir) {
     shell: true
   });
 }
+
+function patchJintProgramOpcMappings(projectOutputDir, csharpGlobals) {
+  const programPath = path.join(projectOutputDir, "NodalisPLC", "Program.cs");
+  let programSource = fs.readFileSync(programPath, "utf-8");
+  const mappingCode = csharpGlobals.map((line) => `        ${line}`).join("\n");
+  programSource = programSource.replace("        // {opcServerMappings}", mappingCode);
+  fs.writeFileSync(programPath, programSource, "utf-8");
+}
+
+function toCSharpStringLiteral(value) {
+  return `"${String(value).replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}

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

@@ -102,6 +102,7 @@ export function convertExpression(expr, isjsfb = false, jsfbVars = [], isjs=fals
     .replace(/\b(?<![><!])=(?!=)/g, '==');  // ✅ fix assignment/comparison
 
   results = rewriteExponentOperator(results, isjs);
+  results = rewriteNumericNotOperator(results);
 
   // JS accepts 0o..., but C++ requires legacy octal form 0...
   if (!isjs) {
@@ -150,6 +151,13 @@ export function convertExpression(expr, isjsfb = false, jsfbVars = [], isjs=fals
   return results;
 }
 
+function rewriteNumericNotOperator(expression) {
+  return String(expression || '').replace(
+    /!\s+([+-]?(?:0[xX][0-9a-fA-F]+|0[bB][01]+|0[oO][0-7]+|\d+))/g,
+    '~$1'
+  );
+}
+
 function rewriteExponentOperator(expression, isjs) {
   let result = String(expression || '');
   const operand = String.raw`(?:\([^()]*\)|[A-Za-z_]\w*(?:\.\d+)?|[+-]?(?:0[xX][0-9a-fA-F]+|0[bB][01]+|0[oO][0-7]+|(?:\d+\.\d*|\d*\.\d+|\d+)(?:[eE][+-]?\d+)?))`;

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

@@ -197,47 +197,86 @@ ModbusRequest ModbusClient::createWriteSingleRegister(uint16_t address, uint16_t
     return { deviceAddress, WRITE_SINGLE_REGISTER, address, 1, data };
 }
 
-bool ModbusClient::sendRequest(const ModbusRequest& req, ModbusResponse& resp) {
+bool ModbusClient::sendRequest(const ModbusRequest &req, ModbusResponse &resp)
+{
     std::vector<uint8_t> pdu;
 
-    // Handle function-specific encoding
-    if (req.function == WRITE_SINGLE_COIL) {
-        // Function 0x05: Write Single Coil
+    if (req.function == WRITE_SINGLE_COIL)
+    {
+        pdu = {
+            req.function,
+            static_cast<uint8_t>(req.startAddress >> 8),
+            static_cast<uint8_t>(req.startAddress & 0xFF)};
+
+        if (req.data.size() != 2)
+        {
+            std::cerr << "Invalid data size for Write Single Coil.\n";
+            return false;
+        }
+
+        pdu.push_back(req.data[0]);
+        pdu.push_back(req.data[1]);
+    }
+    else if (req.function == WRITE_SINGLE_REGISTER)
+    {
         pdu = {
             req.function,
             static_cast<uint8_t>(req.startAddress >> 8),
-            static_cast<uint8_t>(req.startAddress & 0xFF)
-        };
-        if (req.data.size() == 2) {
-            pdu.push_back(req.data[0]);  // Hi byte (0xFF or 0x00)
-            pdu.push_back(req.data[1]);  // Lo byte (always 0x00)
-        } else {
-            std::cerr << "Invalid data size for Write Single Coil (expected 2 bytes).\n";
+            static_cast<uint8_t>(req.startAddress & 0xFF)};
+
+        if (req.data.size() != 2)
+        {
+            std::cerr << "Invalid data size for Write Single Register.\n";
             return false;
         }
-    } else {
-        // Default encoding for most function codes
+
+        pdu.push_back(req.data[0]); // value high byte
+        pdu.push_back(req.data[1]); // value low byte
+    }
+    else if (req.function == READ_HOLDING_REGISTERS ||
+             req.function == READ_INPUT_REGISTERS ||
+             req.function == READ_COILS ||
+             req.function == READ_DISCRETE_INPUTS)
+    {
         pdu = {
             req.function,
             static_cast<uint8_t>(req.startAddress >> 8),
             static_cast<uint8_t>(req.startAddress & 0xFF),
             static_cast<uint8_t>(req.quantity >> 8),
-            static_cast<uint8_t>(req.quantity & 0xFF)
-        };
+            static_cast<uint8_t>(req.quantity & 0xFF)};
+    }
+    else if (req.function == WRITE_MULTIPLE_REGISTERS)
+    {
+        pdu = {
+            req.function,
+            static_cast<uint8_t>(req.startAddress >> 8),
+            static_cast<uint8_t>(req.startAddress & 0xFF),
+            static_cast<uint8_t>(req.quantity >> 8),
+            static_cast<uint8_t>(req.quantity & 0xFF),
+            static_cast<uint8_t>(req.data.size())};
+
         pdu.insert(pdu.end(), req.data.begin(), req.data.end());
     }
+    else
+    {
+        std::cerr << "Unsupported Modbus function: " << static_cast<int>(req.function) << "\n";
+        return false;
+    }
 
     std::vector<uint8_t> response;
-    if (!sendRaw(pdu, response)) return false;
+    if (!sendRaw(pdu, response))
+        return false;
 
-    if (response.size() < 2) return false;
+    if (response.size() < 2)
+        return false;
 
     resp.address = req.address;
     resp.function = response[0];
     resp.data.assign(response.begin() + 1, response.end());
     resp.exceptionCode = (resp.function & 0x80) ? resp.data[0] : 0;
 
-    if (resp.exceptionCode > 0) {
+    if (resp.exceptionCode > 0)
+    {
         std::cerr << "MODBUS exception code: " << static_cast<int>(resp.exceptionCode) << "\n";
         return false;
     }

package/src/compilers/support/jint/nodalis/NodalisEngine/NodalisEngine.csproj

@@ -12,7 +12,7 @@
     <PackageReference Include="BACnet" Version="3.0.2" />
     <PackageReference Include="Jint" Version="4.4.2" />
     <PackageReference Include="System.Text.Json" Version="*" />
-    <PackageReference Include="OPCFoundation.NetStandard.Opc.Ua" Version="1.5.374.118" />
+    <PackageReference Include="OPCFoundation.NetStandard.Opc.Ua" Version="1.5.378.134" />
   </ItemGroup>
   <ItemGroup>
     <None Include="README.md" Pack="true" PackagePath="\" />
@@ -24,7 +24,7 @@
   <PropertyGroup>
   <TargetFrameworks>net8.0</TargetFrameworks> 
   <GeneratePackageOnBuild>true</GeneratePackageOnBuild> <!-- optional -->
-  <Version>1.0.10</Version>
+  <Version>1.0.12</Version>
   <Authors>Nathan Skipper</Authors>
   <Company>Montgomery Technology, Inc.</Company>
   <PackageId>NodalisEngine</PackageId>

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

@@ -21,6 +21,7 @@ using Opc.Ua.Client;
 using Opc.Ua.Configuration;
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Threading.Tasks;
 
 namespace Nodalis
@@ -30,7 +31,7 @@ namespace Nodalis
     /// </summary>
     public class OPCClient : IOClient
     {
-        private Session? _session;
+        private ISession? _session;
         private ApplicationConfiguration? _config;
         /// <summary>
         /// Instantiates a new OPCClient.
@@ -52,23 +53,35 @@ namespace Nodalis
                     {
                         ApplicationName = "NodalisOPCUAClient",
                         ApplicationType = ApplicationType.Client,
-                        SecurityConfiguration = new SecurityConfiguration
-                        {
-                            ApplicationCertificate = new CertificateIdentifier(),
-                            AutoAcceptUntrustedCertificates = true,
-                        },
+                        SecurityConfiguration = CreateSecurityConfiguration(),
                         TransportConfigurations = new TransportConfigurationCollection(),
                         TransportQuotas = new TransportQuotas { OperationTimeout = 15000 },
                         ClientConfiguration = new ClientConfiguration { DefaultSessionTimeout = 60000 }
                     };
                     await _config.Validate(ApplicationType.Client);
+                    await _config.CertificateValidator.UpdateAsync(_config, default);
 
                     var app = new ApplicationInstance { ApplicationName = "NodalisOPCUAClient", ApplicationType = ApplicationType.Client, ApplicationConfiguration = _config };
-                    var endpoint = CoreClientUtils.SelectEndpoint(endpointUrl, false, 15000);
-                    var endpointConfig = EndpointConfiguration.Create(_config);
-                    var endpointDesc = new ConfiguredEndpoint(null, endpoint, endpointConfig);
+                    await app.CheckApplicationInstanceCertificatesAsync(false, 0);
 
-                    _session = await Session.Create(_config, endpointDesc, false, "", 60000, null, null);
+                    var endpoint = CoreClientUtils.SelectEndpoint(_config, endpointUrl, false, 15000);
+                    var endpointConfig = EndpointConfiguration.Create(_config);
+                    var configuredEndpoint = new ConfiguredEndpoint(null, endpoint, endpointConfig);
+
+                    var sessionFactory = new DefaultSessionFactory();
+
+                    _session = await sessionFactory.CreateAsync(
+                        _config,
+                        (ITransportWaitingConnection?)null,
+                        configuredEndpoint,
+                        true,
+                        false,
+                        _config.ApplicationName,
+                        60000,
+                        new UserIdentity(),
+                        null,
+                        default
+                    );
                     connected = true;
                     Console.WriteLine("OPC UA connected.");
                 }
@@ -80,6 +93,46 @@ namespace Nodalis
             });
         }
 
+        private static SecurityConfiguration CreateSecurityConfiguration()
+        {
+            string pkiRoot = Path.Combine(AppContext.BaseDirectory, "pki");
+            string ownStore = Path.Combine(pkiRoot, "own");
+            string trustedPeerStore = Path.Combine(pkiRoot, "trusted");
+            string trustedIssuerStore = Path.Combine(pkiRoot, "issuer");
+            string rejectedStore = Path.Combine(pkiRoot, "rejected");
+
+            Directory.CreateDirectory(ownStore);
+            Directory.CreateDirectory(trustedPeerStore);
+            Directory.CreateDirectory(trustedIssuerStore);
+            Directory.CreateDirectory(rejectedStore);
+
+            return new SecurityConfiguration
+            {
+                ApplicationCertificate = new CertificateIdentifier
+                {
+                    StoreType = CertificateStoreType.Directory,
+                    StorePath = ownStore,
+                    SubjectName = "CN=NodalisOPCUAClient"
+                },
+                TrustedPeerCertificates = new CertificateTrustList
+                {
+                    StoreType = CertificateStoreType.Directory,
+                    StorePath = trustedPeerStore
+                },
+                TrustedIssuerCertificates = new CertificateTrustList
+                {
+                    StoreType = CertificateStoreType.Directory,
+                    StorePath = trustedIssuerStore
+                },
+                RejectedCertificateStore = new CertificateTrustList
+                {
+                    StoreType = CertificateStoreType.Directory,
+                    StorePath = rejectedStore
+                },
+                AutoAcceptUntrustedCertificates = true
+            };
+        }
+
         private NodeId GetNodeId(string remote) => new NodeId($"s={remote}", 1);
 
         public override bool ReadBit(string address, out int result)