koffi 1.1.0-beta.8 → 1.1.2

package/CMakeLists.txt

@@ -23,6 +23,9 @@ if(MSVC)
 else()
     add_compile_options(-Wall -Wextra -Wno-missing-field-initializers
                         -Wno-unused-parameter -Wno-class-memaccess)
+    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+        add_compile_options(-Wno-unknown-warning-option)
+    endif()
 endif()
 
 # ---- Koffi ----

package/README.md

@@ -20,10 +20,10 @@
 
 Koffi is a fast and easy-to-use FFI module for Node.js, with support for primitive and aggregate data types (structs), both by reference (pointer) and by value.
 
-After the release of version 1.0, the following features are planned:
+The following features are planned in the near future:
 
-* 1.1: Asynchronous calls and fixed-size array types
 * 1.2: C to JS callbacks
+* 1.3: Type parser
 
 The following platforms __are officially supported and tested__ at the moment:
 
@@ -231,6 +231,8 @@ Koffi exposes three functions to explore type information:
 Fixed-size arrays are declared with `koffi.array(type, length)`. Just like in C, they cannot be passed
 as functions parameters (they degenerate to pointers), or returned by value. You can however embed them in struct types.
 
+### JS typed arrays
+
 Special rules apply for arrays of primitive integer and float types (uint32_t, double, etc...):
 - When converting from JS to C, Koffi can take a normal Array (e.g. `[1, 2]`) or a TypedArray of the correct type (e.g. `Uint8Array` for an array of `uint8_t` numbers)
 - When converting from C to JS (for return value or output parameters), Koffi will by default use a TypedArray. But you can change this behavior when you create the array type with the optional hint argument: `koffi.array('uint8_t', 64, 'array')`
@@ -258,6 +260,14 @@ console.log(ReturnFoo1({ i: 5, a16: [6, 8] })) // Prints { i: 5, a16: Int16Array
 console.log(ReturnFoo2({ i: 5, a16: [6, 8] })) // Prints { i: 5, a16: [6, 8] }
 ```
 
+### C strings
+
+Koffi can also convert JS strings to fixed-sized arrays in the following cases:
+- char (or int8_t) arrays are filled with the UTF-8 encoded string, truncated if needed. The buffer is always NUL-terminated.
+- char16 (or int16_t) arrays are filled with the UTF-16 encoded string, truncated if needed. The buffer is always NUL-terminated.
+
+The reverse case is also true, Koffi can convert a C fixed-size buffer to a JS string. Use the `string` array hint to do this (e.g. `koffi.array('char', 8, 'string')`).
+
 ## Variadic functions
 
 Variadic functions are declared with an ellipsis as the last argument.
@@ -267,6 +277,7 @@ In order to call a variadic function, you must provide two Javascript arguments
 ```js
 const printf = lib.func('printf', 'int', ['string', '...']);
 
+// The variadic arguments are: 6 (int), 8.5 (double), 'THE END' (const char *) 
 printf('Integer %d, double %g, string %s', 'int', 6, 'double', 8.5, 'string', 'THE END');
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koffi",
-  "version": "1.1.0-beta.8",
+  "version": "1.1.2",
   "description": "Fast and simple FFI (foreign function interface) for Node.js",
   "keywords": [
     "foreign",
@@ -24,7 +24,7 @@
   },
   "license": "AGPL-3.0",
   "dependencies": {
-    "cnoke": "^1.0.7"
+    "cnoke": "^1.0.9"
   },
   "devDependencies": {
     "chalk": "^4.1.2",

package/qemu/qemu.js

@@ -395,7 +395,7 @@ async function pack() {
             }));
 
             let status = copied ? chalk.bold.green('[ok]') : chalk.bold.red('[error]');
-            log(machine, 'Download', status);
+            log(machine, 'Pack', status);
         }));
     }
 

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

@@ -274,6 +274,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 +299,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 +308,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);
 
@@ -390,9 +384,11 @@ static Span<uint8_t> AllocateAndAlign16(Allocator *alloc, Size size)
     return MakeSpan(aligned, size - delta);
 }
 
