koffi 2.3.21-beta.2 → 2.3.21-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "koffi",
-    "version": "2.3.21-beta.2",
+    "version": "2.3.21-beta.4",
     "stable": "2.3.20",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [

package/src/index.d.ts

@@ -93,6 +93,8 @@ declare module 'koffi' {
 
     export function opaque(name: string): IKoffiCType;
     export function opaque(): IKoffiCType;
+    /** @deprecated */ export function handle(name: string): IKoffiCType;
+    /** @deprecated */ export function handle(): IKoffiCType;
 
     export function pointer(value: TypeSpec): IKoffiCType;
     export function pointer(value: TypeSpec, asteriskCount: number): IKoffiCType;
@@ -105,8 +107,10 @@ declare module 'koffi' {
     export function disposable(name: string, type: TypeSpec): IKoffiCType;
     export function disposable(name: string, type: TypeSpec, freeFunction: Function): IKoffiCType;
 
-    export function callback(definition: string): IKoffiCType;
-    export function callback(name: string, result: TypeSpec, arguments: TypeSpec[]): IKoffiCType;
+    export function proto(definition: string): IKoffiCType;
+    export function proto(name: string, result: TypeSpec, arguments: TypeSpec[]): IKoffiCType;
+    /** @deprecated */ export function callback(definition: string): IKoffiCType;
+    /** @deprecated */ export function callback(name: string, result: TypeSpec, arguments: TypeSpec[]): IKoffiCType;
 
     export function register(callback: Function, type: TypeSpec): IKoffiRegisteredCallback;
     export function register(thisValue: any, callback: Function, type: TypeSpec): IKoffiRegisteredCallback;

package/src/index.js

@@ -57,5 +57,6 @@ 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')
+    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')
 };

package/src/koffi/src/abi_arm32.cc

@@ -456,12 +456,12 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
     return true;
 }
 
-void CallData::Execute(const FunctionInfo *func)
+void CallData::Execute(const FunctionInfo *func, void *native)
 {
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
-            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, new_sp, &old_sp) \
-                                         : ForwardCall ## Suffix(func->func, new_sp, &old_sp)); \
+            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(native, new_sp, &old_sp) \
+                                         : ForwardCall ## Suffix(native, new_sp, &old_sp)); \
             return ret; \
         })()
 

package/src/koffi/src/abi_arm64.cc

@@ -561,7 +561,7 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
     return true;
 }
 
-void CallData::Execute(const FunctionInfo *func)
+void CallData::Execute(const FunctionInfo *func, void *native)
 {
 #ifdef _WIN32
     TEB *teb = GetTEB();
@@ -589,8 +589,8 @@ void CallData::Execute(const FunctionInfo *func)
 
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
-            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, new_sp, &old_sp) \
-                                         : ForwardCall ## Suffix(func->func, new_sp, &old_sp)); \
+            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(native, new_sp, &old_sp) \
+                                         : ForwardCall ## Suffix(native, new_sp, &old_sp)); \
             return ret; \
         })()
 

package/src/koffi/src/abi_riscv64.cc

@@ -386,12 +386,12 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
     return true;
 }
 
-void CallData::Execute(const FunctionInfo *func)
+void CallData::Execute(const FunctionInfo *func, void *native)
 {
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
-            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, new_sp, &old_sp) \
-                                         : ForwardCall ## Suffix(func->func, new_sp, &old_sp)); \
+            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(native, new_sp, &old_sp) \
+                                         : ForwardCall ## Suffix(native, new_sp, &old_sp)); \
             return ret; \
         })()
 

package/src/koffi/src/abi_x64_sysv.cc

@@ -425,12 +425,12 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
     return true;
 }
 
-void CallData::Execute(const FunctionInfo *func)
+void CallData::Execute(const FunctionInfo *func, void *native)
 {
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
-            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, new_sp, &old_sp) \
-                                         : ForwardCall ## Suffix(func->func, new_sp, &old_sp)); \
+            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(native, new_sp, &old_sp) \
+                                         : ForwardCall ## Suffix(native, new_sp, &old_sp)); \
             return ret; \
         })()
 

package/src/koffi/src/abi_x64_win.cc

@@ -224,7 +224,7 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
     return true;
 }
 
-void CallData::Execute(const FunctionInfo *func)
+void CallData::Execute(const FunctionInfo *func, void *native)
 {
     TEB *teb = GetTEB();
 
@@ -250,8 +250,8 @@ void CallData::Execute(const FunctionInfo *func)
 
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
-            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(func->func, new_sp, &old_sp) \
-                                         : ForwardCall ## Suffix(func->func, new_sp, &old_sp)); \
+            auto ret = (func->forward_fp ? ForwardCallX ## Suffix(native, new_sp, &old_sp) \
+                                         : ForwardCall ## Suffix(native, new_sp, &old_sp)); \
             return ret; \
         })()
 

package/src/koffi/src/abi_x86.cc

@@ -308,7 +308,7 @@ bool CallData::Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info)
     return true;
 }
 
-void CallData::Execute(const FunctionInfo *func)
+void CallData::Execute(const FunctionInfo *func, void *native)
 {
 #ifdef _WIN32
     TEB *teb = GetTEB();
@@ -336,8 +336,8 @@ void CallData::Execute(const FunctionInfo *func)
 
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
-            auto ret = (func->fast ? ForwardCallR ## Suffix(func->func, new_sp, &old_sp) \
-                                   : ForwardCall ## Suffix(func->func, new_sp, &old_sp)); \
+            auto ret = (func->fast ? ForwardCallR ## Suffix(native, new_sp, &old_sp) \
+                                   : ForwardCall ## Suffix(native, new_sp, &old_sp)); \
             return ret; \
         })()
 

package/src/koffi/src/call.hh

@@ -102,7 +102,7 @@ public:
 #endif
 
     INLINE_IF_UNITY bool Prepare(const FunctionInfo *func, const Napi::CallbackInfo &info);
-    INLINE_IF_UNITY void Execute(const FunctionInfo *func);
+    INLINE_IF_UNITY void Execute(const FunctionInfo *func, void *native);
     INLINE_IF_UNITY Napi::Value Complete(const FunctionInfo *func);
 
 #undef INLINE_IF_UNITY

package/src/koffi/src/ffi.cc

@@ -204,14 +204,6 @@ 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();
@@ -275,7 +267,7 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
             value = array[1u];
             align = (int16_t)align64;
         }
- 
+
         member.type = ResolveType(value);
         if (!member.type)
             return env.Null();
@@ -403,7 +395,7 @@ static Napi::Value CreateUnionType(const Napi::CallbackInfo &info)
             value = array[1u];
             align = (int16_t)align64;
         }
- 
+
         member.type = ResolveType(value);
         if (!member.type)
             return env.Null();
@@ -920,10 +912,12 @@ static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value r
         func->parameters.Append(param);
     }
 
+    func->required_parameters = (int8_t)func->parameters.len;
+
     return true;
 }
 
-static Napi::Value CreateCallbackType(const Napi::CallbackInfo &info)
+static Napi::Value CreateFunctionType(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
@@ -956,6 +950,12 @@ static Napi::Value CreateCallbackType(const Napi::CallbackInfo &info)
     if (!AnalyseFunction(env, instance, func))
         return env.Null();
 
+    // Adjust parameter offsets for koffi.call()
+    for (ParameterInfo &param: func->parameters) {
+        param.offset += 2;
+    }
+    func->required_parameters += 2;
+
     // We cannot fail after this check
     if (instance->types_map.Find(func->name)) {
         ThrowError<Napi::Error>(env, "Duplicate type name '%1'", func->name);
@@ -1239,13 +1239,13 @@ static InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, S
     return mem;
 }
 
-static Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
+static Napi::Value TranslateNormalCall(const FunctionInfo *func, void *native,
+                                       const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
-    FunctionInfo *func = (FunctionInfo *)info.Data();
 
-    if (RG_UNLIKELY(info.Length() < (uint32_t)func->parameters.len)) {
+    if (RG_UNLIKELY(info.Length() < (uint32_t)func->required_parameters)) {
         ThrowError<Napi::TypeError>(env, "Expected %1 arguments, got %2", func->parameters.len, info.Length());
         return env.Null();
     }
@@ -1265,37 +1265,44 @@ static Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
         RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
         exec_call = &call;
 
-        call.Execute(func);
+        call.Execute(func, native);
     }
 
     return call.Complete(func);
 }
 
-static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
+Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
+{
+    FunctionInfo *func = (FunctionInfo *)info.Data();
+    return TranslateNormalCall(func, func->native, info);
+}
+
+static Napi::Value TranslateVariadicCall(const FunctionInfo *func, void *native,
+                                         const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
-    FunctionInfo func;
-    memcpy((void *)&func, info.Data(), RG_SIZE(FunctionInfo));
-    func.lib = nullptr;
+    FunctionInfo copy;
+    memcpy((void *)&copy, func, RG_SIZE(*func));
+    copy.lib = nullptr;
 
     // This makes variadic calls non-reentrant
-    RG_DEFER_C(len = func.parameters.len) {
-        func.parameters.RemoveFrom(len);
-        func.parameters.Leak();
+    RG_DEFER_C(len = copy.parameters.len) {
+        copy.parameters.RemoveFrom(len);
+        copy.parameters.Leak();
     };
 
-    if (RG_UNLIKELY(info.Length() < (uint32_t)func.parameters.len)) {
-        ThrowError<Napi::TypeError>(env, "Expected %1 arguments or more, got %2", func.parameters.len, info.Length());
+    if (RG_UNLIKELY(info.Length() < (uint32_t)copy.required_parameters)) {
+        ThrowError<Napi::TypeError>(env, "Expected %1 arguments or more, got %2", copy.parameters.len, info.Length());
         return env.Null();
     }
-    if (RG_UNLIKELY((info.Length() - func.parameters.len) % 2)) {
+    if (RG_UNLIKELY((info.Length() - copy.required_parameters) % 2)) {
         ThrowError<Napi::Error>(env, "Missing value argument for variadic call");
         return env.Null();
     }
 
-    for (Size i = func.parameters.len; i < (Size)info.Length(); i += 2) {
+    for (Size i = copy.required_parameters; i < (Size)info.Length(); i += 2) {
         ParameterInfo param = {};
 
         param.type = ResolveType(info[(uint32_t)i], &param.directions);
@@ -1306,11 +1313,11 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
             ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a parameter (maybe try %1 *)", param.type->name);
             return env.Null();
         }
-        if (RG_UNLIKELY(func.parameters.len >= MaxParameters)) {
+        if (RG_UNLIKELY(copy.parameters.len >= MaxParameters)) {
             ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 parameters", MaxParameters);
             return env.Null();
         }
-        if (RG_UNLIKELY((param.directions & 2) && ++func.out_parameters >= MaxOutParameters)) {
+        if (RG_UNLIKELY((param.directions & 2) && ++copy.out_parameters >= MaxOutParameters)) {
             ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 output parameters", MaxOutParameters);
             return env.Null();
         }
@@ -1318,20 +1325,20 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
         param.variadic = true;
         param.offset = (int8_t)(i + 1);
 
-        func.parameters.Append(param);
+        copy.parameters.Append(param);
     }
 
-    if (RG_UNLIKELY(!AnalyseFunction(env, instance, &func)))
+    if (RG_UNLIKELY(!AnalyseFunction(env, instance, &copy)))
         return env.Null();
 
     InstanceMemory *mem = instance->memories[0];
     CallData call(env, instance, mem);
 
-    if (!RG_UNLIKELY(call.Prepare(&func, info)))
+    if (!RG_UNLIKELY(call.Prepare(&copy, info)))
         return env.Null();
 
     if (instance->debug) {
-        call.DumpForward(&func);
+        call.DumpForward(&copy);
     }
 
     // Execute call
@@ -1339,23 +1346,31 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
         RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
         exec_call = &call;
 
-        call.Execute(&func);
+        call.Execute(&copy, native);
     }
 
-    return call.Complete(&func);
+    return call.Complete(&copy);
+}
+
+Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
+{
+    FunctionInfo *func = (FunctionInfo *)info.Data();
+    return TranslateVariadicCall(func, func->native, info);
 }
 
 class AsyncCall: public Napi::AsyncWorker {
     Napi::Env env;
+
     const FunctionInfo *func;
+    void *native;
 
     CallData call;
     bool prepared = false;
 
 public:
     AsyncCall(Napi::Env env, InstanceData *instance, const FunctionInfo *func,
-              InstanceMemory *mem, Napi::Function &callback)
-        : Napi::AsyncWorker(callback), env(env), func(func->Ref()),
+              void *native, InstanceMemory *mem, Napi::Function &callback)
+        : Napi::AsyncWorker(callback), env(env), func(func->Ref()), native(native),
           call(env, instance, mem) {}
     ~AsyncCall() { func->Unref(); }
 
@@ -1381,7 +1396,7 @@ void AsyncCall::Execute()
         RG_DEFER_C(prev_call = exec_call) { exec_call = prev_call; };
         exec_call = &call;
 
-        call.Execute(func);
+        call.Execute(func, native);
     }
 }
 
@@ -1400,18 +1415,20 @@ void AsyncCall::OnOK()
     callback.Call(self, RG_LEN(args), args);
 }
 
-static Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info)
+static Napi::Value TranslateAsyncCall(const FunctionInfo *func, void *native,
+                                      const Napi::CallbackInfo &info)
 {
+    RG_ASSERT(!func->variadic);
+
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
-    FunctionInfo *func = (FunctionInfo *)info.Data();
 
-    if (info.Length() <= (uint32_t)func->parameters.len) {
+    if (info.Length() <= (uint32_t)func->required_parameters) {
         ThrowError<Napi::TypeError>(env, "Expected %1 arguments, got %2", func->parameters.len + 1, info.Length());
         return env.Null();
     }
 
-    Napi::Function callback = info[(uint32_t)func->parameters.len].As<Napi::Function>();
+    Napi::Function callback = info[(uint32_t)func->required_parameters].As<Napi::Function>();
 
     if (!callback.IsFunction()) {
         ThrowError<Napi::TypeError>(env, "Expected callback function as last argument, got %1", GetValueType(instance, callback));
@@ -1423,7 +1440,7 @@ static Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info)
         ThrowError<Napi::Error>(env, "Too many asynchronous calls are running");
         return env.Null();
     }
-    AsyncCall *async = new AsyncCall(env, instance, func, mem, callback);
+    AsyncCall *async = new AsyncCall(env, instance, func, native, mem, callback);
 
     if (async->Prepare(info) && instance->debug) {
         async->DumpForward();
@@ -1433,6 +1450,12 @@ static Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info)
     return env.Undefined();
 }
 
+Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info)
+{
+    FunctionInfo *func = (FunctionInfo *)info.Data();
+    return TranslateAsyncCall(func, func->native, info);
+}
+
 static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConvention convention)
 {
     Napi::Env env = info.Env();
@@ -1478,57 +1501,31 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
 #ifdef _WIN32
     if (info[0].IsString()) {
         if (func->decorated_name) {
-            func->func = (void *)GetProcAddress((HMODULE)lib->module, func->decorated_name);
+            func->native = (void *)GetProcAddress((HMODULE)lib->module, func->decorated_name);
         }
-        if (!func->func) {
-            func->func = (void *)GetProcAddress((HMODULE)lib->module, func->name);
+        if (!func->native) {
+            func->native = (void *)GetProcAddress((HMODULE)lib->module, func->name);
         }
     } else {
         uint16_t ordinal = (uint16_t)info[0].As<Napi::Number>().Uint32Value();
 
         func->decorated_name = nullptr;
-        func->func = (void *)GetProcAddress((HMODULE)lib->module, (LPCSTR)(size_t)ordinal);
+        func->native = (void *)GetProcAddress((HMODULE)lib->module, (LPCSTR)(size_t)ordinal);
     }
 #else
     if (func->decorated_name) {
-        func->func = dlsym(lib->module, func->decorated_name);
+        func->native = dlsym(lib->module, func->decorated_name);
     }
-    if (!func->func) {
-        func->func = dlsym(lib->module, func->name);
+    if (!func->native) {
+        func->native = dlsym(lib->module, func->name);
     }
 #endif
-    if (!func->func) {
+    if (!func->native) {
         ThrowError<Napi::Error>(env, "Cannot find function '%1' in shared library", func->name);
         return env.Null();
     }
 
-    Napi::Function::Callback call = func->variadic ? TranslateVariadicCall : TranslateNormalCall;
-    Napi::Function wrapper = Napi::Function::New(env, call, func->name, (void *)func->Ref());
-    wrapper.AddFinalizer([](Napi::Env, FunctionInfo *func) { func->Unref(); }, func);
-
-    if (!func->variadic) {
-        Napi::Function async = Napi::Function::New(env, TranslateAsyncCall, func->name, (void *)func->Ref());
-        async.AddFinalizer([](Napi::Env, FunctionInfo *func) { func->Unref(); }, func);
-        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);
-    }
-
+    Napi::Function wrapper = WrapFunction(env, func);
     return wrapper;
 }
 
@@ -2064,6 +2061,34 @@ static Napi::Value GetPointerAddress(const Napi::CallbackInfo &info)
     return bigint;
 }
 
+static Napi::Value CallPointerSync(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (RG_UNLIKELY(info.Length() < 2)) {
+        ThrowError<Napi::TypeError>(env, "Expected 2 or more arguments, got %1", info.Length());
+        return env.Null();
+    }
+
+    void *ptr = nullptr;
+    if (RG_UNLIKELY(!GetExternalPointer(env, info[0], &ptr)))
+        return env.Null();
+
+    const TypeInfo *type = ResolveType(info[1]);
+    if (RG_UNLIKELY(!type))
+        return env.Null();
+    if (RG_UNLIKELY(type->primitive != PrimitiveKind::Prototype)) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for type, expected function type", GetValueType(instance, info[1]));
+        return env.Null();
+    }
+
+    const FunctionInfo *proto = type->ref.proto;
+    RG_ASSERT(!proto->variadic);
+
+    return TranslateNormalCall(proto, ptr, info);
+}
+
 extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
 {
     if (RG_LIKELY(exec_call)) {
@@ -2106,7 +2131,7 @@ static void SetExports(Napi::Env env, Func func)
     func("opaque", Napi::Function::New(env, CreateOpaqueType));
     func("pointer", Napi::Function::New(env, CreatePointerType));
     func("array", Napi::Function::New(env, CreateArrayType));
-    func("callback", Napi::Function::New(env, CreateCallbackType));
+    func("proto", Napi::Function::New(env, CreateFunctionType));
     func("alias", Napi::Function::New(env, CreateTypeAlias));
 
     func("sizeof", Napi::Function::New(env, GetTypeSize));
@@ -2130,6 +2155,7 @@ static void SetExports(Napi::Env env, Func func)
     func("as", Napi::Function::New(env, CastValue));
     func("decode", Napi::Function::New(env, DecodeValue));
     func("address", Napi::Function::New(env, GetPointerAddress));
+    func("call", Napi::Function::New(env, CallPointerSync));
 
     func("errno", Napi::Function::New(env, GetOrSetErrNo));
 

package/src/koffi/src/ffi.hh

@@ -221,11 +221,12 @@ struct FunctionInfo {
     const char *decorated_name; // Only set for some platforms/calling conventions
     const LibraryHolder *lib = nullptr;
 
-    void *func;
+    void *native;
     CallConvention convention;
 
     ParameterInfo ret;
     HeapArray<ParameterInfo> parameters;
+    int8_t required_parameters;
     int8_t out_parameters;
     bool variadic;
 
@@ -335,4 +336,8 @@ RG_STATIC_ASSERT(MaxTrampolines <= INT16_MAX);
 
 extern SharedData shared;
 
+Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info);
+Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info);
+Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info);
+
 }

package/src/koffi/src/parser.cc

@@ -99,6 +99,8 @@ bool PrototypeParser::Parse(const char *str, FunctionInfo *out_func)
     }
     Consume(")");
 
+    out_func->required_parameters = (int8_t)out_func->parameters.len;
+
     Match(";");
     if (offset < tokens.len) {
         MarkError("Unexpected token '%1' after prototype", tokens[offset]);

package/src/koffi/src/util.cc

@@ -345,6 +345,14 @@ const TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size
     return MakeArrayType(instance, ref, len, hint, false);
 }
 
+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;
+}
+
 bool CanPassType(const TypeInfo *type, int directions)
 {
     if (directions & 2) {
@@ -1041,7 +1049,8 @@ Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, cons
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
     if (len && type->primitive != PrimitiveKind::String &&
-               type->primitive != PrimitiveKind::String16) {
+               type->primitive != PrimitiveKind::String16 &&
+               type->primitive != PrimitiveKind::Prototype) {
         if (*len >= 0) {
             type = MakeArrayType(instance, type, *len);
         } else {
@@ -1144,8 +1153,28 @@ Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, cons
         } break;
 
         case PrimitiveKind::Prototype: {
-            ThrowError<Napi::TypeError>(env, "Cannot decode value of type %1", type->name);
-            return env.Null();
+            const FunctionInfo *proto = type->ref.proto;
+            RG_ASSERT(!proto->variadic);
+            RG_ASSERT(!proto->lib);
+
+            FunctionInfo *func = new FunctionInfo();
+            RG_DEFER { func->Unref(); };
+
+            memcpy((void *)func, proto, RG_SIZE(*proto));
+            memset((void *)&func->parameters, 0, RG_SIZE(func->parameters));
+            func->parameters = proto->parameters;
+
+            func->name = "<anonymous>";
+            func->native = (void *)ptr;
+
+            // Fix back parameter offset
+            for (ParameterInfo &param: func->parameters) {
+                param.offset -= 2;
+            }
+            func->required_parameters -= 2;
+
+            Napi::Function wrapper = WrapFunction(env, func);
+            return wrapper;
         } break;
     }
 
@@ -1155,6 +1184,48 @@ Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, cons
     return env.Null();
 }
 
+Napi::Function WrapFunction(Napi::Env env, const FunctionInfo *func)
+{
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    Napi::Function wrapper;
+    if (func->variadic) {
+        Napi::Function::Callback call = TranslateVariadicCall;
+        wrapper = Napi::Function::New(env, call, func->name, (void *)func->Ref());
+    } else {
+        Napi::Function::Callback call = TranslateNormalCall;
+        wrapper = Napi::Function::New(env, call, func->name, (void *)func->Ref());
+    }
+    wrapper.AddFinalizer([](Napi::Env, FunctionInfo *func) { func->Unref(); }, (FunctionInfo *)func);
+
+    if (!func->variadic) {
+        Napi::Function::Callback call = TranslateAsyncCall;
+        Napi::Function async = Napi::Function::New(env, call, func->name, (void *)func->Ref());
+
+        async.AddFinalizer([](Napi::Env, FunctionInfo *func) { func->Unref(); }, (FunctionInfo *)func);
+        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;
+}
+
 static int AnalyseFlatRec(const TypeInfo *type, int offset, int count, FunctionRef<void(const TypeInfo *type, int offset, int count)> func)
 {
     if (type->primitive == PrimitiveKind::Record) {

package/src/koffi/src/util.hh

@@ -93,6 +93,8 @@ const TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *ref, int
 const TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len);
 const TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len, ArrayHint hint);
 
+Napi::External<TypeInfo> WrapType(Napi::Env env, InstanceData *instance, const TypeInfo *type);
+
 bool CanPassType(const TypeInfo *type, int directions);
 bool CanReturnType(const TypeInfo *type);
 bool CanStoreType(const TypeInfo *type);
@@ -185,6 +187,8 @@ static inline Napi::Value NewBigInt(Napi::Env env, uint64_t value)
     }
 }
 
+Napi::Function WrapFunction(Napi::Env env, const FunctionInfo *func);
+
 int AnalyseFlat(const TypeInfo *type, FunctionRef<void(const TypeInfo *type, int offset, int count)> func);
 
 void DumpMemory(const char *type, Span<const uint8_t> bytes);