koffi 2.5.4 → 2.5.6

package/CHANGELOG.md

@@ -4,21 +4,36 @@
 
 ### Koffi 2.5
 
+#### Koffi 2.5.6
+
+**Main changes:**
+
+- Increase limit of output parameters from 16 to 32
+
+#### Koffi 2.5.5
+
+**Main changes:**
+
+- Support decoding non-char null-terminated arrays
+
 #### Koffi 2.5.4
 
 **Main changes:**
 
-- Fix koffi.pointer() not accepting disposable types
+- Fix `koffi.pointer()` not accepting disposable types
 
 **Other changes:**
 
-- Fix potential issues when making pointer to anonymous types
+- Fix potential issues when making pointers to anonymous types
 
 #### Koffi 2.5.3
 
 **Main changes:**
 
 - Add missing union exports in TS definition file
+
+**Other changes:**
+
 - Fix some parameter names in TS definition file
 
 #### Koffi 2.5.2

package/package.json

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

package/src/core/libcc/libcc.hh

@@ -1254,7 +1254,7 @@ public:
         RemoveFrom(len - count);
     }
 
-    Span<T> Take() const { return Span<T>(data, len); }
+    Span<T> Take() const { return Span<T>((T *)data, len); }
     Span<T> Take(Size offset, Size len) const { return Span<T>((T *)data, N).Take(offset, len); }
     Span<T> TakeAvailable() const { return Span<T>((T *)data + len, N - len); }
 

package/src/koffi/src/call.hh

@@ -61,9 +61,6 @@ class alignas(8) CallData {
     Span<uint8_t> old_stack_mem;
     Span<uint8_t> old_heap_mem;
 
-    LocalArray<int16_t, 16> used_trampolines;
-    LocalArray<OutArgument, MaxOutParameters> out_arguments;
-
     uint8_t *new_sp;
     uint8_t *old_sp;
 
@@ -83,6 +80,9 @@ class alignas(8) CallData {
     } result;
     uint8_t *return_ptr = nullptr;
 
+    LocalArray<int16_t, 16> used_trampolines;
+    LocalArray<OutArgument, MaxParameters> out_arguments;
+
     BlockAllocator call_alloc;
 
 public:

package/src/koffi/src/ffi.cc

@@ -904,8 +904,8 @@ static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value r
             ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 parameters", MaxParameters);
             return false;
         }
-        if ((param.directions & 2) && ++func->out_parameters >= MaxOutParameters) {
-            ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 output parameters", MaxOutParameters);
+        if ((param.directions & 2) && ++func->out_parameters >= MaxParameters) {
+            ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 output parameters", MaxParameters);
             return false;
         }
 
@@ -1317,8 +1317,8 @@ static Napi::Value TranslateVariadicCall(const FunctionInfo *func, void *native,
             ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 parameters", MaxParameters);
             return env.Null();
         }
-        if ((param.directions & 2) && ++copy.out_parameters >= MaxOutParameters) [[unlikely]] {
-            ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 output parameters", MaxOutParameters);
+        if ((param.directions & 2) && ++copy.out_parameters >= MaxParameters) [[unlikely]] {
+            ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 output parameters", MaxParameters);
             return env.Null();
         }
 

package/src/koffi/src/ffi.hh

@@ -37,7 +37,6 @@ static const Size DefaultMaxTypeSize = Mebibytes(64);
 
 static const int MaxAsyncCalls = 256;
 static const Size MaxParameters = 32;
-static const Size MaxOutParameters = 16;
 static const Size MaxTrampolines = 8192;
 
 enum class PrimitiveKind {

package/src/koffi/src/parser.cc

@@ -82,8 +82,8 @@ bool PrototypeParser::Parse(const char *str, FunctionInfo *out_func)
                 MarkError("Functions cannot have more than %1 parameters", MaxParameters);
                 return false;
             }
-            if ((param.directions & 2) && ++out_func->out_parameters >= MaxOutParameters) {
-                MarkError("Functions cannot have more than out %1 parameters", MaxOutParameters);
+            if ((param.directions & 2) && ++out_func->out_parameters >= MaxParameters) {
+                MarkError("Functions cannot have more than out %1 parameters", MaxParameters);
                 return false;
             }
 

package/src/koffi/src/util.cc

@@ -1065,26 +1065,24 @@ Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, cons
         if (*len >= 0) {
             type = MakeArrayType(instance, type, *len);
         } else {
-            if (!(type->flags & (int)TypeFlag::IsCharLike)) [[unlikely]] {
-                ThrowError<Napi::TypeError>(env, "Only char-like types can find their length automatically", type->name);
-                return env.Null();
-            }
-
             switch (type->primitive) {
-                case PrimitiveKind::Int8: {
+                case PrimitiveKind::Int8: 
+                case PrimitiveKind::UInt8: {
                     Size count = strlen((const char *)ptr);
                     type = MakeArrayType(instance, type, count);
                 } break;
-                case PrimitiveKind::Int16: {
+                case PrimitiveKind::Int16: 
+                case PrimitiveKind::UInt16: {
                     Size count = WideStringLength((const char16_t *)ptr, RG_SIZE_MAX);
                     type = MakeArrayType(instance, type, count);
                 } break;
 
-                default: { RG_UNREACHABLE(); } break;
+                default: {
+                    ThrowError<Napi::TypeError>(env, "Cannot determine null-terminated length for type %1", type->name);
+                    return env.Null();
+                } break;
             }
-
         }
-
     }
 
 #define RETURN_INT(Type, NewCall) \