koffi 2.8.10 → 2.9.0-beta.1

package/CHANGELOG.md

@@ -2,12 +2,23 @@
 
 ## Version history
 
+### Koffi 2.9
+
+#### Koffi 2.9.0-beta.1 (2024-07-11)
+
+- Add support for char32_t and wchar_t (wide) strings
+- Include Linux/musl x64 prebuild (based on Alpine)
+
 ### Koffi 2.8
 
-#### Koffi 2.8.10 (2024-06-17)
+#### Koffi 2.8.11 (2024-06-19)
 
 - Work around MSVC compiler bug introduced in Visual Studio 17.10
 
+```{warning}
+Use on platforms without pre-built binaries is broken in Koffi 2.8.10, skip this version.
+```
+
 #### Koffi 2.8.9 (2024-05-17)
 
 - Fix ABI issue regarding bool return values on x86_64 (and possibly other platforms)

package/doc/contribute.md

@@ -72,9 +72,10 @@ These machines are not included directly in this repository (for license and siz
 For example, if you want to run the tests on Debian ARM64, run the following commands:
 
 ```sh
-cd src/koffi/tools/
+cd deploy/qemu/
+
 wget -q -O- https://koromix.dev/files/machines/qemu_debian_arm64.tar.zst | zstd -d | tar xv
-sha256sum -c --ignore-missing registry/sha256sum.txt
+b3sum -c b3sum.txt
 ```
 
 Note that the machine disk content may change each time the machine runs, so the checksum test will fail once a machine has been used at least once.

package/doc/input.md

@@ -18,6 +18,7 @@ int16, int16_t                | Number (integer) | 2     | Signed     |
 uint16, uint16_t              | Number (integer) | 2     | Unsigned   |
 short                         | Number (integer) | 2     | Signed     |
 ushort, unsigned short        | Number (integer) | 2     | Unsigned   |
+char32, char32_t              | Number (integer) | 4     | Signed     |
 int32, int32_t                | Number (integer) | 4     | Signed     |
 uint32, uint32_t              | Number (integer) | 4     | Unsigned   |
 int                           | Number (integer) | 4     | Signed     |
@@ -35,18 +36,20 @@ Koffi also accepts BigInt values when converting from JS to C integers. If the v
 
 Koffi defines a few more types that can change size depending on the OS and the architecture:
 
-C type           | JS type          | Signedness | Note
----------------- | ---------------- | ---------- | ------------------------------------------------
-bool             | Boolean          |            | Usually one byte
-long             | Number (integer) | Signed     | 4 or 8 bytes depending on platform (LP64, LLP64)
-ulong            | Number (integer) | Unsigned   | 4 or 8 bytes depending on platform (LP64, LLP64)
-unsigned long    | Number (integer) | Unsigned   | 4 or 8 bytes depending on platform (LP64, LLP64)
-intptr           | Number (integer) | Signed     | 4 or 8 bytes depending on register width
-intptr_t         | Number (integer) | Signed     | 4 or 8 bytes depending on register width
-uintptr          | Number (integer) | Unsigned   | 4 or 8 bytes depending on register width
-uintptr_t        | Number (integer) | Unsigned   | 4 or 8 bytes depending on register width
-str, string      | String           |            | JS strings are converted to and from UTF-8
-str16, string16  | String           |            | JS strings are converted to and from UTF-16 (LE)
+C type           | JS type          | Signedness  | Note
+---------------- | ---------------- | ----------- | ------------------------------------------------
+bool             | Boolean          |             | Usually one byte
+long             | Number (integer) | Signed      | 4 or 8 bytes depending on platform (LP64, LLP64)
+ulong            | Number (integer) | Unsigned    | 4 or 8 bytes depending on platform (LP64, LLP64)
+unsigned long    | Number (integer) | Unsigned    | 4 or 8 bytes depending on platform (LP64, LLP64)
+intptr           | Number (integer) | Signed      | 4 or 8 bytes depending on register width
+intptr_t         | Number (integer) | Signed      | 4 or 8 bytes depending on register width
+uintptr          | Number (integer) | Unsigned    | 4 or 8 bytes depending on register width
+uintptr_t        | Number (integer) | Unsigned    | 4 or 8 bytes depending on register width
+wchar_t          | Number (integer) | *Undefined* | 2 bytes on Windows, 4 bytes Linux, macOS and BSD
+str, string      | String           |             | JS strings are converted to and from UTF-8
+str16, string16  | String           |             | JS strings are converted to and from UTF-16 (LE)
+str32, string32  | String           |             | JS strings are converted to and from UTF-32 (LE)
 
 Primitive types can be specified by name (in a string) or through `koffi.types`:
 
@@ -384,12 +387,19 @@ The short C-like syntax was introduced in Koffi 2.7.1, use `koffi.array()` for o
 
 ### Fixed-size string buffers
 
+*Changed in Koffi 2.9.0*
+
 Koffi can also convert JS strings to fixed-sized arrays in the following cases:
 
 - **char arrays** are filled with the UTF-8 encoded string, truncated if needed. The buffer is always NUL-terminated.
 - **char16 (or char16_t) arrays** are filled with the UTF-16 encoded string, truncated if needed. The buffer is always NUL-terminated.
+- **char32 (or char32_t) arrays** are filled with the UTF-32 encoded string, truncated if needed. The buffer is always NUL-terminated.
+
+```{note}
+Support for UTF-32 and wchar_t (wide) strings was introduced in Koffi 2.9.0.
+```
 
-The reverse case is also true, Koffi can convert a C fixed-size buffer to a JS string. This happens by default for char, char16 and char16_t arrays, but you can also explicitly ask for this with the `String` array hint (e.g. `koffi.array('char', 8, 'String')`).
+The reverse case is also true, Koffi can convert a C fixed-size buffer to a JS string. This happens by default for char, char16_t and char32_t arrays, but you can also explicitly ask for this with the `String` array hint (e.g. `koffi.array('char', 8, 'String')`).
 
 ### Dynamic arrays (pointers)
 

package/index.js

@@ -1,7 +1,7 @@
 "use strict";
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+var __commonJS = (cb, mod3) => function __require() {
+  return mod3 || (0, cb[__getOwnPropNames(cb)[0]])((mod3 = { exports: {} }).exports, mod3), mod3.exports;
 };
 
 // ../../bin/Koffi/package/src/cnoke/src/tools.js
@@ -11,7 +11,7 @@ var require_tools = __commonJS({
     var crypto = require("crypto");
     var fs2 = require("fs");
     var http = require("https");
-    var path = require("path");
+    var path2 = require("path");
     var zlib = require("zlib");
     async function download_http(url, dest) {
       console.log(">> Downloading " + url);
@@ -107,7 +107,7 @@ var require_tools = __commonJS({
               data = data.subarray(0, header.size);
               if (header.type == "0" || header.type == "7") {
                 let filename3 = dest_dir + "/" + header.filename;
-                let dirname = path.dirname(filename3);
+                let dirname = path2.dirname(filename3);
                 fs2.mkdirSync(dirname, { recursive: true, mode: 493 });
                 fs2.writeFileSync(filename3, data, { mode: header.mode });
               } else if (header.type == "5") {
@@ -151,21 +151,21 @@ var require_tools = __commonJS({
         reader.on("end", resolve);
       });
     }
-    function path_is_absolute(path2) {
-      if (process.platform == "win32" && path2.match(/^[a-zA-Z]:/))
-        path2 = path2.substr(2);
-      return is_path_separator(path2[0]);
+    function path_is_absolute(path3) {
+      if (process.platform == "win32" && path3.match(/^[a-zA-Z]:/))
+        path3 = path3.substr(2);
+      return is_path_separator(path3[0]);
     }
-    function path_has_dotdot(path2) {
+    function path_has_dotdot(path3) {
       let start = 0;
       for (; ; ) {
-        let offset = path2.indexOf("..", start);
+        let offset = path3.indexOf("..", start);
         if (offset < 0)
           break;
         start = offset + 2;
-        if (offset && !is_path_separator(path2[offset - 1]))
+        if (offset && !is_path_separator(path3[offset - 1]))
           continue;
-        if (offset + 2 < path2.length && !is_path_separator(path2[offset + 2]))
+        if (offset + 2 < path3.length && !is_path_separator(path3[offset + 2]))
           continue;
         return true;
       }
@@ -179,8 +179,8 @@ var require_tools = __commonJS({
       return false;
     }
     function determine_arch2() {
-      let arch2 = process.arch;
-      if (arch2 == "riscv32" || arch2 == "riscv64") {
+      let arch = process.arch;
+      if (arch == "riscv32" || arch == "riscv64") {
         let buf = read_file_header(process.execPath, 512);
         let header = decode_elf_header(buf);
         let float_abi = header.e_flags & 6;
@@ -191,32 +191,32 @@ var require_tools = __commonJS({
             break;
           case 2:
             {
-              arch2 += "f";
+              arch += "f";
             }
             break;
           case 4:
             {
-              arch2 += "d";
+              arch += "d";
             }
             break;
           case 6:
             {
-              arch2 += "q";
+              arch += "q";
             }
             break;
         }
-      } else if (arch2 == "arm") {
+      } else if (arch == "arm") {
         let buf = read_file_header(process.execPath, 512);
         let header = decode_elf_header(buf);
         if (header.e_flags & 1024) {
-          arch2 += "hf";
+          arch += "hf";
         } else if (header.e_flags & 512) {
-          arch2 += "sf";
+          arch += "sf";
         } else {
           throw new Error("Unknown ARM floating-point ABI");
         }
       }
-      return arch2;
+      return arch;
     }
     function read_file_header(filename2, read) {
       let fd = null;
@@ -305,12 +305,12 @@ var require_tools = __commonJS({
       }
       return header;
     }
-    function unlink_recursive(path2) {
+    function unlink_recursive(path3) {
       try {
         if (fs2.rmSync != null) {
-          fs2.rmSync(path2, { recursive: true, maxRetries: process.platform == "win32" ? 3 : 0 });
+          fs2.rmSync(path3, { recursive: true, maxRetries: process.platform == "win32" ? 3 : 0 });
         } else {
-          fs2.rmdirSync(path2, { recursive: true, maxRetries: process.platform == "win32" ? 3 : 0 });
+          fs2.rmdirSync(path3, { recursive: true, maxRetries: process.platform == "win32" ? 3 : 0 });
         }
       } catch (err) {
         if (err.code !== "ENOENT")
@@ -363,8 +363,8 @@ var require_package = __commonJS({
   "../../bin/Koffi/package/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.8.10",
-      stable: "2.8.10",
+      version: "2.9.0-beta.1",
+      stable: "2.8.11",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",
@@ -408,141 +408,204 @@ var require_package = __commonJS({
   }
 });
 
-// ../../bin/Koffi/package/src/koffi/index.js
-var util = require("util");
-var fs = require("fs");
-var { get_napi_version, determine_arch } = require_tools();
-var pkg = require_package();
-if (process.versions.napi == null || process.versions.napi < pkg.cnoke.napi) {
-  let major = parseInt(process.versions.node, 10);
-  let required = get_napi_version(pkg.cnoke.napi, major);
-  if (required != null) {
-    throw new Error(`This engine is based on Node ${process.versions.node}, but ${pkg.name} requires Node >= ${required} in the Node ${major}.x branch (N-API >= ${pkg.cnoke.napi})`);
-  } else {
-    throw new Error(`This engine is based on Node ${process.versions.node}, but ${pkg.name} does not support the Node ${major}.x branch (N-API < ${pkg.cnoke.napi})`);
+// ../../bin/Koffi/package/src/koffi/src/init.js
+var require_init = __commonJS({
+  "../../bin/Koffi/package/src/koffi/src/init.js"(exports, module) {
+    var fs = require("fs");
+    var path = require("path");
+    var util = require("util");
+    var { get_napi_version, determine_arch } = require_tools();
+    var pkg = require_package();
+    function detect() {
+      if (process.versions.napi == null || process.versions.napi < pkg.cnoke.napi) {
+        let major = parseInt(process.versions.node, 10);
+        let required = get_napi_version(pkg.cnoke.napi, major);
+        if (required != null) {
+          throw new Error(`This engine is based on Node ${process.versions.node}, but ${pkg.name} requires Node >= ${required} in the Node ${major}.x branch (N-API >= ${pkg.cnoke.napi})`);
+        } else {
+          throw new Error(`This engine is based on Node ${process.versions.node}, but ${pkg.name} does not support the Node ${major}.x branch (N-API < ${pkg.cnoke.napi})`);
+        }
+      }
+      let arch = determine_arch();
+      let triplet3 = `${process.platform}_${arch}`;
+      return triplet3;
+    }
+    function init(triplet, native) {
+      if (native == null) {
+        let roots = [path.join(__dirname, "..")];
+        let triplets = [triplet];
+        if (process.resourcesPath != null)
+          roots.push(process.resourcesPath);
+        if (triplet.startsWith("linux_")) {
+          let musl = triplet.replace(/^linux_/, "musl_");
+          triplets.push(musl);
+        }
+        let filenames = roots.flatMap((root) => triplets.flatMap((triplet3) => [
+          `${root}/build/koffi/${triplet3}/koffi.node`,
+          `${root}/koffi/${triplet3}/koffi.node`,
+          `${root}/node_modules/koffi/build/koffi/${triplet3}/koffi.node`,
+          `${root}/../../bin/Koffi/${triplet3}/koffi.node`
+        ]));
+        let first_err = null;
+        for (let filename of filenames) {
+          if (!fs.existsSync(filename))
+            continue;
+          try {
+            native = eval("require")(filename);
+          } catch (err) {
+            if (first_err == null)
+              first_err = err;
+            continue;
+          }
+          break;
+        }
+        if (first_err != null)
+          throw first_err;
+      }
+      if (native == null)
+        throw new Error("Cannot find the native Koffi module; did you bundle it correctly?");
+      if (native.version != pkg.version)
+        throw new Error("Mismatched native Koffi modules");
+      let mod = wrap(native);
+      return mod;
+    }
+    function wrap(native3) {
+      let obj = {
+        ...native3,
+        // Deprecated functions
+        handle: util.deprecate(native3.opaque, "The koffi.handle() function was deprecated in Koffi 2.1, use koffi.opaque() instead", "KOFFI001"),
+        callback: util.deprecate(native3.proto, "The koffi.callback() function was deprecated in Koffi 2.4, use koffi.proto() instead", "KOFFI002")
+      };
+      obj.load = (...args) => {
+        let lib = native3.load(...args);
+        lib.cdecl = util.deprecate((...args2) => lib.func("__cdecl", ...args2), "The koffi.cdecl() function was deprecated in Koffi 2.7, use koffi.func(...) instead", "KOFFI003");
+        lib.stdcall = util.deprecate((...args2) => lib.func("__stdcall", ...args2), 'The koffi.stdcall() function was deprecated in Koffi 2.7, use koffi.func("__stdcall", ...) instead', "KOFFI004");
+        lib.fastcall = util.deprecate((...args2) => lib.func("__fastcall", ...args2), 'The koffi.fastcall() function was deprecated in Koffi 2.7, use koffi.func("__fastcall", ...) instead', "KOFFI005");
+        lib.thiscall = util.deprecate((...args2) => lib.func("__thiscall", ...args2), 'The koffi.thiscall() function was deprecated in Koffi 2.7, use koffi.func("__thiscall", ...) instead', "KOFFI006");
+        return lib;
+      };
+      return obj;
+    }
+    module.exports = {
+      detect,
+      init
+    };
   }
-}
-var arch = determine_arch();
-var triplet = `${process.platform}_${arch}`;
-var native = null;
+});
+
+// ../../bin/Koffi/package/src/koffi/index.js
+var { detect: detect2, init: init2 } = require_init();
+var triplet2 = detect2();
+var native2 = null;
 try {
-  switch (triplet) {
+  switch (triplet2) {
     case "darwin_arm64":
       {
-        native = require("./build/koffi/darwin_arm64/koffi.node");
+        native2 = require("./build/koffi/darwin_arm64/koffi.node");
       }
       break;
     case "darwin_x64":
       {
-        native = require("./build/koffi/darwin_x64/koffi.node");
+        native2 = require("./build/koffi/darwin_x64/koffi.node");
       }
       break;
     case "freebsd_arm64":
       {
-        native = require("./build/koffi/freebsd_arm64/koffi.node");
+        native2 = require("./build/koffi/freebsd_arm64/koffi.node");
       }
       break;
     case "freebsd_ia32":
       {
-        native = require("./build/koffi/freebsd_ia32/koffi.node");
+        native2 = require("./build/koffi/freebsd_ia32/koffi.node");
       }
       break;
     case "freebsd_x64":
       {
-        native = require("./build/koffi/freebsd_x64/koffi.node");
+        native2 = require("./build/koffi/freebsd_x64/koffi.node");
       }
       break;
     case "linux_armhf":
       {
-        native = require("./build/koffi/linux_armhf/koffi.node");
+        native2 = require("./build/koffi/linux_armhf/koffi.node");
       }
       break;
     case "linux_arm64":
       {
-        native = require("./build/koffi/linux_arm64/koffi.node");
+        native2 = require("./build/koffi/linux_arm64/koffi.node");
       }
       break;
     case "linux_ia32":
       {
-        native = require("./build/koffi/linux_ia32/koffi.node");
+        native2 = require("./build/koffi/linux_ia32/koffi.node");
       }
       break;
     case "linux_riscv64d":
       {
-        native = require("./build/koffi/linux_riscv64d/koffi.node");
+        native2 = require("./build/koffi/linux_riscv64d/koffi.node");
       }
       break;
     case "linux_x64":
       {
-        native = require("./build/koffi/linux_x64/koffi.node");
+        native2 = require("./build/koffi/linux_x64/koffi.node");
       }
       break;
     case "openbsd_ia32":
       {
-        native = require("./build/koffi/openbsd_ia32/koffi.node");
+        native2 = require("./build/koffi/openbsd_ia32/koffi.node");
       }
       break;
     case "openbsd_x64":
       {
-        native = require("./build/koffi/openbsd_x64/koffi.node");
+        native2 = require("./build/koffi/openbsd_x64/koffi.node");
       }
       break;
     case "win32_arm64":
       {
-        native = require("./build/koffi/win32_arm64/koffi.node");
+        native2 = require("./build/koffi/win32_arm64/koffi.node");
       }
       break;
     case "win32_ia32":
       {
-        native = require("./build/koffi/win32_ia32/koffi.node");
+        native2 = require("./build/koffi/win32_ia32/koffi.node");
       }
       break;
     case "win32_x64":
       {
-        native = require("./build/koffi/win32_x64/koffi.node");
+        native2 = require("./build/koffi/win32_x64/koffi.node");
       }
       break;
   }
-} catch (err) {
-}
-if (native == null) {
-  let roots = [__dirname];
-  if (process.resourcesPath != null)
-    roots.push(process.resourcesPath);
-  let names = [
-    `/build/koffi/${process.platform}_${arch}/koffi.node`,
-    `/koffi/${process.platform}_${arch}/koffi.node`,
-    `/node_modules/koffi/build/koffi/${process.platform}_${arch}/koffi.node`,
-    `/../../bin/Koffi/${process.platform}_${arch}/koffi.node`
-  ];
-  for (let root of roots) {
-    for (let name of names) {
-      let filename = root + name;
-      if (fs.existsSync(filename)) {
-        native = eval("require")(filename);
+} catch {
+  try {
+    switch (triplet2) {
+      case "linux_armhf":
+        {
+          native2 = require("./build/koffi/musl_armhf/koffi.node");
+        }
+        break;
+      case "linux_arm64":
+        {
+          native2 = require("./build/koffi/musl_arm64/koffi.node");
+        }
+        break;
+      case "linux_ia32":
+        {
+          native2 = require("./build/koffi/musl_ia32/koffi.node");
+        }
+        break;
+      case "linux_riscv64d":
+        {
+          native2 = require("./build/koffi/musl_riscv64d/koffi.node");
+        }
+        break;
+      case "linux_x64":
+        {
+          native2 = require("./build/koffi/musl_x64/koffi.node");
+        }
         break;
-      }
     }
-    if (native != null)
-      break;
+  } catch {
   }
 }
-if (native == null)
-  throw new Error("Cannot find the native Koffi module; did you bundle it correctly?");
-if (native.version != pkg.version)
-  throw new Error("Mismatched native Koffi modules");
-module.exports = {
-  ...native,
-  // Deprecated functions
-  handle: util.deprecate(native.opaque, "The koffi.handle() function was deprecated in Koffi 2.1, use koffi.opaque() instead", "KOFFI001"),
-  callback: util.deprecate(native.proto, "The koffi.callback() function was deprecated in Koffi 2.4, use koffi.proto() instead", "KOFFI002")
-};
-var load = module.exports.load;
-module.exports.load = (...args) => {
-  let lib = load(...args);
-  lib.cdecl = util.deprecate((...args2) => lib.func("__cdecl", ...args2), "The koffi.stdcall() function was deprecated in Koffi 2.7, use koffi.func(...) instead", "KOFFI003");
-  lib.stdcall = util.deprecate((...args2) => lib.func("__stdcall", ...args2), 'The koffi.stdcall() function was deprecated in Koffi 2.7, use koffi.func("__stdcall", ...) instead', "KOFFI004");
-  lib.fastcall = util.deprecate((...args2) => lib.func("__fastcall", ...args2), 'The koffi.fastcall() function was deprecated in Koffi 2.7, use koffi.func("__fastcall", ...) instead', "KOFFI005");
-  lib.thiscall = util.deprecate((...args2) => lib.func("__thiscall", ...args2), 'The koffi.thiscall() function was deprecated in Koffi 2.7, use koffi.func("__thiscall", ...) instead', "KOFFI006");
-  return lib;
-};
+var mod2 = init2(triplet2, native2);
+module.exports = mod2;