koffi 2.3.1 → 2.3.2

package/src/cnoke/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "cnoke",
+  "version": "3.2.2",
+  "description": "Build native Node addons based on CMake, without extra dependency",
+  "keywords": [
+    "native",
+    "addon",
+    "cmake",
+    "c",
+    "c++"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Koromix/rygel.git"
+  },
+  "author": "Niels Martignène <niels.martignene@protonmail.com>",
+  "bin": "cnoke.js",
+  "license": "LGPL-3.0",
+  "files": [
+    "cnoke.js",
+    "LICENSE.txt",
+    "README.md",
+    "assets"
+  ]
+}

package/src/koffi/src/call.cc

@@ -1011,10 +1011,6 @@ void CallData::PopOutArguments()
             Napi::Object obj(env, value);
             DecodeObject(obj, out.ptr, out.type);
         }
-
-        if (out.type->dispose) {
-            out.type->dispose(env, out.type, out.ptr);
-        }
     }
 }
 

package/src/koffi/src/ffi.cc

@@ -122,13 +122,8 @@ static Napi::Value GetSetConfig(const Napi::CallbackInfo &info)
             return env.Null();
         }
 
-        Size sync_stack_size = instance->sync_stack_size;
-        Size sync_heap_size = instance->sync_heap_size;
-        Size async_stack_size = instance->async_stack_size;
-        Size async_heap_size = instance->async_heap_size;
-        int resident_async_pools = instance->resident_async_pools;
-        int max_async_calls = resident_async_pools + instance->max_temporaries;
-        Size max_type_size = instance->max_type_size;
+        decltype(instance->config) new_config = instance->config;
+        int max_async_calls = new_config.resident_async_pools + new_config.max_temporaries;
 
         Napi::Object obj = info[0].As<Napi::Object>();
         Napi::Array keys = obj.GetPropertyNames();
@@ -138,25 +133,25 @@ static Napi::Value GetSetConfig(const Napi::CallbackInfo &info)
             Napi::Value value = obj[key];
 
             if (key == "sync_stack_size") {
-                if (!ChangeMemorySize(key.c_str(), value, &sync_stack_size))
+                if (!ChangeMemorySize(key.c_str(), value, &new_config.sync_stack_size))
                     return env.Null();
             } else if (key == "sync_heap_size") {
-                if (!ChangeMemorySize(key.c_str(), value, &sync_heap_size))
+                if (!ChangeMemorySize(key.c_str(), value, &new_config.sync_heap_size))
                     return env.Null();
             } else if (key == "async_stack_size") {
-                if (!ChangeMemorySize(key.c_str(), value, &async_stack_size))
+                if (!ChangeMemorySize(key.c_str(), value, &new_config.async_stack_size))
                     return env.Null();
             } else if (key == "async_heap_size") {
-                if (!ChangeMemorySize(key.c_str(), value, &async_heap_size))
+                if (!ChangeMemorySize(key.c_str(), value, &new_config.async_heap_size))
                     return env.Null();
             } else if (key == "resident_async_pools") {
-                if (!ChangeAsyncLimit(key.c_str(), value, RG_LEN(instance->memories.data) - 1, &resident_async_pools))
+                if (!ChangeAsyncLimit(key.c_str(), value, RG_LEN(instance->memories.data) - 1, &new_config.resident_async_pools))
                     return env.Null();
             } else if (key == "max_async_calls") {
                 if (!ChangeAsyncLimit(key.c_str(), value, MaxAsyncCalls, &max_async_calls))
                     return env.Null();
             } else if (key == "max_type_size") {
-                if (!ChangeSize(key.c_str(), value, 32, Mebibytes(512), &max_type_size))
+                if (!ChangeSize(key.c_str(), value, 32, Mebibytes(512), &new_config.max_type_size))
                     return env.Null();
             } else {
                 ThrowError<Napi::Error>(env, "Unexpected config member '%1'", key.c_str());
@@ -164,29 +159,36 @@ static Napi::Value GetSetConfig(const Napi::CallbackInfo &info)
             }
         }
 
