koffi 2.1.0-beta.3 → 2.1.0

package/src/call.cc

@@ -48,78 +48,82 @@ CallData::~CallData()
     }
 }
 
-const char *CallData::PushString(Napi::Value value)
+bool CallData::PushString(Napi::Value value, const char **out_str)
 {
-    RG_ASSERT(value.IsString());
+    if (value.IsString()) {
+        Span<char> buf;
+        size_t len = 0;
+        napi_status status;
 
-    Napi::Env env = value.Env();
+        buf.ptr = (char *)mem->heap.ptr;
+        buf.len = std::max((Size)0, mem->heap.len - Kibibytes(32));
 
-    Span<char> buf;
-    size_t len = 0;
-    napi_status status;
-
-    buf.ptr = (char *)mem->heap.ptr;
-    buf.len = std::max((Size)0, mem->heap.len - Kibibytes(32));
-
-    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);
+        status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
         RG_ASSERT(status == napi_ok);
 
         len++;
 
-        buf.ptr = (char *)Allocator::Allocate(&call_alloc, (Size)len);
-        buf.len = (Size)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);
 
-        status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
-        RG_ASSERT(status == napi_ok);
-    }
+            buf = AllocateMemory<char>(&call_alloc, (Size)len + 1);
+
+            status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
+            RG_ASSERT(status == napi_ok);
+        }
 
-    return buf.ptr;
+        *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));
+        return false;
+    }
 }
 
-const char16_t *CallData::PushString16(Napi::Value value)
+bool CallData::PushString16(Napi::Value value, const char16_t **out_str16)
 {
-    RG_ASSERT(value.IsString());
-
-    Napi::Env env = value.Env();
+    if (value.IsString()) {
+        Span<char16_t> buf;
+        size_t len = 0;
+        napi_status status;
 
-    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;
 
-    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);
+        status = napi_get_value_string_utf16(env, value, buf.ptr, (size_t)buf.len, &len);
         RG_ASSERT(status == napi_ok);
 
         len++;
 
-        buf.ptr = (char16_t *)Allocator::Allocate(&call_alloc, (Size)len * 2);
-        buf.len = (Size)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);
 
-        status = napi_get_value_string_utf16(env, value, buf.ptr, (size_t)buf.len, &len);
-        RG_ASSERT(status == napi_ok);
-    }
+            buf = AllocateMemory<char16_t>(&call_alloc, ((Size)len + 1) * 2);
 
-    return buf.ptr;
+            status = napi_get_value_string_utf16(env, value, buf.ptr, (size_t)buf.len, &len);
+            RG_ASSERT(status == napi_ok);
+        }
+
+        *out_str16 = buf.ptr;
+        return true;
+    } else if (IsNullOrUndefined(value)) {
+        *out_str16 = nullptr;
+        return true;
+    } else {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected string", GetValueType(instance, value));
+        return false;
+    }
 }
 
 bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origin, int16_t realign)
@@ -144,7 +148,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
 
             case PrimitiveKind::Bool: {
                 if (RG_UNLIKELY(!value.IsBoolean())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected boolean", GetValueType(instance, value), member.name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected boolean", GetValueType(instance, value));
                     return false;
                 }
 
@@ -153,7 +157,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
             } break;
             case PrimitiveKind::Int8: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                     return false;
                 }
 
@@ -162,7 +166,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
             } break;
             case PrimitiveKind::UInt8: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                     return false;
                 }
 
@@ -171,7 +175,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
             } break;
             case PrimitiveKind::Int16: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                     return false;
                 }
 
@@ -180,7 +184,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
             } break;
             case PrimitiveKind::Int16S: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                     return false;
                 }
 
@@ -189,7 +193,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
             } break;
             case PrimitiveKind::UInt16: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                     return false;
                 }
 
@@ -198,7 +202,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
             } break;
             case PrimitiveKind::UInt16S: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                     return false;
                 }
 
@@ -207,7 +211,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
             } break;
             case PrimitiveKind::Int32: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                     return false;
                 }
 