-static InstanceMemory *AllocateCallMemory(InstanceData *instance)
+static InstanceMemory *AllocateAsyncMemory(InstanceData *instance)
 {
-    for (InstanceMemory *mem: instance->memories) {
+    for (Size i = 1; i < instance->memories.len; i++) {
+        InstanceMemory *mem = instance->memories[i];
+
         if (!mem->depth)
             return mem;
     }
@@ -422,7 +418,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 +478,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 +554,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) {
@@ -657,9 +653,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());
@@ -930,8 +930,12 @@ void FunctionInfo::Unref() const
 
 InstanceData::InstanceData()
 {
-    AllocateCallMemory(this);
-    RG_ASSERT(memories.len == 1);
+    InstanceMemory *mem = new InstanceMemory();
+
+    mem->stack = AllocateAndAlign16(&mem->mem_alloc, Mebibytes(2));
+    mem->heap = AllocateAndAlign16(&mem->mem_alloc, Mebibytes(4));
+
+    memories.Append(mem);
 }
 
 InstanceData::~InstanceData()
@@ -957,7 +961,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 +1012,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 +1028,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;
@@ -189,7 +190,7 @@ struct InstanceData {
     bool debug;
     uint64_t tag_lower;
 
-    LocalArray<InstanceMemory *, 8> memories;
+    LocalArray<InstanceMemory *, 6> memories;
 
     BlockAllocator str_alloc;
 };

package/src/parser.cc

@@ -19,34 +19,27 @@
 
 namespace RG {
 
-bool PrototypeParser::Parse(Napi::String proto, FunctionInfo *func)
+bool PrototypeParser::Parse(const char *str, FunctionInfo *out_func)
 {
-    if (!proto.IsString()) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for prototype, expected string", GetValueType(instance, proto));
-        return false;
-    }
-
-    std::string hold = proto;
-
     tokens.Clear();
     offset = 0;
     valid = true;
 
-    Tokenize(hold.c_str());
+    Tokenize(str);
 
-    func->ret.type = ParseType();
-    if (func->ret.type->primitive == PrimitiveKind::Array) {
+    out_func->ret.type = ParseType();
+    if (out_func->ret.type->primitive == PrimitiveKind::Array) {
         MarkError("You are not allowed to directly return C arrays");
         return false;
     }
     if (Match("__cdecl")) {
-        func->convention = CallConvention::Cdecl;
+        out_func->convention = CallConvention::Cdecl;
     } else if (Match("__stdcall")) {
-        func->convention = CallConvention::Stdcall;
+        out_func->convention = CallConvention::Stdcall;
     } else if (Match("__fastcall")) {
-        func->convention = CallConvention::Fastcall;
+        out_func->convention = CallConvention::Fastcall;
     }
-    func->name = ParseIdentifier();
+    out_func->name = ParseIdentifier();
 
     Consume("(");
     if (offset < tokens.len && tokens[offset] != ")") {
@@ -54,7 +47,7 @@ bool PrototypeParser::Parse(Napi::String proto, FunctionInfo *func)
             ParameterInfo param = {};
 
             if (Match("...")) {
-                func->variadic = true;
+                out_func->variadic = true;
                 break;
             }
 
@@ -83,18 +76,18 @@ bool PrototypeParser::Parse(Napi::String proto, FunctionInfo *func)
 
             offset += (offset < tokens.len && IsIdentifier(tokens[offset]));
 
-            if (func->parameters.len >= MaxParameters) {
+            if (out_func->parameters.len >= MaxParameters) {
                 MarkError("Functions cannot have more than %1 parameters", MaxParameters);
                 return false;
             }
-            if ((param.directions & 2) && ++func->out_parameters >= MaxOutParameters) {
+            if ((param.directions & 2) && ++out_func->out_parameters >= MaxOutParameters) {
                 MarkError("Functions cannot have more than out %1 parameters", MaxOutParameters);
                 return false;
             }
 
-            param.offset = func->parameters.len;
+            param.offset = out_func->parameters.len;
 
-            func->parameters.Append(param);
+            out_func->parameters.Append(param);
 
             if (offset >= tokens.len || tokens[offset] != ",")
                 break;
@@ -125,6 +118,17 @@ void PrototypeParser::Tokenize(const char *str)
             Span<const char> tok = MakeSpan(str + i, j - i);
             tokens.Append(tok);
 
+            i = j - 1;
+        } else if (IsAsciiDigit(c)) {
+            Size j = i;
+            while (str[++j] && IsAsciiDigit(str[j]));
+            if (str[j] == '.') {
+                while (str[++j] && IsAsciiDigit(str[j]));
+            }
+
+            Span<const char> tok = MakeSpan(str + i, j - i);
+            tokens.Append(tok);
+
             i = j - 1;
         } else if (c == '.' && str[i + 1] == '.' && str[i + 2] == '.') {
             tokens.Append("...");
@@ -250,4 +254,10 @@ bool PrototypeParser::IsIdentifier(Span<const char> tok) const
     return IsAsciiAlpha(tok[0]) || tok[0] == '_';
 }
 
+bool ParsePrototype(Napi::Env env, const char *str, FunctionInfo *out_func)
+{
+    PrototypeParser parser(env);
+    return parser.Parse(str, out_func);
+}
+
 }

package/src/parser.hh

@@ -36,7 +36,7 @@ class PrototypeParser {
 public:
     PrototypeParser(Napi::Env env) : env(env), instance(env.GetInstanceData<InstanceData>()) {}
 
-    bool Parse(Napi::String proto, FunctionInfo *func);
+    bool Parse(const char *str, FunctionInfo *out_func);
 
 private:
     void Tokenize(const char *str);
@@ -60,4 +60,6 @@ private:
     }
 };
 
+bool ParsePrototype(Napi::Env env, const char *str, FunctionInfo *out_func);
+
 }

package/src/util.hh

@@ -78,7 +78,7 @@ T CopyNumber(const Napi::Value &value)
     RG_ASSERT(value.IsNumber() || value.IsBigInt());
 
     if (RG_LIKELY(value.IsNumber())) {
-        return (T)value.As<Napi::Number>();
+        return (T)value.As<Napi::Number>().DoubleValue();
     } else if (value.IsBigInt()) {
         Napi::BigInt bigint = value.As<Napi::BigInt>();
 

package/test/misc.c

@@ -104,6 +104,13 @@ typedef struct PackedBFG {
 } PackedBFG;
 #pragma pack(pop)
 
+typedef struct FixedString {
+    char buf[64];
+} FixedString;
+typedef struct FixedWide {
+    int16_t buf[64];
+} FixedWide;
+
 EXPORT void FillPack1(int a, Pack1 *p)
 {
     p->a = a;
@@ -359,3 +366,13 @@ EXPORT const char16_t *Concat16(const char16_t *str1, const char16_t *str2)
 
     return buf;
 }
+
+EXPORT FixedString ReturnFixedStr(FixedString str)
+{
+    return str;
+}
+
+EXPORT FixedWide ReturnFixedWide(FixedWide str)
+{
+    return str;
+}