koffi 2.1.4 → 2.2.0

package/src/koffi/src/call.cc

@@ -48,38 +48,67 @@ CallData::~CallData()
     }
 }
 
-bool CallData::PushString(Napi::Value value, const char **out_str)
+bool CallData::PushString(Napi::Value value, int directions, const char **out_str)
 {
     if (value.IsString()) {
-        Span<char> buf;
-        size_t len = 0;
-        napi_status status;
+        if (RG_UNLIKELY(directions & 2)) {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected string", GetValueType(instance, value));
+            return false;
+        }
 
-        buf.ptr = (char *)mem->heap.ptr;
-        buf.len = std::max((Size)0, mem->heap.len - Kibibytes(32));
+        PushStringValue(value, out_str);
+        return true;
+    } else if (IsNullOrUndefined(value)) {
+        *out_str = nullptr;
+        return true;
+    } else if (value.IsArray()) {
+        Napi::Array array = value.As<Napi::Array>();
 
-        status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
-        RG_ASSERT(status == napi_ok);
+        if (RG_UNLIKELY(!(directions & 2))) {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected string", GetValueType(instance, value));
+            return false;
+        }
+        if (RG_UNLIKELY(array.Length() != 1)) {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected [string]", GetValueType(instance, value));
+            return false;
+        }
 
-        len++;
+        value = array[0u];
 
-        if (RG_LIKELY(len < (size_t)buf.len)) {
-            mem->heap.ptr += (Size)len;
-            mem->heap.len -= (Size)len;
-        } else {
-            status = napi_get_value_string_utf8(env, value, nullptr, 0, &len);
-            RG_ASSERT(status == napi_ok);
+        if (RG_UNLIKELY(!value.IsString())) {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected [string]", GetValueType(instance, array[0u]));
+            return false;
+        }
+
+        Size len = PushStringValue(value, out_str);
+        if (RG_UNLIKELY(len < 0))
+            return false;
+
+        // Create array type
+        TypeInfo *type;
+        {
+            type = AllocateOne<TypeInfo>(&call_alloc, (int)AllocFlag::Zero);
+
+            type->name = "<temporary>";
+
+            type->primitive = PrimitiveKind::Array;
+            type->align = 1;
+            type->size = (int32_t)len;
+            type->ref.type = instance->char_type;
+            type->hint = TypeInfo::ArrayHint::String;
+        }
 
-            buf = AllocateSpan<char>(&call_alloc, (Size)len + 1);
+        // Prepare output argument
+        {
+            OutArgument *out = out_arguments.AppendDefault();
 
-            status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
+            napi_status status = napi_create_reference(env, array, 1, &out->ref);
             RG_ASSERT(status == napi_ok);
+
+            out->ptr = (const uint8_t *)*out_str;
+            out->type = type;
         }
 
-        *out_str = buf.ptr;
-        return true;
-    } else if (IsNullOrUndefined(value)) {
-        *out_str = nullptr;
         return true;
     } else {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected string", GetValueType(instance, value));
@@ -87,38 +116,100 @@ bool CallData::PushString(Napi::Value value, const char **out_str)
     }
 }
 
-bool CallData::PushString16(Napi::Value value, const char16_t **out_str16)
+Size CallData::PushStringValue(Napi::Value value, const char **out_str)
 {
-    if (value.IsString()) {
-        Span<char16_t> buf;
-        size_t len = 0;
-        napi_status status;
+    Span<char> buf;
+    size_t len = 0;
+    napi_status status;
 
-        buf.ptr = (char16_t *)mem->heap.ptr;
-        buf.len = std::max((Size)0, mem->heap.len - Kibibytes(32)) / 2;
+    buf.ptr = (char *)mem->heap.ptr;
+    buf.len = std::max((Size)0, mem->heap.len - Kibibytes(32));
 
-        status = napi_get_value_string_utf16(env, value, buf.ptr, (size_t)buf.len, &len);
+    status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
+    RG_ASSERT(status == napi_ok);
+
+    len++;
+
+    if (RG_LIKELY(len < (size_t)buf.len)) {
+        mem->heap.ptr += (Size)len;
+        mem->heap.len -= (Size)len;
+    } else {
+        status = napi_get_value_string_utf8(env, value, nullptr, 0, &len);
         RG_ASSERT(status == napi_ok);
 
-        len++;
+        buf = AllocateSpan<char>(&call_alloc, (Size)len + 1);
 
-        if (RG_LIKELY(len < (size_t)buf.len)) {
-            mem->heap.ptr += (Size)len * 2;
-            mem->heap.len -= (Size)len * 2;
-        } else {
-            status = napi_get_value_string_utf16(env, value, nullptr, 0, &len);
-            RG_ASSERT(status == napi_ok);
+        status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
+        RG_ASSERT(status == napi_ok);
 
-            buf = AllocateSpan<char16_t>(&call_alloc, ((Size)len + 1) * 2);
+        len++;
+    }
 
-            status = napi_get_value_string_utf16(env, value, buf.ptr, (size_t)buf.len, &len);
-            RG_ASSERT(status == napi_ok);
+    *out_str = buf.ptr;
+    return (Size)len;
+}
+
+bool CallData::PushString16(Napi::Value value, int directions, const char16_t **out_str16)
+{
+    if (value.IsString()) {
+        if (RG_UNLIKELY(directions & 2)) {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected string", GetValueType(instance, value));
+            return false;
         }
 
-        *out_str16 = buf.ptr;
+        PushString16Value(value, out_str16);
         return true;
     } else if (IsNullOrUndefined(value)) {
         *out_str16 = nullptr;
+        return true;
+    }  else if (value.IsArray()) {
+        Napi::Array array = value.As<Napi::Array>();
+
+        if (RG_UNLIKELY(!(directions & 2))) {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected string", GetValueType(instance, value));
+            return false;
+        }
+        if (RG_UNLIKELY(array.Length() != 1)) {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected [string]", GetValueType(instance, value));
+            return false;
+        }
+
+        value = array[0u];
+
+        if (RG_UNLIKELY(!value.IsString())) {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected [string]", GetValueType(instance, array[0u]));
+            return false;
+        }
+
+        Size len = PushString16Value(value, out_str16);
+        if (RG_UNLIKELY(len < 0))
+            return false;
+
+        // Create array type
+        TypeInfo *type;
+        {
+            type = AllocateOne<TypeInfo>(&call_alloc, (int)AllocFlag::Zero);
+
+            type->name = "<temporary>";
+
+            type->primitive = PrimitiveKind::Array;
+            type->align = 1;
+            type->size = (int32_t)(len * 2);
+            type->ref.type = instance->char16_type;
+            type->hint = TypeInfo::ArrayHint::String;
+        }
+
+        // Prepare output argument
+        {
+            OutArgument *out = out_arguments.AppendDefault();
+
+            napi_status status = napi_create_reference(env, array, 1, &out->ref);
+            RG_ASSERT(status == napi_ok);
+
+            out->ptr = (const uint8_t *)*out_str16;
+            out->type = type;
+        }
+
         return true;
     } else {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected string", GetValueType(instance, value));
@@ -126,6 +217,39 @@ bool CallData::PushString16(Napi::Value value, const char16_t **out_str16)
     }
 }
 
+Size CallData::PushString16Value(Napi::Value value, const char16_t **out_str16)
+{
+    Span<char16_t> buf;
+    size_t len = 0;
+    napi_status status;
+
+    buf.ptr = (char16_t *)mem->heap.ptr;
+    buf.len = std::max((Size)0, mem->heap.len - Kibibytes(32)) / 2;
+
+    status = napi_get_value_string_utf16(env, value, buf.ptr, (size_t)buf.len, &len);
+    RG_ASSERT(status == napi_ok);
+
+    len++;
+
+    if (RG_LIKELY(len < (size_t)buf.len)) {
+        mem->heap.ptr += (Size)len * 2;
+        mem->heap.len -= (Size)len * 2;
+    } else {
+        status = napi_get_value_string_utf16(env, value, nullptr, 0, &len);
+        RG_ASSERT(status == napi_ok);
+
+        buf = AllocateSpan<char16_t>(&call_alloc, ((Size)len + 1) * 2);
+
+        status = napi_get_value_string_utf16(env, value, buf.ptr, (size_t)buf.len, &len);
+        RG_ASSERT(status == napi_ok);
+
+        len++;
+    }
+
+    *out_str16 = buf.ptr;
+    return (Size)len;
+}
+
 bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origin, int16_t realign)
 {
     RG_ASSERT(IsObject(obj));
@@ -161,7 +285,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                     return false;
                 }
 
-                int8_t v = CopyNumber<int8_t>(value);
+                int8_t v = GetNumber<int8_t>(value);
                 *(int8_t *)dest = v;
             } break;
             case PrimitiveKind::UInt8: {
@@ -170,7 +294,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                     return false;
                 }
 
-                uint8_t v = CopyNumber<uint8_t>(value);
+                uint8_t v = GetNumber<uint8_t>(value);
                 *(uint8_t *)dest = v;
             } break;
             case PrimitiveKind::Int16: {
@@ -179,7 +303,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                     return false;
                 }
 
