nodalis-compiler 1.0.13 → 1.0.15

package/CHANGELOG.md

@@ -1,9 +1,12 @@
 # Changelog
 
-All notable changes to this project will be documented in this file.
+## [1.0.15] - 2026-02-10
 
-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).
+- Fixed issue with calling functions. Changed AND/OR to bitwise operators in JS/C
+
+## [1.0.14] - 2026-02-06
+
+- Added support for BACNET-IP to Generic C++ and JINT compilers.
 
 ## [1.0.13] - 2025-12-17
 

package/package.json

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

@@ -232,23 +232,27 @@ int main() {
             'nodalis.cpp',
             'modbus.h',
             'modbus.cpp',
+            'bacnet.h',
+            'bacnet.cpp',
             "json.hpp"
         ];
 
-        if (!target.includes("windows")) {
-            coreFiles.push(...["opcua.h",
-                "opcua.cpp", "open62541.h",
-                "open62541.c"]);
-        }
-        else {
-            coreFiles.push(...["opcua.h",
-                "opcua.cpp"]);
-        }
+        // 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(target.includes("windows") && file.includes("opc") ? coreDir + "/windows/" : coreDir, file), path.join(outputPath, file));
-        }
+        fs.cpSync(coreDir, outputPath, {force: true, recursive: true});
+        // for (const file of coreFiles) {
+            
+        //     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);
@@ -262,29 +266,30 @@ int main() {
             // }
 
             const compiler = this.detectCompiler(hostOs, hostArch, targetInfo.os, targetInfo.arch);
-            const cCompiler = this.getCCompilerBinary(compiler);
+            //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 open62541c = pathTo('open62541.c');
-            const open62541o = pathTo('open62541.o');
-
-            let cCompileCmd = "";
+            //const open62541c = pathTo('open62541.c');
+            const open62541o = pathTo(path.join("open62541", "lib", target, isWindowsTarget ? "open62541.lib" : 'open62541.o'));
+            const bacneta = pathTo(path.join("bacnet-stack", target, "libbacnet.a"));
+            const bacneti = pathTo(path.join("bacnet-stack", target, "include"));
+            //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);
+            // if (!isWindowsTarget) {
+            //     const cFlagSegment = formatFlags(archFlags.c);
 
-                cCompileCmd = `${cCompiler} ${cFlagSegment}-std=c11 -D_DEFAULT_SOURCE -D_BSD_SOURCE -c "${open62541c}" -o "${open62541o}"`;
+            //     cCompileCmd = `${cCompiler} ${cFlagSegment}-std=c11 -D_DEFAULT_SOURCE -D_BSD_SOURCE -c "${open62541c}" -o "${open62541o}"`;
 
-            }
+            // }
 
-            if (cCompileCmd !== "") 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);
@@ -297,18 +302,20 @@ int main() {
                 `"${cppFile}"`,
                 `"${pathTo('nodalis.cpp')}"`,
                 `"${pathTo('modbus.cpp')}"`,
-                `"${pathTo('opcua.cpp')}"`
+                `"${pathTo('opcua.cpp')}"`,
+                `"${pathTo('bacnet.cpp')}"`
             ];
 
-            if (!isWindowsTarget) inputs.push(`"${open62541o}"`);
+            inputs.push(`"${open62541o}"`);
+            inputs.push(`"${bacneta}"`);
 
             if (compiler === 'cl.exe') {
                 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')}"`;
+                cppCompileCmd = `cl.exe /I${bacneti} /I${bacneti}/ports/${isWindowsTarget ? "win32" : "linux"} ${cppFlagSegment}/EHsc /std:c++17 /Fe:"${exeFile}" ` +
+                    `"${cppFile}" "${pathTo('nodalis.cpp')}" "${pathTo('modbus.cpp')}" "${pathTo('opcua.cpp')}" "${pathTo('bacnet.cpp')}"`; //"${pathTo('open62541.obj')}"`;
             } else {
                 const cppFlagSegment = formatFlags(archFlags.cpp);
-                cppCompileCmd = `${compiler} ${cppFlagSegment}-std=c++17 -o "${exeFile}" ${inputs.join(' ')} ${archFlags.linker}`;
+                cppCompileCmd = `${compiler} ${cppFlagSegment}-std=c++17 -I${bacneti} -I${bacneti}/ports/${isWindowsTarget ? "win32" : "linux"} -o "${exeFile}" ${inputs.join(' ')} ${archFlags.linker}`;
             }
 
             execSync(cppCompileCmd, { stdio: 'inherit' });
