koffi 2.6.11 → 2.7.0

package/CHANGELOG.md

@@ -2,8 +2,20 @@
 
 ## 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)
+
+- Fix possible crash introduced in Koffi 2.6.11
+
 #### Koffi 2.6.11 (2023-12-05)
 
 - Speed up resolving simple and often used type names

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.11",
-      stable: "2.6.11",
+      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.11",
-      stable: "2.6.11",
+      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.11",
-    "stable": "2.6.11",
+    "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)
@@ -8372,4 +8371,72 @@ bool PromptYN(const char *prompt, bool *out_value)
     return prompter.ReadYN(out_value);
 }
 
+// ------------------------------------------------------------------------
+// Mime types
+// ------------------------------------------------------------------------
+
+const char *GetMimeType(Span<const char> extension, const char *default_type)
+{
+    static const HashMap<Span<const char>, const char *> mime_types = {
+        #define MIMETYPE(Extension, MimeType) { (Extension), (MimeType) },
+        #include "mimetypes.inc"
+
+        {"", "application/octet-stream"}
+    };
+
+    const char *mime_type = mime_types.FindValue(extension, nullptr);
+
+    if (!mime_type) {
+        LogError("Unknown MIME type for extension '%1'", extension);
+        mime_type = default_type;
+    }
+
+    return mime_type;
+}
+
+bool CanCompressFile(const char *filename)
+{
+    char extension[8];
+    {
+        const char *ptr = GetPathExtension(filename).ptr;
+
+        Size i = 0;
+        while (i < RG_SIZE(extension) - 1 && ptr[i]) {
+            extension[i] = LowerAscii(ptr[i]);
+            i++;
+        }
+        extension[i] = 0;
+    }
+
+    if (TestStrI(extension, ".zip"))
+        return false;
+    if (TestStrI(extension, ".rar"))
+        return false;
+    if (TestStrI(extension, ".7z"))
+        return false;
+    if (TestStrI(extension, ".gz") || TestStrI(extension, ".tgz"))
+        return false;
+    if (TestStrI(extension, ".bz2") || TestStrI(extension, ".tbz2"))
+        return false;
+    if (TestStrI(extension, ".xz") || TestStrI(extension, ".txz"))
+        return false;
+    if (TestStrI(extension, ".zst") || TestStrI(extension, ".tzst"))
+        return false;
+    if (TestStrI(extension, ".woff") || TestStrI(extension, ".woff2"))
+        return false;
+    if (TestStrI(extension, ".db") || TestStrI(extension, ".sqlite3"))
+        return false;
+
+    const char *mime_type = GetMimeType(extension);
+
+    if (StartsWith(mime_type, "video/"))
+        return false;
+    if (StartsWith(mime_type, "audio/"))
+        return false;
+    if (StartsWith(mime_type, "image/") && !TestStr(mime_type, "image/svg+xml"))
+        return false;
+
+    return true;
+}
+
 }

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();
@@ -5016,4 +5016,12 @@ static inline const char *Prompt(const char *prompt, Allocator *alloc)
     { return Prompt(prompt, nullptr, nullptr, alloc); }
 bool PromptYN(const char *prompt, bool *out_value);
 
+// ------------------------------------------------------------------------
+// Mime types
+// ------------------------------------------------------------------------
+
+const char *GetMimeType(Span<const char> extension, const char *default_typ = "application/octet-stream");
+
+bool CanCompressFile(const char *filename);
+
 }