-                int16_t v = CopyNumber<int16_t>(value);
+                int16_t v = GetNumber<int16_t>(value);
                 *(int16_t *)dest = v;
             } break;
             case PrimitiveKind::Int16S: {
@@ -188,7 +312,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                     return false;
                 }
 
-                int16_t v = CopyNumber<int16_t>(value);
+                int16_t v = GetNumber<int16_t>(value);
                 *(int16_t *)dest = ReverseBytes(v);
             } break;
             case PrimitiveKind::UInt16: {
@@ -197,7 +321,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                     return false;
                 }
 
-                uint16_t v = CopyNumber<uint16_t>(value);
+                uint16_t v = GetNumber<uint16_t>(value);
                 *(uint16_t *)dest = v;
             } break;
             case PrimitiveKind::UInt16S: {
@@ -206,7 +330,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                     return false;
                 }
 
-                uint16_t v = CopyNumber<uint16_t>(value);
+                uint16_t v = GetNumber<uint16_t>(value);
                 *(uint16_t *)dest = ReverseBytes(v);
             } break;
             case PrimitiveKind::Int32: {
@@ -215,7 +339,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                     return false;
                 }
 
-                int32_t v = CopyNumber<int32_t>(value);
+                int32_t v = GetNumber<int32_t>(value);
                 *(int32_t *)dest = v;
             } break;
             case PrimitiveKind::Int32S: {
@@ -224,7 +348,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                     return false;
                 }
 