@@ -216,7 +220,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
             } break;
             case PrimitiveKind::Int32S: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                     return false;
                 }
 
@@ -225,7 +229,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
             } break;
             case PrimitiveKind::UInt32: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                     return false;
                 }
 
@@ -234,7 +238,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
             } break;
             case PrimitiveKind::UInt32S: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                     return false;
                 }
 
@@ -243,7 +247,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
             } break;
             case PrimitiveKind::Int64: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                     return false;
                 }
 
@@ -252,7 +256,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
             } break;
             case PrimitiveKind::Int64S: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                     return false;
                 }
 
@@ -261,7 +265,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
             } break;
             case PrimitiveKind::UInt64: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                     return false;
                 }
 
@@ -270,7 +274,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
             } break;
             case PrimitiveKind::UInt64S: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                     return false;
                 }
 
@@ -279,49 +283,28 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
             } break;
             case PrimitiveKind::String: {
                 const char *str;
-                if (RG_LIKELY(value.IsString())) {
-                    str = PushString(value);
-                    if (RG_UNLIKELY(!str))
-                        return false;
-                } else if (IsNullOrUndefined(value)) {
-                    str = nullptr;
-                } else {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected string", GetValueType(instance, value), member.name);
+                if (RG_UNLIKELY(!PushString(value, &str)))
                     return false;
-                }
 
                 *(const char **)dest = str;
             } break;
             case PrimitiveKind::String16: {
                 const char16_t *str16;
-                if (RG_LIKELY(value.IsString())) {
-                    str16 = PushString16(value);
-                    if (RG_UNLIKELY(!str16))
-                        return false;
-                } else if (IsNullOrUndefined(value)) {
-                    str16 = nullptr;
-                } else {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected string", GetValueType(instance, value), member.name);
+                if (RG_UNLIKELY(!PushString16(value, &str16)))
                     return false;
-                }
 
                 *(const char16_t **)dest = str16;
             } break;
             case PrimitiveKind::Pointer: {
-                if (CheckValueTag(instance, value, member.type->ref.marker)) {
-                    Napi::External<void> external = value.As<Napi::External<void>>();
-                    void *ptr = external.Data();
-                    *(void **)dest = ptr;
-                } else if (IsNullOrUndefined(value)) {
-                    *(void **)dest = nullptr;
-                } else {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected %3", GetValueType(instance, value), member.name, member.type->name);
+                void *ptr;
+                if (RG_UNLIKELY(!PushPointer(value, member.type, 1, &ptr)))
                     return false;
-                }
+
+                *(void **)dest = ptr;
             } break;
             case PrimitiveKind::Record: {
                 if (RG_UNLIKELY(!IsObject(value))) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected object", GetValueType(instance, value), member.name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected object", GetValueType(instance, value));
                     return false;
                 }
 
@@ -346,13 +329,13 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                     if (!PushStringArray(value, member.type, dest))
                         return false;
                 } else {
-                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 for member '%2', expected array", GetValueType(instance, value), member.name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected array", GetValueType(instance, value));
                     return false;
                 }
             } break;
             case PrimitiveKind::Float32: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                     return false;
                 }
 
@@ -361,7 +344,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
             } break;
             case PrimitiveKind::Float64: {
                 if (RG_UNLIKELY(!value.IsNumber() && !value.IsBigInt())) {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected number", GetValueType(instance, value), member.name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected number", GetValueType(instance, value));
                     return false;
                 }
 
@@ -383,7 +366,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                 } else if (IsNullOrUndefined(value)) {
                     ptr = nullptr;
                 } else {
-                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member '%2', expected %3", GetValueType(instance, value), member.name, member.type->name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected %2", GetValueType(instance, value), member.type->name);
                     return false;
                 }
 
@@ -401,7 +384,7 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *ref,
 {
     RG_ASSERT(array.IsArray());
 
-    if (RG_UNLIKELY(array.Length() != len)) {
+    if (RG_UNLIKELY(array.Length() != (size_t)len)) {
         ThrowError<Napi::Error>(env, "Expected array of length %1, got %2", len, array.Length());
         return false;
     }
@@ -410,8 +393,8 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *ref,
 
 #define PUSH_ARRAY(Check, Expected, GetCode) \
         do { \
-            for (uint32_t i = 0; i < len; i++) { \
-                Napi::Value value = array[i]; \
+            for (Size i = 0; i < len; i++) { \
+                Napi::Value value = array[(uint32_t)i]; \
                  \
                 int16_t align = std::max(ref->align, realign); \
                  \
@@ -419,7 +402,7 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *ref,
                 uint8_t *dest = origin + offset; \
                  \
                 if (RG_UNLIKELY(!(Check))) { \
-                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected %2", GetValueType(instance, value), (Expected)); \
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected %2", GetValueType(instance, value), (Expected)); \
                     return false; \
                 } \
                  \
@@ -523,37 +506,30 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *ref,
             });
         } break;
         case PrimitiveKind::String: {
-            PUSH_ARRAY(value.IsString() || IsNullOrUndefined(value), "string", {
-                if (!IsNullOrUndefined(value)) {
-                    const char *str = PushString(value);
-                    if (RG_UNLIKELY(!str))
-                        return false;
-                    *(const char **)dest = str;
-                } else {
-                    *(const char **)dest = nullptr;
-                }
+            PUSH_ARRAY(true, "string", {
+                const char *str;
+                if (RG_UNLIKELY(!PushString(value, &str)))
+                    return false;
+
+                *(const char **)dest = str;
             });
         } break;
         case PrimitiveKind::String16: {
-            PUSH_ARRAY(value.IsString() || IsNullOrUndefined(value), "string", {
-                if (!IsNullOrUndefined(value)) {
-                    const char16_t *str16 = PushString16(value);
-                    if (RG_UNLIKELY(!str16))
-                        return false;
-                    *(const char16_t **)dest = str16;
-                } else {
-                    *(const char16_t **)dest = nullptr;
-                }
+            PUSH_ARRAY(true, "string", {
+                const char16_t *str16;
+                if (RG_UNLIKELY(!PushString16(value, &str16)))
+                    return false;
+
+                *(const char16_t **)dest = str16;
             });
         } break;
         case PrimitiveKind::Pointer: {
-            PUSH_ARRAY(CheckValueTag(instance, value, ref->ref.marker) || IsNullOrUndefined(value), ref->name, {
-                if (!IsNullOrUndefined(value)) {
-                    Napi::External<void> external = value.As<Napi::External<void>>();
-                    *(void **)dest = external.Data();
-                } else {
-                    *(void **)dest = nullptr;
-                }
+            PUSH_ARRAY(true, ref->name, {
+                void *ptr;
+                if (RG_UNLIKELY(!PushPointer(value, ref, 1, &ptr)))
+                    return false;
+
+                *(const void **)dest = ptr;
             });
         } break;
         case PrimitiveKind::Record: {
@@ -564,8 +540,8 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *ref,
             });
         } break;
         case PrimitiveKind::Array: {
-            for (uint32_t i = 0; i < len; i++) {
-                Napi::Value value = array[i];
+            for (Size i = 0; i < len; i++) {
+                Napi::Value value = array[(uint32_t)i];
 
                 int16_t align = std::max(ref->align, realign);
                 offset = AlignLen(offset, align);
@@ -588,7 +564,7 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *ref,
                     if (!PushStringArray(value, ref, dest))
                         return false;
                 } else {
-                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected array", GetValueType(instance, value));
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected array", GetValueType(instance, value));
                     return false;
                 }
 
@@ -608,8 +584,8 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *ref,
             });
         } break;
         case PrimitiveKind::Callback: {
-            for (uint32_t i = 0; i < len; i++) {
-                Napi::Value value = array[i];
+            for (Size i = 0; i < len; i++) {
+                Napi::Value value = array[(uint32_t)i];
 
                 int16_t align = std::max(ref->align, realign);
                 offset = AlignLen(offset, align);
@@ -630,7 +606,7 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *ref,
                 } else if (IsNullOrUndefined(value)) {
                     ptr = nullptr;
                 } else {
-                    ThrowError<Napi::TypeError>(env, "Unexpected value %1 in array, expected %2", GetValueType(instance, value), ref->name);
+                    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected %2", GetValueType(instance, value), ref->name);
                     return false;
                 }
 
@@ -669,7 +645,7 @@ bool CallData::PushTypedArray(Napi::TypedArray array, Size len, const TypeInfo *
         Size offset = 0;
         Size size = (Size)array.ElementSize();
 
-        for (uint32_t i = 0; i < len; i++) {
+        for (Size i = 0; i < len; i++) {
             offset = AlignLen(offset, realign);
 
             uint8_t *dest = origin + offset;
@@ -715,10 +691,8 @@ bool CallData::PushStringArray(Napi::Value obj, const TypeInfo *type, uint8_t *o
     return true;
 }
 
-bool CallData::PushPointer(Napi::Value value, const ParameterInfo &param, void **out_ptr)
+bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directions, void **out_ptr)
 {
-    const TypeInfo *type = param.type;
-
     if (CheckValueTag(instance, value, &CastMarker)) {
         Napi::External<ValueCast> external = value.As<Napi::External<ValueCast>>();
         ValueCast *cast = external.Data();
@@ -757,7 +731,7 @@ bool CallData::PushPointer(Napi::Value value, const ParameterInfo &param, void *
 
                 ptr = AllocHeap(size, 16);
 
-                if (param.directions & 1) {
+                if (directions & 1) {
                     if (!PushNormalArray(array, len, type->ref.type, ptr))
                         return false;
                 } else {
@@ -771,7 +745,7 @@ bool CallData::PushPointer(Napi::Value value, const ParameterInfo &param, void *
 
                 ptr = AllocHeap(size, 16);
 
-                if (param.directions & 1) {
+                if (directions & 1) {
                     if (!PushTypedArray(array, len, type->ref.type, ptr))
                         return false;
                 } else {
@@ -789,7 +763,7 @@ bool CallData::PushPointer(Napi::Value value, const ParameterInfo &param, void *
 
                 ptr = AllocHeap(type->ref.type->size, 16);
 
-                if (param.directions & 1) {
+                if (directions & 1) {
                     if (!PushObject(obj, type->ref.type, ptr))
                         return false;
                 } else {
@@ -799,7 +773,7 @@ bool CallData::PushPointer(Napi::Value value, const ParameterInfo &param, void *
                 goto unexpected;
             }
 
-            if (param.directions & 2) {
+            if (directions & 2) {
                 OutArgument *out = out_arguments.AppendDefault();
 
                 napi_status status = napi_create_reference(env, value, 1, &out->ref);
@@ -817,7 +791,7 @@ bool CallData::PushPointer(Napi::Value value, const ParameterInfo &param, void *
     }
 
 unexpected:
-    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected %3", GetValueType(instance, value), param.offset + 1, type->name);
+    ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected %2", GetValueType(instance, value), type->name);
     return false;
 }
 

package/src/call.hh

@@ -97,13 +97,13 @@ private:
     template <typename T = uint8_t>
     T *AllocHeap(Size size, Size align);
 
-    const char *PushString(Napi::Value value);
-    const char16_t *PushString16(Napi::Value value);
+    bool PushString(Napi::Value value, const char **out_str);
+    bool PushString16(Napi::Value value, const char16_t **out_str16);
     bool PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origin, int16_t realign = 0);
     bool PushNormalArray(Napi::Array array, Size len, const TypeInfo *ref, uint8_t *origin, int16_t realign = 0);
     bool PushTypedArray(Napi::TypedArray array, Size len, const TypeInfo *ref, uint8_t *origin, int16_t realign = 0);
     bool PushStringArray(Napi::Value value, const TypeInfo *type, uint8_t *origin);
-    bool PushPointer(Napi::Value value, const ParameterInfo &param, void **out_ptr);
+    bool PushPointer(Napi::Value value, const TypeInfo *type, int directions, void **out_ptr);
 
     void PopObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type, int16_t realign = 0);
     Napi::Object PopObject(const uint8_t *origin, const TypeInfo *type, int16_t realign = 0);
@@ -161,7 +161,7 @@ inline T *CallData::AllocHeap(Size size, Size align)
         int flags = 0;
 #endif
 
-        ptr = (uint8_t *)Allocator::Allocate(&call_alloc, size + align, flags);
+        ptr = AllocateMemory<uint8_t>(&call_alloc, size + align, flags).ptr;
         ptr = AlignUp(ptr, align);
 
         return ptr;

package/src/ffi.cc

@@ -170,6 +170,12 @@ static Napi::Value GetSetConfig(const Napi::CallbackInfo &info)
     return obj;
 }
 
+static inline bool CheckAlignment(int64_t align)
+{
+    bool valid = (align > 0) && (align <= 8 && !(align & (align - 1)));
+    return valid;
+}
+
 static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
 {
     Napi::Env env = info.Env();
@@ -224,8 +230,8 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
 
             int64_t align64 = ((Napi::Value)array[0u]).As<Napi::Number>().Int64Value();
 
-            if (align64 < 1 || align64 > 64) {
-                ThrowError<Napi::Error>(env, "Alignment value must be between 1 and 64");
+            if (!CheckAlignment(align64)) {
+                ThrowError<Napi::Error>(env, "Alignment of member '%1' must be 1, 2, 4 or 8", member.name);
                 return env.Null();
             }
 
@@ -1460,14 +1466,20 @@ static inline PrimitiveKind GetSignPrimitive(Size len, bool sign)
 
 static inline PrimitiveKind GetLittleEndianPrimitive(PrimitiveKind kind)
 {
-    // Sensitive to endianness
+#ifdef RG_BIG_ENDIAN
+    return (PrimitiveKind)((int)kind + 1);
+#else
     return kind;
+#endif
 }
 
 static inline PrimitiveKind GetBigEndianPrimitive(PrimitiveKind kind)
 {
-    // Sensitive to endianness
+#ifdef RG_BIG_ENDIAN
+    return kind;
+#else
     return (PrimitiveKind)((int)kind + 1);
+#endif
 }
 
 static Napi::Object InitBaseTypes(Napi::Env env)

package/src/util.hh

@@ -33,26 +33,6 @@ void ThrowError(Napi::Env env, const char *msg, Args... args)
     err.ThrowAsJavaScriptException();
 }
 
-static inline Size AlignLen(Size len, Size align)
-{
-    Size aligned = (len + align - 1) / align * align;
-    return aligned;
-}
-
-template <typename T>
-static inline T *AlignUp(T *ptr, Size align)
-{
-    uint8_t *aligned = (uint8_t *)(((uintptr_t)ptr + align - 1) / align * align);
-    return (T *)aligned;
-}
-
-template <typename T>
-static inline T *AlignDown(T *ptr, Size align)
-{
-    uint8_t *aligned = (uint8_t *)((uintptr_t)ptr / align * align);
-    return (T *)aligned;
-}
-
 static inline bool IsInteger(const TypeInfo *type)
 {
     bool integer = ((int)type->primitive >= (int)PrimitiveKind::Int8 &&

package/test/callbacks.js

@@ -18,10 +18,10 @@ const assert = require('assert');
 
 const BFG = koffi.struct('BFG', {
     a: 'int8_t',
-    b: [16, 'int64_t'],
+    e: [8, 'short'],
+    b: 'int64_t',
     c: 'char',
-    d: 'str',
-    e: 'short',
+    d: 'const char *',
     inner: koffi.struct({
         f: 'float',
         g: 'double'