koffi 2.8.11 → 2.9.0-beta.1

package/src/koffi/src/util.cc

@@ -328,7 +328,8 @@ const TypeInfo *ResolveType(Napi::Env env, Span<const char> str, int *out_direct
         if (disposables & (1u << i)) {
             if (type->primitive != PrimitiveKind::Pointer &&
                     type->primitive != PrimitiveKind::String &&
-                    type->primitive != PrimitiveKind::String16) [[unlikely]] {
+                    type->primitive != PrimitiveKind::String16 &&
+                    type->primitive != PrimitiveKind::String32) [[unlikely]] {
                 ThrowError<Napi::Error>(env, "Cannot create disposable type for non-pointer");
                 return nullptr;
             }
@@ -482,6 +483,8 @@ bool CanPassType(const TypeInfo *type, int directions)
             return true;
         if (type->primitive == PrimitiveKind::String16)
             return true;
+        if (type->primitive == PrimitiveKind::String32)
+            return true;
 
         return false;
     } else {
@@ -628,6 +631,34 @@ int GetTypedArrayType(const TypeInfo *type)
     RG_UNREACHABLE();
 }
 
+Napi::String MakeStringFromUTF32(Napi::Env env, const char32_t *ptr, Size len)
+{
+    HeapArray<char16_t> buf;
+    buf.Reserve(len * 2);
+
+    for (Size i = 0; i < len; i++) {
+        char32_t uc = ptr[i];
+
+        if (uc < 0xFFFF) {
+            if (uc < 0xD800 || uc > 0xDFFF) {
+                buf.Append((char16_t)uc);
+            } else {
+                buf.Append('?');
+            }
+        } else if (uc < 0x10FFFF) {
+            uc -= 0x0010000UL;
+
+            buf.Append((char16_t)((uc >> 10) + 0xD800));
+            buf.Append((char16_t)((uc & 0x3FFul) + 0xDC00));
+        } else {
+            buf.Append('?');
+        }
+    }
+
+    Napi::String str = Napi::String::New(env, buf.ptr, buf.len);
+    return str;
+}
+
 Napi::Object DecodeObject(Napi::Env env, const uint8_t *origin, const TypeInfo *type)
 {
     // We can't decode unions because we don't know which member is valid
@@ -747,6 +778,10 @@ void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type)
                     member.type->dispose(env, member.type, str16);
                 }
             } break;
+            case PrimitiveKind::String32: {
+                const char32_t *str32 = *(const char32_t **)src;
+                obj.Set(member.name, str32 ? MakeStringFromUTF32(env, str32) : env.Null());
+            } break;
             case PrimitiveKind::Pointer:
             case PrimitiveKind::Callback: {
                 void *ptr2 = *(void **)src;
@@ -881,7 +916,17 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
         case PrimitiveKind::Int16S: { POP_NUMBER_ARRAY_SWAP(Int16Array, int16_t); } break;
         case PrimitiveKind::UInt16: { POP_NUMBER_ARRAY(Uint16Array, uint16_t); } break;
         case PrimitiveKind::UInt16S: { POP_NUMBER_ARRAY_SWAP(Uint16Array, uint16_t); } break;
-        case PrimitiveKind::Int32: { POP_NUMBER_ARRAY(Int32Array, int32_t); } break;
+        case PrimitiveKind::Int32: {
+            if (type->hint == ArrayHint::String) {
+                const char32_t *ptr = (const char32_t *)origin;
+                Size count = NullTerminatedLength(ptr, len);
+
+                Napi::String str = MakeStringFromUTF32(env, ptr, count);
+                return str;
+            }
+
+            POP_NUMBER_ARRAY(Int32Array, int32_t);
+        } break;
         case PrimitiveKind::Int32S: { POP_NUMBER_ARRAY_SWAP(Int32Array, int32_t); } break;
         case PrimitiveKind::UInt32: { POP_NUMBER_ARRAY(Uint32Array, uint32_t); } break;
         case PrimitiveKind::UInt32S: { POP_NUMBER_ARRAY_SWAP(Uint32Array, uint32_t); } break;
@@ -921,6 +966,12 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
                 array.Set(i, str16 ? Napi::String::New(env, str16) : env.Null());
             });
         } break;