-                int32_t v = CopyNumber<int32_t>(value);
+                int32_t v = GetNumber<int32_t>(value);
                 *(int32_t *)dest = ReverseBytes(v);
             } break;
             case PrimitiveKind::UInt32: {
@@ -233,7 +357,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                     return false;
                 }
 
-                uint32_t v = CopyNumber<uint32_t>(value);
+                uint32_t v = GetNumber<uint32_t>(value);
                 *(uint32_t *)dest = v;
             } break;
             case PrimitiveKind::UInt32S: {
@@ -242,7 +366,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                     return false;
                 }
 
-                uint32_t v = CopyNumber<uint32_t>(value);
+                uint32_t v = GetNumber<uint32_t>(value);
                 *(uint32_t *)dest = ReverseBytes(v);
             } break;
             case PrimitiveKind::Int64: {
@@ -251,7 +375,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                     return false;
                 }
 
-                int64_t v = CopyNumber<int64_t>(value);
+                int64_t v = GetNumber<int64_t>(value);
                 *(int64_t *)dest = v;
             } break;
             case PrimitiveKind::Int64S: {
@@ -260,7 +384,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                     return false;
                 }
 
-                int64_t v = CopyNumber<int64_t>(value);
+                int64_t v = GetNumber<int64_t>(value);
                 *(int64_t *)dest = ReverseBytes(v);
             } break;
             case PrimitiveKind::UInt64: {
@@ -269,7 +393,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                     return false;
                 }
 
-                uint64_t v = CopyNumber<uint64_t>(value);
+                uint64_t v = GetNumber<uint64_t>(value);
                 *(uint64_t *)dest = v;
             } break;
             case PrimitiveKind::UInt64S: {
@@ -278,19 +402,19 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                     return false;
                 }
 
-                uint64_t v = CopyNumber<uint64_t>(value);
+                uint64_t v = GetNumber<uint64_t>(value);
                 *(uint64_t *)dest = ReverseBytes(v);
             } break;
             case PrimitiveKind::String: {
                 const char *str;
-                if (RG_UNLIKELY(!PushString(value, &str)))
+                if (RG_UNLIKELY(!PushString(value, 1, &str)))
                     return false;
 
                 *(const char **)dest = str;
             } break;
             case PrimitiveKind::String16: {
                 const char16_t *str16;
-                if (RG_UNLIKELY(!PushString16(value, &str16)))
+                if (RG_UNLIKELY(!PushString16(value, 1, &str16)))
                     return false;
 
                 *(const char16_t **)dest = str16;
@@ -317,13 +441,13 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                     Napi::Array array = value.As<Napi::Array>();
                     Size len = (Size)member.type->size / member.type->ref.type->size;
 
-                    if (!PushNormalArray(array, len, member.type->ref.type, dest, realign))
+                    if (!PushNormalArray(array, len, member.type, dest, realign))
                         return false;
                 } else if (value.IsTypedArray()) {
                     Napi::TypedArray array = value.As<Napi::TypedArray>();
                     Size len = (Size)member.type->size / member.type->ref.type->size;
 
-                    if (!PushTypedArray(array, len, member.type->ref.type, dest, realign))
+                    if (!PushTypedArray(array, len, member.type, dest, realign))
                         return false;
                 } else if (value.IsString() && !realign) {
                     if (!PushStringArray(value, member.type, dest))
@@ -339,7 +463,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                     return false;
                 }
 
