koffi 2.3.15 → 2.3.17

package/CHANGELOG.md

@@ -4,6 +4,24 @@
 
 ### 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:**
+
+- Fix Windows ARM64 build to work with official Node.js version
+- Compile Windows builds with Visual Studio 2022 17.5.3
+
+**Other changes:**
+
+- Support null in `koffi.free()` and `koffi.address()`
+
 #### Koffi 2.3.15
 
 **Main changes:**

package/package.json

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

package/src/cnoke/cnoke.js

@@ -155,7 +155,7 @@ Options:
                                          (default: ${cnoke.DefaultOptions.mode})
     -D, --debug                          Shortcut for --config Debug
 
-        --prebuild                       Use prebuilt binari if available
+        --prebuild                       Use prebuilt binary if available
 
     -a, --arch <ARCH>                    Change architecture and ABI
                                          (default: ${cnoke.determine_arch()})

package/src/cnoke/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cnoke",
-  "version": "3.3.1",
+  "version": "3.3.2",
   "description": "Build native Node addons based on CMake, without extra dependency",
   "keywords": [
     "native",

package/src/cnoke/src/builder.js

@@ -103,7 +103,7 @@ function Builder(config = {}) {
             let basename = `node-v${runtime_version}-headers.tar.gz`;
             let urls = [
                 `https://nodejs.org/dist/v${runtime_version}/${basename}`,
-                `https://unofficial-builds.nodejs.org/download/release/v${runtime_version}/${basename}`
+                // `https://unofficial-builds.nodejs.org/download/release/v${runtime_version}/${basename}`
             ];
             let destname = `${cache_dir}/${basename}`;
 
@@ -130,7 +130,7 @@ function Builder(config = {}) {
             if (!fs.existsSync(destname)) {
                 let urls = [
                     `https://nodejs.org/dist/v${runtime_version}/${dirname}/node.lib`,
-                    `https://unofficial-builds.nodejs.org/download/release/v${runtime_version}/${dirname}/node.lib`
+                    // `https://unofficial-builds.nodejs.org/download/release/v${runtime_version}/${dirname}/node.lib`
                 ];
                 await tools.download_http(urls, destname);
             }

package/src/koffi/CMakeLists.txt

@@ -20,6 +20,8 @@
 # OTHER DEALINGS IN THE SOFTWARE.
 
 cmake_minimum_required(VERSION 3.6)
+cmake_policy(SET CMP0091 NEW)
+
 project(koffi C CXX ASM)
 
 include(CheckCXXCompilerFlag)
@@ -58,6 +60,8 @@ if(CMAKE_SIZEOF_VOID_P EQUAL 8)
     # CMAKE_SYSTEM_PROCESSOR is wrong on Windows ARM64
 
     if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch|arm" OR CMAKE_GENERATOR_PLATFORM STREQUAL "ARM64" OR CMAKE_OSX_ARCHITECTURES MATCHES "arm")
+        set(CMAKE_MSVC_RUNTIME_LIBRARY MultiThreaded)
+
         if(WIN32)
             get_filename_component(cl_dir "${CMAKE_CXX_COMPILER}" DIRECTORY)
             file(TO_CMAKE_PATH "${cl_dir}/armasm64.exe" asm_compiler)

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();
     }
@@ -723,18 +725,25 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
     return WrapType(env, instance, type);
 }
 
-static inline bool CheckExternalPointer(Napi::Env env, Napi::Value value)
+static inline bool GetExternalPointer(Napi::Env env, Napi::Value value, void **out_ptr)
 {
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
-    if (!value.IsExternal() || CheckValueTag(instance, value, &TypeInfoMarker) ||
-                               CheckValueTag(instance, value, &CastMarker) ||
-                               CheckValueTag(instance, value, &MagicUnionMarker)) {
+    if (IsNullOrUndefined(value)) {
+        *out_ptr = 0;
+        return true;
+    } else if (value.IsExternal() && !CheckValueTag(instance, value, &TypeInfoMarker) &&
+                                     !CheckValueTag(instance, value, &CastMarker) &&
+                                     !CheckValueTag(instance, value, &MagicUnionMarker)) {
+        Napi::External<void> external = value.As<Napi::External<void>>();
+        void *ptr = external.Data();
+
+        *out_ptr = ptr;
+        return true;
+    } else {
         ThrowError<Napi::TypeError>(env, "Unexpected %1 value for ptr, expected external pointer", GetValueType(instance, value));
         return false;
     }
-
-    return true;
 }
 
 static Napi::Value CallFree(const Napi::CallbackInfo &info)
@@ -745,11 +754,10 @@ static Napi::Value CallFree(const Napi::CallbackInfo &info)
         ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
         return env.Null();
     }
-    if (!CheckExternalPointer(env, info[0]))
-        return env.Null();
 
-    Napi::External<void> external = info[0].As<Napi::External<void>>();
-    void *ptr = external.Data();
+    void *ptr = nullptr;
+    if (!GetExternalPointer(env, info[0], &ptr))
+        return env.Null();
 
     free(ptr);
 
@@ -1976,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();
     }
 
@@ -2030,11 +2040,10 @@ static Napi::Value GetPointerAddress(const Napi::CallbackInfo &info)
         ThrowError<Napi::TypeError>(env, "Expected 1 argument, got %1", info.Length());
         return env.Null();
     }
-    if (!CheckExternalPointer(env, info[0]))
-        return env.Null();
 
-    Napi::External<void> external = info[0].As<Napi::External<void>>();
-    void *ptr = external.Data();
+    void *ptr = nullptr;
+    if (!GetExternalPointer(env, info[0], &ptr))
+        return env.Null();
 
     uint64_t ptr64 = (uint64_t)(uintptr_t)ptr;
     Napi::BigInt bigint = Napi::BigInt::New(env, ptr64);

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);