koffi 2.6.12 → 2.7.1

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## Version history
 
+### 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
+- Change syntax for [calling conventions](functions.md#calling-conventions) with classic syntax
+- Drop unused "internal" property from Koffi
+
 ### Koffi 2.6
 
 #### Koffi 2.6.12 (2023-12-11)

package/doc/callbacks.md

@@ -8,6 +8,8 @@ The function `koffi.proto()` was introduced in Koffi 2.4, it was called `koffi.c
 
 ## Callback types
 
+*Changed in Koffi 2.7*
+
 In order to pass a JS function to a C function expecting a callback, you must first create a callback type with the expected return type and parameters. The syntax is similar to the one used to load functions from a shared library.
 
 ```js
@@ -21,6 +23,23 @@ const ExampleCallback = koffi.proto('ExampleCallback', 'void', ['int']);
 const AddDoubleFloat = koffi.proto('double AddDoubleFloat(double d, float f)');
 ```
 
+For alternative [calling conventions](functions.md#calling-conventions) (such as `stdcall` on Windows x86 32-bit), you can specify as the first argument with the classic syntax, or after the return type in prototype strings, like this:
+
+```js
+const HANDLE = koffi.pointer('HANDLE', koffi.opaque());
+const HWND = koffi.alias('HWND', HANDLE);
+
+// These two declarations work the same, and use the __stdcall convention on Windows x86
+const EnumWindowsProc = koffi.proto('bool __stdcall EnumWindowsProc (HWND hwnd, long lParam)');
+const EnumWindowsProc = koffi.proto('__stdcall', 'EnumWindowsProc', 'bool', ['HWND', 'long']);
+```
+
+```{warning}
+You have to make sure you **get the calling convention right** (such as specifying __stdcall for a Windows API callback), or your code will crash on Windows 32-bit.
+
+Before Koffi 2.7, it was *impossible to use an alternative callback calling convention with the classic syntax*. Use a prototype string or *upgrade to Koffi 2.7* to solve this limitation.
+```
+
 Once your callback type is declared, you can use a pointer to it in struct definitions, as function parameters and/or return types, or to call/decode function pointers.
 
 ```{note}

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).
 
@@ -83,19 +83,27 @@ On x86 platforms, only the Cdecl convention can be used for variadic functions.
 
 ### Calling conventions
 
+*Changed in Koffi 2.7*
+
 By default, calling a C function happens synchronously.
 
 Most architectures only support one procedure call standard per process. The 32-bit x86 platform is an exception to this, and Koffi supports several x86 conventions:
 
- Convention   | Classic form                  | Prototype form | Description
-------------- | ----------------------------- | -------------- | -------------------------------------------------------------------
- **Cdecl**    | `koffi.cdecl` or `koffi.func` | _(default)_    | This is the default convention, and the only one on other platforms
- **Stdcall**  | `koffi.stdcall`               | __stdcall      | This convention is used extensively within the Win32 API
- **Fastcall** | `koffi.fastcall`              | __fastcall     | Rarely used, uses ECX and EDX for first two parameters
- **Thiscall** | `koffi.thiscall`              | __thiscall     | Rarely used, uses ECX for first parameter
+ Convention   | Classic form                                  | Prototype form | Description
+------------- | --------------------------------------------- | -------------- | -------------------------------------------------------------------
+ **Cdecl**    | `koffi.func(name, ret, params)`               | _(default)_    | This is the default convention, and the only one on other platforms
+ **Stdcall**  | `koffi.func('__stdcall', name, ret, params)`  | __stdcall      | This convention is used extensively within the Win32 API
+ **Fastcall** | `koffi.func('__fastcall', name, ret, params)` | __fastcall     | Rarely used, uses ECX and EDX for first two parameters
+ **Thiscall** | `koffi.func('__thiscall', name, ret, params)` | __thiscall     | Rarely used, uses ECX for first parameter
 
 You can safely use these on non-x86 platforms, they are simply ignored.
 
