koffi 3.0.2 → 3.1.1

package/src/koffi/src/ffi.hh

@@ -36,8 +36,8 @@ namespace K {
 
 #define NAPI_OK(Call) \
     do { \
-        napi_status status = (Call); \
-        K_ASSERT(status == napi_ok); \
+        napi_status _status = (Call); \
+        K_ASSERT(_status == napi_ok); \
     } while (false)
 
 static const Size DefaultSyncStackSize = Mebibytes(1);
@@ -67,7 +67,7 @@ struct RecordMember;
 struct FunctionInfo;
 struct CallData;
 
-typedef void DisposeFunc (Napi::Env env, const TypeInfo *type, const void *ptr);
+typedef void DisposeFunc (InstanceData *instance, const TypeInfo *type, const void *ptr);
 
 enum class TypeFlag {
     HasTypedArray = 1 << 0,
@@ -90,22 +90,30 @@ static const char *const ArrayHintNames[] = {
 
 struct RecordMember {
     const char *name;
-    napi_ref key;
     const TypeInfo *type;
     int32_t offset;
     Size countedby;
+
+    napi_ref key = nullptr;
+
+#if defined(K_DEBUG)
+    ~RecordMember() { K_ASSERT(!key); }
+#endif
 };
 
 struct TypeInfo {
-    const char *name;
+    K_DELETE_COPY(TypeInfo)
+
+    InstanceData *instance = nullptr;
 
+    const char *name;
     alignas(8) PrimitiveKind primitive;
     int32_t size;
     int16_t align;
     uint16_t flags;
 
-    DisposeFunc *dispose;
-    Napi::FunctionReference dispose_ref;
+    DisposeFunc *dispose = nullptr;
+    napi_ref dispose_ref = nullptr;
 
     HeapArray<RecordMember> members; // Record or Union
     struct {
@@ -116,15 +124,23 @@ struct TypeInfo {
     ArrayHint hint; // Array only
     const char *countedby; // Pointer or array
 
-    mutable Napi::FunctionReference construct; // Union only
-    mutable Napi::ObjectReference defn;
+    mutable napi_ref construct = nullptr; // Union only
+    mutable napi_ref defn = nullptr;
+
+    mutable const TypeInfo *reshaped = nullptr;
 
-    mutable const TypeInfo *reshaped;
+    TypeInfo() = default;
+    ~TypeInfo();
+
+    TypeInfo(TypeInfo &&other) = default;
+    TypeInfo &operator=(TypeInfo &&other) = default;
 
     K_HASHTABLE_HANDLER(TypeInfo, name);
 };
 
 struct LibraryHolder {
+    K_DELETE_COPY(LibraryHolder)
+
     void *module = nullptr; // HMODULE on Windows
     mutable int refcount = 1;
 
@@ -196,7 +212,9 @@ struct ParameterInfo {
     // ABI-specific part
 
 #if defined(_M_X64)
-    bool regular; // Used for structs and unions
+    struct {
+        bool regular; // Used for structs and unions
+    } abi;
 #elif defined(__x86_64__)
     struct {
         bool regular;
@@ -222,7 +240,9 @@ struct ReturnInfo {
     // ABI-specific part
 
 #if defined(_M_X64)
-    bool regular;
+    struct {
+        bool regular;
+    } abi;
 #elif defined(__x86_64__)
     struct {
         AbiMethod method;
@@ -233,7 +253,9 @@ struct ReturnInfo {
         int offset;
     } abi;
 #elif defined(__i386__) || defined(_M_IX86)
-    bool trivial;
+    struct {
+        bool regular;
+    } abi;
 #elif __riscv_xlen == 64 || defined(__loongarch64)
     struct {
         AbiMethod method;
@@ -352,8 +374,6 @@ struct InstanceData {
     // Variadic cache
     FunctionInfo *variadic_func = nullptr;
 
-    napi_value (*translate_zero_call)(napi_env env, napi_callback_info info);
-
     std::thread::id main_thread_id;
     napi_threadsafe_function broker = nullptr;
 
@@ -428,12 +448,12 @@ extern const napi_type_tag CastMarker;
 extern SharedData shared;
 
 // Some Node-API functions are loaded dynamically to work around bugs or because they are recent
+extern napi_status (NAPI_CDECL *node_api_delete_reference)(node_api_basic_env env, napi_ref ref);
 extern napi_status (NAPI_CDECL *node_api_get_buffer_info)(napi_env env, napi_value value, void **data, size_t *length);
 extern napi_status (NAPI_CDECL *node_api_create_property_key_utf8)(napi_env env, const char* str, size_t length, napi_value* result);
 extern napi_status (NAPI_CDECL *node_api_post_finalizer)(node_api_basic_env env, napi_finalize finalize_cb, void* finalize_data, void* finalize_hint);
 extern napi_status (NAPI_CDECL *node_api_create_object_with_properties)(napi_env env, napi_value prototype_or_null, const napi_value *property_names,
                                                                         const napi_value *property_values, size_t property_count, napi_value *result);
-extern napi_value (*translate_zero_call)(napi_env env, napi_callback_info info);
 
 InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, Size heap_size);
 void ReleaseMemory(InstanceData *instance, InstanceMemory *mem);

package/src/koffi/src/parser.cc

@@ -2,10 +2,10 @@
 // SPDX-FileCopyrightText: 2026 Niels Martignène <niels.martignene@protonmail.com>
 
 #include "lib/native/base/base.hh"
+#include "call.hh"
 #include "ffi.hh"
 #include "parser.hh"
 #include "type.hh"
-#include "util.hh"
 
 #include <napi.h>
 
@@ -209,9 +209,9 @@ bool PrototypeParser::IsIdentifier(Span<const char> tok) const
     return IsAsciiAlpha(tok[0]) || tok[0] == '_';
 }
 
-bool ParsePrototype(Napi::Env env, const char *str, bool concrete, FunctionInfo *out_func)
+bool ParsePrototype(InstanceData *instance, const char *str, bool concrete, FunctionInfo *out_func)
 {
-    PrototypeParser parser(env);
+    PrototypeParser parser(instance);
     return parser.Parse(str, concrete, out_func);
 }
 

package/src/koffi/src/parser.hh

@@ -24,7 +24,7 @@ class PrototypeParser {
     bool valid;
 
 public:
-    PrototypeParser(Napi::Env env) : env(env), instance(env.GetInstanceData<InstanceData>()) {}
+    PrototypeParser(InstanceData *instance) : env(instance->env), instance(instance) {}
 
     bool Parse(const char *str, bool concrete, FunctionInfo *out_func);
 
@@ -49,6 +49,6 @@ private:
     }
 };
 
-bool ParsePrototype(Napi::Env env, const char *str, bool concrete, FunctionInfo *out_func);
+bool ParsePrototype(InstanceData *instance, const char *str, bool concrete, FunctionInfo *out_func);
 
 }

package/src/koffi/src/static.cjs

@@ -92,6 +92,14 @@ function loadStatic(pkg) {
         }
     }
 
+    if (pkg == 'win32-arm64') {
+        try {
+            native = require('@koromix/koffi-win32-arm64');
+        } catch (err) {
+            // Go on
+        }
+    }
+
     if (pkg == 'darwin-x64') {
         try {
             native = require('@koromix/koffi-darwin-x64');

package/src/koffi/src/static.js

@@ -1,6 +1,9 @@
 // SPDX-License-Identifier: MIT
 // SPDX-FileCopyrightText: 2026 Niels Martignène <niels.martignene@protonmail.com>
 
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+
 function loadStatic(pkg) {
     let native = null;
 
@@ -92,6 +95,14 @@ function loadStatic(pkg) {
         }
     }
 
+    if (pkg == 'win32-arm64') {
+        try {
+            native = require('@koromix/koffi-win32-arm64');
+        } catch (err) {
+            // Go on
+        }
+    }
+
     if (pkg == 'darwin-x64') {
         try {
             native = require('@koromix/koffi-darwin-x64');

package/src/koffi/src/type.cc

@@ -2,9 +2,9 @@
 // SPDX-FileCopyrightText: 2026 Niels Martignène <niels.martignene@protonmail.com>
 
 #include "lib/native/base/base.hh"
+#include "call.hh"
 #include "ffi.hh"
 #include "type.hh"
-#include "util.hh"
 
 #include <napi.h>
 
@@ -36,7 +36,7 @@ TypeObject::TypeObject(const Napi::CallbackInfo &info)
 
 void TypeObject::Finalize(Napi::BasicEnv env)
 {
-    DeleteReferenceSafe(env, *this);
+    node_api_delete_reference(env, *this);
     SuppressDestruct();
 }
 
@@ -306,15 +306,12 @@ const TypeInfo *ResolveType(InstanceData *instance, Span<const char> str)
 
             memcpy((void *)copy, (const void *)type, K_SIZE(*type));
             copy->name = Fmt(&instance->str_alloc, "<anonymous_%1>", instance->types.count).ptr;
-            copy->members.allocator = GetNullAllocator();
-            copy->members.allocator = GetNullAllocator();
-            memset((void *)&copy->defn, 0, K_SIZE(copy->defn));
+            copy->defn = nullptr;
+            K_ASSERT(!type->members.len);
 
             static_assert(!std::is_polymorphic_v<Napi::ObjectReference>);
 
-            copy->dispose = [](Napi::Env env, const TypeInfo *, const void *ptr) {
-                InstanceData *instance = env.GetInstanceData<InstanceData>();
-
+            copy->dispose = [](InstanceData *instance, const TypeInfo *, const void *ptr) {
                 free((void *)ptr);
                 instance->stats.disposed++;
             };
@@ -436,27 +433,27 @@ TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len, A
     return MakeArrayType(instance, ref, len, hint, false);
 }
 
-napi_value WrapType(Napi::Env env, const TypeInfo *type, bool freeze)
+napi_value WrapType(InstanceData *instance, const TypeInfo *type, bool freeze)
 {
-    if (type->defn.IsEmpty()) {
+    Napi::Env env = instance->env;
+
+    if (!type->defn) {
 #if defined(EXTERNAL_TYPES)
         Napi::Object defn = Napi::Object::New(env);
 #else
-        InstanceData *instance = env.GetInstanceData<InstanceData>();
-
         Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, (TypeInfo *)type);
         Napi::Object defn = instance->construct_type.New({ external });
         SetValueTag(env, defn, &TypeObjectMarker);
 #endif
 
-        defn.Set("name", Napi::String::New(env, type->name));
+        defn.Set("name", NewString(env, type->name));
         defn.Set("primitive", PrimitiveKindNames[(int)type->primitive]);
-        defn.Set("size", Napi::Number::New(env, (double)type->size));
-        defn.Set("alignment", Napi::Number::New(env, (double)type->align));
+        defn.Set("size", NewInt(env, type->size));
+        defn.Set("alignment", NewInt(env, type->align));
         defn.Set("disposable", Napi::Boolean::New(env, !!type->dispose));
 
         // Assign before to avoid possible recursion crash
-        type->defn = Napi::Persistent(defn);
+        NAPI_OK(napi_create_reference(env, defn, 1, &type->defn));
 
         switch (type->primitive) {
             case PrimitiveKind::Void:
@@ -483,12 +480,12 @@ napi_value WrapType(Napi::Env env, const TypeInfo *type, bool freeze)
 
             case PrimitiveKind::Array: {
                 uint32_t len = type->size / type->ref.type->size;
-                defn.Set("length", Napi::Number::New(env, (double)len));
+                defn.Set("length", NewInt(env, len));
                 defn.Set("hint", ArrayHintNames[(int)type->hint]);
             } [[fallthrough]];
             case PrimitiveKind::Pointer: {
-                napi_value value = WrapType(env, type->ref.type);
-                defn.Set("ref", value);
+                napi_value ref = WrapType(instance, type->ref.type);
+                defn.Set("ref", ref);
             } break;
             case PrimitiveKind::Record:
             case PrimitiveKind::Union: {
@@ -498,7 +495,7 @@ napi_value WrapType(Napi::Env env, const TypeInfo *type, bool freeze)
                     Napi::Object obj = Napi::Object::New(env);
 
                     obj.Set("name", member.name);
-                    obj.Set("type", WrapType(env, member.type));
+                    obj.Set("type", WrapType(instance, member.type));
                     obj.Set("offset", member.offset);
 
                     members.Set(member.name, obj);
@@ -510,7 +507,7 @@ napi_value WrapType(Napi::Env env, const TypeInfo *type, bool freeze)
 
             case PrimitiveKind::Prototype:
             case PrimitiveKind::Callback: {
-                napi_value meta = DescribeFunction(env, type->proto);
+                napi_value meta = DescribeFunction(instance, type->proto);
                 defn.Set("proto", meta);
             } break;
         }
@@ -526,19 +523,27 @@ napi_value WrapType(Napi::Env env, const TypeInfo *type, bool freeze)
 
     return external;
 #else
-    return type->defn.Value();
+    napi_value defn;
+    NAPI_OK(napi_get_reference_value(env, type->defn, &defn));
+
+    return defn;
 #endif
 }
 
 const TypeInfo *ReshapeType(InstanceData *instance, const TypeInfo *type, int32_t stride, uint16_t flags)
 {
-    K_ASSERT(!type->defn.IsEmpty());
+    K_ASSERT(type->defn);
 
     if (!type->reshaped) {
+        Napi::Env env = instance->env;
+
         TypeInfo *reshaped = nullptr;
 
         switch (type->primitive) {
             case PrimitiveKind::Record: {
+                napi_value defn;
+                NAPI_OK(napi_get_reference_value(env, type->defn, &defn));
+
                 reshaped = instance->types.AppendDefault();
 
                 memcpy((void *)reshaped, (const void *)type, K_SIZE(*type));
@@ -546,31 +551,36 @@ const TypeInfo *ReshapeType(InstanceData *instance, const TypeInfo *type, int32_
                 reshaped->members.Reserve(type->members.len);
                 reshaped->size = 0;
                 reshaped->flags |= flags;
-                memset((void *)&reshaped->defn, 0, K_SIZE(reshaped->defn));
-
-                Napi::Object defn = type->defn.Value();
-                reshaped->defn = Napi::Persistent(defn);
+                NAPI_OK(napi_create_reference(env, defn, 1, &reshaped->defn));
 
                 for (RecordMember member: type->members) {
                     member.offset = reshaped->size;
                     member.type = ReshapeType(instance, member.type, stride, flags);
 
+                    if (member.key) {
+                        napi_value key;
+                        NAPI_OK(napi_get_reference_value(env, member.key, &key));
+                        NAPI_OK(napi_create_reference(env, key, 1, &member.key));
+                    }
+
                     reshaped->members.Append(member);
-                    reshaped->size += AlignLen(member.type->size, stride);
+                    reshaped->size += (int)AlignLen(member.type->size, stride);
+
+                    member.key = nullptr;
                 }
             } break;
 
             case PrimitiveKind::Array: {
                 reshaped = instance->types.AppendDefault();
 
+                napi_value defn;
+                NAPI_OK(napi_get_reference_value(env, type->defn, &defn));
+
                 memcpy((void *)reshaped, (const void *)type, K_SIZE(*type));
                 reshaped->ref.stride = stride;
                 reshaped->size = (type->size / type->ref.stride) * stride;
-                memset((void *)&reshaped->defn, 0, K_SIZE(reshaped->defn));
                 reshaped->flags |= flags;
-
-                Napi::Object defn = type->defn.Value();
-                reshaped->defn = Napi::Persistent(defn);
+                NAPI_OK(napi_create_reference(env, defn, 1, &reshaped->defn));
             } break;
 
             default: { reshaped = (TypeInfo *)type; } break;
@@ -617,7 +627,7 @@ bool CanReturnType(const TypeInfo *type)
     if (type->countedby)
         return false;
 
-    if (type->primitive == PrimitiveKind::Void && !TestStr(type->name, "void"))
+    if (type->primitive == PrimitiveKind::Void && type != type->instance->void_type)
         return false;
     if (type->primitive == PrimitiveKind::Array)
         return false;

package/src/koffi/src/type.hh

@@ -57,7 +57,7 @@ TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *ref, int count
 TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len);
 TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len, ArrayHint hint);
 
-napi_value WrapType(Napi::Env env, const TypeInfo *type, bool freeze = true);
+napi_value WrapType(InstanceData *instance, const TypeInfo *type, bool freeze = true);
 
 const TypeInfo *ReshapeType(InstanceData *instance, const TypeInfo *type, int32_t stride, uint16_t flags);