koffi 1.1.0-beta.7 → 1.1.1

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,11 +231,13 @@ 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.
 
-Special rules apply for arrays of primitive integer and float types (int, int8_t, 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 `int8_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('int8_t', 6, 'array')`
+### JS typed arrays
 
-Example below:
+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')`
+
+See the example below:
 
 ```js
 const koffi = require('koffi');
@@ -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.7",
+  "version": "1.1.1",
   "description": "Fast and simple FFI (foreign function interface) for Node.js",
   "keywords": [
     "foreign",

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())) {
@@ -201,7 +257,7 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
                     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,15 +292,15 @@ 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 &value, const TypeInfo *type, uint8_t *dest, int16_t realign)
 {
-    RG_ASSERT(obj.IsArray() || obj.IsTypedArray());
+    RG_ASSERT(value.IsArray() || value.IsTypedArray() || value.IsString());
     RG_ASSERT(type->primitive == PrimitiveKind::Array);
 
     uint32_t len = type->size / type->ref->size;
 
-    if (obj.IsArray()) {
-        Napi::Array array = obj.As<Napi::Array>();
+    if (value.IsArray()) {
+        Napi::Array array = value.As<Napi::Array>();
 
         if (RG_UNLIKELY(array.Length() != len)) {
             ThrowError<Napi::Error>(env, "Expected array of length %1, got %2", len, array.Length());
@@ -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: {
@@ -322,7 +413,7 @@ bool CallData::PushArray(const Napi::Object &obj, const TypeInfo *type, uint8_t
                 });
             } break;
             case PrimitiveKind::Array: {
-                PUSH_ARRAY(value.IsArray() || value.IsTypedArray(), "array", {
+                PUSH_ARRAY(value.IsArray() || value.IsTypedArray() || value.IsString(), "array", {
                     Napi::Object array = value.As<Napi::Array>();
                     if (!PushArray(array, type->ref, dest, realign))
                         return false;
@@ -343,8 +434,8 @@ bool CallData::PushArray(const Napi::Object &obj, const TypeInfo *type, uint8_t
         }
 
 #undef PUSH_ARRAY
-    } else {
-        Napi::TypedArray array = obj.As<Napi::TypedArray>();
+    } else if (value.IsTypedArray()) {
+        Napi::TypedArray array = value.As<Napi::TypedArray>();
         const uint8_t *buf = (const uint8_t *)array.ArrayBuffer().Data();
 
         if (RG_UNLIKELY(array.ElementLength() != len)) {
@@ -378,6 +469,25 @@ bool CallData::PushArray(const Napi::Object &obj, const TypeInfo *type, uint8_t
 
             dest += type->ref->size;
         }
+    } else if (value.IsString()) {
+        size_t len = 0;
+
+        if (type->ref->primitive == PrimitiveKind::Int8 || type->ref->primitive == PrimitiveKind::UInt8) {
+            napi_status status = napi_get_value_string_utf8(env, value, (char *)dest, type->size, &len);
+            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, value, (char16_t *)dest, type->size / 2, &len);
+            RG_ASSERT(status == napi_ok);
+
+            len *= 2;
+        } else {
+            ThrowError<Napi::TypeError>(env, "Strings cannot be converted to %1 array", type->ref->name);
+            return false;
+        }
+
+        memset_safe(dest + len, 0, type->size - len);
+    } 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 &value, 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) {
@@ -930,8 +926,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()

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/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;
+}