koffi 2.7.0 → 2.7.1

package/CHANGELOG.md

@@ -4,6 +4,11 @@
 
 ### Koffi 2.7
 
+#### Koffi 2.7.1 (2024-01-02)
+
+- Support C-like `int[3]` syntax for [fixed array types](input.md#fixed-size-c-arrays)
+- Refuse type specifiers with invalid tokens at the end (previously ignored)
+
 #### Koffi 2.7.0 (2023-12-21)
 
 - Support alternative [callback calling convention](callbacks.md#callback-types) in classic syntax

package/doc/functions.md

@@ -9,7 +9,7 @@ To declare functions, start by loading the shared library with `koffi.load(filen
 const koffi = require('koffi');
 
 const lib = koffi.load('/path/to/shared/library'); // File extension depends on platforms: .so, .dll, .dylib, etc.
-````
+```
 
 This library will be automatically unloaded once all references to it are gone (including all the functions that use it, as described below).
 

package/doc/input.md

@@ -336,6 +336,8 @@ try {
 
 ### Fixed-size C arrays
 
+*Changed in Koffi 2.7.1*
+
 Fixed-size arrays are declared with `koffi.array(type, length)`. Just like in C, they cannot be passed as functions parameters (they degenerate to pointers), or returned by value. You can however embed them in struct types.
 
 Koffi applies the following conversion rules when passing arrays to/from C:
@@ -350,13 +352,13 @@ See the example below:
 const koffi = require('koffi');
 
 // Those two structs are exactly the same, only the array conversion hint is different
-const Foo1 = koffi.struct('Foo', {
+const Foo1 = koffi.struct('Foo1', {
     i: 'int',
-    a16: koffi.array('int16_t', 8)
+    a16: koffi.array('int16_t', 2)
 });
-const Foo2 = koffi.struct('Foo', {
+const Foo2 = koffi.struct('Foo2', {
     i: 'int',
-    a16: koffi.array('int16_t', 8, 'Array')
+    a16: koffi.array('int16_t', 2, 'Array')
 });
 
 // Uses an hypothetical C function that just returns the struct passed as a parameter
@@ -367,6 +369,19 @@ console.log(ReturnFoo1({ i: 5, a16: [6, 8] })) // Prints { i: 5, a16: Int16Array
 console.log(ReturnFoo2({ i: 5, a16: [6, 8] })) // Prints { i: 5, a16: [6, 8] }
 ```
 
+You can also declare arrays with the C-like short syntax in type declarations, as shown below:
+
+```js
+const StructType = koffi.struct('StructType', {
+    f8: 'float [8]',
+    self4: 'StructType *[4]'
+});
+```
+
+```{note}
+The short C-like syntax was introduced in Koffi 2.7.1, use `koffi.array()` for older versions.
+```
+
 ### Fixed-size string buffers
 
 Koffi can also convert JS strings to fixed-sized arrays in the following cases:

package/index.d.ts

@@ -104,8 +104,8 @@ declare module 'koffi' {
     /** @deprecated */ export function handle(): IKoffiCType;
 
     export function pointer(ref: TypeSpec): IKoffiCType;
-    export function pointer(ref: TypeSpec, asteriskCount: number): IKoffiCType;
-    export function pointer(name: string, ref: TypeSpec, asteriskCount: number): IKoffiCType;
+    export function pointer(ref: TypeSpec, asteriskCount?: number): IKoffiCType;
+    export function pointer(name: string, ref: TypeSpec, asteriskCount?: number): IKoffiCType;
 
     export function out(type: TypeSpec): IKoffiCType;
     export function inout(type: TypeSpec): IKoffiCType;
@@ -131,6 +131,7 @@ declare module 'koffi' {
     export function decode(value: any, offset: number, type: TypeSpec): any;
     export function decode(value: any, offset: number, type: TypeSpec, len: number): any;
     export function address(value: any): bigint;
+    export function call(value: any, type: TypeSpec, ...args: any[]): any;
     export function encode(ref: any, type: TypeSpec): void;
     export function encode(ref: any, type: TypeSpec, value: any): void;
     export function encode(ref: any, type: TypeSpec, value: any, len: number): void;

package/index.js

@@ -378,8 +378,8 @@ var require_package = __commonJS({
   "build/dist/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.7.0",
-      stable: "2.7.0",
+      version: "2.7.1",
+      stable: "2.7.1",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",

package/indirect.js

@@ -378,8 +378,8 @@ var require_package = __commonJS({
   "build/dist/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.7.0",
-      stable: "2.7.0",
+      version: "2.7.1",
+      stable: "2.7.1",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",

package/package.json

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

package/src/core/libcc/libcc.cc

@@ -3881,8 +3881,11 @@ bool CreateOverlappedPipe(bool overlap0, bool overlap1, PipeMode mode, HANDLE ou
 
 void CloseHandleSafe(HANDLE *handle_ptr)
 {
-    if (*handle_ptr && *handle_ptr != INVALID_HANDLE_VALUE) {
-        CloseHandle(*handle_ptr);
+    HANDLE h = *handle_ptr;
+
+    if (h && h != INVALID_HANDLE_VALUE) {
+        CancelIo(h);
+        CloseHandle(h);
     }
 
     *handle_ptr = nullptr;
@@ -4021,6 +4024,7 @@ bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
             CloseHandleSafe(&si.hStdOutput);
             CloseHandleSafe(&si.hStdError);
         };
+
         if (in_func.IsValid() || out_func.IsValid()) {
             if (!DuplicateHandle(GetCurrentProcess(), in_func.IsValid() ? in_pipe[0] : GetStdHandle(STD_INPUT_HANDLE),
                                  GetCurrentProcess(), &si.hStdInput, 0, TRUE, DUPLICATE_SAME_ACCESS)) {
@@ -4095,6 +4099,7 @@ bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                 if (proc_in.err && proc_in.err != ERROR_BROKEN_PIPE && proc_in.err != ERROR_NO_DATA) {
                     LogError("Failed to write to process: %1", GetWin32ErrorString(proc_in.err));
                 }
+
                 proc_in.pending = true;
             }
 
@@ -4111,30 +4116,23 @@ bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                     }
                 }
 
-                if (proc_out.err && proc_out.err != ERROR_BROKEN_PIPE && proc_out.err != ERROR_NO_DATA) {
-                    LogError("Failed to read process output: %1", GetWin32ErrorString(proc_out.err));
+                if (proc_out.err) {
+                    if (proc_out.err != ERROR_BROKEN_PIPE && proc_out.err != ERROR_NO_DATA) {
+                        LogError("Failed to read process output: %1", GetWin32ErrorString(proc_out.err));
+                    }
+                    break;
                 }
+
                 proc_out.pending = true;
             }
 
-            HANDLE events[2] = {
-                process_handle,
-                console_ctrl_event
-            };
-
-            running = (WaitForMultipleObjectsEx(RG_LEN(events), events, FALSE, INFINITE, TRUE) > WAIT_OBJECT_0 + 1);
+            running = (WaitForSingleObjectEx(console_ctrl_event, INFINITE, TRUE) != WAIT_OBJECT_0);
         }
     }
 
     // Terminate any remaining I/O
-    if (in_pipe[1]) {
-        CancelIo(in_pipe[1]);
-        CloseHandleSafe(&in_pipe[1]);
-    }
-    if (out_pipe[0]) {
-        CancelIo(out_pipe[0]);
-        CloseHandleSafe(&out_pipe[0]);
-    }
+    CloseHandleSafe(&in_pipe[1]);
+    CloseHandleSafe(&out_pipe[0]);
 
     // Wait for process exit
     {
@@ -7518,6 +7516,13 @@ void OptionParser::LogUnknownError() const
     }
 }
 
+void OptionParser::LogUnusedArguments() const
+{
+    if (pos < args.len) {
+       LogWarning("Unused command-line arguments");
+    }
+}
+
 // ------------------------------------------------------------------------
 // Console prompter (simplified readline)
 // ------------------------------------------------------------------------

package/src/core/libcc/libcc.hh

@@ -1220,11 +1220,22 @@ public:
     {
         RG_ASSERT(len <= N - count);
 
-        T *it = data + len;
-        *it = {};
-        len += count;
+        T *first = data + len;
+#if __cplusplus >= 201703L
+        if constexpr(!std::is_trivial<T>::value) {
+#else
+        if (true) {
+#endif
+            for (Size i = 0; i < count; i++) {
+                new (data + len) T();
+                len++;
+            }
+        } else {
+            memset_safe(first, 0, count * RG_SIZE(T));
+            len += count;
+        }
 
-        return it;
+        return first;
     }
 
     T *Append(const T &value)
@@ -1434,6 +1445,7 @@ public:
             memset_safe(first, 0, count * RG_SIZE(T));
             len += count;
         }
+
         return first;
     }
 
@@ -4887,7 +4899,9 @@ public:
         { return Test(test1, nullptr, type); }
 
     bool TestHasFailed() const { return test_failed; }
+
     void LogUnknownError() const;
+    void LogUnusedArguments() const;
 };
 
 template <typename T>

package/src/koffi/src/parser.cc

@@ -144,6 +144,10 @@ const TypeInfo *PrototypeParser::ParseType(int *out_directions)
     while (++offset < tokens.len && (tokens[offset] == '*' ||
                                      tokens[offset] == '!' ||
                                      tokens[offset] == "const"));
+    if (offset < tokens.len && tokens[offset] == "[") [[unlikely]] {
+        MarkError("Array types decay to pointers in prototypes (C standard), use pointers");
+        return instance->void_type;
+    }
     offset--;
 
     while (offset >= start) {

package/src/koffi/src/util.cc

@@ -192,7 +192,8 @@ const TypeInfo *ResolveType(Napi::Env env, Span<const char> str, int *out_direct
 {
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
-    int indirect = 0;
+    // Each item can be > 0 for array or 0 for a pointer
+    LocalArray<Size, 8> arrays;
     uint8_t disposables = 0;
 
     // Consume parameter direction qualifier
@@ -223,18 +224,18 @@ const TypeInfo *ResolveType(Napi::Env env, Span<const char> str, int *out_direct
         Span<const char> remain = str;
 
         // Skip initial const qualifiers
-        remain = TrimStr(remain);
+        remain = TrimStrLeft(remain);
         while (SplitIdentifier(remain) == "const") {
             remain = remain.Take(6, remain.len - 6);
-            remain = TrimStr(remain);
+            remain = TrimStrLeft(remain);
         }
-        remain = TrimStr(remain);
+        remain = TrimStrLeft(remain);
 
         after = remain;
 
         // Consume one or more identifiers (e.g. unsigned int)
         for (;;) {
-            after = TrimStr(after);
+            after = TrimStrLeft(after);
 
             Span<const char> token = SplitIdentifier(after);
             if (!token.len)
@@ -245,26 +246,57 @@ const TypeInfo *ResolveType(Napi::Env env, Span<const char> str, int *out_direct
         name = TrimStr(MakeSpan(remain.ptr, after.ptr - remain.ptr));
     }
 
-    // Consume pointer indirections
+    // Consume type indirections (pointer, array, etc.)
     while (after.len) {
         if (after[0] == '*') {
             after = after.Take(1, after.len - 1);
-            indirect++;
 
-            if (indirect >= RG_SIZE(disposables) * 8) [[unlikely]] {
-                ThrowError<Napi::Error>(env, "Too many pointer indirections");
+            if (!arrays.Available()) [[unlikely]] {
+                ThrowError<Napi::Error>(env, "Too many type indirections");
                 return nullptr;
             }
+
+            arrays.Append(0);
         } else if (after[0] == '!') {
             after = after.Take(1, after.len - 1);
-            disposables |= (1u << indirect);
+            disposables |= (1u << arrays.len);
+        } else if (after[0] == '[') {
+            after = after.Take(1, after.len - 1);
+
+            Size len = 0;
+
+            after = TrimStrLeft(after);
+            if (!ParseInt(after, &len, 0, &after) || len < 0) [[unlikely]] {
+                ThrowError<Napi::Error>(env, "Invalid array length");
+                return nullptr;
+            }
+            after = TrimStrLeft(after);
+            if (!after.len || after[0] != ']') [[unlikely]] {
+                ThrowError<Napi::Error>(env, "Expected ']' after array length");
+                return nullptr;
+            }
+            after = after.Take(1, after.len - 1);
+
+            if (!arrays.Available()) [[unlikely]] {
+                ThrowError<Napi::Error>(env, "Too many type indirections");
+                return nullptr;
+            }
+
+            arrays.Append(len);
         } else if (SplitIdentifier(after) == "const") {
             after = after.Take(6, after.len - 6);
         } else {
+            after = TrimStrRight(after);
+
+            if (after.len) [[unlikely]] {
+                ThrowError<Napi::Error>(env, "Unexpected character '%1' in type specifier", after[0]);
+                return nullptr;
+            }
+
             break;
         }
 
-        after = TrimStr(after);
+        after = TrimStrLeft(after);
     }
 
     const TypeInfo *type = instance->types_map.FindValue(name, nullptr);
@@ -317,11 +349,29 @@ const TypeInfo *ResolveType(Napi::Env env, Span<const char> str, int *out_direct
             type = copy;
         }
 
-        if (i >= indirect)
+        if (i >= arrays.len)
             break;
+        Size len = arrays[i];
 
-        type = MakePointerType(instance, type);
-        RG_ASSERT(type);
+        if (len > 0) {
+            if (type->flags & (int)TypeFlag::IsIncomplete) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Cannot make array of incomplete type");
+                return nullptr;
+            }
+
+            if (len > instance->config.max_type_size / type->size) {
+                ThrowError<Napi::TypeError>(env, "Array length is too high (max = %1)", instance->config.max_type_size / type->size);
+                return nullptr;
+            }
+
+            type = MakeArrayType(instance, type, len);
+            RG_ASSERT(type);
+        } else {
+            RG_ASSERT(!len);
+
+            type = MakePointerType(instance, type);
+            RG_ASSERT(type);
+        }
     }
 
     if (type->flags & (int)TypeFlag::IsIncomplete) [[unlikely]] {

package/src/koffi/src/util.hh

@@ -22,15 +22,12 @@
 #pragma once
 
 #include "src/core/libcc/libcc.hh"
+#include "ffi.hh"
 
 #include <napi.h>
 
 namespace RG {
 
-struct InstanceData;
-struct TypeInfo;
-struct FunctionInfo;
-
 extern const int TypeInfoMarker;
 extern const int CastMarker;
 extern const int MagicUnionMarker;

package/src/koffi/src/win32.cc

@@ -21,6 +21,7 @@
 
 #ifdef _WIN32
 
+#include "util.hh"
 #include "win32.hh"
 
 #ifndef NOMINMAX

package/src/koffi/src/win32.hh

@@ -24,6 +24,7 @@
 #include "src/core/libcc/libcc.hh"
 
 #include <intrin.h>
+#include <napi.h>
 
 namespace RG {