koffi 1.0.3 → 1.0.4

package/src/abi_x86.cc

@@ -82,33 +82,24 @@ bool AnalyseFunction(InstanceData *instance, FunctionInfo *func)
     return true;
 }
 
-Napi::Value CallData::Execute(const Napi::CallbackInfo &info)
+bool CallData::Prepare(const Napi::CallbackInfo &info)
 {
-    // Sanity checks
-    if (info.Length() < (uint32_t)func->parameters.len) {
-        ThrowError<Napi::TypeError>(env, "Expected %1 arguments, got %2", func->parameters.len, info.Length());
-        return env.Null();
-    }
-
-    uint8_t *return_ptr = nullptr;
     uint32_t *args_ptr = nullptr;
     uint32_t *fast_ptr = nullptr;
 
     // Pass return value in register or through memory
     if (RG_UNLIKELY(!AllocStack(func->args_size, 16, &args_ptr)))
-        return env.Null();
+        return false;
     if (func->convention == CallConvention::Fastcall) {
         fast_ptr = args_ptr;
         args_ptr += 4;
     }
     if (!func->ret.trivial) {
         if (RG_UNLIKELY(!AllocHeap(func->ret.type->size, 16, &return_ptr)))
-            return env.Null();
+            return false;
         *((func->ret.fast ? fast_ptr : args_ptr)++) = (uint32_t)return_ptr;
     }
 
-    LocalArray<OutObject, MaxOutParameters> out_objects;
-
     // Push arguments
     for (Size i = 0; i < func->parameters.len; i++) {
         const ParameterInfo &param = func->parameters[i];
@@ -122,7 +113,7 @@ Napi::Value CallData::Execute(const Napi::CallbackInfo &info)
             case PrimitiveKind::Bool: {
                 if (RG_UNLIKELY(!value.IsBoolean())) {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected boolean", GetValueType(instance, value), i + 1);
-                    return env.Null();
+                    return false;
                 }
 
                 bool b = value.As<Napi::Boolean>();
@@ -136,7 +127,7 @@ Napi::Value CallData::Execute(const Napi::CallbackInfo &info)
             case PrimitiveKind::UInt32: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
-                    return env.Null();
+                    return false;
                 }
 
                 int32_t v = CopyNumber<int32_t>(value);
@@ -146,43 +137,24 @@ Napi::Value CallData::Execute(const Napi::CallbackInfo &info)
             case PrimitiveKind::UInt64: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
-                    return env.Null();
+                    return false;
                 }
 
                 int64_t v = CopyNumber<int64_t>(value);
                 *(uint64_t *)args_ptr = (uint64_t)v;
                 args_ptr += 2;
             } break;
-            case PrimitiveKind::Float32: {
-                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
-                    return env.Null();
-                }
-
-                float f = CopyNumber<float>(value);
-                *(float *)((param.fast ? fast_ptr : args_ptr)++) = f;
-            } break;
-            case PrimitiveKind::Float64: {
-                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
-                    return env.Null();
-                }
-
-                double d = CopyNumber<double>(value);
-                *(double *)args_ptr = d;
-                args_ptr += 2;
-            } break;
             case PrimitiveKind::String: {
                 const char *str;
                 if (RG_LIKELY(value.IsString())) {
                     str = PushString(value);
                     if (RG_UNLIKELY(!str))
-                        return env.Null();
+                        return false;
                 } else if (IsNullOrUndefined(value)) {
                     str = nullptr;
                 } else {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected string", GetValueType(instance, value), i + 1);
-                    return env.Null();
+                    return false;
                 }
 
                 *(const char **)((param.fast ? fast_ptr : args_ptr)++) = str;
@@ -192,12 +164,12 @@ Napi::Value CallData::Execute(const Napi::CallbackInfo &info)
                 if (RG_LIKELY(value.IsString())) {
                     str16 = PushString16(value);
                     if (RG_UNLIKELY(!str16))
-                        return env.Null();
+                        return false;
                 } else if (IsNullOrUndefined(value)) {
                     str16 = nullptr;
                 } else {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected string", GetValueType(instance, value), i + 1);
-                    return env.Null();
+                    return false;
                 }
 
                 *(const char16_t **)((param.fast ? fast_ptr : args_ptr)++) = str16;
@@ -211,11 +183,11 @@ Napi::Value CallData::Execute(const Napi::CallbackInfo &info)
                     Napi::Object obj = value.As<Napi::Object>();
 
                     if (RG_UNLIKELY(!AllocHeap(param.type->ref->size, 16, &ptr)))
-                        return env.Null();
+                        return false;
 
                     if (param.directions & 1) {
                         if (!PushObject(obj, param.type->ref, ptr))
-                            return env.Null();
+                            return false;
                     } else {
                         memset(ptr, 0, param.type->size);
                     }
@@ -227,16 +199,15 @@ Napi::Value CallData::Execute(const Napi::CallbackInfo &info)
                     ptr = nullptr;
                 } else {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected %3", GetValueType(instance, value), i + 1, param.type->name);
-                    return env.Null();
+                    return false;
                 }
 
                 *(uint8_t **)((param.fast ? fast_ptr : args_ptr)++) = ptr;
             } break;