+```{note}
+Support for specifying the convention as the first argument of the classic form was introduced in Koffi 2.7.
+
+In earlier versions, you had to use `koffi.stdcall()` and similar functions. These functions are still supported but deprecated, and will be removed in Koffi 3.0.
+```
+
 Below you can find a small example showing how to use a non-default calling convention, with the two syntaxes:
 
 ```js
@@ -105,7 +113,7 @@ const koffi = require('koffi');
 const lib = koffi.load('user32.dll');
 
 // The following two declarations are equivalent, and use stdcall on x86 (and the default ABI on other platforms)
-const MessageBoxA_1 = lib.stdcall('MessageBoxA', 'int', ['void *', 'str', 'str', 'uint']);
+const MessageBoxA_1 = lib.func('__stdcall', 'MessageBoxA', 'int', ['void *', 'str', 'str', 'uint']);
 const MessageBoxA_2 = lib.func('int __stdcall MessageBoxA(void *hwnd, str text, str caption, uint type)');
 ```
 

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/doc/start.md

@@ -99,8 +99,8 @@ const IDYES = 6;
 const IDNO = 7;
 
 // Find functions
-const MessageBoxA = lib.stdcall('MessageBoxA', 'int', ['void *', 'str', 'str', 'uint']);
-const MessageBoxW = lib.stdcall('MessageBoxW', 'int', ['void *', 'str16', 'str16', 'uint']);
+const MessageBoxA = lib.func('__stdcall', 'MessageBoxA', 'int', ['void *', 'str', 'str', 'uint']);
+const MessageBoxW = lib.func('__stdcall', 'MessageBoxW', 'int', ['void *', 'str16', 'str16', 'uint']);
 
 let ret = MessageBoxA(null, 'Do you want another message box?', 'Koffi', MB_YESNO | MB_ICONQUESTION);
 if (ret == IDYES)

package/index.d.ts