@@ -443,8 +450,8 @@ int main() {
         };
 
         let linker = {
-            "windows-x64": " -lws2_32 -lcrypt32 -lwsock32 -lole32",
-            "windows-arm64": " -lws2_32 -lcrypt32 -lwsock32 -lole32",
+            "windows-x64": " -lws2_32 -lcrypt32 -lwsock32 -lole32 -liphlpapi",
+            "windows-arm64": " -lws2_32 -lcrypt32 -lwsock32 -lole32 -liphlpapi",
             "linux-x64": "",
             "linux-arm64": "",
             "linux-arm": "",

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

@@ -48,8 +48,8 @@ export function convertExpression(expr, isjsfb = false, jsfbVars = [], isjs=fals
   }
 
   let results = expr
-    .replace(/\bAND\b/gi, '&&')
-    .replace(/\bOR\b/gi, '||')
+    .replace(/\bAND\b/gi, '&')
+    .replace(/\bOR\b/gi, '|')
     .replace(/\bNOT\b/gi, '!')
     .replace(/\bMOD\b/gi, '%')
     .replace(/\bDIV\b/gi, '/')
@@ -78,7 +78,7 @@ export function convertExpression(expr, isjsfb = false, jsfbVars = [], isjs=fals
     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;
+    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;
@@ -94,7 +94,7 @@ export function convertExpression(expr, isjsfb = false, jsfbVars = [], isjs=fals
   }).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 `getBit(${isjs ? "" : "&"}${base}, ${bit})`;
     });
   //}
   

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

@@ -138,8 +138,16 @@ function mapStatement(stmt){
             ...transpileStatements(stmt.body)?.map(s => `  ${s}`),
             `}`
           ];
-        case "CALL":
-          return [stmt.name + "();"];
+      case "CALL": {
+        // If args exist, it's a normal function call: Foo(a, b);
+        if (stmt.args && stmt.args.length) {
+          const argsExpr = convertExpression(stmt.args, infb, fbVars, true);
+          return [`${stmt.name}(${argsExpr});`];
+        }
+
+        // Otherwise treat as FB instance call: FB1();
+        return [stmt.name + "();"];
+      }
         default:
           return [`// unsupported: ${stmt.type}`];
       }

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

@@ -154,13 +154,18 @@ function mapStatement(stmt, infb = false) {
         ];
       }
 
-      case 'CALL':
-        let ext = "";
-        if(infb && fbVars.includes(stmt.name)){
-            ext = "this.";
+      case 'CALL': {
+        // If args exist, it's a normal function call: Foo(a, b);
+        if (stmt.args && stmt.args.length) {
+          const argsExpr = convertExpression(stmt.args, infb, fbVars, true);
+          return [`${stmt.name}(${argsExpr});`];
         }
-        return [`${ext}${stmt.name}.call();`];
 
+      // Otherwise treat as FB instance call: FB1();
+        let ext = "";
+        if (infb && fbVars.includes(stmt.name)) ext = "this.";
+        return [`${ext}${stmt.name}.call();`];
+      }
       default:
         return [`// Unsupported statement type: ${stmt.type}`];
     }

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

@@ -162,13 +162,27 @@ if (peek(i)?.value === ':=') {
   return { type: 'ASSIGN', left: lhs, right };
 }
 