-        if (max_async_calls < resident_async_pools) {
+        if (max_async_calls < new_config.resident_async_pools) {
             ThrowError<Napi::Error>(env, "Setting max_async_calls must be >= to resident_async_pools");
             return env.Null();
         }
 
-        instance->sync_stack_size = sync_stack_size;
-        instance->sync_heap_size = sync_heap_size;
-        instance->async_stack_size = async_stack_size;
-        instance->async_heap_size = async_heap_size;
-        instance->resident_async_pools = resident_async_pools;
-        instance->max_temporaries = max_async_calls - resident_async_pools;
-        instance->max_type_size = max_type_size;
+        new_config.max_temporaries =  max_async_calls - new_config.resident_async_pools;
+        instance->config = new_config;
     }
 
     Napi::Object obj = Napi::Object::New(env);
 
-    obj.Set("sync_stack_size", instance->sync_stack_size);
-    obj.Set("sync_heap_size", instance->sync_heap_size);
-    obj.Set("async_stack_size", instance->async_stack_size);
-    obj.Set("async_heap_size", instance->async_heap_size);
-    obj.Set("resident_async_pools", instance->resident_async_pools);
-    obj.Set("max_async_calls", instance->resident_async_pools + instance->max_temporaries);
-    obj.Set("max_type_size", instance->max_type_size);
+    obj.Set("sync_stack_size", instance->config.sync_stack_size);
+    obj.Set("sync_heap_size", instance->config.sync_heap_size);
+    obj.Set("async_stack_size", instance->config.async_stack_size);
+    obj.Set("async_heap_size", instance->config.async_heap_size);
+    obj.Set("resident_async_pools", instance->config.resident_async_pools);
+    obj.Set("max_async_calls", instance->config.resident_async_pools + instance->config.max_temporaries);
+    obj.Set("max_type_size", instance->config.max_type_size);
+
+    return obj;
+}
+
+static Napi::Value GetStats(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    Napi::Object obj = Napi::Object::New(env);
+
+    obj.Set("disposed", instance->stats.disposed);
 
     return obj;
 }
@@ -197,6 +199,14 @@ static inline bool CheckAlignment(int64_t align)
     return valid;
 }
 
+static inline Napi::External<TypeInfo> WrapType(Napi::Env env, InstanceData *instance, const TypeInfo *type)
+{
+    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, (TypeInfo *)type);
+    SetValueTag(instance, external, &TypeInfoMarker);
+
+    return external;
+}
+
 static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
 {
     Napi::Env env = info.Env();
@@ -277,7 +287,7 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
         size = member.offset + member.type->size;
         type->align = std::max(type->align, align);
 
-        if (size > instance->max_type_size) {
+        if (size > instance->config.max_type_size) {
             ThrowError<Napi::Error>(env, "Struct '%1' size is too high (max = %2)", type->name, FmtMemSize(size));
             return env.Null();
         }
@@ -312,10 +322,7 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
     }
     err_guard.Disable();
 
-    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, type);
-    SetValueTag(instance, external, &TypeInfoMarker);
-
-    return external;
+    return WrapType(env, instance, type);
 }
 
 static Napi::Value CreatePaddedStructType(const Napi::CallbackInfo &info)
@@ -363,10 +370,7 @@ static Napi::Value CreateOpaqueType(const Napi::CallbackInfo &info)
     }
     err_guard.Disable();
 
-    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, type);
-    SetValueTag(instance, external, &TypeInfoMarker);
-
-    return external;
+    return WrapType(env, instance, type);
 }
 
 static Napi::Value CreatePointerType(const Napi::CallbackInfo &info)
@@ -436,10 +440,7 @@ static Napi::Value CreatePointerType(const Napi::CallbackInfo &info)
         type = copy;
     }
 
-    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, (TypeInfo *)type);
-    SetValueTag(instance, external, &TypeInfoMarker);
-
-    return external;
+    return WrapType(env, instance, type);
 }
 
 static Napi::Value EncodePointerDirection(const Napi::CallbackInfo &info, int directions)
@@ -463,13 +464,10 @@ static Napi::Value EncodePointerDirection(const Napi::CallbackInfo &info, int di
         return env.Null();
     }
 
-    // We need to lose the const for Napi::External to work
-    TypeInfo *marked = (TypeInfo *)((uint8_t *)type + directions - 1);
-
-    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, marked);
-    SetValueTag(instance, external, &TypeInfoMarker);
+    // Embed direction in unused pointer bits
+    const TypeInfo *marked = (const TypeInfo *)((uint8_t *)type + directions - 1);
 
