koffi 1.2.4 → 1.3.0-rc.1

package/src/call.cc

@@ -32,6 +32,10 @@ CallData::CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *fu
 
 CallData::~CallData()
 {
+    for (const OutArgument &out: out_arguments) {
+        napi_delete_reference(env, out.ref);
+    }
+
     mem->stack = old_stack_mem;
     mem->heap = old_heap_mem;
 
@@ -42,7 +46,7 @@ CallData::~CallData()
     }
 }
 
-const char *CallData::PushString(const Napi::Value &value)
+const char *CallData::PushString(Napi::Value value)
 {
     RG_ASSERT(value.IsString());
 
@@ -79,7 +83,7 @@ const char *CallData::PushString(const Napi::Value &value)
     return buf.ptr;
 }
 
-const char16_t *CallData::PushString16(const Napi::Value &value)
+const char16_t *CallData::PushString16(Napi::Value value)
 {
     RG_ASSERT(value.IsString());
 
@@ -116,7 +120,7 @@ const char16_t *CallData::PushString16(const Napi::Value &value)
     return buf.ptr;
 }
 
-bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t *origin, int16_t realign)
+bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origin, int16_t realign)
 {
     RG_ASSERT(IsObject(obj));
     RG_ASSERT(type->primitive == PrimitiveKind::Record);
@@ -265,14 +269,25 @@ 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() && !value.IsString())) {
+                if (value.IsArray()) {
+                    Napi::Array array = value.As<Napi::Array>();
+                    Size len = (Size)member.type->size / member.type->ref->size;
+
+                    if (!PushNormalArray(array, len, member.type->ref, dest, realign))
+                        return false;
+                } else if (value.IsTypedArray()) {
+                    Napi::TypedArray array = value.As<Napi::TypedArray>();
+                    Size len = (Size)member.type->size / member.type->ref->size;
+
+                    if (!PushTypedArray(array, len, member.type->ref, dest, realign))
+                        return false;
+                } else if (value.IsString() && !realign) {
+                    if (!PushStringArray(value, member.type, dest))
+                        return false;
+                } else {
                     ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected array", GetValueType(instance, value), member.name);
                     return false;
                 }
-
-                Napi::Array array = value.As<Napi::Array>();
-                if (!PushArray(array, member.type, dest, realign))
-                    return false;
             } break;
             case PrimitiveKind::Float32: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
@@ -321,248 +336,404 @@ bool CallData::PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t
     return true;
 }
 
-bool CallData::PushArray(const Napi::Value &obj, const TypeInfo *type, uint8_t *origin, int16_t realign)
+bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *ref, uint8_t *origin, int16_t realign)
 {
-    RG_ASSERT(obj.IsArray() || obj.IsTypedArray() || obj.IsString());
-    RG_ASSERT(type->primitive == PrimitiveKind::Array);
+    RG_ASSERT(array.IsArray());
 
-    uint32_t len = type->size / type->ref->size;
-    Size offset = 0;
-
-    if (obj.IsArray()) {
-        Napi::Array array = obj.As<Napi::Array>();
+    if (RG_UNLIKELY(array.Length() != len)) {
+        ThrowError<Napi::Error>(env, "Expected array of length %1, got %2", len, array.Length());
+        return false;
+    }
 
-        if (RG_UNLIKELY(array.Length() != len)) {
-            ThrowError<Napi::Error>(env, "Expected array of length %1, got %2", len, array.Length());
-            return false;
-        }
+    Size offset = 0;
 
 #define PUSH_ARRAY(Check, Expected, GetCode) \
-            do { \
-                for (uint32_t i = 0; i < len; i++) { \
-                    Napi::Value value = array[i]; \
-                     \
-                    int16_t align = std::max(type->ref->align, realign); \
-                     \
-                    offset = AlignLen(offset, align); \
-                    uint8_t *dest = origin + offset; \
-                     \
-                    if (RG_UNLIKELY(!(Check))) { \
-                        ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected %2", GetValueType(instance, value), (Expected)); \
-                        return false; \
-                    } \
-                     \
-                    GetCode \
-                     \
-                    offset += type->ref->size; \
+        do { \
+            for (uint32_t i = 0; i < len; i++) { \
+                Napi::Value value = array[i]; \
+                 \
+                int16_t align = std::max(ref->align, realign); \
+                 \
+                offset = AlignLen(offset, align); \
+                uint8_t *dest = origin + offset; \
+                 \
+                if (RG_UNLIKELY(!(Check))) { \
+                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected %2", GetValueType(instance, value), (Expected)); \
+                    return false; \
                 } \
-            } while (false)
+                 \
+                GetCode \
+                 \
+                offset += ref->size; \
+            } \
+        } while (false)
 
