koffi 1.2.4 → 1.3.1

package/src/abi_arm32.cc

@@ -247,7 +247,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
 
             case PrimitiveKind::Bool: {
                 if (RG_UNLIKELY(!value.IsBoolean())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected boolean", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected boolean", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
@@ -260,7 +260,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
             case PrimitiveKind::UInt16:
             case PrimitiveKind::Int32: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
@@ -269,7 +269,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
             } break;
             case PrimitiveKind::UInt32: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
@@ -278,7 +278,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
             } break;
             case PrimitiveKind::Int64: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
@@ -296,7 +296,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
             } break;
             case PrimitiveKind::UInt64: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
@@ -321,7 +321,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 } else if (IsNullOrUndefined(value)) {
                     str = nullptr;
                 } else {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected string", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected string", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
@@ -336,47 +336,22 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 } else if (IsNullOrUndefined(value)) {
                     str16 = nullptr;
                 } else {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected string", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected string", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
                 *(const char16_t **)((param.gpr_count ? gpr_ptr : args_ptr)++) = str16;
             } break;
             case PrimitiveKind::Pointer: {
-                uint8_t *ptr;
-
-                if (CheckValueTag(instance, value, param.type)) {
-                    ptr = value.As<Napi::External<uint8_t>>().Data();
-                } else if (IsObject(value) && param.type->ref->primitive == PrimitiveKind::Record) {
-                    Napi::Object obj = value.As<Napi::Object>();
-
-                    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);
-                    }
-                    if (param.directions & 2) {
-                        OutObject *out = out_objects.AppendDefault();
-
-                        out->ref.Reset(obj, 1);
-                        out->ptr = ptr;
-                        out->type = param.type->ref;
-                    }
-                } else if (IsNullOrUndefined(value)) {
-                    ptr = nullptr;
-                } else {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected %3", GetValueType(instance, value), i + 1, param.type->name);
+                void *ptr;
+                if (RG_UNLIKELY(!PushPointer(value, param, &ptr)))
                     return false;
-                }
 
                 *(void **)((param.gpr_count ? gpr_ptr : args_ptr)++) = ptr;
             } break;
             case PrimitiveKind::Record: {
                 if (RG_UNLIKELY(!IsObject(value))) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected object", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected object", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
@@ -409,7 +384,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
             case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
             case PrimitiveKind::Float32: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
@@ -425,7 +400,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
             } break;
             case PrimitiveKind::Float64: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
@@ -458,7 +433,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 } else if (IsNullOrUndefined(value)) {
                     ptr = nullptr;
                 } else {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected %3", GetValueType(instance, value), i + 1, param.type->name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected %3", GetValueType(instance, value), param.offset + 1, param.type->name);
                     return false;
                 }
 
