koffi 2.5.9 → 2.5.11

package/CHANGELOG.md

@@ -4,6 +4,15 @@
 
 ### Koffi 2.5
 
+#### Koffi 2.5.11
+
+- Support casting function pointers with [koffi.as()](parameters.md#input-polymorphism)
+- Build in C++20 mode
+
+#### Koffi 2.5.10
+
+- Fix CMake regression when client has to build Koffi
+
 #### Koffi 2.5.9
 
 **Main changes:**

package/doc/packaging.md

@@ -6,42 +6,43 @@
 
 Koffi uses native modules to work. The NPM package contains binaries for various platforms and architectures, and the appropriate module is selected at runtime.
 
-In theory, the bundlers should be able to find recorgnize all native modules because they are explictly listed in the Javascript file, as static strings.
+In theory, the **packagers/bundlers should be able to find all native modules** because they are explictly listed in the Javascript file (as static strings) and package them somehow.
 
 If that is not the case, you can manually arrange to copy the `node_modules/koffi/build/koffi` directory next to your bundled script.
 
 Here is an example that would work:
 
 ```
-    koffi/
-        win32_x64/
-            koffi.node
-        linux_x64/
-            koffi.node
-        ...
-    MyBundle.js
+koffi/
+    win32_x64/
+        koffi.node
+    linux_x64/
+        koffi.node
+    ...
+MyBundle.js
 ```
 
 When running in Electron, Koffi will also try to find the native module in `process.resourcesPath`. For an Electron app you could do something like this
 
 ```
-    locales/
-    resources/
-        koffi/
-            darwin_arm64/
-                koffi.node
-            darwin_x64/
-                koffi.node
-    MyApp.exe
+locales/
+resources/
+    koffi/
+        win32_ia32/
+            koffi.node
+        win32_x64/
+            koffi.node
+        ...
+MyApp.exe
 ```
 
 ## Packaging examples
 
 ### Electron with electron-builder
 
-Packaging with electron-builder should work as-is:
+Packaging with electron-builder should work as-is.
 
-You can also go take a look at the full [working example in the repository](https://github.com/Koromix/rygel/tree/master/src/koffi/examples/electron-builder).
+Take a look at the full [working example in the repository](https://github.com/Koromix/rygel/tree/master/src/koffi/examples/electron-builder).
 
 ### Electron Forge
 
@@ -51,10 +52,20 @@ Packaging with Electron Force should work as-is, even when using webpack as conf
 npm init electron-app@latest my-app -- --template=webpack
 ```
 
-You can also go take a look at the full [working example in the repository](https://github.com/Koromix/rygel/tree/master/src/koffi/examples/electron-forge).
+Take a look at the full [working example in the repository](https://github.com/Koromix/rygel/tree/master/src/koffi/examples/electron-forge).
 
 ### NW.js
 
 Packagers such as nw-builder should work as-is.
 
 You can find a full [working example in the repository](https://github.com/Koromix/rygel/tree/master/src/koffi/examples/nwjs).
+
+### Node.js and esbuild
+
+You can easily tell esbuild to copy the native files with the copy loader and things should just work. Use something like:
+
+```sh
+esbuild index.js --platform=node --bundle --loader:.node=copy --outdir=dist/
+```
+
+You can find a full [working example in the repository](https://github.com/Koromix/rygel/tree/master/src/koffi/examples/node-esbuild).

package/package.json

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

package/src/core/libcc/libcc.cc

@@ -801,6 +801,108 @@ bool ParseBool(Span<const char> str, bool *out_value, unsigned int flags,
     return false;
 }
 
+bool ParseSize(Span<const char> str, int64_t *out_size, unsigned int flags, Span<const char> *out_remaining)
+{
+    uint64_t size = 0;
+
+    if (!ParseInt(str, &size, flags & ~(int)ParseFlag::End, &str))
+        return false;
+    if (size > INT64_MAX) [[unlikely]]
+        goto overflow;
+
+    if (str.len) {
+        uint64_t multiplier = 1;
+        int next = 1;
+
+        switch (str[0]) {
+            case 'B': { multiplier = 1; } break;
+            case 'k': { multiplier = 1000; } break;
+            case 'M': { multiplier = 1000000; } break;
+            case 'G': { multiplier = 1000000000; } break;
+            case 'T': { multiplier = 1000000000000; } break;
+            default: { next = 0; } break;
+        }
+
+        if ((flags & (int)ParseFlag::End) && str.len > next) [[unlikely]] {
+            if (flags & (int)ParseFlag::Log) {
+                LogError("Unknown size unit '%1'", str[0]);
+            }
+            return false;
+        }
+        str = str.Take(next, str.len - next);
+
+        uint64_t total = size * multiplier;
+        if ((size && total / size != multiplier) || total > INT64_MAX) [[unlikely]]
+            goto overflow;
+        size = total;
+    }
+
+    *out_size = (int64_t)size;
+    if (out_remaining) {
+        *out_remaining = str;
+    }
+    return true;
+
+overflow:
+    if (flags & (int)ParseFlag::Log) {
+        LogError("Size value is too high");
+    }
+    return false;
+}
+
+bool ParseDuration(Span<const char> str, int64_t *out_duration, unsigned int flags, Span<const char> *out_remaining)
+{
+    uint64_t duration = 0;
+
+    if (!ParseInt(str, &duration, flags & ~(int)ParseFlag::End, &str))
+        return false;
+    if (duration > INT64_MAX) [[unlikely]]
+        goto overflow;
+
+    if (str.len) {
+        uint64_t multiplier = 1;
+        int next = 1;
+
+        switch (str[0]) {
+            case 's': { multiplier = 1000; } break;
+            case 'm': { multiplier = 60000; } break;
+            case 'h': { multiplier = 3600000; } break;
+            case 'd': { multiplier = 86400000; } break;
+            default: { next = 0; } break;
+        }
+
+        if ((flags & (int)ParseFlag::End) && str.len > next) [[unlikely]] {
+            if (flags & (int)ParseFlag::Log) {
+                LogError("Unknown duration unit '%1'", str[0]);
+            }
+            return false;
+        }
+        str = str.Take(next, str.len - next);
+
+        uint64_t total = duration * multiplier;
+        if ((duration && total / duration != multiplier) || total > INT64_MAX) [[unlikely]]
+            goto overflow;
+        duration = total;
+    } else {
+        uint64_t total = duration * 1000;
+        if ((duration && total / duration != 1000) || total > INT64_MAX) [[unlikely]]
+            goto overflow;
+        duration = total;
+    }
+
+    *out_duration = (int64_t)duration;
+    if (out_remaining) {
+        *out_remaining = str;
+    }
+    return true;
+
+overflow:
+    if (flags & (int)ParseFlag::Log) {
+        LogError("Duration value is too high");
+    }
+    return false;
+}
+
 // ------------------------------------------------------------------------
 // Format
 // ------------------------------------------------------------------------
@@ -4832,7 +4934,8 @@ const char *GetTemporaryDirectory()
 
 #endif
 
-const char *FindConfigFile(const char *name, Allocator *alloc, LocalArray<const char *, 4> *out_possibilities)
+const char *FindConfigFile(Span<const char *const> names, Allocator *alloc,
+                           LocalArray<const char *, 4> *out_possibilities)
 {
     decltype(GetUserConfigPath) *funcs[] = {
         [](const char *name, Allocator *alloc) {
@@ -4850,16 +4953,19 @@ const char *FindConfigFile(const char *name, Allocator *alloc, LocalArray<const
     const char *filename = nullptr;
 
     for (const auto &func: funcs) {
-        const char *path = func(name, alloc);
+        for (const char *name: names) {
+            const char *path = func(name, alloc);
 
-        if (!path)
-            continue;
+            if (!path)
+                continue;
 
-        if (TestFile(path, FileType::File)) {
-            filename = path;
-        }
-        if (out_possibilities) {
-            out_possibilities->Append(path);
+            if (TestFile(path, FileType::File)) {
+                filename = path;
+            }
+            if (out_possibilities) {
+                out_possibilities->Append(path);
+                break;
+            }
         }
     }
 
@@ -6756,6 +6862,16 @@ bool SpliceStream(StreamReader *reader, int64_t max_len, StreamWriter *writer)
     return true;
 }
 
+bool IsCompressorAvailable(CompressionType compression_type)
+{
+    return CompressorFunctions[(int)compression_type];
+}
+
+bool IsDecompressorAvailable(CompressionType compression_type)
+{
+    return DecompressorFunctions[(int)compression_type];
+}
+
 // ------------------------------------------------------------------------
 // INI
 // ------------------------------------------------------------------------

package/src/core/libcc/libcc.hh

@@ -3315,41 +3315,38 @@ static inline int CmpStr(const char *str1, Span<const char> str2)
 static inline int CmpStr(const char *str1, const char *str2)
     { return strcmp(str1, str2); }
 
-static inline Size StartsWith(Span<const char> str, Span<const char> prefix)
+static inline bool StartsWith(Span<const char> str, Span<const char> prefix)
 {
     Size i = 0;
     while (i < str.len && i < prefix.len) {
         if (str[i] != prefix[i])
-            return 0;
-
+            return false;
         i++;
     }
 
-    return (i == prefix.len) ? i : 0;
+    return (i == prefix.len);
 }
-static inline Size StartsWith(Span<const char> str, const char *prefix)
+static inline bool StartsWith(Span<const char> str, const char *prefix)
 {
     Size i = 0;
     while (i < str.len && prefix[i]) {
         if (str[i] != prefix[i])
-            return 0;
-
+            return false;
         i++;
     }
 
-    return !prefix[i] ? i : 0;
+    return !prefix[i];
 }
-static inline Size StartsWith(const char *str, const char *prefix)
+static inline bool StartsWith(const char *str, const char *prefix)
 {
     Size i = 0;
     while (str[i] && prefix[i]) {
         if (str[i] != prefix[i])
-            return 0;
-
+            return false;
         i++;
     }
 
-    return !prefix[i] ? i : 0;
+    return !prefix[i];
 }
 
 static inline bool EndsWith(Span<const char> str, const char *suffix)
@@ -3703,6 +3700,31 @@ overflow:
 bool ParseBool(Span<const char> str, bool *out_value, unsigned int flags = RG_DEFAULT_PARSE_FLAGS,
                Span<const char> *out_remaining = nullptr);
 
+bool ParseSize(Span<const char> str, int64_t *out_size, unsigned int flags = RG_DEFAULT_PARSE_FLAGS,
+               Span<const char> *out_remaining = nullptr);
+#if RG_SIZE_MAX < INT64_MAX
+static inline bool ParseSize(Span<const char> str, Size *out_size,
+                             unsigned int flags = RG_DEFAULT_PARSE_FLAGS, Span<const char> *out_remaining = nullptr)
+{
+    int64_t size = 0;
+    if (!ParseSize(str, &size, flags, out_remaining))
+        return false;
+
+    if (size > RG_SIZE_MAX) [[unlikely]] {
+        if (flags & (int)ParseFlag::Log) {
+            LogError("Size value is too high");
+        }
+        return false;
+    }
+
+    *out_size = (Size)size;
+    return true;
+}
+#endif
+
+bool ParseDuration(Span<const char> str, int64_t *out_duration, unsigned int flags = RG_DEFAULT_PARSE_FLAGS,
+                   Span<const char> *out_remaining = nullptr);
+
 static inline Size EncodeUtf8(int32_t c, char out_buf[4])
 {
     if (c < 0x80) {
@@ -4096,11 +4118,11 @@ bool NotifySystemd();
         })()
 #endif
 
+void InitRG();
+int Main(int argc, char **argv);
+
 static inline int RunApp(int argc, char **argv)
 {
-    void InitRG();
-    int Main(int argc, char **argv);
-
     InitRG();
     return Main(argc, argv);
 }
@@ -4114,7 +4136,8 @@ const char *GetUserCachePath(const char *name, Allocator *alloc); // Can return
 const char *GetSystemConfigPath(const char *name, Allocator *alloc);
 const char *GetTemporaryDirectory();
 
-const char *FindConfigFile(const char *name, Allocator *alloc, LocalArray<const char *, 4> *out_possibilities = nullptr);
+const char *FindConfigFile(Span<const char *const> names, Allocator *alloc,
+                           LocalArray<const char *, 4> *out_possibilities = nullptr);
 
 const char *CreateUniqueFile(Span<const char> directory, const char *prefix, const char *extension,
                              Allocator *alloc, FILE **out_fp = nullptr);
@@ -4657,6 +4680,9 @@ public:
 
 bool SpliceStream(StreamReader *reader, int64_t max_len, StreamWriter *writer);
 
+bool IsCompressorAvailable(CompressionType compression_type);
+bool IsDecompressorAvailable(CompressionType compression_type);
+
 // For convenience, don't close them
 extern StreamReader stdin_st;
 extern StreamWriter stdout_st;

package/src/index.js

@@ -21,14 +21,14 @@
 
 'use strict';
 
-const cnoke = require('./cnoke/src/index.js');
 const util = require('util');
 const fs = require('fs');
+const { get_napi_version, determine_arch } = require('./cnoke/src/tools.js');
 const pkg = require('../package.json');
 
 if (process.versions.napi == null || process.versions.napi < pkg.cnoke.napi) {
     let major = parseInt(process.versions.node, 10);
-    let required = cnoke.get_napi_version(pkg.cnoke.napi, major);
+    let required = get_napi_version(pkg.cnoke.napi, major);
 
     if (required != null) {
         throw new Error(`Project ${pkg.name} requires Node >= ${required} in the Node ${major}.x branch (N-API >= ${pkg.cnoke.napi})`);
@@ -37,7 +37,7 @@ if (process.versions.napi == null || process.versions.napi < pkg.cnoke.napi) {
     }
 }
 
-let arch = cnoke.determine_arch();
+let arch = determine_arch();
 let triplet = `${process.platform}_${arch}`;
 
 let native = null;

package/src/koffi/CMakeLists.txt

@@ -28,7 +28,7 @@ include(CheckCXXCompilerFlag)
 
 find_package(CNoke)
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 if(MSVC)
     set(CMAKE_MSVC_RUNTIME_LIBRARY MultiThreaded)
 
@@ -47,7 +47,11 @@ endif()
 
 # ---- Koffi ----
 
-file(READ ${CMAKE_CURRENT_SOURCE_DIR}/package.json PKG)
+if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/package.json)
+    file(READ ${CMAKE_CURRENT_SOURCE_DIR}/package.json PKG)
+else()
+    file(READ ${CMAKE_CURRENT_SOURCE_DIR}/../../package.json PKG)
+endif()
 string(REGEX MATCH "\"version\": \"([^\"]+)\"" XX "${PKG}")
 set(KOFFI_VERSION ${CMAKE_MATCH_1})
 

package/src/koffi/examples/electron-builder/README.md

@@ -3,18 +3,6 @@ This is a simple example shows:
 - How to communicate with Koffi from a renderer window
 - How to use electron-builder with an application that uses Koffi
 
-One of the important piece for the packaging is in `package.json`, specifically this part:
-
-```json
-  "build": {
-    "extraResources": [
-      { "from": "node_modules/koffi/build", "to": "koffi" }
-    ]
-  }
-```
-
-This instructs electron-builder to copy the native koffi modules to a place where your application will find them.
-
 Use the following commands to package the app for your system:
 
 ```sh

package/src/koffi/examples/electron-builder/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "Koffi Config",
+  "name": "KoffiConfig",
   "version": "1.0.0",
   "description": "Koffi Electron Example",
   "main": "src/app.js",
@@ -16,6 +16,6 @@
     "esbuild": "^0.18.17"
   },
   "dependencies": {
-    "koffi": "^2.5.8"
+    "koffi": "^2.5.9"
   }
 }

package/src/koffi/examples/electron-forge/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "Koffi Config",
+  "name": "KoffiConfig",
   "version": "1.0.0",
   "description": "Koffi Electron Example",
   "main": ".webpack/main",
@@ -32,6 +32,6 @@
   },
   "dependencies": {
     "electron-squirrel-startup": "^1.0.0",
-    "koffi": "^2.5.8"
+    "koffi": "^2.5.9"
   }
 }