-                float f = CopyNumber<float>(value);
+                float f = GetNumber<float>(value);
                 *(float *)dest = f;
             } break;
             case PrimitiveKind::Float64: {
@@ -348,7 +472,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                     return false;
                 }
 
-                double d = CopyNumber<double>(value);
+                double d = GetNumber<double>(value);
                 *(double *)dest = d;
             } break;
             case PrimitiveKind::Callback: {
@@ -380,10 +504,12 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
     return true;
 }
 
-bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *ref, uint8_t *origin, int16_t realign)
+bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *type, uint8_t *origin, int16_t realign)
 {
     RG_ASSERT(array.IsArray());
 
+    const TypeInfo *ref = type->ref.type;
+
     if (RG_UNLIKELY(array.Length() != (size_t)len)) {
         ThrowError<Napi::Error>(env, "Expected array of length %1, got %2", len, array.Length());
         return false;
@@ -413,7 +539,10 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *ref,
         } while (false)
 
     switch (ref->primitive) {
-        case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
+        case PrimitiveKind::Void: {
+            ThrowError<Napi::TypeError>(env, "Ambigous parameter type %1, use koffi.as(value, type)", type->name); \
+            return false;
+        } break;
 
         case PrimitiveKind::Bool: {
             PUSH_ARRAY(value.IsBoolean(), "boolean", {
@@ -423,92 +552,92 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *ref,
         } break;
         case PrimitiveKind::Int8: {
             PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                int8_t v = CopyNumber<int8_t>(value);
+                int8_t v = GetNumber<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 v = GetNumber<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 v = GetNumber<int16_t>(value);
                 *(int16_t *)dest = v;
             });
         } break;
         case PrimitiveKind::Int16S: {
             PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                int16_t v = CopyNumber<int16_t>(value);
+                int16_t v = GetNumber<int16_t>(value);
                 *(int16_t *)dest = ReverseBytes(v);
             });
         } break;
         case PrimitiveKind::UInt16: {
             PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                uint16_t v = CopyNumber<uint16_t>(value);
+                uint16_t v = GetNumber<uint16_t>(value);
                 *(uint16_t *)dest = v;
             });
         } break;
         case PrimitiveKind::UInt16S: {
             PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                uint16_t v = CopyNumber<uint16_t>(value);
+                uint16_t v = GetNumber<uint16_t>(value);
                 *(uint16_t *)dest = ReverseBytes(v);
             });
         } break;
         case PrimitiveKind::Int32: {
             PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                int32_t v = CopyNumber<int32_t>(value);
+                int32_t v = GetNumber<int32_t>(value);
                 *(int32_t *)dest = v;
             });
         } break;
         case PrimitiveKind::Int32S: {
             PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                int32_t v = CopyNumber<int32_t>(value);
+                int32_t v = GetNumber<int32_t>(value);
                 *(int32_t *)dest = ReverseBytes(v);
             });
         } break;
         case PrimitiveKind::UInt32: {
             PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                uint32_t v = CopyNumber<uint32_t>(value);
+                uint32_t v = GetNumber<uint32_t>(value);
                 *(uint32_t *)dest = v;
             });
         } break;
         case PrimitiveKind::UInt32S: {
             PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                uint32_t v = CopyNumber<uint32_t>(value);
+                uint32_t v = GetNumber<uint32_t>(value);
                 *(uint32_t *)dest = ReverseBytes(v);
             });
         } break;
         case PrimitiveKind::Int64: {
             PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                int64_t v = CopyNumber<int64_t>(value);
+                int64_t v = GetNumber<int64_t>(value);
                 *(int64_t *)dest = v;
             });
         } break;
         case PrimitiveKind::Int64S: {
             PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                int64_t v = CopyNumber<int64_t>(value);
+                int64_t v = GetNumber<int64_t>(value);
                 *(int64_t *)dest = ReverseBytes(v);
             });
         } break;
         case PrimitiveKind::UInt64: {
             PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                uint64_t v = CopyNumber<uint64_t>(value);
+                uint64_t v = GetNumber<uint64_t>(value);
                 *(uint64_t *)dest = v;
             });
         } break;
         case PrimitiveKind::UInt64S: {
             PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                uint64_t v = CopyNumber<uint64_t>(value);
+                uint64_t v = GetNumber<uint64_t>(value);
                 *(uint64_t *)dest = ReverseBytes(v);
             });
         } break;
         case PrimitiveKind::String: {
             PUSH_ARRAY(true, "string", {
                 const char *str;
-                if (RG_UNLIKELY(!PushString(value, &str)))
+                if (RG_UNLIKELY(!PushString(value, 1, &str)))
                     return false;
 
                 *(const char **)dest = str;
@@ -517,7 +646,7 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *ref,
         case PrimitiveKind::String16: {
             PUSH_ARRAY(true, "string", {
                 const char16_t *str16;
-                if (RG_UNLIKELY(!PushString16(value, &str16)))
+                if (RG_UNLIKELY(!PushString16(value, 1, &str16)))
                     return false;
 
                 *(const char16_t **)dest = str16;
@@ -552,13 +681,13 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *ref,
                     Napi::Array array2 = value.As<Napi::Array>();
                     Size len2 = (Size)ref->size / ref->ref.type->size;
 
-                    if (!PushNormalArray(array2, len2, ref->ref.type, dest, realign))
+                    if (!PushNormalArray(array2, len2, ref, dest, realign))
                         return false;
                 } else if (value.IsTypedArray()) {
                     Napi::TypedArray array2 = value.As<Napi::TypedArray>();
                     Size len2 = (Size)ref->size / ref->ref.type->size;
 
-                    if (!PushTypedArray(array2, len2, ref->ref.type, dest, realign))
+                    if (!PushTypedArray(array2, len2, ref, dest, realign))
                         return false;
                 } else if (value.IsString() && !realign) {
                     if (!PushStringArray(value, ref, dest))
@@ -573,13 +702,13 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *ref,
         } break;
         case PrimitiveKind::Float32: {
             PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                float f = CopyNumber<float>(value);
+                float f = GetNumber<float>(value);
                 *(float *)dest = f;
             });
         } break;
         case PrimitiveKind::Float64: {
             PUSH_ARRAY(value.IsNumber() || value.IsBigInt(), "number", {
-                double d = CopyNumber<double>(value);
+                double d = GetNumber<double>(value);
                 *(double *)dest = d;
             });
         } break;
@@ -624,10 +753,12 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *ref,
     return true;
 }
 
-bool CallData::PushTypedArray(Napi::TypedArray array, Size len, const TypeInfo *ref, uint8_t *origin, int16_t realign)
+bool CallData::PushTypedArray(Napi::TypedArray array, Size len, const TypeInfo *type, uint8_t *origin, int16_t realign)
 {
     RG_ASSERT(array.IsTypedArray());
 
+    const TypeInfo *ref = type->ref.type;
+
     if (RG_UNLIKELY(array.ElementLength() != (size_t)len)) {
         ThrowError<Napi::Error>(env, "Expected array of length %1, got %2", len, array.ElementLength());
         return false;
@@ -732,7 +863,7 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
                 ptr = AllocHeap(size, 16);
 
                 if (directions & 1) {
-                    if (!PushNormalArray(array, len, type->ref.type, ptr))
+                    if (!PushNormalArray(array, len, type, ptr))
                         return false;
                 } else {
                     memset(ptr, 0, size);
@@ -746,7 +877,7 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
                 ptr = AllocHeap(size, 16);
 
                 if (directions & 1) {
-                    if (!PushTypedArray(array, len, type->ref.type, ptr))
+                    if (!PushTypedArray(array, len, type, ptr))
                         return false;
                 } else {
                     if (RG_UNLIKELY(array.TypedArrayType() != GetTypedArrayType(type->ref.type) &&
@@ -813,13 +944,13 @@ void CallData::PopOutArguments()
 
         if (value.IsArray()) {
             Napi::Array array(env, value);
-            PopNormalArray(array, out.ptr, out.type);
+            DecodeNormalArray(array, out.ptr, out.type);
         } else if (value.IsTypedArray()) {
             Napi::TypedArray array(env, value);
-            PopTypedArray(array, out.ptr, out.type);
+            DecodeTypedArray(array, out.ptr, out.type);
         } else {
             Napi::Object obj(env, value);
-            PopObject(obj, out.ptr, out.type);
+            DecodeObject(obj, out.ptr, out.type);
         }
 
         if (out.type->dispose) {
@@ -845,531 +976,13 @@ void *CallData::ReserveTrampoline(const FunctionInfo *proto, Napi::Function func
 
     trampoline->proto = proto;
     trampoline->func.Reset(func, 1);
+    trampoline->recv.Reset();
     trampoline->generation = (int32_t)mem->generation;
 
     void *ptr = GetTrampoline(idx, proto);
     return ptr;
 }
 
-void CallData::PopObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type, int16_t realign)
-{
-    Napi::Env env = obj.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
-
-    RG_ASSERT(type->primitive == PrimitiveKind::Record);
-
-    for (Size i = 0; i < type->members.len; i++) {
-        const RecordMember &member = type->members[i];
-
-        Size offset = realign ? (i * realign) : member.offset;
-        const uint8_t *src = origin + offset;
-
-        switch (member.type->primitive) {
-            case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
-
-            case PrimitiveKind::Bool: {
-                bool b = *(bool *)src;
-                obj.Set(member.name, Napi::Boolean::New(env, b));
-            } break;
-            case PrimitiveKind::Int8: {
-                double d = (double)*(int8_t *)src;
-                obj.Set(member.name, Napi::Number::New(env, d));
-            } break;
-            case PrimitiveKind::UInt8: {
-                double d = (double)*(uint8_t *)src;
-                obj.Set(member.name, Napi::Number::New(env, d));
-            } break;
-            case PrimitiveKind::Int16: {
-                double d = (double)*(int16_t *)src;
-                obj.Set(member.name, Napi::Number::New(env, d));
-            } break;
-            case PrimitiveKind::Int16S: {
-                int16_t v = *(int16_t *)src;
-                double d = (double)ReverseBytes(v);
-
-                obj.Set(member.name, Napi::Number::New(env, d));
-            } break;
-            case PrimitiveKind::UInt16: {
-                double d = (double)*(uint16_t *)src;
-                obj.Set(member.name, Napi::Number::New(env, d));
-            } break;
-            case PrimitiveKind::UInt16S: {
-                uint16_t v = *(uint16_t *)src;
-                double d = (double)ReverseBytes(v);
-
-                obj.Set(member.name, Napi::Number::New(env, d));
-            } break;
-            case PrimitiveKind::Int32: {
-                double d = (double)*(int32_t *)src;
-                obj.Set(member.name, Napi::Number::New(env, d));
-            } break;
-            case PrimitiveKind::Int32S: {
-                int32_t v = *(int32_t *)src;
-                double d = (double)ReverseBytes(v);
-
-                obj.Set(member.name, Napi::Number::New(env, d));
-            } break;
-            case PrimitiveKind::UInt32: {
-                double d = (double)*(uint32_t *)src;
-                obj.Set(member.name, Napi::Number::New(env, d));
-            } break;
-            case PrimitiveKind::UInt32S: {
-                uint32_t v = *(uint32_t *)src;
-                double d = (double)ReverseBytes(v);
-
-                obj.Set(member.name, Napi::Number::New(env, d));
-            } break;
-            case PrimitiveKind::Int64: {
-                int64_t v = *(int64_t *)src;
-                obj.Set(member.name, NewBigInt(env, v));
-            } break;
-            case PrimitiveKind::Int64S: {
-                int64_t v = ReverseBytes(*(int64_t *)src);
-                obj.Set(member.name, NewBigInt(env, v));
-            } break;
-            case PrimitiveKind::UInt64: {
-                uint64_t v = *(uint64_t *)src;
-                obj.Set(member.name, NewBigInt(env, v));
-            } break;
-            case PrimitiveKind::UInt64S: {
-                uint64_t v = ReverseBytes(*(uint64_t *)src);
-                obj.Set(member.name, NewBigInt(env, v));
-            } break;
-            case PrimitiveKind::String: {
-                const char *str = *(const char **)src;
-                obj.Set(member.name, str ? Napi::String::New(env, str) : env.Null());
-
-                if (member.type->dispose) {
-                    member.type->dispose(env, member.type, str);
-                }
-            } break;
-            case PrimitiveKind::String16: {
-                const char16_t *str16 = *(const char16_t **)src;
-                obj.Set(member.name, str16 ? Napi::String::New(env, str16) : env.Null());
-
-                if (member.type->dispose) {
-                    member.type->dispose(env, member.type, str16);
-                }
-            } break;
-            case PrimitiveKind::Pointer:
-            case PrimitiveKind::Callback: {
-                void *ptr2 = *(void **)src;
-
-                if (ptr2) {
-                    Napi::External<void> external = Napi::External<void>::New(env, ptr2);
-                    SetValueTag(instance, external, member.type->ref.marker);
-
-                    obj.Set(member.name, external);
-                } else {
-                    obj.Set(member.name, env.Null());
-                }
-
-                if (member.type->dispose) {
-                    member.type->dispose(env, member.type, ptr2);
-                }
-            } break;
-            case PrimitiveKind::Record: {
-                Napi::Object obj2 = PopObject(src, member.type, realign);
-                obj.Set(member.name, obj2);
-            } break;
-            case PrimitiveKind::Array: {
-                Napi::Value value = PopArray(src, member.type, realign);
-                obj.Set(member.name, value);
-            } break;
-            case PrimitiveKind::Float32: {
-                float f = *(float *)src;
-                obj.Set(member.name, Napi::Number::New(env, (double)f));
-            } break;
-            case PrimitiveKind::Float64: {
-                double d = *(double *)src;
-                obj.Set(member.name, Napi::Number::New(env, d));
-            } break;
-
-            case PrimitiveKind::Prototype: { RG_UNREACHABLE(); } break;
-        }
-    }
-}
-
-Napi::Object CallData::PopObject(const uint8_t *origin, const TypeInfo *type, int16_t realign)
-{
-    Napi::Object obj = Napi::Object::New(env);
-    PopObject(obj, origin, type, realign);
-    return obj;
-}
-
-static Size WideStringLength(const char16_t *str16, Size max)
-{
-    Size len = 0;
-
-    while (len < max && str16[len]) {
-        len++;
-    }
-
-    return len;
-}
-
-void CallData::PopNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo *ref, int16_t realign)
-{
-    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)
-#define POP_NUMBER_ARRAY_SWAP(CType) \
-        do { \
-            POP_ARRAY({ \
-                CType v = *(CType *)src; \
-                double d = (double)ReverseBytes(v); \
-                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::Int16S: { POP_NUMBER_ARRAY_SWAP(int16_t); } break;
-        case PrimitiveKind::UInt16: { POP_NUMBER_ARRAY(uint16_t); } break;
-        case PrimitiveKind::UInt16S: { POP_NUMBER_ARRAY_SWAP(uint16_t); } break;
-        case PrimitiveKind::Int32: { POP_NUMBER_ARRAY(int32_t); } break;
-        case PrimitiveKind::Int32S: { POP_NUMBER_ARRAY_SWAP(int32_t); } break;
-        case PrimitiveKind::UInt32: { POP_NUMBER_ARRAY(uint32_t); } break;
-        case PrimitiveKind::UInt32S: { POP_NUMBER_ARRAY_SWAP(uint32_t); } break;
-        case PrimitiveKind::Int64: {
-            POP_ARRAY({
-                int64_t v = *(int64_t *)src;
-                array.Set(i, NewBigInt(env, v));
-            });
-        } break;
-        case PrimitiveKind::Int64S: {
-            POP_ARRAY({
-                int64_t v = ReverseBytes(*(int64_t *)src);
-                array.Set(i, NewBigInt(env, v));
-            });
-        } break;
-        case PrimitiveKind::UInt64: {
-            POP_ARRAY({
-                uint64_t v = *(uint64_t *)src;
-                array.Set(i, NewBigInt(env, v));
-            });
-        } break;
-        case PrimitiveKind::UInt64S: {
-            POP_ARRAY({
-                uint64_t v = ReverseBytes(*(uint64_t *)src);
-                array.Set(i, NewBigInt(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());
-
-                if (ref->dispose) {
-                    ref->dispose(env, ref, str);
-                }
-            });
-        } 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());
-
-                if (ref->dispose) {
-                    ref->dispose(env, ref, str16);
-                }
-            });
-        } 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->ref.marker);
-
-                    array.Set(i, external);
-                } else {
-                    array.Set(i, env.Null());
-                }
-
-                if (ref->dispose) {
-                    ref->dispose(env, ref, ptr2);
-                }
-            });
-        } 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;
-
-        case PrimitiveKind::Prototype: { RG_UNREACHABLE(); } break;
-    }
-
-#undef POP_NUMBER_ARRAY_SWAP
-#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() ||
-              ref == instance->void_type);
-
-    uint8_t *buf = (uint8_t *)array.ArrayBuffer().Data();
-
-    if (realign) {
-        Size offset = 0;
-        Size len = (Size)array.ElementLength();
-        Size size = (Size)array.ElementSize();
-
-        for (Size i = 0; i < len; i++) {
-            offset = AlignLen(offset, realign);
-
-            uint8_t *dest = buf + i * size;
-            const uint8_t *src = origin + offset;
-
-            memcpy(dest, src, size);
-
-            offset += size;
-        }
-    } else {
-        memcpy_safe(buf, origin, (size_t)array.ByteLength());
-    }
-
-#define SWAP(CType) \
-        do { \
-            CType *data = (CType *)buf; \
-            Size len = (Size)array.ElementLength(); \
-             \
-            for (Size i = 0; i < len; i++) { \
-                data[i] = ReverseBytes(data[i]); \
-            } \
-        } while (false)
-
-    if (ref->primitive == PrimitiveKind::Int16S || ref->primitive == PrimitiveKind::UInt16S) {
-        SWAP(uint16_t);
-    } else if (ref->primitive == PrimitiveKind::Int32S || ref->primitive == PrimitiveKind::UInt32S) {
-        SWAP(uint32_t);
-    } else if (ref->primitive == PrimitiveKind::Int64S || ref->primitive == PrimitiveKind::UInt64S) {
-        SWAP(uint64_t);
-    }
-
-#undef SWAP
-}
-
-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.type->size;
-    Size offset = 0;
-
-#define POP_ARRAY(SetCode) \
-        do { \
-            Napi::Array array = Napi::Array::New(env); \
-             \
-            for (uint32_t i = 0; i < len; i++) { \
-                int16_t align = std::max(realign, type->ref.type->align); \
-                offset = AlignLen(offset, align); \
-                 \
-                const uint8_t *src = origin + offset; \
-                 \
-                SetCode \
-                 \
-                offset += type->ref.type->size; \
-            } \
-             \
-            return array; \
-        } while (false)
-#define POP_NUMBER_ARRAY(TypedArrayType, CType) \
-        do { \
-            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); \
-                PopTypedArray(array, origin, type->ref.type, realign); \
-                 \
-                return array; \
-            } \
-        } while (false)
-#define POP_NUMBER_ARRAY_SWAP(TypedArrayType, CType) \
-        do { \
-            if (type->hint == TypeInfo::ArrayHint::Array) { \
-                POP_ARRAY({ \
-                    CType v = *(CType *)src; \
-                    double d = (double)ReverseBytes(v); \
-                    array.Set(i, Napi::Number::New(env, d)); \
-                }); \
-            } else { \
-                Napi::TypedArrayType array = Napi::TypedArrayType::New(env, len); \
-                PopTypedArray(array, origin, type->ref.type, realign); \
-                 \
-                return array; \
-            } \
-        } while (false)
-
-    switch (type->ref.type->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: {
-            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(Int8Array, int8_t);
-        } break;
-        case PrimitiveKind::UInt8: { 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 *)origin;
-                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::Int16S: { POP_NUMBER_ARRAY_SWAP(Int16Array, int16_t); } break;
-        case PrimitiveKind::UInt16: { POP_NUMBER_ARRAY(Uint16Array, uint16_t); } break;
-        case PrimitiveKind::UInt16S: { POP_NUMBER_ARRAY_SWAP(Uint16Array, uint16_t); } break;
-        case PrimitiveKind::Int32: { POP_NUMBER_ARRAY(Int32Array, int32_t); } break;
-        case PrimitiveKind::Int32S: { POP_NUMBER_ARRAY_SWAP(Int32Array, int32_t); } break;
-        case PrimitiveKind::UInt32: { POP_NUMBER_ARRAY(Uint32Array, uint32_t); } break;
-        case PrimitiveKind::UInt32S: { POP_NUMBER_ARRAY_SWAP(Uint32Array, uint32_t); } break;
-        case PrimitiveKind::Int64: {
-            POP_ARRAY({
-                int64_t v = *(int64_t *)src;
-                array.Set(i, NewBigInt(env, v));
-            });
-        } break;
-        case PrimitiveKind::Int64S: {
-            POP_ARRAY({
-                int64_t v = ReverseBytes(*(int64_t *)src);
-                array.Set(i, NewBigInt(env, v));
-            });
-        } break;
-        case PrimitiveKind::UInt64: {
-            POP_ARRAY({
-                uint64_t v = *(uint64_t *)src;
-                array.Set(i, NewBigInt(env, v));
-            });
-        } break;
-        case PrimitiveKind::UInt64S: {
-            POP_ARRAY({
-                uint64_t v = ReverseBytes(*(uint64_t *)src);
-                array.Set(i, NewBigInt(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, type->ref.type->ref.marker);
-
-                    array.Set(i, external);
-                } else {
-                    array.Set(i, env.Null());
-                }
-            });
-        } break;
-        case PrimitiveKind::Record: {
-            POP_ARRAY({
-                Napi::Object obj = PopObject(src, type->ref.type, realign);
-                array.Set(i, obj);
-            });
-        } break;
-        case PrimitiveKind::Array: {
-            POP_ARRAY({
-                Napi::Value value = PopArray(src, type->ref.type, realign);
-                array.Set(i, value);
-            });
-        } break;
-        case PrimitiveKind::Float32: { POP_NUMBER_ARRAY(Float32Array, float); } break;
-        case PrimitiveKind::Float64: { POP_NUMBER_ARRAY(Float64Array, double); } break;
-
-        case PrimitiveKind::Prototype: { RG_UNREACHABLE(); } break;
-    }
-
-#undef POP_NUMBER_ARRAY_SWAP
-#undef POP_NUMBER_ARRAY
-#undef POP_ARRAY
-
-    RG_UNREACHABLE();
-}
-
 void CallData::DumpForward() const
 {
     PrintLn(stderr, "%!..+---- %1 (%2) ----%!0", func->name, CallConventionNames[(int)func->convention]);