-        switch (type->ref->primitive) {
-            case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
+    switch (ref->primitive) {
+        case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
 
-            case PrimitiveKind::Bool: {
-                PUSH_ARRAY(value.IsBoolean(), "boolean", {
-                    bool b = value.As<Napi::Boolean>();
-                    *(bool *)dest = b;
-                });
-            } break;
-            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);
-                    *(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: {
-                PUSH_ARRAY(value.IsString(), "string", {
+        case PrimitiveKind::Bool: {
+            PUSH_ARRAY(value.IsBoolean(), "boolean", {
+                bool b = value.As<Napi::Boolean>();
+                *(bool *)dest = b;
+            });
+        } break;
+        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);
+                *(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: {
+            PUSH_ARRAY(value.IsString() || IsNullOrUndefined(value), "string", {
+                if (!IsNullOrUndefined(value)) {
                     const char *str = PushString(value);
                     if (RG_UNLIKELY(!str))
                         return false;
                     *(const char **)dest = str;
-                });
-            } break;
-            case PrimitiveKind::String16: {
-                PUSH_ARRAY(value.IsString(), "string", {
+                } else {
+                    *(const char **)dest = nullptr;
+                }
+            });
+        } break;
+        case PrimitiveKind::String16: {
+            PUSH_ARRAY(value.IsString() || IsNullOrUndefined(value), "string", {
+                if (!IsNullOrUndefined(value)) {
                     const char16_t *str16 = PushString16(value);
                     if (RG_UNLIKELY(!str16))
                         return false;
                     *(const char16_t **)dest = str16;
-                });
-            } break;
-            case PrimitiveKind::Pointer: {
-                PUSH_ARRAY(CheckValueTag(instance, value, type->ref) || IsNullOrUndefined(value), type->ref->name, {
-                    if (!IsNullOrUndefined(value)) {
-                        Napi::External external = value.As<Napi::External<void>>();
-                        *(void **)dest = external.Data();
-                    } else {
-                        *(void **)dest = nullptr;
-                    }
-                });
-            } break;
-            case PrimitiveKind::Record: {
-                PUSH_ARRAY(IsObject(value), "object", {
-                    Napi::Object obj2 = value.As<Napi::Object>();
-                    if (!PushObject(obj2, type->ref, dest, realign))
+                } else {
+                    *(const char16_t **)dest = nullptr;
+                }
+            });
+        } break;
+        case PrimitiveKind::Pointer: {
+            PUSH_ARRAY(CheckValueTag(instance, value, ref) || IsNullOrUndefined(value), ref->name, {
+                if (!IsNullOrUndefined(value)) {
+                    Napi::External external = value.As<Napi::External<void>>();
+                    *(void **)dest = external.Data();
+                } else {
+                    *(void **)dest = nullptr;
+                }
+            });
+        } break;
+        case PrimitiveKind::Record: {
+            PUSH_ARRAY(IsObject(value), "object", {
+                Napi::Object obj2 = value.As<Napi::Object>();
+                if (!PushObject(obj2, ref, dest, realign))
+                    return false;
+            });
+        } break;
+        case PrimitiveKind::Array: {
+            for (uint32_t i = 0; i < len; i++) {
+                Napi::Value value = array[i];
+
+                int16_t align = std::max(ref->align, realign);
+                offset = AlignLen(offset, align);
+
+                uint8_t *dest = origin + offset;
+
+                if (value.IsArray()) {
+                    Napi::Array array2 = value.As<Napi::Array>();
+                    Size len2 = (Size)ref->size / ref->ref->size;
+
+                    if (!PushNormalArray(array2, len2, ref->ref, dest, realign))
                         return false;
-                });
-            } break;
-            case PrimitiveKind::Array: {
-                PUSH_ARRAY(value.IsArray() || value.IsTypedArray() || value.IsString(), "array", {
-                    Napi::Object array2 = value.As<Napi::Array>();
-                    if (!PushArray(array2, type->ref, dest, realign))
+                } else if (value.IsTypedArray()) {
+                    Napi::TypedArray array2 = value.As<Napi::TypedArray>();
+                    Size len2 = (Size)ref->size / ref->ref->size;
+
+                    if (!PushTypedArray(array2, len2, ref->ref, dest, realign))
                         return false;
-                });
-            } break;
-            case PrimitiveKind::Float32: {
-                PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                    float f = CopyNumber<float>(value);
-                    *(float *)dest = f;
-                });
-            } break;
-            case PrimitiveKind::Float64: {
-                PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                    double d = CopyNumber<double>(value);
-                    *(double *)dest = d;
-                });
-            } break;
-            case PrimitiveKind::Callback: {
-                for (uint32_t i = 0; i < len; i++) {
-                    Napi::Value value = array[i];
+                } else if (value.IsString() && !realign) {
+                    if (!PushStringArray(value, ref, dest))
+                        return false;
+                } else {
+                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected array", GetValueType(instance, value));
+                    return false;
+                }
+
+                offset += ref->size;
+            }
+        } break;
+        case PrimitiveKind::Float32: {
+            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
+                float f = CopyNumber<float>(value);
+                *(float *)dest = f;
+            });
+        } break;
+        case PrimitiveKind::Float64: {
+            PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
+                double d = CopyNumber<double>(value);
+                *(double *)dest = d;
+            });
+        } break;
+        case PrimitiveKind::Callback: {
+            for (uint32_t i = 0; i < len; i++) {
+                Napi::Value value = array[i];
 
-                    int16_t align = std::max(type->ref->align, realign);
-                    offset = AlignLen(offset, align);
+                int16_t align = std::max(ref->align, realign);
+                offset = AlignLen(offset, align);
 
-                    uint8_t *dest = origin + offset;
+                uint8_t *dest = origin + offset;
 
-                    void *ptr;
+                void *ptr;
 
-                    if (value.IsFunction()) {
-                        Napi::Function func = value.As<Napi::Function>();
+                if (value.IsFunction()) {
+                    Napi::Function func = value.As<Napi::Function>();
 
-                        ptr = ReserveTrampoline(type->proto, func);
-                        if (RG_UNLIKELY(!ptr))
-                            return false;
-                    } else if (CheckValueTag(instance, value, type->ref)) {
-                        Napi::External external = value.As<Napi::External<void>>();
-                        ptr = external.Data();
-                    } else if (IsNullOrUndefined(value)) {
-                        ptr = nullptr;
-                    } else {
-                        ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected %2", GetValueType(instance, value), type->ref->name);
+                    ptr = ReserveTrampoline(ref->proto, func);
+                    if (RG_UNLIKELY(!ptr))
                         return false;
-                    }
+                } else if (CheckValueTag(instance, value, ref)) {
+                    Napi::External external = value.As<Napi::External<void>>();
+                    ptr = external.Data();
+                } else if (IsNullOrUndefined(value)) {
+                    ptr = nullptr;
+                } else {
+                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected %2", GetValueType(instance, value), ref->name);
+                    return false;
+                }
 
-                    *(void **)dest = ptr;
+                *(void **)dest = ptr;
 
-                    offset += type->ref->size;
-                }
-            } break;
-        }
+                offset += ref->size;
+            }
+        } break;
+    }
 
 #undef PUSH_ARRAY