package/src/koffi/examples/electron-forge/src/main.js

@@ -21,7 +21,7 @@ const createWindow = () => {
   mainWindow.loadURL(MAIN_WINDOW_WEBPACK_ENTRY);
 
   // Open the DevTools.
-  mainWindow.webContents.openDevTools();
+  // mainWindow.webContents.openDevTools();
 };
 
 // This method will be called when Electron has finished

package/src/koffi/examples/node-esbuild/README.md

@@ -0,0 +1,19 @@
+This is a simple example to bundle a CLI node.js app that uses Koffi, using esbuild.
+
+To run the app, execute the following:
+
+```sh
+cd examples/node-esbuild
+npm install
+npm start
+```
+
+You can bundle the script and the native modules with the following command
+
+```sh
+cd examples/node-esbuild
+npm install
+npm run bundle
+```
+
+Internally, this uses the esbuild copy loader to handle the native `.node` modules.

package/src/koffi/examples/node-esbuild/index.js

@@ -0,0 +1,2 @@
+const koffi = require('koffi');
+console.log(koffi.config());

package/src/koffi/examples/node-esbuild/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "KoffiConfig",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js",
+    "bundle": "esbuild index.js --platform=node --bundle --loader:.node=copy --outdir=dist/"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "esbuild": "^0.18.17",
+    "koffi": "^2.5.9"
+  }
+}