@@ -517,10 +492,7 @@ void CallData::Execute()
 
 Napi::Value CallData::Complete()
 {
-    for (const OutObject &out: out_objects) {
-        Napi::Object obj = out.ref.Value().As<Napi::Object>();
-        PopObject(obj, out.ptr, out.type);
-    }
+    PopOutArguments();
 
     switch (func->ret.type->primitive) {
         case PrimitiveKind::Void: return env.Null();
@@ -533,8 +505,8 @@ Napi::Value CallData::Complete()
         case PrimitiveKind::UInt32: return Napi::Number::New(env, (double)result.u32);
         case PrimitiveKind::Int64: return Napi::BigInt::New(env, (int64_t)result.u64);
         case PrimitiveKind::UInt64: return Napi::BigInt::New(env, result.u64);
-        case PrimitiveKind::String: return Napi::String::New(env, (const char *)result.ptr);
-        case PrimitiveKind::String16: return Napi::String::New(env, (const char16_t *)result.ptr);
+        case PrimitiveKind::String: return result.ptr ? Napi::String::New(env, (const char *)result.ptr) : env.Null();
+        case PrimitiveKind::String16: return result.ptr ? Napi::String::New(env, (const char16_t *)result.ptr) : env.Null();
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Callback: {
             if (result.ptr) {
@@ -646,13 +618,13 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             case PrimitiveKind::String: {
                 const char *str = *(const char **)((param.gpr_count ? gpr_ptr : args_ptr)++);
 
-                Napi::Value arg = Napi::String::New(env, str);
+                Napi::Value arg = str ? Napi::String::New(env, str) : env.Null();
                 arguments.Append(arg);
             } break;
             case PrimitiveKind::String16: {
                 const char16_t *str16 = *(const char16_t **)((param.gpr_count ? gpr_ptr : args_ptr)++);
 
-                Napi::Value arg = Napi::String::New(env, str16);
+                Napi::Value arg = str16 ? Napi::String::New(env, str16) : env.Null();
                 arguments.Append(arg);
             } break;
             case PrimitiveKind::Pointer:
@@ -906,9 +878,9 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             void *ptr;
 
             if (value.IsFunction()) {
-                Napi::Function func = value.As<Napi::Function>();
+                Napi::Function func2 = value.As<Napi::Function>();
 
-                ptr = ReserveTrampoline(type->proto, func);
+                ptr = ReserveTrampoline(type->proto, func2);
                 if (RG_UNLIKELY(!ptr))
                     return;
             } else if (CheckValueTag(instance, value, type)) {

package/src/abi_arm64.cc

@@ -237,7 +237,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
 
             case PrimitiveKind::Bool: {
                 if (RG_UNLIKELY(!value.IsBoolean())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected boolean", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected boolean", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
@@ -262,7 +262,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
             case PrimitiveKind::UInt32:
             case PrimitiveKind::Int64: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
@@ -282,7 +282,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
             } break;
             case PrimitiveKind::UInt64: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
@@ -302,7 +302,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 } else if (IsNullOrUndefined(value)) {
                     str = nullptr;
                 } else {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected string", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected string", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
@@ -320,7 +320,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 } else if (IsNullOrUndefined(value)) {
                     str16 = nullptr;
                 } else {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected string", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected string", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
@@ -330,34 +330,9 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 *(const char16_t **)((param.gpr_count ? gpr_ptr : args_ptr)++) = str16;
             } break;
             case PrimitiveKind::Pointer: {
-                uint8_t *ptr;
-
-                if (CheckValueTag(instance, value, param.type)) {
-                    ptr = value.As<Napi::External<uint8_t>>().Data();
-                } else if (IsObject(value) && param.type->ref->primitive == PrimitiveKind::Record) {
-                    Napi::Object obj = value.As<Napi::Object>();
-
-                    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);
-                    }
-                    if (param.directions & 2) {
-                        OutObject *out = out_objects.AppendDefault();
-
-                        out->ref.Reset(obj, 1);
-                        out->ptr = ptr;
-                        out->type = param.type->ref;
-                    }
-                } else if (IsNullOrUndefined(value)) {
-                    ptr = nullptr;
-                } else {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected %3", GetValueType(instance, value), i + 1, param.type->name);
+                void *ptr;
+                if (RG_UNLIKELY(!PushPointer(value, param, &ptr)))
                     return false;
-                }
 
 #ifdef __APPLE__
                 args_ptr = param.gpr_count ? args_ptr : AlignUp(args_ptr, 8);
@@ -366,7 +341,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
             } break;
             case PrimitiveKind::Record: {
                 if (RG_UNLIKELY(!IsObject(value))) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected object", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected object", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
@@ -413,7 +388,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
             case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
             case PrimitiveKind::Float32: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
@@ -440,7 +415,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
             } break;
             case PrimitiveKind::Float64: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
@@ -473,7 +448,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 } else if (IsNullOrUndefined(value)) {
                     ptr = nullptr;
                 } else {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected %3", GetValueType(instance, value), i + 1, param.type->name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected %3", GetValueType(instance, value), param.offset + 1, param.type->name);
                     return false;
                 }
 
@@ -538,10 +513,7 @@ void CallData::Execute()
 
 Napi::Value CallData::Complete()
 {
-    for (const OutObject &out: out_objects) {
-        Napi::Object obj = out.ref.Value().As<Napi::Object>();
-        PopObject(obj, out.ptr, out.type);
-    }
+    PopOutArguments();
 
     switch (func->ret.type->primitive) {
         case PrimitiveKind::Void: return env.Null();
@@ -554,8 +526,8 @@ Napi::Value CallData::Complete()
         case PrimitiveKind::UInt32: return Napi::Number::New(env, (double)result.u32);
         case PrimitiveKind::Int64: return Napi::BigInt::New(env, (int64_t)result.u64);
         case PrimitiveKind::UInt64: return Napi::BigInt::New(env, result.u64);
-        case PrimitiveKind::String: return Napi::String::New(env, (const char *)result.ptr);
-        case PrimitiveKind::String16: return Napi::String::New(env, (const char16_t *)result.ptr);
+        case PrimitiveKind::String: return result.ptr ? Napi::String::New(env, (const char *)result.ptr) : env.Null();
+        case PrimitiveKind::String16: return result.ptr ? Napi::String::New(env, (const char16_t *)result.ptr) : env.Null();
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Callback: {
             if (result.ptr) {
@@ -751,7 +723,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
 
                 const char *str = *(const char **)((param.gpr_count ? gpr_ptr : args_ptr)++);
 
-                Napi::Value arg = Napi::String::New(env, str);
+                Napi::Value arg = str ? Napi::String::New(env, str) : env.Null();
                 arguments.Append(arg);
             } break;
             case PrimitiveKind::String16: {
@@ -761,7 +733,7 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
 
                 const char16_t *str16 = *(const char16_t **)((param.gpr_count ? gpr_ptr : args_ptr)++);
 
-                Napi::Value arg = Napi::String::New(env, str16);
+                Napi::Value arg = str16 ? Napi::String::New(env, str16) : env.Null();
                 arguments.Append(arg);
             } break;
             case PrimitiveKind::Pointer:
@@ -987,9 +959,9 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             void *ptr;
 
             if (value.IsFunction()) {
-                Napi::Function func = value.As<Napi::Function>();
+                Napi::Function func2 = value.As<Napi::Function>();
 
-                ptr = ReserveTrampoline(type->proto, func);
+                ptr = ReserveTrampoline(type->proto, func2);
                 if (RG_UNLIKELY(!ptr))
                     return;
             } else if (CheckValueTag(instance, value, type)) {

package/src/abi_arm64_fwd.S

@@ -20,6 +20,11 @@
 # Forward
 # ----------------------------
 
+#ifdef __APPLE__
+# Fix "arm64 function not 4-byte aligned" linker warnings
+.p2align 2
+#endif
+
 # These three are the same, but they differ (in the C side) by their return type.
 # Unlike the three next functions, these ones don't forward XMM argument registers.
 .global SYMBOL(ForwardCallGG)

package/src/abi_riscv64.cc

@@ -196,7 +196,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
 
             case PrimitiveKind::Bool: {
                 if (RG_UNLIKELY(!value.IsBoolean())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected boolean", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected boolean", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
@@ -208,7 +208,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
             case PrimitiveKind::Int32:
             case PrimitiveKind::Int64: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
@@ -220,7 +220,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
             case PrimitiveKind::UInt32:
             case PrimitiveKind::UInt64: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
@@ -236,7 +236,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 } else if (IsNullOrUndefined(value)) {
                     str = nullptr;
                 } else {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected string", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected string", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
@@ -251,47 +251,22 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 } else if (IsNullOrUndefined(value)) {
                     str16 = nullptr;
                 } else {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected string", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected string", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
                 *(const char16_t **)((param.gpr_count ? gpr_ptr : args_ptr)++) = str16;
             } break;
             case PrimitiveKind::Pointer: {
-                uint8_t *ptr;
-
-                if (CheckValueTag(instance, value, param.type)) {
-                    ptr = value.As<Napi::External<uint8_t>>().Data();
-                } else if (IsObject(value) && param.type->ref->primitive == PrimitiveKind::Record) {
-                    Napi::Object obj = value.As<Napi::Object>();
-
-                    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);
-                    }
-                    if (param.directions & 2) {
-                        OutObject *out = out_objects.AppendDefault();
-
-                        out->ref.Reset(obj, 1);
-                        out->ptr = ptr;
-                        out->type = param.type->ref;
-                    }
-                } else if (IsNullOrUndefined(value)) {
-                    ptr = nullptr;
-                } else {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected %3", GetValueType(instance, value), i + 1, param.type->name);
+                void *ptr;
+                if (RG_UNLIKELY(!PushPointer(value, param, &ptr)))
                     return false;
-                }
 
-                *(uint8_t **)((param.gpr_count ? gpr_ptr : args_ptr)++) = ptr;
+                *(void **)((param.gpr_count ? gpr_ptr : args_ptr)++) = ptr;
             } break;
             case PrimitiveKind::Record: {
                 if (RG_UNLIKELY(!IsObject(value))) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected object", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected object", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
@@ -340,7 +315,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
             case PrimitiveKind::Array: { RG_UNREACHABLE(); } break;
             case PrimitiveKind::Float32: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
@@ -359,7 +334,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
             } break;
             case PrimitiveKind::Float64: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected number", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
@@ -387,7 +362,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
                 } else if (IsNullOrUndefined(value)) {
                     ptr = nullptr;
                 } else {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected %3", GetValueType(instance, value), i + 1, param.type->name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected %3", GetValueType(instance, value), param.offset + 1, param.type->name);
                     return false;
                 }
 
@@ -453,10 +428,7 @@ void CallData::Execute()
 
 Napi::Value CallData::Complete()
 {
-    for (const OutObject &out: out_objects) {
-        Napi::Object obj = out.ref.Value().As<Napi::Object>();
-        PopObject(obj, out.ptr, out.type);
-    }
+    PopOutArguments();
 
     switch (func->ret.type->primitive) {
         case PrimitiveKind::Void: return env.Null();
@@ -469,8 +441,8 @@ Napi::Value CallData::Complete()
         case PrimitiveKind::UInt32: return Napi::Number::New(env, (double)result.u32);
         case PrimitiveKind::Int64: return Napi::BigInt::New(env, (int64_t)result.u64);
         case PrimitiveKind::UInt64: return Napi::BigInt::New(env, result.u64);
-        case PrimitiveKind::String: return Napi::String::New(env, (const char *)result.ptr);
-        case PrimitiveKind::String16: return Napi::String::New(env, (const char16_t *)result.ptr);
+        case PrimitiveKind::String: return result.ptr ? Napi::String::New(env, (const char *)result.ptr) : env.Null();
+        case PrimitiveKind::String16: return result.ptr ? Napi::String::New(env, (const char16_t *)result.ptr) : env.Null();
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Callback: {
             if (result.ptr) {
@@ -581,13 +553,13 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             case PrimitiveKind::String: {
                 const char *str = *(const char **)((param.gpr_count ? gpr_ptr : args_ptr)++);
 
-                Napi::Value arg = Napi::String::New(env, str);
+                Napi::Value arg = str ? Napi::String::New(env, str) : env.Null();
                 arguments.Append(arg);
             } break;
             case PrimitiveKind::String16: {
                 const char16_t *str16 = *(const char16_t **)((param.gpr_count ? gpr_ptr : args_ptr)++);
 
-                Napi::Value arg = Napi::String::New(env, str16);
+                Napi::Value arg = str16 ? Napi::String::New(env, str16) : env.Null();
                 arguments.Append(arg);
             } break;
             case PrimitiveKind::Pointer:
@@ -792,9 +764,9 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             void *ptr;
 
             if (value.IsFunction()) {
-                Napi::Function func = value.As<Napi::Function>();
+                Napi::Function func2 = value.As<Napi::Function>();
 
-                ptr = ReserveTrampoline(type->proto, func);
+                ptr = ReserveTrampoline(type->proto, func2);
                 if (RG_UNLIKELY(!ptr))
                     return;
             } else if (CheckValueTag(instance, value, type)) {