koffi 1.1.0 → 1.1.3

package/src/call.cc

@@ -142,21 +142,77 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
                 bool b = value.As<Napi::Boolean>();
                 *(bool *)dest = b;
             } break;
-            case PrimitiveKind::Int8:
-            case PrimitiveKind::UInt8:
-            case PrimitiveKind::Int16:
-            case PrimitiveKind::UInt16:
-            case PrimitiveKind::Int32:
-            case PrimitiveKind::UInt32:
-            case PrimitiveKind::Int64:
-            case PrimitiveKind::UInt64: {
+            case PrimitiveKind::Int8: {
+                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
+                    return false;
+                }
+
+                int8_t v = CopyNumber<int8_t>(value);
+                *(int8_t *)dest = v;
+            } break;
+            case PrimitiveKind::UInt8: {
+                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
+                    return false;
+                }
+
+                uint8_t v = CopyNumber<uint8_t>(value);
+                *(uint8_t *)dest = v;
+            } break;
+            case PrimitiveKind::Int16: {
+                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
+                    return false;
+                }
+
+                int16_t v = CopyNumber<int16_t>(value);
+                *(int16_t *)dest = v;
+            } break;
+            case PrimitiveKind::UInt16: {
+                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
+                    return false;
+                }
+
+                uint16_t v = CopyNumber<uint16_t>(value);
+                *(uint16_t *)dest = v;
+            } break;
+            case PrimitiveKind::Int32: {
+                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
+                    return false;
+                }
+
+                int32_t v = CopyNumber<int32_t>(value);
+                *(int32_t *)dest = v;
+            } break;
+            case PrimitiveKind::UInt32: {
+                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
+                    return false;
+                }
+
+                uint32_t v = CopyNumber<uint32_t>(value);
+                *(uint32_t *)dest = v;
+            } break;
+            case PrimitiveKind::Int64: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
                     return false;
                 }
 
                 int64_t v = CopyNumber<int64_t>(value);
-                memcpy(dest, &v, member.type->size); // Little Endian
+                *(int64_t *)dest = v;
+            } break;
+            case PrimitiveKind::UInt64: {
+                if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
+                    return false;
+                }
+
+                uint64_t v = CopyNumber<uint64_t>(value);
+                *(uint64_t *)dest = v;
             } break;
             case PrimitiveKind::String: {
                 if (RG_UNLIKELY(!value.IsString())) {
@@ -196,12 +252,12 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
                     return false;
                 }
 
-                Napi::Object obj = value.As<Napi::Object>();
-                if (!PushObject(obj, member.type, dest, realign))
+                Napi::Object obj2 = value.As<Napi::Object>();
+                if (!PushObject(obj2, member.type, dest, realign))
                     return false;
             } break;
             case PrimitiveKind::Array: {
-                if (RG_UNLIKELY(!value.IsArray() && !value.IsTypedArray())) {
+                if (RG_UNLIKELY(!value.IsArray() && !value.IsTypedArray() && !value.IsString())) {
                     ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected array", GetValueType(instance, value), member.name);
                     return false;
                 }
@@ -236,9 +292,9 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
     return true;
 }
 
-bool CallData::PushArray(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest, int16_t realign)
+bool CallData::PushArray(const Napi::Value &obj, const TypeInfo *type, uint8_t *dest, int16_t realign)
 {
-    RG_ASSERT(obj.IsArray() || obj.IsTypedArray());
+    RG_ASSERT(obj.IsArray() || obj.IsTypedArray() || obj.IsString());
     RG_ASSERT(type->primitive == PrimitiveKind::Array);
 
     uint32_t len = type->size / type->ref->size;
@@ -279,17 +335,52 @@ bool CallData::PushArray(const Napi::Object &obj, const TypeInfo *type, uint8_t
                     *(bool *)dest = b;
                 });
             } break;
