nodalis-compiler 1.0.12 → 1.0.13

package/CHANGELOG.md

@@ -5,6 +5,10 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),  
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.0.13] - 2025-12-17
+
+- Added cross-compilation for the CPPCompiler. Added more detail to the README for compilers.
+
 ## [1.0.12] - 2025-12-16
 
 - Fixed issue with copying support files for CPP and JS compilers.

package/README.md

@@ -105,6 +105,64 @@ await app.compile({
 
 ---
 
+## 🧠 Compiler Specifics
+
+### CPPCompiler
+
+`CPPCompiler` translates IEC Ladder Diagram (`.iec`) and Structured Text (`.st`, `.iec`) sources into ANSI C++ output. Depending on the requested output type it either produces compilable sources or invokes the toolchain to emit an executable.
+
+#### Dependencies
+
+- Uses a default cross-compiler profile tuned for macOS-style Clang/LLVM toolchains when no overrides are provided.
+- Supply a `toolchain.json` file beside your source to describe a custom toolchain. Example:
+
+```json
+{
+    "linux-arm": "arm-linux-gnueabi-g++",
+    "linux-arm64": "aarch64-linux-gnu-g++",
+    "linux-x64": "x86_64-linux-gnu-g++",
+    "macos-arm64": "clang++",
+    "macos-x64": "clang++",
+    "windows-x64": "x86_64-w64-mingw32-g++",
+    "windows-arm64": "/opt/llvm-mingw/bin/aarch64-w64-mingw32-g++"
+}
+```
+
+- Without an explicit file Nodalis falls back to the default compiler for the host OS (`clang++` on macOS, `g++` on Linux, and `cl.exe` or MinGW-w64 `g++` on Windows).
+- Common cross-compiler sources: Homebrew packages (`brew install armmbed/formulae/arm-none-eabi-gcc`) and osxcross for macOS targeting, MinGW-w64/MSYS2 or Visual Studio Build Tools for Windows, and distro packages such as `gcc-arm-linux-gnueabihf` or `x86_64-w64-mingw32-g++` on Linux.
+
+#### Variations
+
+- Windows builds exclude the OPC/UA client and server components to keep dependencies minimal.
+
+---
+
+## 🟦 JSCompiler
+
+`JSCompiler` transpiles LD (`.iec`) and ST (`.st`, `.iec`) programs into JavaScript for either **Node.js** or **jint** targets.
+
+- Node.js target: emits a Node module in the output directory and installs the needed npm dependencies.
+- jint target: generates a .NET 8 project embedding jint that cross-compiles to Windows, macOS, and Linux for `arm64`, `arm`, and `x64` architectures.
+
+### Dependencies
+
+- Node.js target requires `node` and `npm` to be available on the host.
+- jint target requires the .NET SDK (8.0+).
+
+---
+
+## 🗒 SkipCompiler
+
+`SkipCompiler` converts Skipper Sheet (`.skip`) files into three possible targets:
+
+- `xml`: produces MTI device-ready XML definitions.
+- `iec`: emits IEC ladder logic mirroring the sheet.
+- `st`: emits Structured Text representing the sheet logic.
+
+Choose the desired format via the CLI `--target`/`--outputType` flags.
+
+---
+
 ## 🗂 Project Structure
 
 | File | Description |

package/package.json

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

@@ -28,6 +28,18 @@ import { dirname } from 'node:path';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
+const DEFAULT_TOOLCHAIN = {
+    "linux-arm": "arm-linux-gnueabi-g++",
+    "linux-arm64": "aarch64-linux-gnu-g++",
+    "linux-x64": "x86_64-linux-gnu-g++",
+    "macos-arm64": "clang++",
+    "macos-x64": "clang++",
+    "windows-x64": "x86_64-w64-mingw32-g++",
+    "windows-arm64": "/opt/llvm-mingw/bin/aarch64-w64-mingw32-g++"
+};
+
+let ToolChain = { ...DEFAULT_TOOLCHAIN };
+
 export class CPPCompiler extends Compiler {
     constructor(options) {
         super(options);
@@ -43,7 +55,7 @@ export class CPPCompiler extends Compiler {
     }
 
     get supportedTargetDevices() {
-        return ['linux', 'macos', 'windows'];
+        return ['linux-arm', "linux-arm64", "linux-x64", 'macos-x64', "macos-arm64", 'windows-x64', "windows-arm64"];
     }
 
     get supportedProtocols() {
@@ -56,6 +68,25 @@ export class CPPCompiler extends Compiler {
 
     async compile() {
         const { sourcePath, outputPath, target, outputType, resourceName } = this.options;
+
+        ToolChain = { ...DEFAULT_TOOLCHAIN };
+        const sourceDir = fs.lstatSync(sourcePath).isDirectory() ? sourcePath : path.dirname(sourcePath);
+        const toolchainConfigPath = path.join(sourceDir, "toolchain.json");
+        if (fs.existsSync(toolchainConfigPath)) {
+            try {
+                const customToolchain = JSON.parse(fs.readFileSync(toolchainConfigPath, "utf-8"));
+                if (typeof customToolchain !== "object" || customToolchain === null) {
+                    throw new Error("The toolchain configuration must be a JSON object.");
+                }
+                ToolChain = { ...ToolChain, ...customToolchain };
+            } catch (err) {
+                throw new Error(`Failed to load toolchain configuration from ${toolchainConfigPath}: ${err.message}`);
+            }
+        }
+        else {
+            fs.writeFileSync(toolchainConfigPath, JSON.stringify(ToolChain, null, 4));
+        }
+
         var sourceCode = fs.readFileSync(sourcePath, 'utf-8');
         const filename = path.basename(sourcePath, path.extname(sourcePath));
         const cppFile = path.join(outputPath, `${filename}.cpp`);
@@ -201,77 +232,247 @@ int main() {
             'nodalis.cpp',
             'modbus.h',
             'modbus.cpp',
-            "json.hpp",
-            "opcua.h",
-            "opcua.cpp",
-            "open62541.h",
-            "open62541.c"
+            "json.hpp"
         ];
 
+        if (!target.includes("windows")) {
+            coreFiles.push(...["opcua.h",
+                "opcua.cpp", "open62541.h",
+                "open62541.c"]);
+        }
+        else {
+            coreFiles.push(...["opcua.h",
+                "opcua.cpp"]);
+        }
+
         const coreDir = path.resolve(__dirname + '/support/generic');
         for (const file of coreFiles) {
-            fs.copyFileSync(path.join(coreDir, file), path.join(outputPath, file));
+            fs.copyFileSync(path.join(target.includes("windows") && file.includes("opc") ? coreDir + "/windows/" : coreDir, file), path.join(outputPath, file));
         }
 
        const pathTo = name => path.join(outputPath, name);
+        const targetInfo = this.resolveTarget(target);
 
         if (outputType === 'executable') {
-            let compiler = null;
-            const isWindows = os.platform() === 'win32';
+            const requestedTarget = target ?? `${targetInfo.os}-${targetInfo.arch}`;
+            const hostOs = this.getHostOS();
+            const hostArch = this.getHostArch();
+            // if (targetInfo.os !== hostOs || targetInfo.arch !== hostArch) {
+            //     throw new Error(`Cross-compiling to ${requestedTarget} is not supported from a ${hostOs}-${hostArch} host.`);
+            // }
 
-            // Step 1: Detect compilers
-            try {
-                execSync('clang++ --version', { stdio: 'ignore' });
-                compiler = 'clang++';
-            } catch {
-                try {
-                    execSync('g++ --version', { stdio: 'ignore' });
-                    compiler = 'g++';
-                } catch {
-                    try {
-                        execSync('cl.exe /?', { stdio: 'ignore' });
-                        compiler = 'cl.exe';
-                    } catch {
-                        throw new Error('No C++ compiler found (clang++, g++, or cl.exe)');
-                    }
-                }
-            }
+            const compiler = this.detectCompiler(hostOs, hostArch, targetInfo.os, targetInfo.arch);
+            const cCompiler = this.getCCompilerBinary(compiler);
+            const archFlags = this.getArchFlags(targetInfo.os, targetInfo.arch, compiler);
+            const formatFlags = (flags = []) => (flags.length ? `${flags.join(' ')} ` : '');
+            const isWindowsTarget = targetInfo.os === 'windows';
 
             // Step 2: Compile open62541.c with C compiler
-            const cCompiler = compiler === 'cl.exe' ? 'cl.exe' : compiler.replace('++', '');
             const open62541c = pathTo('open62541.c');
             const open62541o = pathTo('open62541.o');
 
-            let cCompileCmd;
-            if (compiler === 'cl.exe') {
-                // Compile C file with cl
-                cCompileCmd = `cl.exe /c /TC "${open62541c}" /Fo"${pathTo('open62541.obj')}"`;
-            } else {
-                cCompileCmd = `${cCompiler} -std=c11 -D_DEFAULT_SOURCE -D_BSD_SOURCE -c "${open62541c}" -o "${open62541o}"`;
+            let cCompileCmd = "";
+            // if (compiler === 'cl.exe') {
+            //     // Compile C file with cl
+            //     const cFlagSegment = formatFlags(archFlags.c);
+            //     cCompileCmd = `cl.exe ${cFlagSegment}/c /TC "${open62541c}" /Fo"${pathTo('open62541.obj')}"`;
+            // } else {
+            if (!isWindowsTarget) {
+                const cFlagSegment = formatFlags(archFlags.c);
+
+                cCompileCmd = `${cCompiler} ${cFlagSegment}-std=c11 -D_DEFAULT_SOURCE -D_BSD_SOURCE -c "${open62541c}" -o "${open62541o}"`;
 
             }
 
-            execSync(cCompileCmd, { stdio: 'inherit' });
+            if (cCompileCmd !== "") execSync(cCompileCmd, { stdio: 'inherit' });
 
             // Step 3: Compile C++ files with C++ compiler and link object
             let exeFile = path.join(outputPath, filename);
-            if (isWindows && !exeFile.endsWith('.exe')) {
+            if (isWindowsTarget && !exeFile.endsWith('.exe')) {
                 exeFile += '.exe';
             }
 
             let cppCompileCmd;
+            const inputs = [
+                `"${cppFile}"`,
+                `"${pathTo('nodalis.cpp')}"`,
+                `"${pathTo('modbus.cpp')}"`,
+                `"${pathTo('opcua.cpp')}"`
+            ];
+
+            if (!isWindowsTarget) inputs.push(`"${open62541o}"`);
+
             if (compiler === 'cl.exe') {
-                cppCompileCmd = `cl.exe /EHsc /std:c++17 /Fe:"${exeFile}" ` +
-                    `"${cppFile}" "${pathTo('nodalis.cpp')}" "${pathTo('modbus.cpp')}" "${pathTo('opcua.cpp')}" "${pathTo('open62541.obj')}"`;
+                const cppFlagSegment = formatFlags(archFlags.cpp);
+                cppCompileCmd = `cl.exe ${cppFlagSegment}/EHsc /std:c++17 /Fe:"${exeFile}" ` +
+                    `"${cppFile}" "${pathTo('nodalis.cpp')}" "${pathTo('modbus.cpp')}" "${pathTo('opcua.cpp')}"`; //"${pathTo('open62541.obj')}"`;
             } else {
-                cppCompileCmd = `${compiler} -std=c++17 -o "${exeFile}" ` +
-                    `"${cppFile}" "${pathTo('nodalis.cpp')}" "${pathTo('modbus.cpp')}" "${pathTo('opcua.cpp')}" "${open62541o}"`;
+                const cppFlagSegment = formatFlags(archFlags.cpp);
+                cppCompileCmd = `${compiler} ${cppFlagSegment}-std=c++17 -o "${exeFile}" ${inputs.join(' ')} ${archFlags.linker}`;
             }
 
             execSync(cppCompileCmd, { stdio: 'inherit' });
         }
     }
 
+    resolveTarget(target) {
+        if (!target || typeof target !== 'string') {
+            throw new Error('You must provide a valid target (e.g., linux-x64, macos-arm64).');
+        }
+        const [osPart, archPart] = target.split('-');
+        if (!osPart || !archPart) {
+            throw new Error(`Invalid target format: ${target}. Expected <os>-<arch>.`);
+        }
+
+        const normalizedOs = this.normalizeOs(osPart);
+        const normalizedArch = this.normalizeArch(archPart);
+        if (!normalizedOs || !normalizedArch) {
+            throw new Error(`Unsupported target: ${target}.`);
+        }
+        return { os: normalizedOs, arch: normalizedArch };
+    }
+
+    normalizeOs(osPart) {
+        const map = {
+            linux: 'linux',
+            macos: 'macos',
+            darwin: 'macos',
+            windows: 'windows',
+            win32: 'windows'
+        };
+        return map[osPart.toLowerCase()];
+    }
+
+    normalizeArch(archPart) {
+        const map = {
+            x64: 'x64',
+            amd64: 'x64',
+            arm64: 'arm64',
+            aarch64: 'arm64',
+            arm: 'arm'
+        };
+        return map[archPart.toLowerCase()];
+    }
+
+    getHostOS() {
+        const platform = os.platform();
+        if (platform === 'win32') return 'windows';
+        if (platform === 'darwin') return 'macos';
+        if (platform === 'linux') return 'linux';
+        throw new Error(`Unsupported host platform: ${platform}`);
+    }
+
+    getHostArch() {
+        const arch = os.arch();
+        if (arch === 'x64') return 'x64';
+        if (arch === 'arm64') return 'arm64';
+        if (arch.startsWith('arm')) return 'arm';
+        throw new Error(`Unsupported host architecture: ${arch}`);
+    }
+
+    detectCompiler(hostOs, hostArch, targetOs, targetArch) {
+        const hostDefaults = {
+            linux: "g++",
+            macos: "clang++",
+            windows: "cl.exe"
+        };
+        const hostKey = `${hostOs}-${hostArch}`;
+        const targetKey = `${targetOs}-${targetArch}`;
+
+        const ensureCompilerAvailable = (compilerName, message) => {
+            const versionCommand = compilerName === "cl.exe" ? compilerName : `${compilerName} --version`;
+            try {
+                execSync(versionCommand, { stdio: "ignore" });
+            } catch {
+                throw new Error(message);
+            }
+        };
+
+        if (targetKey === hostKey) {
+            const defaultCompiler = hostDefaults[hostOs];
+            if (!defaultCompiler) {
+                throw new Error(`No default compiler configured for host platform ${hostOs}.`);
+            }
+            ensureCompilerAvailable(
+                defaultCompiler,
+                `The default compiler "${defaultCompiler}" is not available. Install it using your package manager (e.g., brew install ${defaultCompiler} or apt install ${defaultCompiler}).
+                You can also create a file called "toolchain.json" in your source directory which will supply the path to the gnu c compiler for each platform. See the README file for more details.`
+            );
+            return defaultCompiler;
+        }
+
+        const configuredCompiler = ToolChain[targetKey];
+        if (!configuredCompiler) {
+            throw new Error(`No cross-compiler is configured for target ${targetKey}. Add it to toolchain.json or update the ToolChain defaults.`);
+        }
+        ensureCompilerAvailable(
+            configuredCompiler,
+            `Cross-compiler "${configuredCompiler}" for target ${targetKey} is not available. Install it via your package manager (e.g., brew install ${configuredCompiler} or apt install ${configuredCompiler}).
+                You can also create a file called "toolchain.json" in your source directory which will supply the path to the gnu c compiler for each platform. See the README file for more details.`
+        );
+        return configuredCompiler;
+    }
+
+    getCCompilerBinary(cppCompiler) {
+        if (cppCompiler === 'cl.exe') {
+            return 'cl.exe';
+        }
+        if (cppCompiler.includes('clang')) {
+            return cppCompiler.replace('++', '');
+        }
+        if (cppCompiler.includes('g++')) {
+            return cppCompiler.replace('++', 'cc');
+        }
+        return 'cc';
+    }
+
+
+
+    getArchFlags(osType, arch, compiler) {
+        if (compiler === 'cl.exe') {
+            return { c: [], cpp: [] };
+        }
+        let flags = { //default flags are for macos clang
+            'linux-x64': [],
+            'linux-arm64': [],
+            'linux-arm': [],
+            'macos-x64': ['-arch', 'x86_64'],
+            'macos-arm64': ['-arch', 'arm64'],
+            'windows-x64': [],
+            'windows-arm64': []
+        };
+
+        let linker = {
+            "windows-x64": " -lws2_32 -lcrypt32 -lwsock32 -lole32",
+            "windows-arm64": " -lws2_32 -lcrypt32 -lwsock32 -lole32",
+            "linux-x64": "",
+            "linux-arm64": "",
+            "linux-arm": "",
+            "macos-x64": "",
+            "macos-arm64": "",
+        }
+
+        if (!compiler.includes("clang")) {
+            flags = {
+                'linux-x64': ["-D_POSIX_C_SOURCE=200809L -D_GNU_SOURCE -pthread"],
+                'linux-arm64': ["-D_POSIX_C_SOURCE=200809L -D_GNU_SOURCE -pthread"],
+                'linux-arm': ["-D_POSIX_C_SOURCE=200809L -D_GNU_SOURCE -pthread"],
+                'windows-x64': ["-DUA_ARCHITECTURE_WIN32 -D_POSIX_C_SOURCE=200809L -D_GNU_SOURCE"],
+                'windows-arm64': ["-DUA_ARCHITECTURE_WIN32 -D_POSIX_C_SOURCE=200809L -D_GNU_SOURCE"]
+            };
+        }
+
+        const key = `${osType}-${arch}`;
+
+        const resolved = flags[key];
+        if (!resolved) {
+            throw new Error(`Architecture flags are not defined for ${key}.`);
+        }
+
+        return { c: resolved, cpp: resolved, linker: linker[key] };
+    }
 }
 
+
+
 export default CPPCompiler;

package/src/compilers/support/generic/windows/opcua.cpp

@@ -0,0 +1,74 @@
+#include "opcua.h"
+#include <iostream>
+
+OPCUAClient::OPCUAClient()
+    : IOClient("opcua"), endpointUrl("opc.tcp://localhost:4840") {
+    
+}
+
+OPCUAClient::~OPCUAClient() {
+}
+
+void OPCUAClient::connect() {
+    
+}
+
+
+// Implement required IOClient methods
+
+bool OPCUAClient::readBit(const std::string& remote, int& result) {
+    return false;
+}
+
+bool OPCUAClient::writeBit(const std::string& remote, int value) {
+    return false;
+}
+
+bool OPCUAClient::readByte(const std::string& remote, uint8_t& result) {
+    return false;
+}
+
+bool OPCUAClient::writeByte(const std::string& remote, uint8_t value) {
+    return false;
+}
+
+bool OPCUAClient::readWord(const std::string& remote, uint16_t& result) {
+    return false;
+}
+
+bool OPCUAClient::writeWord(const std::string& remote, uint16_t value) {
+    return false;
+}
+
+bool OPCUAClient::readDWord(const std::string& remote, uint32_t& result) {
+    return false;
+}
+
+bool OPCUAClient::writeDWord(const std::string& remote, uint32_t value) {
+    return false;
+}
+
+
+OPCUAServer::OPCUAServer() {
+    
+}
+
+OPCUAServer::~OPCUAServer() {
+    
+}
+
+void OPCUAServer::start() {
+    
+}
+
+void OPCUAServer::stop() {
+    
+}
+
+void OPCUAServer::run() {
+}
+
+void OPCUAServer::mapVariable(std::string varname, std::string addr){
+   
+    
+}

package/src/compilers/support/generic/windows/opcua.h

@@ -0,0 +1,39 @@
+#pragma once
+#include "nodalis.h"
+
+
+class OPCUAClient : public IOClient {
+public:
+    OPCUAClient();
+    ~OPCUAClient();
+
+protected:
+    void connect() override;
+
+    bool readBit(const std::string& remote, int& result) override;
+    bool writeBit(const std::string& remote, int value) override;
+    bool readByte(const std::string& remote, uint8_t& result) override;
+    bool writeByte(const std::string& remote, uint8_t value) override;
+    bool readWord(const std::string& remote, uint16_t& result) override;
+    bool writeWord(const std::string& remote, uint16_t value) override;
+    bool readDWord(const std::string& remote, uint32_t& result) override;
+    bool writeDWord(const std::string& remote, uint32_t value) override;
+
+private:
+   
+    std::string endpointUrl;
+};
+
+class OPCUAServer {
+public:
+    OPCUAServer();
+    ~OPCUAServer();
+
+    void start();
+    void stop();
+    void mapVariable(std::string varname, std::string addr);
+
+private:
+    void run();
+
+};