koffi 2.8.11 → 2.9.0-beta.1

package/indirect.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,61 +408,93 @@ var require_package = __commonJS({
   }
 });
 
-// ../../bin/Koffi/package/src/koffi/indirect.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})`);
-  }
-}
-var arch = determine_arch();
-var triplet = `${process.platform}_${arch}`;
-var 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);
-        break;
+// ../../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;
     }
-    if (native != null)
-      break;
+    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(native2) {
+      let obj = {
+        ...native2,
+        // Deprecated functions
+        handle: util.deprecate(native2.opaque, "The koffi.handle() function was deprecated in Koffi 2.1, use koffi.opaque() instead", "KOFFI001"),
+        callback: util.deprecate(native2.proto, "The koffi.callback() function was deprecated in Koffi 2.4, use koffi.proto() instead", "KOFFI002")
+      };
+      obj.load = (...args) => {
+        let lib = native2.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
+    };
   }
-}
-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;
-};
+});
+
+// ../../bin/Koffi/package/src/koffi/indirect.js
+var { detect: detect2, init: init2 } = require_init();
+var triplet2 = detect2();
+var mod2 = init2(triplet2, null);
+module.exports = mod2;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "koffi",
-    "version": "2.8.11",
+    "version": "2.9.0-beta.1",
     "stable": "2.8.11",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [
@@ -35,4 +35,4 @@
         "napi": 8,
         "require": "./index.js"
     }
-}
+}

package/src/koffi/CMakeLists.txt

@@ -50,7 +50,17 @@ endif()
 
 # ---- Koffi ----
 
-set(KOFFI_VERSION 2.8.10)
+# Recompute the version string after each commit
+if(EXISTS "${CMAKE_SOURCE_DIR}/../../.git/logs/HEAD")
+    configure_file("${CMAKE_SOURCE_DIR}/../../.git/logs/HEAD" git_logs_HEAD COPYONLY)
+endif()
+if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/package.json)
+    file(READ ${CMAKE_CURRENT_SOURCE_DIR}/package.json PKG)
+else()
+    file(READ ${CMAKE_CURRENT_SOURCE_DIR}/../../package.json PKG)
+endif()
+string(REGEX MATCH "\"version\": \"([^\"]+)\"" XX "${PKG}")
+set(KOFFI_VERSION ${CMAKE_MATCH_1})
 
 set_source_files_properties(src/ffi.cc PROPERTIES COMPILE_DEFINITIONS VERSION=${KOFFI_VERSION})
 

package/src/koffi/src/abi_arm32.cc

@@ -125,6 +125,7 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
             case PrimitiveKind::UInt32S:
             case PrimitiveKind::String:
             case PrimitiveKind::String16:
+            case PrimitiveKind::String32:
             case PrimitiveKind::Pointer:
             case PrimitiveKind::Callback: {
                 if (gpr_avail) {
@@ -343,6 +344,13 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 
                 *(const char16_t **)((param.gpr_count ? gpr_ptr : args_ptr)++) = str16;
             } break;
+            case PrimitiveKind::String32: {
+                const char32_t *str32;
+                if (!PushString32(value, param.directions, &str32)) [[unlikely]]
+                    return false;
+
+                *(const char32_t **)((param.gpr_count ? gpr_ptr : args_ptr)++) = str32;
+            } break;
             case PrimitiveKind::Pointer: {
                 void *ptr;
                 if (!PushPointer(value, param.type, param.directions, &ptr)) [[unlikely]]
@@ -485,6 +493,7 @@ void CallData::Execute(const FunctionInfo *func, void *native)
         case PrimitiveKind::UInt64S:
         case PrimitiveKind::String:
         case PrimitiveKind::String16:
+        case PrimitiveKind::String32:
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Callback: { result.u64 = PERFORM_CALL(GG); } break;
         case PrimitiveKind::Record:
@@ -535,6 +544,7 @@ Napi::Value CallData::Complete(const FunctionInfo *func)
         case PrimitiveKind::UInt64S: return NewBigInt(env, ReverseBytes(result.u64));
         case PrimitiveKind::String: return result.ptr ? Napi::String::New(env, (const char *)result.ptr) : env.Null();
         case PrimitiveKind::String16: return result.ptr ? Napi::String::New(env, (const char16_t *)result.ptr) : env.Null();
+        case PrimitiveKind::String32: return result.ptr ? MakeStringFromUTF32(env, (const char32_t *)result.ptr) : env.Null();
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Callback: {
             if (result.ptr) {
@@ -726,6 +736,12 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool switch_
                     param.type->dispose(env, param.type, str16);
                 }
             } break;
+            case PrimitiveKind::String32: {
+                const char32_t *str32 = *(const char32_t **)((param.gpr_count ? gpr_ptr : args_ptr)++);
+
+                Napi::Value arg = str32 ? MakeStringFromUTF32(env, str32) : env.Null();
+                arguments.Append(arg);
+            } break;
             case PrimitiveKind::Pointer:
             case PrimitiveKind::Callback: {
                 void *ptr2 = *(void **)((param.gpr_count ? gpr_ptr : args_ptr)++);
@@ -923,6 +939,13 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool switch_
 
             out_reg->r0 = (uint32_t)str16;
         } break;
+        case PrimitiveKind::String32: {
+            const char32_t *str32;
+            if (!PushString32(value, 1, &str32)) [[unlikely]]
+                return;
+
+            out_reg->r0 = (uint32_t)str32;
+        } break;
         case PrimitiveKind::Pointer: {
             uint8_t *ptr;
 

package/src/koffi/src/abi_arm64.cc

@@ -162,6 +162,7 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
             case PrimitiveKind::UInt64S:
             case PrimitiveKind::String:
             case PrimitiveKind::String16:
+            case PrimitiveKind::String32:
             case PrimitiveKind::Pointer:
             case PrimitiveKind::Callback: {
 #ifdef __APPLE__
@@ -415,6 +416,16 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 #endif
                 *(const char16_t **)((param.gpr_count ? gpr_ptr : args_ptr)++) = str16;
             } break;
+            case PrimitiveKind::String32: {
+                const char32_t *str32;
+                if (!PushString32(value, param.directions, &str32)) [[unlikely]]
+                    return false;
+
+#if defined(__APPLE__)
+                args_ptr = param.gpr_count ? args_ptr : AlignUp(args_ptr, 8);
+#endif
+                *(const char32_t **)((param.gpr_count ? gpr_ptr : args_ptr)++) = str32;
+            } break;
             case PrimitiveKind::Pointer: {
                 void *ptr;
                 if (!PushPointer(value, param.type, param.directions, &ptr)) [[unlikely]]
@@ -618,6 +629,7 @@ void CallData::Execute(const FunctionInfo *func, void *native)
         case PrimitiveKind::UInt64S:
         case PrimitiveKind::String:
         case PrimitiveKind::String16:
+        case PrimitiveKind::String32:
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Callback: { result.u64 = PERFORM_CALL(GG).x0; } break;
         case PrimitiveKind::Record:
@@ -671,6 +683,7 @@ Napi::Value CallData::Complete(const FunctionInfo *func)
         case PrimitiveKind::UInt64S: return NewBigInt(env, ReverseBytes(result.u64));
         case PrimitiveKind::String: return result.ptr ? Napi::String::New(env, (const char *)result.ptr) : env.Null();
         case PrimitiveKind::String16: return result.ptr ? Napi::String::New(env, (const char16_t *)result.ptr) : env.Null();
+        case PrimitiveKind::String32: return result.ptr ? MakeStringFromUTF32(env, (const char32_t *)result.ptr) : env.Null();
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Callback: {
             if (result.ptr) {
@@ -1034,6 +1047,16 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool switch_
                     param.type->dispose(env, param.type, str16);
                 }
             } break;
+            case PrimitiveKind::String32: {
+#if defined(__APPLE__)
+                args_ptr = AlignUp(args_ptr, 8);
+#endif
+
+                const char32_t *str32 = *(const char32_t **)((param.gpr_count ? gpr_ptr : args_ptr)++);
+
+                Napi::Value arg = str32 ? MakeStringFromUTF32(env, str32) : env.Null();
+                arguments.Append(arg);
+            } break;
             case PrimitiveKind::Pointer:
             case PrimitiveKind::Callback: {
 #ifdef __APPLE__
@@ -1215,6 +1238,13 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool switch_
 
             out_reg->x0 = (uint64_t)str16;
         } break;
+        case PrimitiveKind::String32: {
+            const char32_t *str32;
+            if (!PushString32(value, 1, &str32)) [[unlikely]]
+                return;
+
+            out_reg->x0 = (uint64_t)str32;
+        } break;
         case PrimitiveKind::Pointer: {
             uint8_t *ptr;
 

package/src/koffi/src/abi_riscv64.cc

@@ -252,6 +252,13 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 
                 *(const char16_t **)((param.gpr_count ? gpr_ptr : args_ptr)++) = str16;
             } break;
+            case PrimitiveKind::String32: {
+                const char32_t *str32;
+                if (!PushString32(value, param.directions, &str32)) [[unlikely]]
+                    return false;
+
+                *(const char32_t **)((param.gpr_count ? gpr_ptr : args_ptr)++) = str32;
+            } break;
             case PrimitiveKind::Pointer: {
                 void *ptr;
                 if (!PushPointer(value, param.type, param.directions, &ptr)) [[unlikely]]
@@ -415,6 +422,7 @@ void CallData::Execute(const FunctionInfo *func, void *native)
         case PrimitiveKind::UInt64S:
         case PrimitiveKind::String:
         case PrimitiveKind::String16:
+        case PrimitiveKind::String32:
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Callback: { result.u64 = PERFORM_CALL(GG).a0; } break;
         case PrimitiveKind::Record:
@@ -472,6 +480,7 @@ Napi::Value CallData::Complete(const FunctionInfo *func)
         case PrimitiveKind::UInt64S: return NewBigInt(env, ReverseBytes(result.u64));
         case PrimitiveKind::String: return result.ptr ? Napi::String::New(env, (const char *)result.ptr) : env.Null();
         case PrimitiveKind::String16: return result.ptr ? Napi::String::New(env, (const char16_t *)result.ptr) : env.Null();
+        case PrimitiveKind::String32: return result.ptr ? MakeStringFromUTF32(env, (const char32_t *)result.ptr) : env.Null();
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Callback: {
             if (result.ptr) {
@@ -656,6 +665,12 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool switch_
                     param.type->dispose(env, param.type, str16);
                 }
             } break;
+            case PrimitiveKind::String32: {
+                const char32_t *str32 = *(const char32_t **)((param.gpr_count ? gpr_ptr : args_ptr)++);
+
+                Napi::Value arg = str32 ? MakeStringFromUTF32(env, str32) : env.Null();
+                arguments.Append(arg);
+            } break;
             case PrimitiveKind::Pointer:
             case PrimitiveKind::Callback: {
                 void *ptr2 = *(void **)((param.gpr_count ? gpr_ptr : args_ptr)++);
@@ -812,6 +827,13 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool switch_
 
             out_reg->a0 = (uint64_t)str16;
         } break;
+        case PrimitiveKind::String32: {
+            const char32_t *str32;
+            if (!PushString32(value, 1, &str32)) [[unlikely]]
+                return;
+
+            out_reg->a0 = (uint64_t)str32;
+        } break;
         case PrimitiveKind::Pointer: {
             uint8_t *ptr;
 

package/src/koffi/src/abi_x64_sysv.cc

@@ -121,6 +121,7 @@ static Size ClassifyType(const TypeInfo *type, Size offset, Span<RegisterClass>
         case PrimitiveKind::UInt64S:
         case PrimitiveKind::String:
         case PrimitiveKind::String16:
+        case PrimitiveKind::String32:
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Callback: {
             classes[0] = MergeClasses(classes[0], RegisterClass::Integer);
@@ -326,6 +327,13 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 
                 *(const char16_t **)((param.gpr_count ? gpr_ptr : args_ptr)++) = str16;
             } break;
+            case PrimitiveKind::String32: {
+                const char32_t *str32;
+                if (!PushString32(value, param.directions, &str32)) [[unlikely]]
+                    return false;
+
+                *(const char32_t **)((param.gpr_count ? gpr_ptr : args_ptr)++) = str32;
+            } break;
             case PrimitiveKind::Pointer: {
                 void *ptr;
                 if (!PushPointer(value, param.type, param.directions, &ptr)) [[unlikely]]
@@ -455,6 +463,7 @@ void CallData::Execute(const FunctionInfo *func, void *native)
         case PrimitiveKind::UInt64S:
         case PrimitiveKind::String:
         case PrimitiveKind::String16:
+        case PrimitiveKind::String32:
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Callback: { result.u64 = PERFORM_CALL(GG).rax; } break;
         case PrimitiveKind::Record:
@@ -512,6 +521,7 @@ Napi::Value CallData::Complete(const FunctionInfo *func)
         case PrimitiveKind::UInt64S: return NewBigInt(env, ReverseBytes(result.u64));
         case PrimitiveKind::String: return result.ptr ? Napi::String::New(env, (const char *)result.ptr) : env.Null();
         case PrimitiveKind::String16: return result.ptr ? Napi::String::New(env, (const char16_t *)result.ptr) : env.Null();
+        case PrimitiveKind::String32: return result.ptr ? MakeStringFromUTF32(env, (const char32_t *)result.ptr) : env.Null();
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Callback: {
             if (result.ptr) {
@@ -691,6 +701,12 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool switch_
                     param.type->dispose(env, param.type, str16);
                 }
             } break;
+            case PrimitiveKind::String32: {
+                const char32_t *str32 = *(const char32_t **)((param.gpr_count ? gpr_ptr : args_ptr)++);
+
+                Napi::Value arg = str32 ? MakeStringFromUTF32(env, str32) : env.Null();
+                arguments.Append(arg);
+            } break;
             case PrimitiveKind::Pointer:
             case PrimitiveKind::Callback: {
                 void *ptr2 = *(void **)((param.gpr_count ? gpr_ptr : args_ptr)++);
@@ -836,6 +852,13 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool switch_
 
             out_reg->rax = (uint64_t)str16;
         } break;
+        case PrimitiveKind::String32: {
+            const char32_t *str32;
+            if (!PushString32(value, 1, &str32)) [[unlikely]]
+                return;
+
+            out_reg->rax = (uint64_t)str32;
+        } break;
         case PrimitiveKind::Pointer: {
             uint8_t *ptr;
 

package/src/koffi/src/abi_x64_win.cc

@@ -144,6 +144,13 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
 
                 *(const char16_t **)(args_ptr++) = str16;
             } break;
+            case PrimitiveKind::String32: {
+                const char32_t *str32;
+                if (!PushString32(value, param.directions, &str32)) [[unlikely]]
+                    return false;
+
+                *(const char32_t **)(args_ptr++) = str32;
+            } break;
             case PrimitiveKind::Pointer: {
                 void *ptr;
                 if (!PushPointer(value, param.type, param.directions, &ptr)) [[unlikely]]
@@ -281,6 +288,7 @@ void CallData::Execute(const FunctionInfo *func, void *native)
         case PrimitiveKind::UInt64S:
         case PrimitiveKind::String:
         case PrimitiveKind::String16:
+        case PrimitiveKind::String32:
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Record:
         case PrimitiveKind::Union:
@@ -324,6 +332,7 @@ Napi::Value CallData::Complete(const FunctionInfo *func)
         case PrimitiveKind::UInt64S: return NewBigInt(env, ReverseBytes(result.u64));
         case PrimitiveKind::String: return result.ptr ? Napi::String::New(env, (const char *)result.ptr) : env.Null();
         case PrimitiveKind::String16: return result.ptr ? Napi::String::New(env, (const char16_t *)result.ptr) : env.Null();
+        case PrimitiveKind::String32: return result.ptr ? MakeStringFromUTF32(env, (const char32_t *)result.ptr) : env.Null();
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Callback: {
             if (result.ptr) {
@@ -535,6 +544,13 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool switch_
                     param.type->dispose(env, param.type, str16);
                 }
             } break;
+            case PrimitiveKind::String32: {
+                const char32_t *str32 = *(const char32_t **)(j < 4 ? gpr_ptr + j : args_ptr);
+                args_ptr += (j >= 4);
+
+                Napi::Value arg = str32 ? MakeStringFromUTF32(env, str32) : env.Null();
+                arguments.Append(arg);
+            } break;
             case PrimitiveKind::Pointer:
             case PrimitiveKind::Callback: {
                 void *ptr2 = *(void **)(j < 4 ? gpr_ptr + j : args_ptr);
@@ -661,6 +677,13 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, bool switch_
 
             out_reg->rax = (uint64_t)str16;
         } break;
+        case PrimitiveKind::String32: {
+            const char32_t *str32;
+            if (!PushString32(value, 1, &str32)) [[unlikely]]
+                return;
+
+            out_reg->rax = (uint64_t)str32;
+        } break;
         case PrimitiveKind::Pointer: {
             uint8_t *ptr;