-
             case PrimitiveKind::Record: {
                 if (RG_UNLIKELY(!IsObject(value))) {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected object", GetValueType(instance, value), i + 1);
-                    return env.Null();
+                    return false;
                 }
 
                 Napi::Object obj = value.As<Napi::Object>();
@@ -244,93 +215,107 @@ Napi::Value CallData::Execute(const Napi::CallbackInfo &info)
                 if (param.fast) {
                     uint8_t *ptr = (uint8_t *)(fast_ptr++);
                     if (!PushObject(obj, param.type, ptr))
-                        return env.Null();
+                        return false;
                 } else {
                     uint8_t *ptr = (uint8_t *)AlignUp(args_ptr, param.type->align);
                     if (!PushObject(obj, param.type, ptr))
-                        return env.Null();
+                        return false;
                     args_ptr = (uint32_t *)AlignUp(ptr + param.type->size, 4);
                 }
             } break;
+            case PrimitiveKind::Float32: {
+                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
+                    return false;
+                }
+
+                float f = CopyNumber<float>(value);
+                *(float *)((param.fast ? fast_ptr : args_ptr)++) = f;
+            } break;
+            case PrimitiveKind::Float64: {
+                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
+                    return false;
+                }
+
+                double d = CopyNumber<double>(value);
+                *(double *)args_ptr = d;
+                args_ptr += 2;
+            } break;
         }
     }
 
-    if (instance->debug) {
-        DumpDebug();
-    }
+    return true;
+}
 