-    } else if (obj.IsTypedArray()) {
-        Napi::TypedArray array = obj.As<Napi::TypedArray>();
-        const uint8_t *buf = (const uint8_t *)array.ArrayBuffer().Data();
 
-        if (RG_UNLIKELY(array.ElementLength() != len)) {
-            ThrowError<Napi::Error>(env, "Expected array of length %1, got %2", len, array.ElementLength());
-            return false;
-        }
+    return true;
+}
 
-        bool match;
-        switch (type->ref->primitive) {
-            case PrimitiveKind::Int8: { match = (array.TypedArrayType() == napi_int8_array); } break;
-            case PrimitiveKind::UInt8: { match = (array.TypedArrayType() == napi_uint8_array); } break;
-            case PrimitiveKind::Int16: { match = (array.TypedArrayType() == napi_int16_array); } break;
-            case PrimitiveKind::UInt16: { match = (array.TypedArrayType() == napi_uint16_array); } break;
-            case PrimitiveKind::Int32: { match = (array.TypedArrayType() == napi_int32_array); } break;
-            case PrimitiveKind::UInt32: { match = (array.TypedArrayType() == napi_uint32_array); } break;
-            case PrimitiveKind::Float32: { match = (array.TypedArrayType() == napi_float32_array); } break;
-            case PrimitiveKind::Float64: { match = (array.TypedArrayType() == napi_float64_array); } break;
-
-            default: { match = false; } break;
-        }
-        if (RG_UNLIKELY(!match)) {
-            ThrowError<Napi::TypeError>(env, "TypedArray is not approriate for %1 array", type->ref->name);
-            return false;
-        }
+bool CallData::PushTypedArray(Napi::TypedArray array, Size len, const TypeInfo *ref, uint8_t *origin, int16_t realign)
+{
+    RG_ASSERT(array.IsTypedArray());
+
+    if (RG_UNLIKELY(array.ElementLength() != (size_t)len)) {
+        ThrowError<Napi::Error>(env, "Expected array of length %1, got %2", len, array.ElementLength());
+        return false;
+    }
 
+    Size offset = 0;
+    const uint8_t *buf = (const uint8_t *)array.ArrayBuffer().Data();
+
+    if (RG_UNLIKELY(array.TypedArrayType() != GetTypedArrayType(ref))) {
+        ThrowError<Napi::TypeError>(env, "Cannot use %1 value for %2 array", GetValueType(instance, array), ref->name);
+        return false;
+    }
+
+    if (realign) {
         for (uint32_t i = 0; i < len; i++) {
-            int16_t align = std::max(type->ref->align, realign);
+            int16_t align = std::max(ref->align, realign);
             offset = AlignLen(offset, align);
 
             uint8_t *dest = origin + offset;
 
-            memcpy(dest, buf + i * type->ref->size, type->ref->size);
+            memcpy(dest, buf + i * ref->size, ref->size);
 
-            offset += type->ref->size;
+            offset += ref->size;
         }
-    } else if (obj.IsString()) {
-        size_t encoded = 0;
+    } else {
+        memcpy_safe(origin, buf, (size_t)array.ByteLength());
+    }
 
-        if (type->ref->primitive == PrimitiveKind::Int8 || type->ref->primitive == PrimitiveKind::UInt8) {
+    return true;
+}
+
+bool CallData::PushStringArray(Napi::Value obj, const TypeInfo *type, uint8_t *origin)
+{
+    RG_ASSERT(obj.IsString());
+    RG_ASSERT(type->primitive == PrimitiveKind::Array);
+
+    size_t encoded = 0;
+
+    switch (type->ref->primitive) {
+        case PrimitiveKind::Int8: {
             napi_status status = napi_get_value_string_utf8(env, obj, (char *)origin, type->size, &encoded);
             RG_ASSERT(status == napi_ok);
-        } else if (type->ref->primitive == PrimitiveKind::Int16 || type->ref->primitive == PrimitiveKind::UInt16) {
+        } break;
+        case PrimitiveKind::Int16: {
             napi_status status = napi_get_value_string_utf16(env, obj, (char16_t *)origin, type->size / 2, &encoded);
             RG_ASSERT(status == napi_ok);
 
             encoded *= 2;
-        } else {
+        } break;
+
+        default: {
             ThrowError<Napi::TypeError>(env, "Strings cannot be converted to %1 array", type->ref->name);
             return false;
-        }
-
-        memset_safe(origin + encoded, 0, type->size - encoded);
-    } else {
-        RG_UNREACHABLE();
+        } break;
     }
 
+    memset_safe(origin + encoded, 0, type->size - encoded);
+
     return true;
 }
 