@@ -67,18 +67,16 @@ declare module 'koffi' {
     export interface IKoffiLib {
         func(definition: string): KoffiFunction;
         func(name: string, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
+        func(convention: string, name: string, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
 
-        cdecl(definition: string): KoffiFunction;
-        cdecl(name: string, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
-
-        stdcall(definition: string): KoffiFunction;
-        stdcall(name: string, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
-
-        fastcall(definition: string): KoffiFunction;
-        fastcall(name: string, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
-
-        thiscall(definition: string): KoffiFunction;
-        thiscall(name: string, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
+        /** @deprecated */ cdecl(definition: string): KoffiFunction;
+        /** @deprecated */ cdecl(name: string, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
+        /** @deprecated */ stdcall(definition: string): KoffiFunction;
+        /** @deprecated */ stdcall(name: string, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
+        /** @deprecated */ fastcall(definition: string): KoffiFunction;
+        /** @deprecated */ fastcall(name: string, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
+        /** @deprecated */ thiscall(definition: string): KoffiFunction;
+        /** @deprecated */ thiscall(name: string, result: TypeSpec, arguments: TypeSpec[]): KoffiFunction;
 
         symbol(name: string, type: TypeSpec): any;
 
@@ -106,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;
@@ -118,8 +116,10 @@ declare module 'koffi' {
 
     export function proto(definition: string): IKoffiCType;
     export function proto(name: string, result: TypeSpec, arguments: TypeSpec[]): IKoffiCType;
+    export function proto(convention: string, name: string, result: TypeSpec, arguments: TypeSpec[]): IKoffiCType;
     /** @deprecated */ export function callback(definition: string): IKoffiCType;
     /** @deprecated */ export function callback(name: string, result: TypeSpec, arguments: TypeSpec[]): IKoffiCType;
+    /** @deprecated */ export function callback(convention: string, name: string, result: TypeSpec, arguments: TypeSpec[]): IKoffiCType;
 
     export function register(callback: Function, type: TypeSpec): IKoffiRegisteredCallback;
     export function register(thisValue: any, callback: Function, type: TypeSpec): IKoffiRegisteredCallback;
@@ -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.6.12",
-      stable: "2.6.12",
+      version: "2.7.1",
+      stable: "2.7.1",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",
@@ -557,3 +557,12 @@ module.exports = {
   handle: util.deprecate(native.opaque, "The koffi.handle() function was deprecated in Koffi 2.1, use koffi.opaque() instead", "KOFFI001"),
   callback: util.deprecate(native.proto, "The koffi.callback() function was deprecated in Koffi 2.4, use koffi.proto() instead", "KOFFI002")
 };
+var load = module.exports.load;
+module.exports.load = (...args) => {
+  let lib = load(...args);
+  lib.cdecl = util.deprecate((...args2) => lib.func("__cdecl", ...args2), "The koffi.stdcall() function was deprecated in Koffi 2.7, use koffi.func(...) instead", "KOFFI003");
+  lib.stdcall = util.deprecate((...args2) => lib.func("__stdcall", ...args2), 'The koffi.stdcall() function was deprecated in Koffi 2.7, use koffi.func("__stdcall", ...) instead', "KOFFI004");
+  lib.fastcall = util.deprecate((...args2) => lib.func("__fastcall", ...args2), 'The koffi.fastcall() function was deprecated in Koffi 2.7, use koffi.func("__fastcall", ...) instead', "KOFFI005");
+  lib.thiscall = util.deprecate((...args2) => lib.func("__thiscall", ...args2), 'The koffi.thiscall() function was deprecated in Koffi 2.7, use koffi.func("__thiscall", ...) instead', "KOFFI006");
+  return lib;
+};

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.6.12",
-      stable: "2.6.12",
+      version: "2.7.1",
+      stable: "2.7.1",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",
@@ -477,3 +477,12 @@ module.exports = {
   handle: util.deprecate(native.opaque, "The koffi.handle() function was deprecated in Koffi 2.1, use koffi.opaque() instead", "KOFFI001"),
   callback: util.deprecate(native.proto, "The koffi.callback() function was deprecated in Koffi 2.4, use koffi.proto() instead", "KOFFI002")
 };
+var load = module.exports.load;
+module.exports.load = (...args) => {
+  let lib = load(...args);
+  lib.cdecl = util.deprecate((...args2) => lib.func("__cdecl", ...args2), "The koffi.stdcall() function was deprecated in Koffi 2.7, use koffi.func(...) instead", "KOFFI003");
+  lib.stdcall = util.deprecate((...args2) => lib.func("__stdcall", ...args2), 'The koffi.stdcall() function was deprecated in Koffi 2.7, use koffi.func("__stdcall", ...) instead', "KOFFI004");
+  lib.fastcall = util.deprecate((...args2) => lib.func("__fastcall", ...args2), 'The koffi.fastcall() function was deprecated in Koffi 2.7, use koffi.func("__fastcall", ...) instead', "KOFFI005");
+  lib.thiscall = util.deprecate((...args2) => lib.func("__thiscall", ...args2), 'The koffi.thiscall() function was deprecated in Koffi 2.7, use koffi.func("__thiscall", ...) instead', "KOFFI006");
+  return lib;
+};

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "koffi",
-    "version": "2.6.12",
-    "stable": "2.6.12",
+    "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
     {
@@ -5599,7 +5597,6 @@ public:
     AsyncPool(int threads, bool leak);
 
     int GetWorkerCount() const { return (int)workers.len; }
-    int CountPendingTasks() const { return pending_tasks; }
 
     void RegisterAsync();
     void UnregisterAsync();
@@ -5673,11 +5670,6 @@ bool Async::Sync()
     return success;
 }
 
-int Async::CountPendingTasks()
-{
-    return pool->CountPendingTasks();
-}
-
 bool Async::IsTaskRunning()
 {
     return async_running_task;
@@ -5806,6 +5798,11 @@ void AsyncPool::AddTask(Async *async, const std::function<bool()> &func)
         pending_cv.notify_all();
         sync_cv.notify_all();
     }
+
+    // Limit queue size (back pressure)
+    while (pending_tasks >= RG_ASYNC_MAX_PENDING_TASKS) {
+        RunTasks(0);
+    }
 }
 
 void AsyncPool::RunWorker(int worker_idx)
@@ -7519,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

@@ -93,6 +93,8 @@ namespace RG {
 
 #define RG_ASYNC_MAX_THREADS 2048
 #define RG_ASYNC_MAX_IDLE_TIME 10000
+#define RG_ASYNC_MAX_PENDING_TASKS 1024
+
 #define RG_FIBER_DEFAULT_STACK_SIZE Kibibytes(128)
 
 // ------------------------------------------------------------------------
@@ -1218,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)
@@ -1432,6 +1445,7 @@ public:
             memset_safe(first, 0, count * RG_SIZE(T));
             len += count;
         }
+
         return first;
     }
 
@@ -4265,8 +4279,6 @@ public:
     void Run(const std::function<bool()> &f);
     bool Sync();
 
-    int CountPendingTasks();
-
     static bool IsTaskRunning();
     static int GetWorkerIdx();
     static int GetWorkerCount();
@@ -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/ffi.cc

@@ -880,35 +880,50 @@ static Napi::Value CreateArrayType(const Napi::CallbackInfo &info)
     return WrapType(env, instance, type);
 }
 
-static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value ret,
-                                 Napi::Array parameters, FunctionInfo *func)
+static bool ParseClassicFunction(const Napi::CallbackInfo &info, FunctionInfo *out_func)
 {
+    Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
+    Napi::String name = info[0u].As<Napi::String>();
+    Napi::Value ret = info[1u];
+    Napi::Array parameters = info[2u].As<Napi::Array>();
+
+    // Detect optional call convention
+    if (name.IsString() && DetectCallConvention(name.Utf8Value().c_str(), &out_func->convention)) {
+        if (info.Length() < 4) {
+            ThrowError<Napi::TypeError>(env, "Expected 4 arguments, got %1", info.Length());
+            return false;
+        }
+
+        name = info[1u].As<Napi::String>();
+        ret = info[2u];
+        parameters = info[3u].As<Napi::Array>();
+    }
+
 #ifdef _WIN32
-    if (!name.IsString() && !name.IsNumber()) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string or integer", GetValueType(instance, name));
-        return false;
+    if (name.IsNumber()) {
+        out_func->ordinal_name = name.As<Napi::Number>().Int32Value();
+        name = name.ToString();
     }
-#else
+#endif
     if (!name.IsString()) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string", GetValueType(instance, name));
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for name, expected string or integer", GetValueType(instance, name));
         return false;
     }
-#endif
 
-    func->name = DuplicateString(name.ToString().Utf8Value().c_str(), &instance->str_alloc).ptr;
+    out_func->name = DuplicateString(name.ToString().Utf8Value().c_str(), &instance->str_alloc).ptr;
 
-    func->ret.type = ResolveType(ret);
-    if (!func->ret.type)
+    out_func->ret.type = ResolveType(ret);
+    if (!out_func->ret.type)
         return false;
-    if (!CanReturnType(func->ret.type)) {
-        ThrowError<Napi::TypeError>(env, "You are not allowed to directly return %1 values (maybe try %1 *)", func->ret.type->name);
+    if (!CanReturnType(out_func->ret.type)) {
+        ThrowError<Napi::TypeError>(env, "You are not allowed to directly return %1 values (maybe try %1 *)", out_func->ret.type->name);
         return false;
     }
 
     if (!parameters.IsArray()) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for parameters of '%2', expected an array", GetValueType(instance, parameters), func->name);
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for parameters of '%2', expected an array", GetValueType(instance, parameters), out_func->name);
         return false;
     }
 
@@ -918,7 +933,7 @@ static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value r
         Napi::String str = parameters.Get(parameters_len - 1).As<Napi::String>();
 
         if (str.IsString() && str.Utf8Value() == "...") {
-            func->variadic = true;
+            out_func->variadic = true;
             parameters_len--;
         }
     }
@@ -934,21 +949,21 @@ static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value r
             ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a parameter", param.type->name);
             return false;
         }
-        if (func->parameters.len >= MaxParameters) {
+        if (out_func->parameters.len >= MaxParameters) {
             ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 parameters", MaxParameters);
             return false;
         }
-        if ((param.directions & 2) && ++func->out_parameters >= MaxParameters) {
+        if ((param.directions & 2) && ++out_func->out_parameters >= MaxParameters) {
             ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 output parameters", MaxParameters);
             return false;
         }
 
         param.offset = (int8_t)j;
 
-        func->parameters.Append(param);
+        out_func->parameters.Append(param);
     }
 
-    func->required_parameters = (int8_t)func->parameters.len;
+    out_func->required_parameters = (int8_t)out_func->parameters.len;
 
     return true;
 }
@@ -962,7 +977,7 @@ static Napi::Value CreateFunctionType(const Napi::CallbackInfo &info)
     RG_DEFER_N(err_guard) { instance->callbacks.RemoveLast(1); };
 
     if (info.Length() >= 3) {
-        if (!ParseClassicFunction(env, info[0u].As<Napi::String>(), info[1u], info[2u].As<Napi::Array>(), func))
+        if (!ParseClassicFunction(info, func))
             return env.Null();
     } else if (info.Length() >= 1) {
         if (!info[0].IsString()) {
@@ -1519,7 +1534,7 @@ extern "C" void RelayCallback(Size idx, uint8_t *own_sp, uint8_t *caller_sp, Bac
     }
 }
 
-static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConvention convention)
+static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
@@ -1529,10 +1544,9 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
     RG_DEFER { func->Unref(); };
 
     func->lib = lib->Ref();
-    func->convention = convention;
 
     if (info.Length() >= 3) {
-        if (!ParseClassicFunction(env, info[0u].As<Napi::String>(), info[1u], info[2u].As<Napi::Array>(), func))
+        if (!ParseClassicFunction(info, func))
             return env.Null();
     } else if (info.Length() >= 1) {
         if (!info[0].IsString()) {
@@ -1562,7 +1576,7 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
     }
 
 #ifdef _WIN32
-    if (info[0].IsString()) {
+    if (func->ordinal_name < 0) {
         if (func->decorated_name) {
             func->native = (void *)GetProcAddress((HMODULE)lib->module, func->decorated_name);
         }
@@ -1570,7 +1584,7 @@ static Napi::Value FindLibraryFunction(const Napi::CallbackInfo &info, CallConve
             func->native = (void *)GetProcAddress((HMODULE)lib->module, func->name);
         }
     } else {
-        uint16_t ordinal = (uint16_t)info[0].As<Napi::Number>().Uint32Value();
+        uint16_t ordinal = (uint16_t)func->ordinal_name;
 
         func->decorated_name = nullptr;
         func->native = (void *)GetProcAddress((HMODULE)lib->module, (LPCSTR)(size_t)ordinal);
@@ -1720,20 +1734,13 @@ static Napi::Value LoadSharedLibrary(const Napi::CallbackInfo &info)
             func.AddFinalizer([](Napi::Env, LibraryHolder *lib) { lib->Unref(); }, lib); \
             obj.Set((Name), func); \
         } while (false)
-#define ADD_CONVENTION(Name, Value) ADD_METHOD((Name), FindLibraryFunction(info, Value))
-
-    ADD_CONVENTION("func", CallConvention::Cdecl);
-    ADD_CONVENTION("cdecl", CallConvention::Cdecl);
-    ADD_CONVENTION("stdcall", CallConvention::Stdcall);
-    ADD_CONVENTION("fastcall", CallConvention::Fastcall);
-    ADD_CONVENTION("thiscall", CallConvention::Thiscall);
 
+    ADD_METHOD("func", FindLibraryFunction(info));
     ADD_METHOD("symbol", FindSymbol(info));
 
     // We can't unref the library after unload, obviously
     obj.Set("unload", Napi::Function::New(env, UnloadLibrary, "unload", (void *)lib->Ref()));
 
-#undef ADD_CONVENTION
 #undef ADD_METHOD
 
     return obj;
@@ -2326,7 +2333,6 @@ static Napi::Object InitModule(Napi::Env env, Napi::Object exports)
     Napi::Object types = InitBaseTypes(env);
     exports.Set("types", types);
 
-    exports.Set("internal", Napi::Boolean::New(env, false));
     exports.Set("version", Napi::String::New(env, RG_STRINGIFY(VERSION)));
 
     return exports;

package/src/koffi/src/ffi.hh

@@ -220,6 +220,9 @@ struct FunctionInfo {
 
     const char *name;
     const char *decorated_name; // Only set for some platforms/calling conventions
+#ifdef _WIN32
+    int ordinal_name = -1;
+#endif
     const LibraryHolder *lib = nullptr;
 
     void *native;

package/src/koffi/src/parser.cc

@@ -40,15 +40,7 @@ bool PrototypeParser::Parse(const char *str, FunctionInfo *out_func)
         MarkError("You are not allowed to directly return %1 values (maybe try %1 *)", out_func->ret.type->name);
         return false;
     }
-    if (Match("__cdecl")) {
-        out_func->convention = CallConvention::Cdecl;
-    } else if (Match("__stdcall")) {
-        out_func->convention = CallConvention::Stdcall;
-    } else if (Match("__fastcall")) {
-        out_func->convention = CallConvention::Fastcall;
-    } else if (Match("__thiscall")) {
-        out_func->convention = CallConvention::Thiscall;
-    }
+    offset += (offset < tokens.len && DetectCallConvention(tokens[offset], &out_func->convention));
     out_func->name = ParseIdentifier();
 
     Consume("(");
@@ -152,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]] {
@@ -1508,6 +1558,25 @@ Napi::Function WrapFunction(Napi::Env env, const FunctionInfo *func)
     return wrapper;
 }
 
+bool DetectCallConvention(Span<const char> name, CallConvention *out_convention)
+{
+    if (name == "__cdecl") {
+        *out_convention = CallConvention::Cdecl;
+        return true;
+    } else if (name == "__stdcall") {
+        *out_convention = CallConvention::Stdcall;
+        return true;
+    } else if (name == "__fastcall") {
+        *out_convention = CallConvention::Fastcall;
+        return true;
+    } else if (name == "__thiscall") {
+        *out_convention = CallConvention::Thiscall;
+        return true;
+    } else {
+        return false;
+    }
+}
+
 static int AnalyseFlatRec(const TypeInfo *type, int offset, int count, FunctionRef<void(const TypeInfo *type, int offset, int count)> func)
 {
     if (type->primitive == PrimitiveKind::Record) {

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;
@@ -208,6 +205,8 @@ static inline Napi::Array GetOwnPropertyNames(Napi::Object obj)
 
 Napi::Function WrapFunction(Napi::Env env, const FunctionInfo *func);
 
+bool DetectCallConvention(Span<const char> name, CallConvention *out_convention);
+
 int AnalyseFlat(const TypeInfo *type, FunctionRef<void(const TypeInfo *type, int offset, int count)> func);
 
 void DumpMemory(const char *type, Span<const uint8_t> bytes);

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 {