-    return external;
+    return WrapType(env, instance, marked);
 }
 
 static Napi::Value MarkIn(const Napi::CallbackInfo &info)
@@ -543,10 +541,16 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
             };
 
             ref.Call(self, RG_LEN(args), args);
+            instance->stats.disposed++;
         };
         dispose_func = func;
     } else {
-        dispose = [](Napi::Env, const TypeInfo *, const void *ptr) { free((void *)ptr); };
+        dispose = [](Napi::Env env, const TypeInfo *, const void *ptr) {
+            InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+            free((void *)ptr);
+            instance->stats.disposed++;
+        };
     }
 
     TypeInfo *type = instance->types.AppendDefault();
@@ -570,10 +574,7 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
     }
     err_guard.Disable();
 
-    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, type);
-    SetValueTag(instance, external, &TypeInfoMarker);
-
-    return external;
+    return WrapType(env, instance, type);
 }
 
 static Napi::Value CallFree(const Napi::CallbackInfo &info)
@@ -582,7 +583,7 @@ static Napi::Value CallFree(const Napi::CallbackInfo &info)
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
     if (info.Length() < 1) {
-        ThrowError<Napi::TypeError>(env, "Expected 1 or 2 arguments, got %1", info.Length());
+        ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
         return env.Null();
     }
     if (!info[0].IsExternal() || CheckValueTag(instance, info[0], &TypeInfoMarker)) {
@@ -621,8 +622,8 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
         ThrowError<Napi::TypeError>(env, "Array length must be positive and non-zero");
         return env.Null();
     }
-    if (len > instance->max_type_size / ref->size) {
-        ThrowError<Napi::TypeError>(env, "Array length is too high (max = %1)", instance->max_type_size / ref->size);
+    if (len > instance->config.max_type_size / ref->size) {
+        ThrowError<Napi::TypeError>(env, "Array length is too high (max = %1)", instance->config.max_type_size / ref->size);
         return env.Null();
     }
 
@@ -658,10 +659,7 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
         type = MakeArrayType(instance, ref, len);
     }
 
-    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, (TypeInfo *)type);
-    SetValueTag(instance, external, &TypeInfoMarker);
-
-    return external;
+    return WrapType(env, instance, type);
 }
 
 static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value ret,
@@ -786,10 +784,7 @@ static Napi::Value CreateCallbackType(const Napi::CallbackInfo &info)
 
     instance->types_map.Set(type->name, type);
 
-    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, type);
-    SetValueTag(instance, external, &TypeInfoMarker);
-
-    return external;
+    return WrapType(env, instance, type);
 }
 
 static Napi::Value CreateTypeAlias(const Napi::CallbackInfo &info)
@@ -821,10 +816,7 @@ static Napi::Value CreateTypeAlias(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, (TypeInfo *)type);
-    SetValueTag(instance, external, &TypeInfoMarker);
-
-    return external;
+    return WrapType(env, instance, type);
 }
 
 static Napi::Value GetTypeSize(const Napi::CallbackInfo &info)
@@ -907,10 +899,7 @@ static Napi::Value GetResolvedType(const Napi::CallbackInfo &info)
     if (!type)
         return env.Null();
 
-    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, (TypeInfo *)type);
-    SetValueTag(instance, external, &TypeInfoMarker);
-
-    return external;
+    return WrapType(env, instance, type);
 }
 
 static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
@@ -934,6 +923,7 @@ static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
         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("disposable", Napi::Boolean::New(env, !!type->dispose));
 
         switch (type->primitive) {
             case PrimitiveKind::Void:
@@ -964,10 +954,8 @@ static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
                 defn.Set("length", Napi::Number::New(env, (double)len));
             } [[fallthrough]];
             case PrimitiveKind::Pointer: {
-                Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, (TypeInfo *)type->ref.type);
-                SetValueTag(instance, external, &TypeInfoMarker);
-
-                defn.Set("ref", external);
+                Napi::Value value = WrapType(env, instance, type->ref.type);
+                defn.Set("ref", value);
             } break;
             case PrimitiveKind::Record: {
                 Napi::Object members = Napi::Object::New(env);
@@ -975,11 +963,8 @@ static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
                 for (const RecordMember &member: type->members) {
                     Napi::Object obj = Napi::Object::New(env);
 
-                    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, (TypeInfo *)member.type);
-                    SetValueTag(instance, external, &TypeInfoMarker);
-
                     obj.Set("name", member.name);
-                    obj.Set("type", external);
+                    obj.Set("type", WrapType(env, instance, member.type));
                     obj.Set("offset", member.offset);
 
                     members.Set(member.name, obj);
@@ -1007,7 +992,7 @@ static InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, S
             return mem;
     }
 