+void CallData::Execute()
+{
 #define PERFORM_CALL(Suffix) \
         ([&]() { \
             auto ret = (func->convention == CallConvention::Fastcall ? ForwardCallR ## Suffix(func->func, GetSP()) \
                                                                      : ForwardCall ## Suffix(func->func, GetSP())); \
-            PopOutArguments(out_objects); \
             return ret; \
         })()
 
     // Execute and convert return value
     switch (func->ret.type->primitive) {
-        case PrimitiveKind::Void: {
-            PERFORM_CALL(G);
-            return env.Null();
-        } break;
-        case PrimitiveKind::Bool: {
-            uint32_t rax = (uint32_t)PERFORM_CALL(G);
-            return Napi::Boolean::New(env, rax);
-        } break;
+        case PrimitiveKind::Void:
+        case PrimitiveKind::Bool:
         case PrimitiveKind::Int8:
         case PrimitiveKind::UInt8:
         case PrimitiveKind::Int16:
         case PrimitiveKind::UInt16:
         case PrimitiveKind::Int32:
-        case PrimitiveKind::UInt32: {
-            uint32_t rax = (uint32_t)PERFORM_CALL(G);
-            return Napi::Number::New(env, (double)rax);
-        } break;
-        case PrimitiveKind::Int64: {
-            uint64_t ret = PERFORM_CALL(G);
-            return Napi::BigInt::New(env, (int64_t)ret);
-        } break;
-        case PrimitiveKind::UInt64: {
-            uint64_t ret = PERFORM_CALL(G);
-            return Napi::BigInt::New(env, ret);
-        } break;
-        case PrimitiveKind::Float32: {
-            float f = PERFORM_CALL(F);
-            return Napi::Number::New(env, (double)f);
-        } break;
-        case PrimitiveKind::Float64: {
-            double d = PERFORM_CALL(D);
-            return Napi::Number::New(env, d);
-        } break;
-        case PrimitiveKind::String: {
-            uint32_t rax = (uint32_t)PERFORM_CALL(G);
-            return Napi::String::New(env, (const char *)rax);
-        } break;
-        case PrimitiveKind::String16: {
-            uint32_t rax = (uint32_t)PERFORM_CALL(G);
-            return Napi::String::New(env, (const char16_t *)rax);
-        } break;
-        case PrimitiveKind::Pointer: {
-            uint32_t rax = (uint32_t)PERFORM_CALL(G);
-            void *ptr = (void *)rax;
+        case PrimitiveKind::UInt32:
+        case PrimitiveKind::Int64:
+        case PrimitiveKind::UInt64:
+        case PrimitiveKind::String:
+        case PrimitiveKind::String16:
+        case PrimitiveKind::Pointer:
+        case PrimitiveKind::Record: { result.u64 = PERFORM_CALL(G); } break;
+        case PrimitiveKind::Float32: { result.f = PERFORM_CALL(F); } break;
+        case PrimitiveKind::Float64: { result.d = PERFORM_CALL(D); } break;
+    }
 
-            Napi::External<void> external = Napi::External<void>::New(env, ptr);
+#undef PERFORM_CALL
+}
+
+Napi::Value CallData::Complete()
+{
+    for (const OutObject &obj: out_objects) {
+        PopObject(obj.obj, obj.ptr, obj.type);
+    }
+
+    switch (func->ret.type->primitive) {
+        case PrimitiveKind::Void: return env.Null();
+        case PrimitiveKind::Bool: return Napi::Boolean::New(env, result.u32);
+        case PrimitiveKind::Int8:
+        case PrimitiveKind::UInt8:
+        case PrimitiveKind::Int16:
+        case PrimitiveKind::UInt16:
+        case PrimitiveKind::Int32:
+        case PrimitiveKind::UInt32: return Napi::Number::New(env, (double)result.u32);
+        case PrimitiveKind::Int64: return Napi::BigInt::New(env, (int64_t)result.u64);
+        case PrimitiveKind::UInt64: return Napi::BigInt::New(env, result.u64);
+        case PrimitiveKind::String: return Napi::String::New(env, (const char *)result.ptr);
+        case PrimitiveKind::String16: return Napi::String::New(env, (const char16_t *)result.ptr);
+        case PrimitiveKind::Pointer: {
+            Napi::External<void> external = Napi::External<void>::New(env, result.ptr);
             SetValueTag(instance, external, func->ret.type);
 
             return external;
         } break;
-
         case PrimitiveKind::Record: {
-            uint64_t ret = PERFORM_CALL(G);
-            const uint8_t *ptr = return_ptr ? return_ptr : (const uint8_t *)&ret;
+            const uint8_t *ptr = return_ptr ? (const uint8_t *)return_ptr
+                                            : (const uint8_t *)&result.buf;
 
-            Napi::Object obj = PopObject(env, ptr, func->ret.type);
+            Napi::Object obj = PopObject(ptr, func->ret.type);
             return obj;
         } break;
+        case PrimitiveKind::Float32: return Napi::Number::New(env, (double)result.f);
+        case PrimitiveKind::Float64: return Napi::Number::New(env, result.d);
     }
 
-#undef PERFORM_CALL
-
     RG_UNREACHABLE();
 }
 

package/src/call.cc

@@ -156,24 +156,6 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
                 int64_t v = CopyNumber<int64_t>(value);
                 memcpy(dest, &v, member.type->size); // Little Endian
             } break;
-            case PrimitiveKind::Float32: {
-                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected number", GetValueType(instance, value), member.name);
-                    return false;
-                }
-
-                float f = CopyNumber<float>(value);
-                memcpy(dest, &f, 4);
-            } break;
-            case PrimitiveKind::Float64: {
-                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected number", GetValueType(instance, value), member.name);
-                    return false;
-                }
-
-                double d = CopyNumber<double>(value);
-                memcpy(dest, &d, 8);
-            } break;
             case PrimitiveKind::String: {
                 if (RG_UNLIKELY(!value.IsString())) {
                     ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected string", GetValueType(instance, value), member.name);
@@ -206,7 +188,6 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
                 void *ptr = external.Data();
                 *(void **)dest = ptr;
             } break;
-
             case PrimitiveKind::Record: {
                 if (RG_UNLIKELY(!IsObject(value))) {
                     ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected object", GetValueType(instance, value), member.name);
@@ -217,6 +198,24 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
                 if (!PushObject(obj, member.type, dest))
                     return false;
             } break;
+            case PrimitiveKind::Float32: {
+                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected number", GetValueType(instance, value), member.name);
+                    return false;
+                }
+
+                float f = CopyNumber<float>(value);
+                memcpy(dest, &f, 4);
+            } break;
+            case PrimitiveKind::Float64: {
+                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected number", GetValueType(instance, value), member.name);
+                    return false;
+                }
+
+                double d = CopyNumber<double>(value);
+                memcpy(dest, &d, 8);
+            } break;
         }
 
         dest += member.type->size;