package/src/koffi/examples/nwjs/src/package.json

@@ -1,9 +1,10 @@
 {
-  "name": "Koffi Config",
+  "name": "KoffiConfig",
+  "version": "1.0.0",
   "main": "index.html",
   "author": "Niels Martignène <niels.martignene@protonmail.com>",
   "license": "MIT",
   "dependencies": {
-    "koffi": "^2.5.8"
+    "koffi": "^2.5.9"
   }
 }

package/src/koffi/src/call.cc

@@ -1043,12 +1043,6 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
                 out_kind = OutArgument::Kind::Buffer;
             } else if (type->ref.type->primitive == PrimitiveKind::Record ||
                        type->ref.type->primitive == PrimitiveKind::Union) [[likely]] {
-                if (!type->ref.type->size) [[unlikely]] {
-                    ThrowError<Napi::TypeError>(env, "Cannot pass %1 value to %2, use koffi.as()",
-                                                type->ref.type != instance->void_type ? "opaque" : "ambiguous", type->name);
-                    return false;
-                }
-
                 Napi::Object obj = value.As<Napi::Object>();
                 RG_ASSERT(IsObject(value));
 
@@ -1108,6 +1102,22 @@ bool CallData::PushPointer(Napi::Value value, const TypeInfo *type, int directio
             }
         } break;
 
+        case napi_function: {
+            if (type->primitive != PrimitiveKind::Callback) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Cannot pass function to type %1", type->name);
+                return false;
+            }
+
+            Napi::Function func = value.As<Napi::Function>();
+
+            void *ptr = ReserveTrampoline(type->ref.proto, func);
+            if (!ptr) [[unlikely]]
+                return false;
+
+            *out_ptr = (void *)ptr;
+            return true;
+        } break;
+
         case napi_number: {
             Napi::Number number = value.As<Napi::Number>();
             intptr_t ptr = (intptr_t)number.Int32Value();

package/src/koffi/src/ffi.cc

@@ -1775,8 +1775,9 @@ static Napi::Value CastValue(const Napi::CallbackInfo &info)
     if (!type) [[unlikely]]
         return env.Null();
     if (type->primitive != PrimitiveKind::Pointer &&
+            type->primitive != PrimitiveKind::Callback &&
             type->primitive != PrimitiveKind::String &&
-            type->primitive != PrimitiveKind::String16) {
+            type->primitive != PrimitiveKind::String16) [[unlikely]] {
         ThrowError<Napi::TypeError>(env, "Only pointer or string types can be used for casting");
         return env.Null();
     }