+        case PrimitiveKind::String32: {
+            POP_ARRAY({
+                const char32_t *str32 = *(const char32_t **)src;
+                array.Set(i, str32 ? MakeStringFromUTF32(env, str32) : env.Null());
+            });
+        } break;
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Callback: {
             POP_ARRAY({
@@ -1063,6 +1114,16 @@ void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo
                 }
             });
         } break;
+        case PrimitiveKind::String32: {
+            POP_ARRAY({
+                const char32_t *str32 = *(const char32_t **)src;
+                array.Set(i, str32 ? MakeStringFromUTF32(env, str32) : env.Null());
+
+                if (ref->dispose) {
+                    ref->dispose(env, ref, str32);
+                }
+            });
+        } break;
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Callback: {
             POP_ARRAY({
@@ -1171,6 +1232,7 @@ Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, cons
 
     if (len && type->primitive != PrimitiveKind::String &&
                type->primitive != PrimitiveKind::String16 &&
+               type->primitive != PrimitiveKind::String32 &&
                type->primitive != PrimitiveKind::Prototype) {
         if (*len >= 0) {
             type = MakeArrayType(instance, type, *len);
@@ -1186,6 +1248,11 @@ Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, cons
                     Size count = NullTerminatedLength((const char16_t *)ptr, RG_SIZE_MAX);
                     type = MakeArrayType(instance, type, count);
                 } break;
+                case PrimitiveKind::Int32:
+                case PrimitiveKind::UInt32: {
+                    Size count = NullTerminatedLength((const char32_t *)ptr, RG_SIZE_MAX);
+                    type = MakeArrayType(instance, type, count);
+                } break;
 
                 case PrimitiveKind::Pointer: {
                     Size count = NullTerminatedLength((const void **)ptr, RG_SIZE_MAX);
@@ -1253,6 +1320,15 @@ Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, cons
                 return str16 ? Napi::String::New(env, str16) : env.Null();
             }
         } break;
+        case PrimitiveKind::String32: {
+            if (len) {
+                const char32_t *str32 = *(const char32_t **)ptr;
+                return str32 ? MakeStringFromUTF32(env, str32, *len) : env.Null();
+            } else {
+                const char32_t *str32 = *(const char32_t **)ptr;
+                return str32 ? MakeStringFromUTF32(env, str32) : env.Null();
+            }
+        } break;
         case PrimitiveKind::Pointer:
         case PrimitiveKind::Callback: {
             void *ptr2 = *(void **)ptr;
@@ -1348,6 +1424,7 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
 
     if (len && type->primitive != PrimitiveKind::String &&
                type->primitive != PrimitiveKind::String16 &&
+               type->primitive != PrimitiveKind::String32 &&
                type->primitive != PrimitiveKind::Prototype) {
         if (*len < 0) [[unlikely]] {
             ThrowError<Napi::TypeError>(env, "Automatic (negative) length is only supported when decoding");
@@ -1419,6 +1496,12 @@ bool Encode(Napi::Env env, uint8_t *origin, Napi::Value value, const TypeInfo *t
                 return false;
             *(const char16_t **)origin = str16;
         } break;
+        case PrimitiveKind::String32: {
+            const char32_t *str32;
+            if (!call.PushString32(value, 1, &str32)) [[unlikely]]
+                return false;
+            *(const char32_t **)origin = str32;
+        } break;
         case PrimitiveKind::Pointer: {
             void *ptr;
             if (!call.PushPointer(value, type, 1, &ptr)) [[unlikely]]

package/src/koffi/src/util.hh

@@ -156,6 +156,15 @@ T GetNumber(Napi::Value value)
     RG_UNREACHABLE();
 }
 
+template <typename T>
+Size NullTerminatedLength(const T *ptr)
+{
+    Size len = 0;
+    while (ptr[len]) {
+        len++;
+    }
+    return len;
+}
 template <typename T>
 Size NullTerminatedLength(const T *ptr, Size max)
 {
@@ -166,6 +175,10 @@ Size NullTerminatedLength(const T *ptr, Size max)
     return len;
 }
 
+Napi::String MakeStringFromUTF32(Napi::Env env, const char32_t *ptr, Size len);
+static inline Napi::String MakeStringFromUTF32(Napi::Env env, const char32_t *ptr)
+    { return MakeStringFromUTF32(env, ptr, NullTerminatedLength(ptr)); }
+
 Napi::Object DecodeObject(Napi::Env env, const uint8_t *origin, const TypeInfo *type);
 void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type);
 Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *type);