-    if (RG_UNLIKELY(instance->temporaries >= instance->max_temporaries))
+    if (RG_UNLIKELY(instance->temporaries >= instance->config.max_temporaries))
         return nullptr;
 
     InstanceMemory *mem = new InstanceMemory();
@@ -1065,7 +1050,7 @@ static InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, S
 
     mem->depth = 0;
 
-    if (instance->memories.len <= instance->resident_async_pools) {
+    if (instance->memories.len <= instance->config.resident_async_pools) {
         instance->memories.Append(mem);
         mem->temporary = false;
     } else {
@@ -1256,7 +1241,7 @@ static Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    InstanceMemory *mem = AllocateMemory(instance, instance->async_stack_size, instance->async_heap_size);
+    InstanceMemory *mem = AllocateMemory(instance, instance->config.async_stack_size, instance->config.async_heap_size);
     if (RG_UNLIKELY(!mem)) {
         ThrowError<Napi::Error>(env, "Too many asynchronous calls are running");
         return env.Null();
@@ -1350,6 +1335,23 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
         wrapper.Set("async", async);
     }
 
+    // Create info object
+    {
+        Napi::Object meta = Napi::Object::New(env);
+        Napi::Array arguments = Napi::Array::New(env, func->parameters.len);
+
+        meta.Set("name", Napi::String::New(env, func->name));
+        meta.Set("arguments", arguments);
+        meta.Set("result", WrapType(env, instance, func->ret.type));
+
+        for (Size i = 0; i < func->parameters.len; i++) {
+            const ParameterInfo &param = func->parameters[i];
+            arguments.Set((uint32_t)i, WrapType(env, instance, param.type));
+        }
+
+        wrapper.Set("info", meta);
+    }
+
     return wrapper;
 }
 
@@ -1368,7 +1370,7 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
     }
 
     if (!instance->memories.len) {
-        AllocateMemory(instance, instance->sync_stack_size, instance->sync_heap_size);
+        AllocateMemory(instance, instance->config.sync_stack_size, instance->config.sync_heap_size);
         RG_ASSERT(instance->memories.len);
     }
 
@@ -1591,8 +1593,7 @@ static void RegisterPrimitiveType(Napi::Env env, Napi::Object map, std::initiali
         type->ref.marker = marker;
     }
 
-    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, type);
-    SetValueTag(instance, external, &TypeInfoMarker);
+    Napi::Value wrapper = WrapType(env, instance, type);
 
     for (const char *name: names) {
         bool inserted;
@@ -1600,7 +1601,7 @@ static void RegisterPrimitiveType(Napi::Env env, Napi::Object map, std::initiali
         RG_ASSERT(inserted);
 
         if (!EndsWith(name, "*")) {
-            map.Set(name, external);
+            map.Set(name, wrapper);
         }
     }
 }
@@ -1974,7 +1975,7 @@ extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, Bac
         Napi::Env env = trampoline->func.Env();
         InstanceData *instance = env.GetInstanceData<InstanceData>();
 
