koffi 1.2.4 → 1.3.0-rc.1

package/src/abi_x64_sysv.cc

@@ -276,7 +276,7 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
 
             case PrimitiveKind::Bool: {
                 if (RG_UNLIKELY(!value.IsBoolean())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argmument %2, expected boolean", GetValueType(instance, value), i + 1);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argmument %2, expected boolean", GetValueType(instance, value), param.offset + 1);
                     return false;
                 }
 
@@ -291,7 +291,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;
                 }
 
@@ -300,7 +300,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;
                 }
 
@@ -316,7 +316,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;
                 }
 
@@ -331,47 +331,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;
                 }
 
@@ -410,7 +385,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;
                 }
 
@@ -422,7 +397,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;
                 }
 
@@ -443,7 +418,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;
                 }
 
@@ -509,10 +484,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();
@@ -525,8 +497,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) {
@@ -632,13 +604,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:
@@ -849,9 +821,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_x64_win.cc

@@ -121,7 +121,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;
                 }
 
@@ -137,7 +137,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;
                 }
 
@@ -146,7 +146,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;
                 }
 
@@ -162,7 +162,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;
                 }
 
@@ -177,47 +177,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 **)(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 **)(args_ptr++) = ptr;
+                *(void **)(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;
                 }
 
@@ -236,7 +211,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;
                 }
 
@@ -247,7 +222,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;
                 }
 
@@ -268,7 +243,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;
                 }
 
@@ -319,10 +294,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();
@@ -335,8 +307,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) {
@@ -451,14 +423,14 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                 const char *str = *(const char **)(j < 4 ? gpr_ptr + j : args_ptr);
                 args_ptr += (j >= 4);
 
-                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 **)(j < 4 ? gpr_ptr + j : args_ptr);
                 args_ptr += (j >= 4);
 
-                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:
@@ -631,9 +603,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_x86.cc

@@ -177,7 +177,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;
                 }
 
@@ -190,7 +190,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;
                 }
 
@@ -199,7 +199,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;
                 }
 
@@ -208,7 +208,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;
                 }
 
@@ -218,7 +218,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;
                 }
 
@@ -235,7 +235,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;
                 }
 
@@ -250,47 +250,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.fast ? fast_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.fast ? fast_ptr : args_ptr)++) = ptr;
+                *(void **)((param.fast ? fast_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;
                 }
 
@@ -310,7 +285,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;
                 }
 
@@ -319,7 +294,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;
                 }
 
@@ -341,7 +316,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;
                 }
 
@@ -393,10 +368,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();
@@ -409,8 +381,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) {
@@ -526,13 +498,13 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
             case PrimitiveKind::String: {
                 const char *str = *(const char **)(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 **)(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:
@@ -708,9 +680,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)) {