-  // Function block call like: T1();
-  if (token.value && peek(1)?.value === '(' && peek(2)?.value === ')') {
-    const name = consume().value;
-    consume(); // (
-    consume(); // )
+  // Call statement like: Foo(...);
+  if (token.type === 'IDENTIFIER' && peek(1)?.value === '(') {
+    const name = consume().value; // IDENTIFIER
+    consume(); // '('
+
+    const args = [];
+    let depth = 1;
+
+    while (peek() && depth > 0) {
+      const t = consume();
+
+      if (t.value === '(') depth++;
+      else if (t.value === ')') depth--;
+
+      if (depth > 0) args.push(t.value); // don't include final ')'
+    }
+
+  // optional semicolon
     if (peek()?.value === ';') consume();
-    return { type: 'CALL', name };
+
+    return { type: 'CALL', name, args };
   }
 
   consume(); // Skip unknown

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

@@ -36,7 +36,7 @@ export function tokenize(code) {
   code = code.replace(/\(\*[\s\S]*?\*\)/g, '');
 
   //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 = /(%[IQM][A-Z]*\d+(?:\.\d+)?)|(:=|>=|<=|<>|!=)|([A-Za-z_]\w*\.\d+)|([A-Za-z_]\w*\.\w+)|([A-Za-z_]\w*)|(\d+)|([<>+\-*/=;():])/g;
+  const regex = /(%[IQM][A-Z]*\d+(?:\.\d+)?)|(:=|>=|<=|<>|!=)|([A-Za-z_]\w*\.\d+)|([A-Za-z_]\w*\.\w+)|([A-Za-z_]\w*)|(\d+)|([<>+\-*/=;():,])/g;
 
 while ((match = regex.exec(code)) !== null) {
   const [_, address, compoundSymbol, bitIdentifier, propIdentifier, identifier, number, symbol] = match;

package/src/compilers/support/generic/bacnet-stack/bacnet-build.sh

@@ -0,0 +1,215 @@
+#Builds the bacnet-stack static library for macos, linux, and windows in arm, arm64, and x64.
+#This file must be in the root of the bacnet-stack repo to work.
+#Output directories are created under dist/[os]-[arch].
+SCRIPT_DIR=$(printf %s $(CDPATH= cd -- "$(dirname "$0")" && pwd))
+
+#Make for Linux-arm
+DEST=$SCRIPT_DIR/dist/linux-arm
+echo "Making Linux-Arm To $DEST"
+rm -rf $DEST
+mkdir -p $DEST
+make clean
+make library \
+    BACDL=bip \
+    BACNET_PORT=linux \
+    BACNET_LIB_DIR=$DEST \
+    CC=arm-linux-gnueabi-gcc \
+    AR=arm-linux-gnueabi-ar \
+    RANLIB=arm-linux-gnueabi-ranlib
+
+mkdir -p "$DEST/include/bacnet"
+rsync -a --delete \
+      --prune-empty-dirs \
+      --include '*/' \
+      --include '*.h' --include '*.hpp' \
+      --exclude '*' \
+      src/bacnet/ "$DEST/include/bacnet/"
+
+mkdir -p "$DEST/include/ports/linux"
+rsync -a --delete \
+      --prune-empty-dirs \
+      --include '*/' \
+      --include '*.h' --include '*.hpp' \
+      --exclude '*' \
+      ports/linux/ "$DEST/include/ports/linux/"
+
+
+#Make for Linux-arm64
+DEST=$(printf %s "$SCRIPT_DIR/dist/macos-arm64")
+echo "Making Linux-Arm64 To $DEST"
+rm -rf $DEST
+mkdir -p $DEST
+make clean
+make library \
+    BACDL=bip \
+    BACNET_PORT=linux \
+    BACNET_LIB_DIR=$DEST \
+    CC=aarch64-linux-gnu-gcc \
+    AR=aarch64-linux-gnu-ar \
+    RANLIB=aarch64-linux-gnu-ranlib 
+
+mkdir -p "$DEST/include/bacnet"
+rsync -a --delete \
+      --prune-empty-dirs \
+      --include '*/' \
+      --include '*.h' --include '*.hpp' \
+      --exclude '*' \
+      src/bacnet/ "$DEST/include/bacnet/"
+
+mkdir -p "$DEST/include/ports/linux"
+rsync -a --delete \
+      --prune-empty-dirs \
+      --include '*/' \
+      --include '*.h' --include '*.hpp' \
+      --exclude '*' \
+      ports/linux/ "$DEST/include/ports/linux/"
+
+#Make for Linux-x64
+DEST=$SCRIPT_DIR/dist/linux-x64
+echo "Making Linux-x64 To $DEST"
+rm -rf $DEST
+mkdir -p $DEST
+make clean
+make library \
+    BACDL=bip \
+    BACNET_PORT=linux \
+    BACNET_LIB_DIR=$DEST \
+    CC=x86_64-linux-gnu-gcc \
+    AR=x86_64-linux-gnu-ar \
+    RANLIB=x86_64-linux-gnu-ranlib 
+
+mkdir -p "$DEST/include/bacnet"
+rsync -a --delete \
+      --prune-empty-dirs \
+      --include '*/' \
+      --include '*.h' --include '*.hpp' \
+      --exclude '*' \
+      src/bacnet/ "$DEST/include/bacnet/"
+
+mkdir -p "$DEST/include/ports/linux"
+rsync -a --delete \
+      --prune-empty-dirs \
+      --include '*/' \
+      --include '*.h' --include '*.hpp' \
+      --exclude '*' \
+      ports/linux/ "$DEST/include/ports/linux/"
+
+#Make for MacOS arm64
+DEST="$SCRIPT_DIR/dist/macos-arm64"
+echo "Making MacOS arm64 To $DEST"
+rm -rf $DEST
+mkdir -p $DEST
+make clean
+make library \
+    BACDL=bip \
+    BACNET_PORT=bsd \
+    BACNET_LIB_DIR=$DEST \
+    CC="clang -arch arm64" \
+    AR=llvm-ar \
+    RANLIB=llvm-ranlib 
+
+mkdir -p "$DEST/include/bacnet"
+rsync -a --delete \
+      --prune-empty-dirs \
+      --include '*/' \
+      --include '*.h' --include '*.hpp' \
+      --exclude '*' \
+      src/bacnet/ "$DEST/include/bacnet/"
+
+mkdir -p "$DEST/include/ports/bsd"
+rsync -a --delete \
+      --prune-empty-dirs \
+      --include '*/' \
+      --include '*.h' --include '*.hpp' \
+      --exclude '*' \
+      ports/linux/ "$DEST/include/ports/bsd/"
+
+#Make for MacOS x64
+DEST="$SCRIPT_DIR/dist/macos-x64"
+echo "Making MacOS x64 To $DEST"
+rm -rf $DEST
+mkdir -p $DEST
+make clean
+make library \
+    BACDL=bip \
+    BACNET_PORT=bsd \
+    BACNET_LIB_DIR=$DEST \
+    CC="clang -arch x86_64" \
+    AR=llvm-ar \
+    RANLIB=llvm-ranlib 
+
+mkdir -p "$DEST/include/bacnet"
+rsync -a --delete \
+      --prune-empty-dirs \
+      --include '*/' \
+      --include '*.h' --include '*.hpp' \
+      --exclude '*' \
+      src/bacnet/ "$DEST/include/bacnet/"
+
+mkdir -p "$DEST/include/ports/bsd"
+rsync -a --delete \
+      --prune-empty-dirs \
+      --include '*/' \
+      --include '*.h' --include '*.hpp' \
+      --exclude '*' \
+      ports/linux/ "$DEST/include/ports/bsd/"
+
+#Make for Windows x64
+DEST=$SCRIPT_DIR/dist/windows-x64
+echo "Making Windows x64 To $DEST"
+rm -rf $DEST
+mkdir -p $DEST
+make clean
+make library \
+    BACDL=bip \
+    BACNET_PORT=win32 \
+    BACNET_LIB_DIR=$DEST \
+    CC=x86_64-w64-mingw32-gcc \
+    AR=x86_64-w64-mingw32-ar \
+    RANLIB=x86_64-w64-mingw32-ranlib 
+
+mkdir -p "$DEST/include/bacnet"
+rsync -a --delete \
+      --prune-empty-dirs \
+      --include '*/' \
+      --include '*.h' --include '*.hpp' \
+      --exclude '*' \
+      src/bacnet/ "$DEST/include/bacnet/"
+
+mkdir -p "$DEST/include/ports/win32"
+rsync -a --delete \
+      --prune-empty-dirs \
+      --include '*/' \
+      --include '*.h' --include '*.hpp' \
+      --exclude '*' \
+      ports/linux/ "$DEST/include/ports/win32/"
+
+#Make for Windows arm64
+DEST=$SCRIPT_DIR/dist/windows-arm64
+echo "Making Windows arm64 To $DEST"
+rm -rf $DEST
+mkdir -p $DEST
+make clean
+make library \
+    BACDL=bip \
+    BACNET_PORT=win32 \
+    BACNET_LIB_DIR=$DEST \
+    CC=/opt/llvm-mingw/bin/aarch64-w64-mingw32-gcc \
+    AR=/opt/llvm-mingw/bin/aarch64-w64-mingw32-ar \
+    RANLIB=/opt/llvm-mingw/bin/aarch64-w64-mingw32-ranlib
+
+mkdir -p "$DEST/include/bacnet"
+rsync -a --delete \
+      --prune-empty-dirs \
+      --include '*/' \
+      --include '*.h' --include '*.hpp' \
+      --exclude '*' \
+      src/bacnet/ "$DEST/include/bacnet/"
+
+mkdir -p "$DEST/include/ports/win32"
+rsync -a --delete \
+      --prune-empty-dirs \
+      --include '*/' \
+      --include '*.h' --include '*.hpp' \
+      --exclude '*' \
+      ports/linux/ "$DEST/include/ports/win32/"

package/src/compilers/support/generic/bacnet-stack/linux-arm/include/bacnet/abort.h

@@ -0,0 +1,42 @@
+/**
+ * @file
+ * @brief BACnet Abort Reason Encoding and Decoding
+ * @author Steve Karg <skarg@users.sourceforge.net>
+ * @author Peter McShane <petermcs@users.sourceforge.net>
+ * @date 2007
+ * @copyright SPDX-License-Identifier: MIT
+ */
+#ifndef BACNET_ABORT_H
+#define BACNET_ABORT_H
+
+#include <stdint.h>
+#include <stdbool.h>
+/* BACnet Stack defines - first */
+#include "bacnet/bacdef.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+BACNET_STACK_EXPORT
+BACNET_ABORT_REASON abort_convert_error_code(BACNET_ERROR_CODE error_code);
+BACNET_STACK_EXPORT
+bool abort_valid_error_code(BACNET_ERROR_CODE error_code);
+BACNET_STACK_EXPORT
+BACNET_ERROR_CODE abort_convert_to_error_code(BACNET_ABORT_REASON abort_code);
+
+BACNET_STACK_EXPORT
+int abort_encode_apdu(
+    uint8_t *apdu, uint8_t invoke_id, uint8_t abort_reason, bool server);
+
+BACNET_STACK_EXPORT
+int abort_decode_service_request(
+    const uint8_t *apdu,
+    unsigned apdu_len,
+    uint8_t *invoke_id,
+    uint8_t *abort_reason);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif

package/src/compilers/support/generic/bacnet-stack/linux-arm/include/bacnet/access_rule.h

@@ -0,0 +1,61 @@
+/**
+ * @file
+ * @brief BACnetAccessRule service encode and decode
+ * @author Nikola Jelic <nikola.jelic@euroicc.com>
+ * @date 2015
+ * @copyright SPDX-License-Identifier: MIT
+ */
+#ifndef BACNET_ACCESS_RULE_H
+#define BACNET_ACCESS_RULE_H
+
+#include <stdbool.h>
+#include <stdint.h>
+/* BACnet Stack defines - first */
+#include "bacnet/bacdef.h"
+/* BACnet Stack API */
+#include "bacnet/bacdevobjpropref.h"
+
+typedef enum {
+    TIME_RANGE_SPECIFIER_SPECIFIED = 0,
+    TIME_RANGE_SPECIFIER_ALWAYS = 1,
+    TIME_RANGE_SPECIFIER_MAX = 2
+} BACNET_ACCESS_RULE_TIME_RANGE_SPECIFIER;
+
+typedef enum {
+    LOCATION_SPECIFIER_SPECIFIED = 0,
+    LOCATION_SPECIFIER_ALL = 1,
+    LOCATION_SPECIFIER_MAX = 2
+} BACNET_ACCESS_RULE_LOCATION_SPECIFIER;
+
+typedef struct BACnetAccessRule {
+    BACNET_ACCESS_RULE_TIME_RANGE_SPECIFIER time_range_specifier;
+    BACNET_DEVICE_OBJECT_PROPERTY_REFERENCE time_range;
+    BACNET_ACCESS_RULE_LOCATION_SPECIFIER location_specifier;
+    BACNET_DEVICE_OBJECT_REFERENCE location;
+    bool enable;
+} BACNET_ACCESS_RULE;
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+BACNET_STACK_EXPORT
+int bacapp_encode_access_rule(uint8_t *apdu, const BACNET_ACCESS_RULE *rule);
+BACNET_STACK_DEPRECATED("Use bacnet_access_rule_decode() instead")
+BACNET_STACK_EXPORT
+int bacapp_decode_access_rule(const uint8_t *apdu, BACNET_ACCESS_RULE *rule);
+
+BACNET_STACK_EXPORT
+int bacnet_access_rule_decode(
+    const uint8_t *apdu, size_t apdu_size, BACNET_ACCESS_RULE *data);
+
+BACNET_STACK_EXPORT
+bool bacnet_access_rule_from_ascii(BACNET_ACCESS_RULE *value, const char *argv);
+BACNET_STACK_EXPORT
+bool bacnet_access_rule_same(
+    const BACNET_ACCESS_RULE *value1, const BACNET_ACCESS_RULE *value2);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif

package/src/compilers/support/generic/bacnet-stack/linux-arm/include/bacnet/alarm_ack.h

@@ -0,0 +1,58 @@
+/**
+ * @file
+ * @brief BACnetAcknowledgeAlarmInfo service encode and decode
+ * @author John Minack <minack@users.sourceforge.net>
+ * @author Steve Karg <skarg@users.sourceforge.net>
+ * @date 2009
+ * @copyright SPDX-License-Identifier: MIT
+ */
+#ifndef BACNET_ALARM_ACK_H
+#define BACNET_ALARM_ACK_H
+
+#include <stdint.h>
+#include <stdbool.h>
+/* BACnet Stack defines - first */
+#include "bacnet/bacdef.h"
+/* BACnet Stack API */
+#include "bacnet/bacapp.h"
+#include "bacnet/timestamp.h"
+
+typedef struct BACnetAcknowledgeAlarmInfo {
+    uint32_t ackProcessIdentifier;
+    BACNET_OBJECT_ID eventObjectIdentifier;
+    BACNET_EVENT_STATE eventStateAcked;
+    BACNET_TIMESTAMP eventTimeStamp;
+    BACNET_CHARACTER_STRING ackSource;
+    BACNET_TIMESTAMP ackTimeStamp;
+} BACNET_ALARM_ACK_DATA;
+
+/* return +1 if alarm was acknowledged
+   return -1 if any error occurred
+   return -2 abort */
+typedef int (*alarm_ack_function)(
+    BACNET_ALARM_ACK_DATA *alarmack_data, BACNET_ERROR_CODE *error_code);
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+BACNET_STACK_EXPORT
+int alarm_ack_encode_apdu(
+    uint8_t *apdu, uint8_t invoke_id, const BACNET_ALARM_ACK_DATA *data);
+
+BACNET_STACK_EXPORT
+int alarm_ack_encode_service_request(
+    uint8_t *apdu, const BACNET_ALARM_ACK_DATA *data);
+
+BACNET_STACK_EXPORT
+size_t bacnet_acknowledge_alarm_info_request_encode(
+    uint8_t *apdu, size_t apdu_size, const BACNET_ALARM_ACK_DATA *data);
+
+BACNET_STACK_EXPORT
+int alarm_ack_decode_service_request(
+    const uint8_t *apdu, unsigned apdu_len, BACNET_ALARM_ACK_DATA *data);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif