koffi 2.3.21-beta.3 → 2.3.21-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "koffi",
-    "version": "2.3.21-beta.3",
+    "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/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();
@@ -1279,7 +1271,7 @@ static Napi::Value TranslateNormalCall(const FunctionInfo *func, void *native,
     return call.Complete(func);
 }
 
-static Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
+Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
 {
     FunctionInfo *func = (FunctionInfo *)info.Data();
     return TranslateNormalCall(func, func->native, info);
@@ -1360,7 +1352,7 @@ static Napi::Value TranslateVariadicCall(const FunctionInfo *func, void *native,
     return call.Complete(&copy);
 }
 
-static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
+Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
 {
     FunctionInfo *func = (FunctionInfo *)info.Data();
     return TranslateVariadicCall(func, func->native, info);
@@ -1458,7 +1450,7 @@ static Napi::Value TranslateAsyncCall(const FunctionInfo *func, void *native,
     return env.Undefined();
 }
 
-static Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info)
+Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info)
 {
     FunctionInfo *func = (FunctionInfo *)info.Data();
     return TranslateAsyncCall(func, func->native, info);
@@ -1533,41 +1525,7 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
         return env.Null();
     }
 
-    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(); }, 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(); }, 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;
 }
 
@@ -2120,50 +2078,15 @@ static Napi::Value CallPointerSync(const Napi::CallbackInfo &info)
     const TypeInfo *type = ResolveType(info[1]);
     if (RG_UNLIKELY(!type))
         return env.Null();
-    if (RG_UNLIKELY(type->primitive != PrimitiveKind::Callback)) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for type, expected function pointer type", GetValueType(instance, info[1]));
+    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);
 
-    if (proto->variadic) {
-        return TranslateVariadicCall(proto, ptr, info);
-    } else {
-        return TranslateNormalCall(proto, ptr, info);
-    }
-}
-
-static Napi::Value CallPointerAsync(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::Callback)) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for type, expected function pointer type", GetValueType(instance, info[1]));
-        return env.Null();
-    }
-
-    const FunctionInfo *proto = type->ref.proto;
-
-    if (RG_UNLIKELY(proto->variadic)) {
-        ThrowError<Napi::TypeError>(env, "Cannot call variadic function asynchronously");
-        return env.Null();
-    }
-
-    return TranslateAsyncCall(proto, ptr, info);
+    return TranslateNormalCall(proto, ptr, info);
 }
 
 extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg)
@@ -2233,7 +2156,6 @@ static void SetExports(Napi::Env env, Func func)
     func("decode", Napi::Function::New(env, DecodeValue));
     func("address", Napi::Function::New(env, GetPointerAddress));
     func("call", Napi::Function::New(env, CallPointerSync));
-    func("callAsync", Napi::Function::New(env, CallPointerAsync));
 
     func("errno", Napi::Function::New(env, GetOrSetErrNo));
 

package/src/koffi/src/ffi.hh

@@ -336,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/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);