-        InstanceMemory *mem = AllocateMemory(instance, instance->async_stack_size, instance->async_heap_size);
+        InstanceMemory *mem = AllocateMemory(instance, instance->config.async_stack_size, instance->config.async_heap_size);
         if (RG_UNLIKELY(!mem)) {
             ThrowError<Napi::Error>(env, "Too many asynchronous calls are running");
             return;
@@ -1993,6 +1994,7 @@ template <typename Func>
 static void SetExports(Napi::Env env, Func func)
 {
     func("config", Napi::Function::New(env, GetSetConfig));
+    func("stats", Napi::Function::New(env, GetStats));
 
     func("struct", Napi::Function::New(env, CreatePaddedStructType));
     func("pack", Napi::Function::New(env, CreatePackedStructType));

package/src/koffi/src/ffi.hh

@@ -264,13 +264,19 @@ struct InstanceData {
 
     BlockAllocator str_alloc;
 
-    Size sync_stack_size = DefaultSyncStackSize;
-    Size sync_heap_size = DefaultSyncHeapSize;
-    Size async_stack_size = DefaultAsyncStackSize;
-    Size async_heap_size = DefaultAsyncHeapSize;
-    int resident_async_pools = DefaultResidentAsyncPools;
-    int max_temporaries = DefaultMaxAsyncCalls - DefaultResidentAsyncPools;
-    Size max_type_size = DefaultMaxTypeSize;
+    struct {
+        Size sync_stack_size = DefaultSyncStackSize;
+        Size sync_heap_size = DefaultSyncHeapSize;
+        Size async_stack_size = DefaultAsyncStackSize;
+        Size async_heap_size = DefaultAsyncHeapSize;
+        int resident_async_pools = DefaultResidentAsyncPools;
+        int max_temporaries = DefaultMaxAsyncCalls - DefaultResidentAsyncPools;
+        Size max_type_size = DefaultMaxTypeSize;
+    } config;
+
+    struct {
+        int64_t disposed = 0;
+    } stats;
 };
 RG_STATIC_ASSERT(DefaultResidentAsyncPools <= RG_LEN(InstanceData::memories.data) - 1);
 RG_STATIC_ASSERT(DefaultMaxAsyncCalls >= DefaultResidentAsyncPools);

package/src/koffi/src/index.d.ts

@@ -25,11 +25,19 @@ declare module 'koffi' {
         primitive: string;
         size: number;
         alignment: number;
+        disposable: boolean;
         length: number;
         ref: IKoffiCType;
         members: Record<string, { name: string, type: IKoffiCType, offset: number }>;
     };
-    type KoffiFunction = Function & { async: Function };
+    type KoffiFunction = Function & {
+        async: Function;
+        info: {
+            name: string,
+            arguments: IKoffiCType[],
+            result: IKoffiCType
+        };
+    };
 
     export interface IKoffiLib {
         func(definition: string): KoffiFunction;
@@ -92,4 +100,5 @@ declare module 'koffi' {
 
     export function config(): Record<string, unknown>;
     export function config(cfg: Record<string, unknown>): Record<string, unknown>;
+    export function stats(): Record<string, unknown>;
 }

package/src/koffi/src/parser.cc

@@ -141,34 +141,36 @@ const TypeInfo *PrototypeParser::ParseType()
 
     if (offset >= tokens.len) {
         MarkError("Unexpected end of prototype, expected type");
-        return instance->types_map.FindValue("void", nullptr);
+        return instance->void_type;
     } else if (!IsIdentifier(tokens[offset])) {
         MarkError("Unexpected token '%1', expected type", tokens[offset]);
-        return instance->types_map.FindValue("void", nullptr);
+        return instance->void_type;
     }
 
-    while (offset < tokens.len && (IsIdentifier(tokens[offset]) ||
-                                   tokens[offset] == '*')) {
-        offset++;
-    }
-    offset += (offset < tokens.len && tokens[offset] == "!");
-    offset = std::min(tokens.len - 1, offset);
+    while (++offset < tokens.len && IsIdentifier(tokens[offset]));
+    offset--;
+    while (++offset < tokens.len && (tokens[offset] == '*' ||
+                                     tokens[offset] == '!' ||
+                                     tokens[offset] == "const"));
+    offset--;
 
     while (offset >= start) {
         Span<const char> str = MakeSpan(tokens[start].ptr, tokens[offset].end() - tokens[start].ptr);
-        const TypeInfo *type = ResolveType(instance, str);
+        const TypeInfo *type = ResolveType(env, str);
 
         if (type) {
             offset++;
             return type;
         }
+        if (RG_UNLIKELY(env.IsExceptionPending()))
+            return instance->void_type;
 
         offset--;
     }
     offset = start;
 
     MarkError("Unknown or invalid type name '%1'", tokens[offset]);
-    return instance->types_map.FindValue("void", nullptr);
+    return instance->void_type;
 }
 
 const char *PrototypeParser::ParseIdentifier()