@@ -225,4 +224,130 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
     return true;
 }
 
+void CallData::PopObject(Napi::Object obj, const uint8_t *ptr, const TypeInfo *type)
+{
+    Napi::Env env = obj.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    RG_ASSERT(type->primitive == PrimitiveKind::Record);
+
+    for (const RecordMember &member: type->members) {
+        ptr = AlignUp(ptr, member.align);
+
+        switch (member.type->primitive) {
+            case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
+
+            case PrimitiveKind::Bool: {
+                bool b = *(bool *)ptr;
+                obj.Set(member.name, Napi::Boolean::New(env, b));
+            } break;
+            case PrimitiveKind::Int8: {
+                double d = (double)*(int8_t *)ptr;
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::UInt8: {
+                double d = (double)*(uint8_t *)ptr;
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::Int16: {
+                double d = (double)*(int16_t *)ptr;
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::UInt16: {
+                double d = (double)*(uint16_t *)ptr;
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::Int32: {
+                double d = (double)*(int32_t *)ptr;
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::UInt32: {
+                double d = (double)*(uint32_t *)ptr;
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+            case PrimitiveKind::Int64: {
+                int64_t v = *(int64_t *)ptr;
+                obj.Set(member.name, Napi::BigInt::New(env, v));
+            } break;
+            case PrimitiveKind::UInt64: {
+                uint64_t v = *(uint64_t *)ptr;
+                obj.Set(member.name, Napi::BigInt::New(env, v));
+            } break;
+            case PrimitiveKind::String: {
+                const char *str = *(const char **)ptr;
+                obj.Set(member.name, Napi::String::New(env, str));
+            } break;
+            case PrimitiveKind::String16: {
+                const char16_t *str16 = *(const char16_t **)ptr;
+                obj.Set(member.name, Napi::String::New(env, str16));
+            } break;
+            case PrimitiveKind::Pointer: {
+                void *ptr2 = *(void **)ptr;
+
+                Napi::External<void> external = Napi::External<void>::New(env, ptr2);
+                SetValueTag(instance, external, member.type);
+
+                obj.Set(member.name, external);
+            } break;
+            case PrimitiveKind::Record: {
+                Napi::Object obj2 = PopObject(ptr, member.type);
+                obj.Set(member.name, obj2);
+            } break;
+            case PrimitiveKind::Float32: {
+                float f;
+                memcpy(&f, ptr, 4);
+                obj.Set(member.name, Napi::Number::New(env, (double)f));
+            } break;
+            case PrimitiveKind::Float64: {
+                double d;
+                memcpy(&d, ptr, 8);
+                obj.Set(member.name, Napi::Number::New(env, d));
+            } break;
+        }
+
+        ptr += member.type->size;
+    }
+}
+
+Napi::Object CallData::PopObject(const uint8_t *ptr, const TypeInfo *type)
+{
+    Napi::Object obj = Napi::Object::New(env);
+    PopObject(obj, ptr, type);
+    return obj;
+}
+
+static void DumpMemory(const char *type, Span<const uint8_t> bytes)
+{
+    if (bytes.len) {
+        PrintLn(stderr, "%1 at 0x%2 (%3):", type, bytes.ptr, FmtMemSize(bytes.len));
+
+        for (const uint8_t *ptr = bytes.begin(); ptr < bytes.end();) {
+            Print(stderr, "  [0x%1 %2 %3]  ", FmtArg(ptr).Pad0(-16),
+                                              FmtArg((ptr - bytes.begin()) / sizeof(void *)).Pad(-4),
+                                              FmtArg(ptr - bytes.begin()).Pad(-4));
+            for (int i = 0; ptr < bytes.end() && i < (int)sizeof(void *); i++, ptr++) {
+                Print(stderr, " %1", FmtHex(*ptr).Pad0(-2));
+            }
+            PrintLn(stderr);
+        }
+    }
+}
+
+void CallData::DumpDebug() const
+{
+    PrintLn(stderr, "%!..+---- %1 (%2) ----%!0", func->name, CallConventionNames[(int)func->convention]);
+
+    if (func->parameters.len) {
+        PrintLn(stderr, "Parameters:");
+        for (Size i = 0; i < func->parameters.len; i++) {
+            const ParameterInfo &param = func->parameters[i];
+            PrintLn(stderr, "  %1 = %2 (%3)", i, param.type->name, FmtMemSize(param.type->size));
+        }
+    }
+    PrintLn(stderr, "Return: %1 (%2)", func->ret.type->name, FmtMemSize(func->ret.type->size));
+
+    DumpMemory("Stack", GetStack());
+    DumpMemory("Heap", GetHeap());
+}
+
 }

package/src/call.hh

@@ -28,13 +28,30 @@ class CallData {
     InstanceData *instance;
     const FunctionInfo *func;
 
+    struct OutObject {
+        Napi::Object obj;
+        const uint8_t *ptr;
+        const TypeInfo *type;
+    };
+
     Span<uint8_t> *stack_mem;
     Span<uint8_t> *heap_mem;
+    LocalArray<OutObject, MaxOutParameters> out_objects;
     BlockAllocator big_alloc;
 
     Span<uint8_t> old_stack_mem;
     Span<uint8_t> old_heap_mem;
 
+    union {
+        uint32_t u32;
+        uint64_t u64;
+        float f;
+        double d;
+        void *ptr;
+        uint8_t buf[32];
+    } result;
+    uint8_t *return_ptr = nullptr;
+
 public:
     CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func);
     ~CallData();
@@ -56,6 +73,26 @@ public:
         return MakeSpan(ptr, len);
     }
 
+    bool Prepare(const Napi::CallbackInfo &info);
+    void Execute();
+    Napi::Value Complete();
+
+    Napi::Value Run(const Napi::CallbackInfo &info)
+    {
+        if (!RG_UNLIKELY(Prepare(info)))
+            return env.Null();
+
+        if (instance->debug) {
+            DumpDebug();
+        }
+
+        Execute();
+        return Complete();
+    }
+
+    void DumpDebug() const;
+
+private:
     template <typename T = void>
     bool AllocStack(Size size, Size align, T **out_ptr = nullptr);
     template <typename T = void>
@@ -65,9 +102,8 @@ public:
     const char16_t *PushString16(const Napi::Value &value);
     bool PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest);
 
-    void DumpDebug() const;
-
-    Napi::Value Execute(const Napi::CallbackInfo &info);
+    void PopObject(Napi::Object obj, const uint8_t *ptr, const TypeInfo *type);
+    Napi::Object PopObject(const uint8_t *ptr, const TypeInfo *type);
 };
 
 template <typename T>

package/src/ffi.cc

@@ -247,8 +247,13 @@ static Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
     InstanceData *instance = env.GetInstanceData<InstanceData>();
     FunctionInfo *func = (FunctionInfo *)info.Data();
 
+    if (info.Length() < (uint32_t)func->parameters.len) {
+        ThrowError<Napi::TypeError>(env, "Expected %1 arguments, got %2", func->parameters.len, info.Length());
+        return env.Null();
+    }
+
     CallData call(env, instance, func);
-    return call.Execute(info);
+    return call.Run(info);
 }
 
 static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
@@ -266,6 +271,10 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
         func.parameters.Leak();
     };
 
