koffi 2.6.12 → 2.7.0

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## Version history
 
+### Koffi 2.7
+
+#### 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

@@ -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/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;
 
@@ -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;

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.0",
+      stable: "2.7.0",
       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.0",
+      stable: "2.7.0",
       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.0",
+    "stable": "2.7.0",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [
         "foreign",

package/src/core/libcc/libcc.cc

@@ -5599,7 +5599,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 +5672,6 @@ bool Async::Sync()
     return success;
 }
 
-int Async::CountPendingTasks()
-{
-    return pool->CountPendingTasks();
-}
-
 bool Async::IsTaskRunning()
 {
     return async_running_task;
@@ -5806,6 +5800,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)

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)
 
 // ------------------------------------------------------------------------
@@ -4265,8 +4267,6 @@ public:
     void Run(const std::function<bool()> &f);
     bool Sync();
 
-    int CountPendingTasks();
-
     static bool IsTaskRunning();
     static int GetWorkerIdx();
     static int GetWorkerCount();

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

package/src/koffi/src/util.cc

@@ -1508,6 +1508,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

@@ -208,6 +208,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);