koffi 2.3.16 → 2.3.17

package/CHANGELOG.md

@@ -4,6 +4,13 @@
 
 ### Koffi 2.3
 
+#### Koffi 2.3.17
+
+**Main changes:**
+
+- Allow strings for input `void *`, `int8_t *` and `int16_t *` pointer arguments
+- Support using `[string]` (single-element string arrays) for polymorphic input/output arguments
+
 #### Koffi 2.3.16
 
 **Main changes:**
@@ -13,7 +20,7 @@
 
 **Other changes:**
 
-- Support null in koffi.free() and koffi.address()
+- Support null in `koffi.free()` and `koffi.address()`
 
 #### Koffi 2.3.15
 

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "koffi",
-    "version": "2.3.16",
-    "stable": "2.3.16",
+    "version": "2.3.17",
+    "stable": "2.3.17",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [
         "foreign",

package/src/koffi/src/call.cc

@@ -147,7 +147,7 @@ bool CallData::PushString(Napi::Value value, int directions, const char **out_st
 {
     if (value.IsString()) {
         if (RG_UNLIKELY(directions & 2)) {
-            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected string", GetValueType(instance, value));
+            ThrowError<Napi::TypeError>(env, "Unexpected %1 value, expected [string]", GetValueType(instance, value));
             return false;
         }
 
@@ -200,6 +200,7 @@ bool CallData::PushString(Napi::Value value, int directions, const char **out_st
             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;
         }
@@ -301,6 +302,7 @@ bool CallData::PushString16(Napi::Value value, int directions, const char16_t **
             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;
         }
@@ -973,6 +975,9 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
         case napi_object: {
             uint8_t *ptr = nullptr;
 
+            OutArgument::Kind out_kind;
+            Size out_max_len = -1;
+
             if (value.IsArray()) {
                 if (RG_UNLIKELY(!type->ref.type->size)) {
                     ThrowError<Napi::TypeError>(env, "Cannot pass %1 value to void *, use koffi.as()",
@@ -981,17 +986,25 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
                 }
 
                 Napi::Array array = value.As<Napi::Array>();
+                Size len = PushIndirectString(array, type->ref.type, &ptr);
 
-                Size len = (Size)array.Length();
-                Size size = len * type->ref.type->size;
+                if (len >= 0) {
+                    out_kind = (type->ref.type->size == 2) ? OutArgument::Kind::String16 : OutArgument::Kind::String;
+                    out_max_len = len;
+                } else {
+                    Size len = (Size)array.Length();
+                    Size size = len * type->ref.type->size;
 
-                ptr = AllocHeap(size, 16);
+                    ptr = AllocHeap(size, 16);
 
-                if (directions & 1) {
-                    if (!PushNormalArray(array, len, type, ptr))
-                        return false;
-                } else {
-                    memset_safe(ptr, 0, size);
+                    if (directions & 1) {
+                        if (!PushNormalArray(array, len, type, ptr))
+                            return false;
+                    } else {
+                        memset_safe(ptr, 0, size);
+                    }
+
+                    out_kind = OutArgument::Kind::Array;
                 }
             } else if (IsRawBuffer(value)) {
                 Span<uint8_t> buffer = GetRawBuffer(value);
@@ -1006,6 +1019,8 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
                     ptr = buffer.ptr;
                     directions = 1;
                 }
+
+                out_kind = OutArgument::Kind::Buffer;
             } else if (RG_LIKELY(type->ref.type->primitive == PrimitiveKind::Record ||
                                  type->ref.type->primitive == PrimitiveKind::Union)) {
                 if (RG_UNLIKELY(!type->ref.type->size)) {
@@ -1031,6 +1046,8 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
 
                     memset_safe(ptr, 0, type->size);
                 }
+
+                out_kind = OutArgument::Kind::Object;
             } else {
                 goto unexpected;
             }
@@ -1041,14 +1058,36 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
                 napi_status status = napi_create_reference(env, value, 1, &out->ref);
                 RG_ASSERT(status == napi_ok);
 
+                out->kind = out_kind;
                 out->ptr = ptr;
                 out->type = type->ref.type;
+                out->max_len = out_max_len;
             }
 
             *out_ptr = ptr;
             return true;
         } break;
 
+        case napi_string: {
+            RG_ASSERT(type->primitive == PrimitiveKind::Pointer);
+
+            if (RG_UNLIKELY(directions & 2))
+                goto unexpected;
+
+            if (type->ref.type == instance->void_type) {
+                PushStringValue(value, (const char **)out_ptr);
+                return true;
+            } else if (type->ref.type->primitive == PrimitiveKind::Int8) {
+                PushStringValue(value, (const char **)out_ptr);
+                return true;
+            } else if (type->ref.type->primitive == PrimitiveKind::Int16) {
+                PushString16Value(value, (const char16_t **)out_ptr);
+                return true;
+            } else {
+                goto unexpected;
+            }
+        } break;
+
         case napi_number: {
             Napi::Number number = value.As<Napi::Number>();
             intptr_t ptr = (intptr_t)number.Int32Value();
@@ -1075,6 +1114,27 @@ unexpected:
     return false;
 }
 
+Size CallData::PushIndirectString(Napi::Array array, const TypeInfo *ref, uint8_t **out_ptr)
+{
+    if (array.Length() != 1)
+        return -1;
+
+    Napi::Value value = array[0u];
+
+    if (!value.IsString())
+        return -1;
+
+    if (ref == instance->void_type) {
+        return PushStringValue(value, (const char **)out_ptr);
+    } else if (ref->primitive == PrimitiveKind::Int8) {
+        return PushStringValue(value, (const char **)out_ptr);
+    } else if (ref->primitive == PrimitiveKind::Int16) {
+        return PushString16Value(value, (const char16_t **)out_ptr);
+    } else {
+        return -1;
+    }
+}
+
 static inline Napi::Value GetReferenceValue(Napi::Env env, napi_ref ref)
 {
     napi_value value;
@@ -1091,21 +1151,55 @@ void CallData::PopOutArguments()
         Napi::Value value = GetReferenceValue(env, out.ref);
         RG_ASSERT(!value.IsEmpty());
 
-        if (value.IsArray()) {
-            Napi::Array array(env, value);
-            DecodeNormalArray(array, out.ptr, out.type);
-        } else if (IsRawBuffer(value)) {
-            Span<uint8_t> buffer = GetRawBuffer(value);
-            DecodeBuffer(buffer, out.ptr, out.type);
-        } else {
-            Napi::Object obj = value.As<Napi::Object>();
-
-            if (CheckValueTag(instance, value, &MagicUnionMarker)) {
-                MagicUnion *u = MagicUnion::Unwrap(obj);
-                u->SetRaw(out.ptr);
-            } else {
-                DecodeObject(obj, out.ptr, out.type);
-            }
+        switch (out.kind) {
+            case OutArgument::Kind::Array: {
+                RG_ASSERT(value.IsArray());
+
+                Napi::Array array(env, value);
+                DecodeNormalArray(array, out.ptr, out.type);
+            } break;
+
+            case OutArgument::Kind::Buffer: {
+                RG_ASSERT(IsRawBuffer(value));
+
+                Span<uint8_t> buffer = GetRawBuffer(value);
+                DecodeBuffer(buffer, out.ptr, out.type);
+            } break;
+
+            case OutArgument::Kind::String: {
+                Napi::Array array(env, value);
+
+                RG_ASSERT(array.IsArray());
+                RG_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);
+
+                array.Set(0u, str);
+            } break;
+
+            case OutArgument::Kind::String16: {
+                Napi::Array array(env, value);
+
+                RG_ASSERT(array.IsArray());
+                RG_ASSERT(array.Length() == 1);
+
+                Size len = WideStringLength((const char16_t *)out.ptr, out.max_len);
+                Napi::String str = Napi::String::New(env, (const char16_t *)out.ptr, len);
+
+                array.Set(0u, str);
+            } break;
+
+            case OutArgument::Kind::Object: {
+                Napi::Object obj = value.As<Napi::Object>();
+
+                if (CheckValueTag(instance, value, &MagicUnionMarker)) {
+                    MagicUnion *u = MagicUnion::Unwrap(obj);
+                    u->SetRaw(out.ptr);
+                } else {
+                    DecodeObject(obj, out.ptr, out.type);
+                }
+            } break;
         }
     }
 }

package/src/koffi/src/call.hh

@@ -37,9 +37,21 @@ struct BackRegisters;
 // But on Windows i386, without it, the alignment may not be correct (compiler bug?).
 class alignas(8) CallData {
     struct OutArgument {
+        enum class Kind {
+            Array,
+            Buffer,
+            String,
+            String16,
+            Object
+        };
+
+        Kind kind;
+
         napi_ref ref;
         const uint8_t *ptr;
         const TypeInfo *type;
+
+        Size max_len; // Only for indirect strings
     };
 
     Napi::Env env;
@@ -116,6 +128,7 @@ private:
     bool PushBuffer(Span<const uint8_t> buffer, Size size, const TypeInfo *type, uint8_t *origin);
     bool PushStringArray(Napi::Value value, const TypeInfo *type, uint8_t *origin);
     bool PushPointer(Napi::Value value, const TypeInfo *type, int directions, void **out_ptr);
+    Size PushIndirectString(Napi::Array array, const TypeInfo *ref, uint8_t **out_ptr);
 
     void PopOutArguments();
 

package/src/koffi/src/ffi.cc

@@ -605,8 +605,10 @@ static Napi::Value EncodePointerDirection(const Napi::CallbackInfo &info, int di
     if (!type)
         return env.Null();
 
-    if (type->primitive != PrimitiveKind::Pointer) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 type, expected pointer type", type->name);
+    if (type->primitive != PrimitiveKind::Pointer &&
+            type->primitive != PrimitiveKind::String &&
+            type->primitive != PrimitiveKind::String16) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 type, expected pointer or string type", type->name);
         return env.Null();
     }
 
@@ -653,9 +655,9 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
     const TypeInfo *src = ResolveType(info[named]);
     if (!src)
         return env.Null();
-    if (src->primitive != PrimitiveKind::String &&
-            src->primitive != PrimitiveKind::String16 &&
-            src->primitive != PrimitiveKind::Pointer) {
+    if (src->primitive != PrimitiveKind::Pointer &&
+            src->primitive != PrimitiveKind::String &&
+            src->primitive != PrimitiveKind::String16) {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 type, expected pointer or string type", src->name);
         return env.Null();
     }
@@ -1982,8 +1984,10 @@ static Napi::Value CastValue(const Napi::CallbackInfo &info)
     const TypeInfo *type = ResolveType(info[1]);
     if (RG_UNLIKELY(!type))
         return env.Null();
-    if (type->primitive != PrimitiveKind::Pointer) {
-        ThrowError<Napi::TypeError>(env, "Only pointer types can be used for casting");
+    if (type->primitive != PrimitiveKind::Pointer &&
+            type->primitive != PrimitiveKind::String &&
+            type->primitive != PrimitiveKind::String16) {
+        ThrowError<Napi::TypeError>(env, "Only pointer or string types can be used for casting");
         return env.Null();
     }
 

package/src/koffi/src/util.cc

@@ -647,7 +647,7 @@ void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type)
     }
 }
 
-static Size WideStringLength(const char16_t *str16, Size max)
+Size WideStringLength(const char16_t *str16, Size max)
 {
     Size len = 0;
 

package/src/koffi/src/util.hh

@@ -154,6 +154,8 @@ T GetNumber(Napi::Value value)
     RG_UNREACHABLE();
 }
 
+Size WideStringLength(const char16_t *str16, Size max);
+
 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);