+    if (info.Length() < (uint32_t)func.parameters.len) {
+        ThrowError<Napi::TypeError>(env, "Expected %1 arguments or more, got %2", func.parameters.len, info.Length());
+        return env.Null();
+    }
     if ((info.Length() - func.parameters.len) % 2) {
         ThrowError<Napi::Error>(env, "Missing value argument for variadic call");
         return env.Null();
@@ -301,7 +310,7 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
         return env.Null();
 
     CallData call(env, instance, &func);
-    return call.Execute(info);
+    return call.Run(info);
 }
 
 static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value ret,

package/src/ffi.hh

@@ -26,7 +26,6 @@ extern const int TypeInfoMarker;
 
 enum class PrimitiveKind {
     Void,
-
     Bool,
     Int8,
     UInt8,
@@ -36,18 +35,15 @@ enum class PrimitiveKind {
     UInt32,
     Int64,
     UInt64,
-    Float32,
-    Float64,
     String,
     String16,
-
     Pointer,
-
-    Record
+    Record,
+    Float32,
+    Float64
 };
 static const char *const PrimitiveKindNames[] = {
     "Void",
-
     "Bool",
     "Int8",
     "UInt8",
@@ -57,14 +53,12 @@ static const char *const PrimitiveKindNames[] = {
     "UInt32",
     "Int64",
     "UInt64",
-    "Float32",
-    "Float64",
     "String",
     "String16",
-
     "Pointer",
-
-    "Record"
+    "Record",
+    "Float32",
+    "Float64"
 };
 
 struct TypeInfo;