+bool CallData::PushPointer(Napi::Value value, const ParameterInfo &param, void **out_ptr)
+{
+    switch (value.Type()) {
+        case napi_undefined:
+        case napi_null: {
+            *out_ptr = nullptr;
+            return true;
+        } break;
+
+        case napi_external: {
+            if (RG_UNLIKELY(!CheckValueTag(instance, value, param.type)))
+                goto unexpected;
+
+            *out_ptr = value.As<Napi::External<uint8_t>>().Data();
+            return true;
+        } break;
+
+        case napi_object: {
+            uint8_t *ptr = nullptr;
+
+            if (value.IsArray()) {
+                Napi::Array array = value.As<Napi::Array>();
+
+                Size len = (Size)array.Length();
+                Size size = len * param.type->ref->size;
+
+                ptr = AllocHeap(size, 16);
+
+                if (param.directions & 1) {
+                    if (!PushNormalArray(array, len, param.type->ref, ptr))
+                        return false;
+                } else {
+                    memset(ptr, 0, size);
+                }
+            } else if (value.IsTypedArray()) {
+                Napi::TypedArray array = value.As<Napi::TypedArray>();
+
+                Size len = (Size)array.ElementLength();
+                Size size = (Size)array.ByteLength();
+
+                ptr = AllocHeap(size, 16);
+
+                if (param.directions & 1) {
+                    if (!PushTypedArray(array, len, param.type->ref, ptr))
+                        return false;
+                } else {
+                    if (RG_UNLIKELY(array.TypedArrayType() != GetTypedArrayType(param.type->ref))) {
+                        ThrowError<Napi::TypeError>(env, "Cannot use %1 value for %2 array", GetValueType(instance, array), param.type->ref->name);
+                        return false;
+                    }
+
+                    memset(ptr, 0, size);
+                }
+            } else if (RG_LIKELY(param.type->ref->primitive == PrimitiveKind::Record)) {
+                Napi::Object obj = value.As<Napi::Object>();
+                RG_ASSERT(IsObject(value));
+
+                ptr = AllocHeap(param.type->ref->size, 16);
+
+                if (param.directions & 1) {
+                    if (!PushObject(obj, param.type->ref, ptr))
+                        return false;
+                } else {
+                    memset(ptr, 0, param.type->size);
+                }
+            } else {
+                goto unexpected;
+            }
+
+            if (param.directions & 2) {
+                OutArgument *out = out_arguments.AppendDefault();
+
+                napi_status status = napi_create_reference(env, value, 1, &out->ref);
+                RG_ASSERT(status == napi_ok);
+
+                out->ptr = ptr;
+                out->type = param.type->ref;
+            }
+
+            *out_ptr = ptr;
+            return true;
+        } break;
+
+        default: {} break;
+    }
+
+unexpected:
+    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected %3", GetValueType(instance, value), param.offset + 1, param.type->name);
+    return false;
+}
+
+static inline Napi::Value GetReferenceValue(Napi::Env env, napi_ref ref)
+{
+    napi_value value;
+
+    napi_status status = napi_get_reference_value(env, ref, &value);
+    RG_ASSERT(status == napi_ok);
+
+    return Napi::Value(env, value);
+}
+
+void CallData::PopOutArguments()
+{
+    for (const OutArgument &out: out_arguments) {
+        Napi::Value value = GetReferenceValue(env, out.ref);
+        RG_ASSERT(!value.IsEmpty());
+
+        if (value.IsArray()) {
+            Napi::Array array(env, value);
+            PopNormalArray(array, out.ptr, out.type);
+        } else if (value.IsTypedArray()) {
+            Napi::TypedArray array(env, value);
+            PopTypedArray(array, out.ptr, out.type);
+        } else {
+            Napi::Object obj(env, value);
+            PopObject(obj, out.ptr, out.type);
+        }
+    }
+}
+
 void *CallData::ReserveTrampoline(const FunctionInfo *proto, Napi::Function func)
 {
     uint32_t idx = CountTrailingZeros(instance->free_trampolines);
@@ -638,11 +809,11 @@ void CallData::PopObject(Napi::Object obj, const uint8_t *origin, const TypeInfo
             } break;
             case PrimitiveKind::String: {
                 const char *str = *(const char **)src;
-                obj.Set(member.name, Napi::String::New(env, str));
+                obj.Set(member.name, str ? Napi::String::New(env, str) : env.Null());
             } break;
             case PrimitiveKind::String16: {
                 const char16_t *str16 = *(const char16_t **)src;
-                obj.Set(member.name, Napi::String::New(env, str16));
+                obj.Set(member.name, str16 ? Napi::String::New(env, str16) : env.Null());
             } break;
             case PrimitiveKind::Pointer:
             case PrimitiveKind::Callback: {
@@ -697,10 +868,137 @@ static Size WideStringLength(const char16_t *str16, Size max)
     return len;
 }
 
-Napi::Value CallData::PopArray(const uint8_t *origin, const TypeInfo *type, int16_t realign)
+void CallData::PopNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo *ref, int16_t realign)
 {
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    RG_ASSERT(array.IsArray());
+
+    Size offset = 0;
+    uint32_t len = array.Length();
+
+#define POP_ARRAY(SetCode) \
+        do { \
+            for (uint32_t i = 0; i < len; i++) { \
+                int16_t align = std::max(realign, ref->align); \
+                offset = AlignLen(offset, align); \
+                 \
+                const uint8_t *src = origin + offset; \
+                 \
+                SetCode \
+                 \
+                offset += ref->size; \
+            } \
+        } while (false)
+#define POP_NUMBER_ARRAY(CType) \
+        do { \
+            POP_ARRAY({ \
+                double d = (double)*(CType *)src; \
+                array.Set(i, Napi::Number::New(env, d)); \
+            }); \
+        } while (false)
+
+    switch (ref->primitive) {
+        case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
+
+        case PrimitiveKind::Bool: {
+            POP_ARRAY({
+                bool b = *(bool *)src;
+                array.Set(i, Napi::Boolean::New(env, b));
+            });
+        } break;
+        case PrimitiveKind::Int8: { POP_NUMBER_ARRAY(int8_t); } break;
+        case PrimitiveKind::UInt8: { POP_NUMBER_ARRAY(uint8_t); } break;
+        case PrimitiveKind::Int16: { POP_NUMBER_ARRAY(int16_t); } break;
+        case PrimitiveKind::UInt16: { POP_NUMBER_ARRAY(uint16_t); } break;
+        case PrimitiveKind::Int32: { POP_NUMBER_ARRAY(int32_t); } break;
+        case PrimitiveKind::UInt32: { POP_NUMBER_ARRAY(uint32_t); } break;
+        case PrimitiveKind::Int64: {
+            POP_ARRAY({
+                int64_t v = *(int64_t *)src;
+                array.Set(i, Napi::BigInt::New(env, v));
+            });
+        } break;
+        case PrimitiveKind::UInt64: {
+            POP_ARRAY({
+                uint64_t v = *(uint64_t *)src;
+                array.Set(i, Napi::BigInt::New(env, v));
+            });
+        } break;
+        case PrimitiveKind::String: {
+            POP_ARRAY({
+                const char *str = *(const char **)src;
+                array.Set(i, str ? Napi::String::New(env, str) : env.Null());
+            });
+        } break;
+        case PrimitiveKind::String16: {
+            POP_ARRAY({
+                const char16_t *str16 = *(const char16_t **)src;
+                array.Set(i, str16 ? Napi::String::New(env, str16) : env.Null());
+            });
+        } break;
+        case PrimitiveKind::Pointer:
+        case PrimitiveKind::Callback: {
+            POP_ARRAY({
+                void *ptr2 = *(void **)src;
+
+                if (ptr2) {
+                    Napi::External<void> external = Napi::External<void>::New(env, ptr2);
+                    SetValueTag(instance, external, ref);
+
+                    array.Set(i, external);
+                } else {
+                    array.Set(i, env.Null());
+                }
+            });
+        } break;
+        case PrimitiveKind::Record: {
+            POP_ARRAY({
+                Napi::Object obj = PopObject(src, ref, realign);
+                array.Set(i, obj);
+            });
+        } break;
+        case PrimitiveKind::Array: {
+            POP_ARRAY({
+                Napi::Value value = PopArray(src, ref, realign);
+                array.Set(i, value);
+            });
+        } break;
+        case PrimitiveKind::Float32: { POP_NUMBER_ARRAY(float); } break;
+        case PrimitiveKind::Float64: { POP_NUMBER_ARRAY(double); } break;
+    }
+
+#undef POP_NUMBER_ARRAY
+#undef POP_ARRAY
+}
+
+void CallData::PopTypedArray(Napi::TypedArray array, const uint8_t *origin, const TypeInfo *ref, int16_t realign)
+{
+    RG_ASSERT(array.IsTypedArray());
+    RG_ASSERT(GetTypedArrayType(ref) == array.TypedArrayType());
+
+    uint8_t *buf = (uint8_t *)array.ArrayBuffer().Data();
+
+    if (realign) {
+        Size offset = 0;
+        Size len = (Size)array.ElementLength();
+
+        for (Size i = 0; i < len; i++) {
+            int16_t align = std::max(ref->align, realign);
+            offset = AlignLen(offset, align);
 
+            uint8_t *dest = buf + i * ref->size;
+            const uint8_t *src = origin + offset;
+
+            memcpy(dest, src, ref->size);
+
+            offset += ref->size;
+        }
+    } else {
+        memcpy_safe(buf, origin, (size_t)array.ByteLength());
+    }
+}
+
+Napi::Value CallData::PopArray(const uint8_t *origin, const TypeInfo *type, int16_t realign)
+{
     RG_ASSERT(type->primitive == PrimitiveKind::Array);
 
     uint32_t len = type->size / type->ref->size;
@@ -732,18 +1030,7 @@ Napi::Value CallData::PopArray(const uint8_t *origin, const TypeInfo *type, int1
                 }); \
             } else { \
                 Napi::TypedArrayType array = Napi::TypedArrayType::New(env, len); \
-                 \
-                for (uint32_t i = 0; i < len; i++) { \
-                    int16_t align = std::max(realign, type->ref->align); \
-                    offset = AlignLen(offset, align); \
-                     \
-                    const uint8_t *src = origin + offset; \
-                     \
-                    CType f = *(CType *)src; \
-                    array[i] = f; \
-                     \
-                    offset += type->ref->size; \
-                } \
+                PopTypedArray(array, origin, type->ref, realign); \
                  \
                 return array; \
             } \