-            case PrimitiveKind::Int8:
-            case PrimitiveKind::UInt8:
-            case PrimitiveKind::Int16:
-            case PrimitiveKind::UInt16:
-            case PrimitiveKind::Int32:
-            case PrimitiveKind::UInt32:
-            case PrimitiveKind::Int64:
-            case PrimitiveKind::UInt64: {
+            case PrimitiveKind::Int8: {
+                PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
+                    int8_t v = CopyNumber<int8_t>(value);
+                    *(int8_t *)dest = v;
+                });
+            } break;
+            case PrimitiveKind::UInt8: {
+                PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
+                    uint8_t v = CopyNumber<uint8_t>(value);
+                    *(uint8_t *)dest = v;
+                });
+            } break;
+            case PrimitiveKind::Int16: {
+                PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
+                    int16_t v = CopyNumber<int16_t>(value);
+                    *(int16_t *)dest = v;
+                });
+            } break;
+            case PrimitiveKind::UInt16: {
+                PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
+                    uint16_t v = CopyNumber<uint16_t>(value);
+                    *(uint16_t *)dest = v;
+                });
+            } break;
+            case PrimitiveKind::Int32: {
+                PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
+                    int32_t v = CopyNumber<int32_t>(value);
+                    *(int32_t *)dest = v;
+                });
+            } break;
+            case PrimitiveKind::UInt32: {
+                PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
+                    uint32_t v = CopyNumber<uint32_t>(value);
+                    *(uint32_t *)dest = v;
+                });
+            } break;
+            case PrimitiveKind::Int64: {
                 PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
                     int64_t v = CopyNumber<int64_t>(value);
-                    memcpy(dest, &v, type->ref->size); // Little Endian
+                    *(int64_t *)dest = v;
+                });
+            } break;
+            case PrimitiveKind::UInt64: {
+                PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
+                    uint64_t v = CopyNumber<uint64_t>(value);
+                    *(uint64_t *)dest = v;
                 });
             } break;
             case PrimitiveKind::String: {
@@ -316,15 +407,15 @@ bool CallData::PushArray(const Napi::Object &obj, const TypeInfo *type, uint8_t
             } break;
             case PrimitiveKind::Record: {
                 PUSH_ARRAY(IsObject(value), "object", {
-                    Napi::Object obj = value.As<Napi::Object>();
-                    if (!PushObject(obj, type->ref, dest, realign))
+                    Napi::Object obj2 = value.As<Napi::Object>();
+                    if (!PushObject(obj2, type->ref, dest, realign))
                         return false;
                 });
             } break;
             case PrimitiveKind::Array: {
-                PUSH_ARRAY(value.IsArray() || value.IsTypedArray(), "array", {
-                    Napi::Object array = value.As<Napi::Array>();
-                    if (!PushArray(array, type->ref, dest, realign))
+                PUSH_ARRAY(value.IsArray() || value.IsTypedArray() || value.IsString(), "array", {
+                    Napi::Object array2 = value.As<Napi::Array>();
+                    if (!PushArray(array2, type->ref, dest, realign))
                         return false;
                 });
             } break;
@@ -343,7 +434,7 @@ bool CallData::PushArray(const Napi::Object &obj, const TypeInfo *type, uint8_t
         }
 
 #undef PUSH_ARRAY
-    } else {
+    } else if (obj.IsTypedArray()) {
         Napi::TypedArray array = obj.As<Napi::TypedArray>();
         const uint8_t *buf = (const uint8_t *)array.ArrayBuffer().Data();
 
@@ -378,6 +469,25 @@ bool CallData::PushArray(const Napi::Object &obj, const TypeInfo *type, uint8_t
 
             dest += type->ref->size;
         }
+    } else if (obj.IsString()) {
+        size_t encoded = 0;
+
+        if (type->ref->primitive == PrimitiveKind::Int8 || type->ref->primitive == PrimitiveKind::UInt8) {
+            napi_status status = napi_get_value_string_utf8(env, obj, (char *)dest, type->size, &encoded);
+            RG_ASSERT(status == napi_ok);
+        } else if (type->ref->primitive == PrimitiveKind::Int16 || type->ref->primitive == PrimitiveKind::UInt16) {
+            napi_status status = napi_get_value_string_utf16(env, obj, (char16_t *)dest, type->size / 2, &encoded);
+            RG_ASSERT(status == napi_ok);
+
+            encoded *= 2;
+        } else {
+            ThrowError<Napi::TypeError>(env, "Strings cannot be converted to %1 array", type->ref->name);
+            return false;
+        }
+
+        memset_safe(dest + encoded, 0, type->size - encoded);
+    } else {
+        RG_UNREACHABLE();
     }
 
     return true;
@@ -451,8 +561,8 @@ void CallData::PopObject(Napi::Object obj, const uint8_t *src, const TypeInfo *t
                 obj.Set(member.name, obj2);
             } break;
             case PrimitiveKind::Array: {
-                Napi::Object obj2 = PopArray(src, member.type, realign);
-                obj.Set(member.name, obj2);
+                Napi::Value value = PopArray(src, member.type, realign);
+                obj.Set(member.name, value);
             } break;
             case PrimitiveKind::Float32: {
                 float f;
@@ -477,7 +587,18 @@ Napi::Object CallData::PopObject(const uint8_t *src, const TypeInfo *type, int16
     return obj;
 }
 
-Napi::Object CallData::PopArray(const uint8_t *src, const TypeInfo *type, int16_t realign)
+Size WideStringLength(const char16_t *str16, Size max)
+{
+    Size len = 0;
+
+    while (len < max && str16[len]) {
+        len++;
+    }
+
+    return len;
+}
+
+Napi::Value CallData::PopArray(const uint8_t *src, const TypeInfo *type, int16_t realign)
 {
     RG_ASSERT(type->primitive == PrimitiveKind::Array);
 
@@ -500,7 +621,12 @@ Napi::Object CallData::PopArray(const uint8_t *src, const TypeInfo *type, int16_
         } while (false)
 #define POP_NUMBER_ARRAY(TypedArrayType, CType) \
         do { \
-            if (type->hint == TypeInfo::ArrayHint::TypedArray) { \
+            if (type->hint == TypeInfo::ArrayHint::Array) { \
+                POP_ARRAY({ \
+                    double d = (double)*(CType *)src; \
+                    array.Set(i, Napi::Number::New(env, d)); \
+                }); \
+            } else { \
                 Napi::TypedArrayType array = Napi::TypedArrayType::New(env, len); \
                  \
                 for (uint32_t i = 0; i < len; i++) { \
@@ -514,11 +640,6 @@ Napi::Object CallData::PopArray(const uint8_t *src, const TypeInfo *type, int16_
                 } \
                  \
                 return array; \
-            } else { \
-                POP_ARRAY({ \
-                    double d = (double)*(CType *)src; \
-                    array.Set(i, Napi::Number::New(env, d)); \
-                }); \
             } \
         } while (false)
 
@@ -531,10 +652,58 @@ Napi::Object CallData::PopArray(const uint8_t *src, const TypeInfo *type, int16_
                 array.Set(i, Napi::Boolean::New(env, b));
             });
         } break;
-        case PrimitiveKind::Int8: { POP_NUMBER_ARRAY(Int8Array, int8_t); } break;
-        case PrimitiveKind::UInt8: { POP_NUMBER_ARRAY(Uint8Array, uint8_t); } break;
-        case PrimitiveKind::Int16: { POP_NUMBER_ARRAY(Int16Array, int16_t); } break;
-        case PrimitiveKind::UInt16: { POP_NUMBER_ARRAY(Uint16Array, uint16_t); } break;
+        case PrimitiveKind::Int8: {
+            if (type->hint == TypeInfo::ArrayHint::String) {
+                RG_ASSERT(!realign);
+
+                const char *ptr = (const char *)src;
+                size_t count = strnlen(ptr, (size_t)len);
+
+                Napi::String str = Napi::String::New(env, ptr, count);
+                return str;
+            }
+
+            POP_NUMBER_ARRAY(Int8Array, int8_t);
+        } break;
+        case PrimitiveKind::UInt8: {
+            if (type->hint == TypeInfo::ArrayHint::String) {
+                RG_ASSERT(!realign);
+
+                const char *ptr = (const char *)src;
+                size_t count = strnlen(ptr, (size_t)len);
+
+                Napi::String str = Napi::String::New(env, ptr, count);
+                return str;
+            }
+
+            POP_NUMBER_ARRAY(Uint8Array, uint8_t);
+        } break;
+        case PrimitiveKind::Int16: {
+            if (type->hint == TypeInfo::ArrayHint::String) {
+                RG_ASSERT(!realign);
+
+                const char16_t *ptr = (const char16_t *)src;
+                Size count = WideStringLength(ptr, len);
+
+                Napi::String str = Napi::String::New(env, ptr, count);
+                return str;
+            }
+
+            POP_NUMBER_ARRAY(Int16Array, int16_t);
+        } break;
+        case PrimitiveKind::UInt16: {
+            if (type->hint == TypeInfo::ArrayHint::String) {
+                RG_ASSERT(!realign);
+
+                const char16_t *ptr = (const char16_t *)src;
+                Size count = WideStringLength(ptr, len);
+
+                Napi::String str = Napi::String::New(env, ptr, count);
+                return str;
+            }
+
+            POP_NUMBER_ARRAY(Uint16Array, uint16_t);
+        } break;
         case PrimitiveKind::Int32: { POP_NUMBER_ARRAY(Int32Array, int32_t); } break;
         case PrimitiveKind::UInt32: { POP_NUMBER_ARRAY(Uint32Array, uint32_t); } break;
         case PrimitiveKind::Int64: {
@@ -579,8 +748,8 @@ Napi::Object CallData::PopArray(const uint8_t *src, const TypeInfo *type, int16_
         } break;
         case PrimitiveKind::Array: {
             POP_ARRAY({
-                Napi::Object obj = PopArray(src, type->ref, realign);
-                array.Set(i, obj);
+                Napi::Value value = PopArray(src, type->ref, realign);
+                array.Set(i, value);
             });
         } break;
         case PrimitiveKind::Float32: { POP_NUMBER_ARRAY(Float32Array, float); } break;

package/src/call.hh

@@ -78,11 +78,11 @@ private:
     const char *PushString(const Napi::Value &value);
     const char16_t *PushString16(const Napi::Value &value);
     bool PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest, int16_t realign = 0);
-    bool PushArray(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest, int16_t realign = 0);
+    bool PushArray(const Napi::Value &obj, const TypeInfo *type, uint8_t *dest, int16_t realign = 0);
 
     void PopObject(Napi::Object obj, const uint8_t *src, const TypeInfo *type, int16_t realign = 0);
     Napi::Object PopObject(const uint8_t *src, const TypeInfo *type, int16_t realign = 0);
-    Napi::Object PopArray(const uint8_t *src, const TypeInfo *type, int16_t realign = 0);
+    Napi::Value PopArray(const uint8_t *src, const TypeInfo *type, int16_t realign = 0);
 };
 
 template <typename T>

package/src/ffi.cc

@@ -29,6 +29,7 @@
 #else
     #include <dlfcn.h>
     #include <unistd.h>
+    #include <sys/mman.h>
 #endif
 
 #include <napi.h>
@@ -39,6 +40,11 @@
 
 namespace RG {
 
+const Size SyncStackSize = Mebibytes(2);
+const Size SyncHeapSize = Mebibytes(4);
+const Size AsyncStackSize = Mebibytes(1);
+const Size AsyncHeapSize = Mebibytes(2);
+
 // Value does not matter, the tag system uses memory addresses
 const int TypeInfoMarker = 0xDEADBEEF;
 
@@ -274,6 +280,8 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
             hint = TypeInfo::ArrayHint::TypedArray;
         } else if (to == "array") {
             hint = TypeInfo::ArrayHint::Array;
+        } else if (to == "string") {
+            hint = TypeInfo::ArrayHint::String;
         } else {
             ThrowError<Napi::Error>(env, "Array conversion hint must be 'typed' or 'array'");
             return env.Null();
@@ -297,7 +305,6 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
     }
 
     TypeInfo *type = instance->types.AppendDefault();
-    RG_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
 
     type->name = Fmt(&instance->str_alloc, "%1[%2]", ref->name, len).ptr;
 
@@ -307,13 +314,6 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
     type->ref = ref;
     type->hint = hint;
 
-    // If the insert succeeds, we cannot fail anymore
-    if (!instance->types_map.TrySet(type).second) {
-        ThrowError<Napi::Error>(env, "Duplicate type name '%1'", type->name);
-        return env.Null();
-    }
-    err_guard.Disable();
-
     Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, type);
     SetValueTag(instance, external, &TypeInfoMarker);
 
@@ -375,32 +375,34 @@ static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
     return type->defn.Value();
 }
 
-static Span<uint8_t> AllocateAndAlign16(Allocator *alloc, Size size)
+static InstanceMemory *AllocateAsyncMemory(InstanceData *instance)
 {
-    RG_ASSERT(AlignLen(size, 16) == size);
-    RG_ASSERT(size >= Kibibytes(1));
+    for (Size i = 1; i < instance->memories.len; i++) {
+        InstanceMemory *mem = instance->memories[i];
 
-    // Account for allocator overhead
-    size -= 256;
-
-    uint8_t *ptr = (uint8_t *)Allocator::Allocate(alloc, size);
-    uint8_t *aligned = AlignUp(ptr, 16);
-    Size delta = AlignLen(aligned - ptr, 16);
-
-    return MakeSpan(aligned, size - delta);
-}
-
-static InstanceMemory *AllocateCallMemory(InstanceData *instance)
-{
-    for (InstanceMemory *mem: instance->memories) {
         if (!mem->depth)
             return mem;
     }
 
     InstanceMemory *mem = new InstanceMemory();
 
-    mem->stack = AllocateAndAlign16(&mem->mem_alloc, Mebibytes(1));
-    mem->heap = AllocateAndAlign16(&mem->mem_alloc, Mebibytes(2));
+    mem->stack.len = AsyncStackSize;
+#if defined(_WIN32)
+    mem->stack.ptr = (uint8_t *)VirtualAlloc(nullptr, mem->stack.len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+#elif defined(__APPLE__)
+    mem->stack.ptr = (uint8_t *)mmap(nullptr, mem->stack.len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
+#else
+    mem->stack.ptr = (uint8_t *)mmap(nullptr, mem->stack.len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON | MAP_STACK, -1, 0);
+#endif
+    RG_CRITICAL(mem->stack.ptr, "Failed to allocate %1 of memory", mem->stack.len);
+
+    mem->heap.len = AsyncHeapSize;
+#ifdef _WIN32
+    mem->heap.ptr = (uint8_t *)VirtualAlloc(nullptr, mem->heap.len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+#else
+    mem->heap.ptr = (uint8_t *)mmap(nullptr, mem->heap.len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
+#endif
+    RG_CRITICAL(mem->heap.ptr, "Failed to allocate %1 of memory", mem->heap.len);
 
     if (instance->memories.Available()) {
         instance->memories.Append(mem);
@@ -422,7 +424,7 @@ static Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    InstanceMemory *mem = AllocateCallMemory(instance);
+    InstanceMemory *mem = instance->memories[0];
     CallData call(env, instance, func, mem);
 
     return call.Run(info);
@@ -482,7 +484,7 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
     if (RG_UNLIKELY(!AnalyseFunction(instance, &func)))
         return env.Null();
 
-    InstanceMemory *mem = AllocateCallMemory(instance);
+    InstanceMemory *mem = instance->memories[0];
     CallData call(env, instance, &func, mem);
 
     return call.Run(info);
@@ -558,7 +560,7 @@ static Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    InstanceMemory *mem = AllocateCallMemory(instance);
+    InstanceMemory *mem = AllocateAsyncMemory(instance);
     AsyncCall *async = new AsyncCall(env, instance, func, mem, callback);
 
     if (async->Prepare(info) && instance->debug) {
@@ -601,10 +603,10 @@ static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value r
         return false;
     }
 
-    Size parameters_len = parameters.Length();
+    uint32_t parameters_len = parameters.Length();
 
     if (parameters_len) {
-        Napi::String str = ((Napi::Value)parameters[(uint32_t)(parameters_len - 1)]).As<Napi::String>();
+        Napi::String str = ((Napi::Value)parameters[parameters_len - 1]).As<Napi::String>();
 
         if (str.IsString() && str.Utf8Value() == "...") {
             func->variadic = true;
@@ -657,9 +659,13 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
         if (!ParseClassicFunction(env, info[0u].As<Napi::String>(), info[1u], info[2u].As<Napi::Array>(), func))
             return env.Null();
     } else if (info.Length() >= 1) {
-        PrototypeParser parser(env);
+        if (!info[0].IsString()) {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value for prototype, expected string", GetValueType(instance, info[0]));
+            return env.Null();
+        }
 
-        if (!parser.Parse(info[0u].As<Napi::String>(), func))
+        std::string proto = info[0u].As<Napi::String>();
+        if (!ParsePrototype(env, proto.c_str(), func))
             return env.Null();
     } else {
         ThrowError<Napi::TypeError>(env, "Expected 1 or 3 arguments, not %1", info.Length());
@@ -788,6 +794,7 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
     ADD_CONVENTION("cdecl", CallConvention::Cdecl);
     ADD_CONVENTION("stdcall", CallConvention::Stdcall);
     ADD_CONVENTION("fastcall", CallConvention::Fastcall);
+    ADD_CONVENTION("thiscall", CallConvention::Thiscall);
 
 #undef ADD_CONVENTION
 
@@ -930,8 +937,27 @@ void FunctionInfo::Unref() const
 
 InstanceData::InstanceData()
 {
-    AllocateCallMemory(this);
-    RG_ASSERT(memories.len == 1);
+    InstanceMemory *mem = new InstanceMemory();
+
+    mem->stack.len = SyncStackSize;
+#if defined(_WIN32)
+    mem->stack.ptr = (uint8_t *)VirtualAlloc(nullptr, mem->stack.len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+#elif defined(__APPLE__)
+    mem->stack.ptr = (uint8_t *)mmap(nullptr, mem->stack.len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
+#else
+    mem->stack.ptr = (uint8_t *)mmap(nullptr, mem->stack.len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON | MAP_STACK, -1, 0);
+#endif
+    RG_CRITICAL(mem->stack.ptr, "Failed to allocate %1 of memory", mem->stack.len);
+
+    mem->heap.len = SyncHeapSize;
+#ifdef _WIN32
+    mem->heap.ptr = (uint8_t *)VirtualAlloc(nullptr, mem->heap.len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+#else
+    mem->heap.ptr = (uint8_t *)mmap(nullptr, mem->heap.len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
+#endif
+    RG_CRITICAL(mem->heap.ptr, "Failed to allocate %1 of memory", mem->heap.len);
+
+    memories.Append(mem);
 }
 
 InstanceData::~InstanceData()
@@ -957,7 +983,6 @@ static void SetExports(Napi::Env env, Func func)
     func("out", Napi::Function::New(env, MarkOut));
     func("inout", Napi::Function::New(env, MarkInOut));
 
-    func("internal", Napi::Boolean::New(env, true));
 #if defined(_WIN32)
     func("extension", Napi::String::New(env, ".dll"));
 #elif defined(__APPLE__)
@@ -1009,6 +1034,7 @@ static void InitInternal(v8::Local<v8::Object> target, v8::Local<v8::Value>,
     FillRandomSafe(&instance->tag_lower, RG_SIZE(instance->tag_lower));
 
     SetExports(env_napi, [&](const char *name, Napi::Value value) { SetValue(env, target, name, value); });
+    SetValue(env, target, "internal", Napi::Boolean::New(env_cxx, true));
 }
 
 #else
@@ -1024,6 +1050,7 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
     FillRandomSafe(&instance->tag_lower, RG_SIZE(instance->tag_lower));
 
     SetExports(env, [&](const char *name, Napi::Value value) { exports.Set(name, value); });
+    exports.Set("internal", Napi::Boolean::New(env, false));
 
     return exports;
 }

package/src/ffi.hh

@@ -69,7 +69,8 @@ struct RecordMember;
 struct TypeInfo {
     enum class ArrayHint {
         Array,
-        TypedArray
+        TypedArray,
+        String
     };
 
     const char *name;
@@ -108,12 +109,14 @@ struct LibraryHolder {
 enum class CallConvention {
     Cdecl,
     Stdcall,
-    Fastcall
+    Fastcall,
+    Thiscall
 };
 static const char *const CallConventionNames[] = {
     "Cdecl",
     "Stdcall",
-    "Fastcall"
+    "Fastcall",
+    "Thiscall"
 };
 
 struct ParameterInfo {
@@ -162,6 +165,9 @@ struct FunctionInfo {
 #if defined(__arm__) || defined(__aarch64__) || defined(__x86_64__) || defined(_WIN64)
     bool forward_fp;
 #endif
+#if defined(__i386__) || defined(_M_IX86)
+    bool fast;
+#endif
 
     ~FunctionInfo();
 
@@ -189,7 +195,7 @@ struct InstanceData {
     bool debug;
     uint64_t tag_lower;
 
-    LocalArray<InstanceMemory *, 8> memories;
+    LocalArray<InstanceMemory *, 6> memories;
 
     BlockAllocator str_alloc;
 };