koffi 2.14.0 → 2.14.1

package/src/koffi/src/call.cc

@@ -26,7 +26,7 @@
 
 #include <napi.h>
 
-namespace RG {
+namespace K {
 
 struct RelayContext {
     CallData *call;
@@ -49,8 +49,8 @@ CallData::CallData(Napi::Env env, InstanceData *instance, InstanceMemory *mem)
     mem->generation += !mem->depth;
     mem->depth++;
 
-    RG_ASSERT(AlignUp(mem->stack.ptr, 16) == mem->stack.ptr);
-    RG_ASSERT(AlignUp(mem->stack.end(), 16) == mem->stack.end());
+    K_ASSERT(AlignUp(mem->stack.ptr, 16) == mem->stack.ptr);
+    K_ASSERT(AlignUp(mem->stack.end(), 16) == mem->stack.end());
 }
 
 CallData::~CallData()
@@ -77,8 +77,8 @@ void CallData::Dispose()
             int16_t idx = used_trampolines[i];
             TrampolineInfo *trampoline = &shared.trampolines[idx];
 
-            RG_ASSERT(trampoline->instance == instance);
-            RG_ASSERT(!trampoline->func.IsEmpty());
+            K_ASSERT(trampoline->instance == instance);
+            K_ASSERT(!trampoline->func.IsEmpty());
 
             trampoline->instance = nullptr;
             trampoline->func.Reset();
@@ -147,6 +147,7 @@ void CallData::RelayAsync(napi_env, napi_value, void *, void *udata)
 
 bool CallData::PushString(Napi::Value value, int directions, const char **out_str)
 {
+    // Fast path
     if (value.IsString()) {
         if (directions & 2) [[unlikely]] {
             ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected [string]", GetValueType(instance, value));
@@ -155,62 +156,41 @@ bool CallData::PushString(Napi::Value value, int directions, const char **out_st
 
         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>();
+    }
 
-        if (!(directions & 2)) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected string", GetValueType(instance, value));
-            return false;
-        }
-        if (array.Length() != 1) [[unlikely]] {
+    return PushPointer(value, instance->str_type, directions, (void **)out_str);
+}
+
+bool CallData::PushString16(Napi::Value value, int directions, const char16_t **out_str16)
+{
+    // Fast path
+    if (value.IsString()) {
+        if (directions & 2) [[unlikely]] {
             ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected [string]", GetValueType(instance, value));
             return false;
         }
 
-        value = array[0u];
+        PushString16Value(value, out_str16);
+        return true;
+    }
 
-        if (!value.IsString()) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected [string]", GetValueType(instance, array[0u]));
-            return false;
-        }
+    return PushPointer(value, instance->str16_type, directions, (void **)out_str16);
+}
 
-        Size len = PushStringValue(value, out_str);
-        if (len < 0) [[unlikely]]
+bool CallData::PushString32(Napi::Value value, int directions, const char32_t **out_str32)
+{
+    // Fast path
+    if (value.IsString()) {
+        if (directions & 2) [[unlikely]] {
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected [string]", GetValueType(instance, value));
             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 = 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->kind = OutArgument::Kind::Array;
-            out->ptr = (const uint8_t *)*out_str;
-            out->type = type;
         }
 
+        PushString32Value(value, out_str32);
         return true;
-    } else {
-        return PushPointer(value, instance->str_type, directions, (void **)out_str);
     }
+
+    return PushPointer(value, instance->str32_type, directions, (void **)out_str32);
 }
 
 Size CallData::PushStringValue(Napi::Value value, const char **out_str)
@@ -223,7 +203,7 @@ Size CallData::PushStringValue(Napi::Value value, const char **out_str)
     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);
+    K_ASSERT(status == napi_ok);
 
     len++;
 
@@ -232,13 +212,13 @@ Size CallData::PushStringValue(Napi::Value value, const char **out_str)
         mem->heap.len -= (Size)len;
     } else {
         status = napi_get_value_string_utf8(env, value, nullptr, 0, &len);
-        RG_ASSERT(status == napi_ok);
+        K_ASSERT(status == napi_ok);
 
         len++;
         buf = AllocateSpan<char>(&call_alloc, (Size)len);
 
         status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
-        RG_ASSERT(status == napi_ok);
+        K_ASSERT(status == napi_ok);
 
         len++;
     }
@@ -247,74 +227,6 @@ Size CallData::PushStringValue(Napi::Value value, const char **out_str)
     return (Size)len;
 }
 
-bool CallData::PushString16(Napi::Value value, int directions, const char16_t **out_str16)
-{
-    if (value.IsString()) {
-        if (directions & 2) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected string", GetValueType(instance, value));
-            return false;
-        }
-
-        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 (!(directions & 2)) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected string", GetValueType(instance, value));
-            return false;
-        }
-        if (array.Length() != 1) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected [string]", GetValueType(instance, value));
-            return false;
-        }
-
-        value = array[0u];
-
-        if (!value.IsString()) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected [string]", GetValueType(instance, array[0u]));
-            return false;
-        }
-
-        Size len = PushString16Value(value, out_str16);
-        if (len < 0) [[unlikely]]
-            return false;
-
-        // Create array type
-        TypeInfo *type;
-        {
-            type = AllocateOne<TypeInfo>(&call_alloc, (int)AllocFlag::Zero);
-
-            type->name = "<temporary>";
-
-            type->primitive = PrimitiveKind::Array;
-            type->align = 2;
-            type->size = (int32_t)(len * 2);
-            type->ref.type = instance->char16_type;
-            type->hint = 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->kind = OutArgument::Kind::Array;
-            out->ptr = (const uint8_t *)*out_str16;
-            out->type = type;
-        }
-
-        return true;
-    } else {
-        return PushPointer(value, instance->str16_type, directions, (void **)out_str16);
-    }
-}
-
 Size CallData::PushString16Value(Napi::Value value, const char16_t **out_str16)
 {
     Span<char16_t> buf;
@@ -326,7 +238,7 @@ Size CallData::PushString16Value(Napi::Value value, const char16_t **out_str16)
     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);
+    K_ASSERT(status == napi_ok);
 
     len++;
 
@@ -335,13 +247,13 @@ Size CallData::PushString16Value(Napi::Value value, const char16_t **out_str16)
         mem->heap.len -= (Size)len * 2;
     } else {
         status = napi_get_value_string_utf16(env, value, nullptr, 0, &len);
-        RG_ASSERT(status == napi_ok);
+        K_ASSERT(status == napi_ok);
 
         len++;
         buf = AllocateSpan<char16_t>(&call_alloc, (Size)len);
 
         status = napi_get_value_string_utf16(env, value, buf.ptr, (size_t)buf.len, &len);
-        RG_ASSERT(status == napi_ok);
+        K_ASSERT(status == napi_ok);
 
         len++;
     }
@@ -350,74 +262,6 @@ Size CallData::PushString16Value(Napi::Value value, const char16_t **out_str16)
     return (Size)len;
 }
 
-bool CallData::PushString32(Napi::Value value, int directions, const char32_t **out_str32)
-{
-    if (value.IsString()) {
-        if (directions & 2) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected string", GetValueType(instance, value));
-            return false;
-        }
-
-        PushString32Value(value, out_str32);
-        return true;
-    } else if (IsNullOrUndefined(value)) {
-        *out_str32 = nullptr;
-        return true;
-    }  else if (value.IsArray()) {
-        Napi::Array array = value.As<Napi::Array>();
-
-        if (!(directions & 2)) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected string", GetValueType(instance, value));
-            return false;
-        }
-        if (array.Length() != 1) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected [string]", GetValueType(instance, value));
-            return false;
-        }
-
-        value = array[0u];
-
-        if (!value.IsString()) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected [string]", GetValueType(instance, array[0u]));
-            return false;
-        }
-
-        Size len = PushString32Value(value, out_str32);
-        if (len < 0) [[unlikely]]
-            return false;
-
-        // Create array type
-        TypeInfo *type;
-        {
-            type = AllocateOne<TypeInfo>(&call_alloc, (int)AllocFlag::Zero);
-
-            type->name = "<temporary>";
-
-            type->primitive = PrimitiveKind::Array;
-            type->align = 4;
-            type->size = (int32_t)(len * 4);
-            type->ref.type = instance->char32_type;
-            type->hint = 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->kind = OutArgument::Kind::Array;
-            out->ptr = (const uint8_t *)*out_str32;
-            out->type = type;
-        }
-
-        return true;
-    } else {
-        return PushPointer(value, instance->str32_type, directions, (void **)out_str32);
-    }
-}
-
 Size CallData::PushString32Value(Napi::Value value, const char32_t **out_str32)
 {
     Span<char32_t> buf;
@@ -463,8 +307,8 @@ Size CallData::PushString32Value(Napi::Value value, const char32_t **out_str32)
 
 bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origin)
 {
-    RG_ASSERT(IsObject(obj));
-    RG_ASSERT(type->primitive == PrimitiveKind::Record ||
+    K_ASSERT(IsObject(obj));
+    K_ASSERT(type->primitive == PrimitiveKind::Record ||
               type->primitive == PrimitiveKind::Union);
 
     Span<const RecordMember> members = {};
@@ -514,7 +358,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
             }
         }
     } else {
-        RG_UNREACHABLE();
+        K_UNREACHABLE();
     }
 
     MemSet(origin, 0, type->size);
@@ -536,7 +380,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
         uint8_t *dest = origin + member.offset;
 
         switch (member.type->primitive) {
-            case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
+            case PrimitiveKind::Void: { K_UNREACHABLE(); } break;
 
             case PrimitiveKind::Bool: {
                 if (!value.IsBoolean()) [[unlikely]] {
@@ -754,7 +598,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                 *(void **)dest = ptr;
             } break;
 
-            case PrimitiveKind::Prototype: { RG_UNREACHABLE(); } break;
+            case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
         }
     }
 
@@ -763,7 +607,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
 
 bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size size, uint8_t *origin)
 {
-    RG_ASSERT(array.IsArray());
+    K_ASSERT(array.IsArray());
 
     const TypeInfo *ref = type->ref.type;
     Size len = (Size)array.Length();
@@ -992,7 +836,7 @@ bool CallData::PushNormalArray(Napi::Array array, const TypeInfo *type, Size siz
             }
         } break;
 
-        case PrimitiveKind::Prototype: { RG_UNREACHABLE(); } break;
+        case PrimitiveKind::Prototype: { K_UNREACHABLE(); } break;
     }
 
 #undef PUSH_ARRAY
@@ -1011,7 +855,7 @@ void CallData::PushBuffer(Span<const uint8_t> buffer, const TypeInfo *type, uint
 #define SWAP(CType) \
         do { \
             CType *data = (CType *)origin; \
-            Size len = buffer.len / RG_SIZE(CType); \
+            Size len = buffer.len / K_SIZE(CType); \
              \
             for (Size i = 0; i < len; i++) { \
                 data[i] = ReverseBytes(data[i]); \
@@ -1035,19 +879,19 @@ void CallData::PushBuffer(Span<const uint8_t> buffer, const TypeInfo *type, uint
 
 bool CallData::PushStringArray(Napi::Value obj, const TypeInfo *type, uint8_t *origin)
 {
-    RG_ASSERT(obj.IsString());
-    RG_ASSERT(type->primitive == PrimitiveKind::Array);
+    K_ASSERT(obj.IsString());
+    K_ASSERT(type->primitive == PrimitiveKind::Array);
 
     size_t encoded = 0;
 
     switch (type->ref.type->primitive) {
         case PrimitiveKind::Int8: {
             napi_status status = napi_get_value_string_utf8(env, obj, (char *)origin, type->size, &encoded);
-            RG_ASSERT(status == napi_ok);
+            K_ASSERT(status == napi_ok);
         } break;
         case PrimitiveKind::Int16: {
             napi_status status = napi_get_value_string_utf16(env, obj, (char16_t *)origin, type->size / 2, &encoded);
-            RG_ASSERT(status == napi_ok);
+            K_ASSERT(status == napi_ok);
 
             encoded *= 2;
         } break;
@@ -1073,6 +917,8 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
         type = cast->type;
     }
 
+    const TypeInfo *ref = type->ref.type;
+
     switch (value.Type()) {
         case napi_undefined:
         case napi_null: {
@@ -1081,14 +927,14 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
         } break;
 
         case napi_external: {
-            RG_ASSERT(type->primitive == PrimitiveKind::Pointer ||
+            K_ASSERT(type->primitive == PrimitiveKind::Pointer ||
                       type->primitive == PrimitiveKind::String ||
                       type->primitive == PrimitiveKind::String16 ||
                       type->primitive == PrimitiveKind::String32);
 
             if (!CheckValueTag(instance, value, type->ref.marker) &&
                     !CheckValueTag(instance, value, instance->void_type) &&
-                    type->ref.type != instance->void_type) [[unlikely]]
+                    ref != instance->void_type) [[unlikely]]
                 goto unexpected;
 
             *out_ptr = value.As<Napi::External<uint8_t>>().Data();
@@ -1103,29 +949,29 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
 
             if (value.IsArray()) {
                 Napi::Array array = value.As<Napi::Array>();
-                Size len = PushIndirectString(array, type->ref.type, &ptr);
+                Size len = PushIndirectString(array, ref, &ptr);
 
                 if (len >= 0) {
-                    if (!type->ref.type->size && type->ref.type != instance->void_type) [[unlikely]] {
+                    if (!ref->size && ref != instance->void_type) [[unlikely]] {
                         ThrowError<Napi::TypeError>(env, "Cannot pass [string] value to %1", type->name);
                         return false;
                     }
 
-                    switch (type->ref.type->size) {
+                    switch (ref->size) {
                         default: { out_kind = OutArgument::Kind::String; } break;
                         case 2: { out_kind = OutArgument::Kind::String16; } break;
                         case 4: { out_kind = OutArgument::Kind::String32; } break;
                     }
                     out_max_len = len;
                 } else {
-                    if (!type->ref.type->size) [[unlikely]] {
+                    if (!ref->size) [[unlikely]] {
                         ThrowError<Napi::TypeError>(env, "Cannot pass %1 value to %2, use koffi.as()",
-                                                    type->ref.type != instance->void_type ? "opaque" : "ambiguous", type->name);
+                                                    ref != instance->void_type ? "opaque" : "ambiguous", type->name);
                         return false;
                     }
 
                     Size len = (Size)array.Length();
-                    Size size = len * type->ref.type->size;
+                    Size size = len * ref->size;
 
                     ptr = AllocHeap(size, 16);
 
@@ -1146,24 +992,24 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
                 directions = 1;
 
                 out_kind = OutArgument::Kind::Buffer;
-            } else if (type->ref.type->primitive == PrimitiveKind::Record ||
-                       type->ref.type->primitive == PrimitiveKind::Union) [[likely]] {
+            } else if (ref->primitive == PrimitiveKind::Record ||
+                       ref->primitive == PrimitiveKind::Union) [[likely]] {
                 Napi::Object obj = value.As<Napi::Object>();
-                RG_ASSERT(IsObject(value));
+                K_ASSERT(IsObject(value));
 
-                ptr = AllocHeap(type->ref.type->size, 16);
+                ptr = AllocHeap(ref->size, 16);
 
-                if (type->ref.type->primitive == PrimitiveKind::Union &&
+                if (ref->primitive == PrimitiveKind::Union &&
                         (directions & 2) && !CheckValueTag(instance, obj, &MagicUnionMarker)) [[unlikely]] {
                     ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected union value", GetValueType(instance, obj));
                     return false;
                 }
 
                 if (directions & 1) {
-                    if (!PushObject(obj, type->ref.type, ptr))
+                    if (!PushObject(obj, ref, ptr))
                         return false;
                 } else {
-                    MemSet(ptr, 0, type->size);
+                    MemSet(ptr, 0, ref->size);
                 }
 
                 out_kind = OutArgument::Kind::Object;
@@ -1175,11 +1021,11 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
                 OutArgument *out = out_arguments.AppendDefault();
 
                 napi_status status = napi_create_reference(env, value, 1, &out->ref);
-                RG_ASSERT(status == napi_ok);
+                K_ASSERT(status == napi_ok);
 
                 out->kind = out_kind;
                 out->ptr = ptr;
-                out->type = type->ref.type;
+                out->type = ref;
                 out->max_len = out_max_len;
             }
 
@@ -1188,21 +1034,21 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
         } break;
 
         case napi_string: {
-            RG_ASSERT(type->primitive == PrimitiveKind::Pointer);
+            K_ASSERT(type->primitive == PrimitiveKind::Pointer);
 
             if (directions & 2) [[unlikely]]
                 goto unexpected;
 
-            if (type->ref.type == instance->void_type) {
+            if (ref == instance->void_type) {
                 PushStringValue(value, (const char **)out_ptr);
                 return true;
-            } else if (type->ref.type->primitive == PrimitiveKind::Int8) {
+            } else if (ref->primitive == PrimitiveKind::Int8) {
                 PushStringValue(value, (const char **)out_ptr);
                 return true;
-            } else if (type->ref.type->primitive == PrimitiveKind::Int16) {
+            } else if (ref->primitive == PrimitiveKind::Int16) {
                 PushString16Value(value, (const char16_t **)out_ptr);
                 return true;
-            } else if (type->ref.type->primitive == PrimitiveKind::Int32) {
+            } else if (ref->primitive == PrimitiveKind::Int32) {
                 PushString32Value(value, (const char32_t **)out_ptr);
                 return true;
             } else {
@@ -1324,7 +1170,7 @@ void *CallData::ReserveTrampoline(const FunctionInfo *proto, Napi::Function func
             return env.Null();
         }
         if (!used_trampolines.Available()) [[unlikely]] {
-            ThrowError<Napi::Error>(env, "This call uses too many temporary callbacks (max = %1)", RG_LEN(used_trampolines.data));
+            ThrowError<Napi::Error>(env, "This call uses too many temporary callbacks (max = %1)", K_LEN(used_trampolines.data));
             return env.Null();
         }
 
@@ -1413,7 +1259,7 @@ static inline Napi::Value GetReferenceValue(Napi::Env env, napi_ref ref)
     napi_value value;
 
     napi_status status = napi_get_reference_value(env, ref, &value);
-    RG_ASSERT(status == napi_ok);
+    K_ASSERT(status == napi_ok);
 
     return Napi::Value(env, value);
 }
@@ -1422,18 +1268,18 @@ void CallData::PopOutArguments()
 {
     for (const OutArgument &out: out_arguments) {
         Napi::Value value = GetReferenceValue(env, out.ref);
-        RG_ASSERT(!value.IsEmpty());
+        K_ASSERT(!value.IsEmpty());
 
         switch (out.kind) {
             case OutArgument::Kind::Array: {
-                RG_ASSERT(value.IsArray());
+                K_ASSERT(value.IsArray());
 
                 Napi::Array array(env, value);
                 DecodeNormalArray(array, out.ptr, out.type);
             } break;
 
             case OutArgument::Kind::Buffer: {
-                RG_ASSERT(IsRawBuffer(value));
+                K_ASSERT(IsRawBuffer(value));
 
                 Span<uint8_t> buffer = GetRawBuffer(value);
                 DecodeBuffer(buffer, out.ptr, out.type);
@@ -1442,8 +1288,8 @@ void CallData::PopOutArguments()
             case OutArgument::Kind::String: {
                 Napi::Array array(env, value);
 
-                RG_ASSERT(array.IsArray());
-                RG_ASSERT(array.Length() == 1);
+                K_ASSERT(array.IsArray());
+                K_ASSERT(array.Length() == 1);
 
                 Size len = strnlen((const char *)out.ptr, out.max_len);
                 Napi::String str = Napi::String::New(env, (const char *)out.ptr, len);
@@ -1454,8 +1300,8 @@ void CallData::PopOutArguments()
             case OutArgument::Kind::String16: {
                 Napi::Array array(env, value);
 
-                RG_ASSERT(array.IsArray());
-                RG_ASSERT(array.Length() == 1);
+                K_ASSERT(array.IsArray());
+                K_ASSERT(array.Length() == 1);
 
                 Size len = NullTerminatedLength((const char16_t *)out.ptr, out.max_len);
                 Napi::String str = Napi::String::New(env, (const char16_t *)out.ptr, len);
@@ -1466,8 +1312,8 @@ void CallData::PopOutArguments()
             case OutArgument::Kind::String32: {
                 Napi::Array array(env, value);
 
-                RG_ASSERT(array.IsArray());
-                RG_ASSERT(array.Length() == 1);
+                K_ASSERT(array.IsArray());
+                K_ASSERT(array.Length() == 1);
 
                 Size len = NullTerminatedLength((const char32_t *)out.ptr, out.max_len);
                 Napi::String str = MakeStringFromUTF32(env, (const char32_t *)out.ptr, len);

package/src/koffi/src/call.hh

@@ -27,7 +27,7 @@
 
 #include <napi.h>
 
-namespace RG {
+namespace K {
 
 bool AnalyseFunction(Napi::Env env, InstanceData *instance, FunctionInfo *func);
 
@@ -115,10 +115,10 @@ public:
     void DumpForward(const FunctionInfo *func) const;
 
     bool PushString(Napi::Value value, int directions, const char **out_str);
-    Size PushStringValue(Napi::Value value, const char **out_str);
     bool PushString16(Napi::Value value, int directions, const char16_t **out_str16);
-    Size PushString16Value(Napi::Value value, const char16_t **out_str16);
     bool PushString32(Napi::Value value, int directions, const char32_t **out_str32);
+    Size PushStringValue(Napi::Value value, const char **out_str);
+    Size PushString16Value(Napi::Value value, const char16_t **out_str16);
     Size PushString32Value(Napi::Value value, const char32_t **out_str32);
     bool PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origin);
     bool PushNormalArray(Napi::Array array, const TypeInfo *type, Size size, uint8_t *origin);
@@ -155,7 +155,7 @@ inline bool CallData::AllocStack(Size size, Size align, T **out_ptr)
         return false;
     }
 
-#if defined(RG_DEBUG)
+#if defined(K_DEBUG)
     MemSet(ptr, 0, delta);
 #endif
 
@@ -172,7 +172,7 @@ inline T *CallData::AllocHeap(Size size, Size align)
     Size delta = size + (ptr - mem->heap.ptr);
 
     if (size < 4096 && delta <= mem->heap.len) [[likely]] {
-#if defined(RG_DEBUG)
+#if defined(K_DEBUG)
         MemSet(mem->heap.ptr, 0, delta);
 #endif
 
@@ -181,7 +181,7 @@ inline T *CallData::AllocHeap(Size size, Size align)
 
         return ptr;
     } else {
-#if defined(RG_DEBUG)
+#if defined(K_DEBUG)
         int flags = (int)AllocFlag::Zero;
 #else
         int flags = 0;