@@ -771,19 +1058,7 @@ Napi::Value CallData::PopArray(const uint8_t *origin, const TypeInfo *type, int1
 
             POP_NUMBER_ARRAY(Int8Array, int8_t);
         } break;
-        case PrimitiveKind::UInt8: {
-            if (type->hint == TypeInfo::ArrayHint::String) {
-                RG_ASSERT(!realign);
-
-                const char *ptr = (const char *)origin;
-                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::UInt8: { POP_NUMBER_ARRAY(Uint8Array, uint8_t); } break;
         case PrimitiveKind::Int16: {
             if (type->hint == TypeInfo::ArrayHint::String) {
                 RG_ASSERT(!realign);
@@ -797,19 +1072,7 @@ Napi::Value CallData::PopArray(const uint8_t *origin, const TypeInfo *type, int1
 
             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 *)origin;
-                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::UInt16: { 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: {
@@ -827,13 +1090,13 @@ Napi::Value CallData::PopArray(const uint8_t *origin, const TypeInfo *type, int1
         case PrimitiveKind::String: {
             POP_ARRAY({
                 const char *str = *(const char **)src;
-                array.Set(i, Napi::String::New(env, str));
+                array.Set(i, str ? Napi::String::New(env, str) : env.Null());
             });
         } break;
         case PrimitiveKind::String16: {
             POP_ARRAY({
                 const char16_t *str16 = *(const char16_t **)src;
-                array.Set(i, Napi::String::New(env, str16));
+                array.Set(i, str16 ? Napi::String::New(env, str16) : env.Null());
             });
         } break;
         case PrimitiveKind::Pointer: