koffi 2.5.3 → 2.5.4

package/CHANGELOG.md

@@ -4,6 +4,16 @@
 
 ### Koffi 2.5
 
+#### Koffi 2.5.4
+
+**Main changes:**
+
+- Fix koffi.pointer() not accepting disposable types
+
+**Other changes:**
+
+- Fix potential issues when making pointer to anonymous types
+
 #### Koffi 2.5.3
 
 **Main changes:**

package/README.md

@@ -19,7 +19,7 @@ RISC-V 64 [^3]     | ⬜️ *N/A*    | ✅ Yes   | ⬜️ *N/A*    | 🟨 Probab
 
 [^1]: The following call conventions are supported: cdecl, stdcall, MS fastcall, thiscall.
 [^2]: The prebuilt binary uses the hard float ABI and expects a VFP coprocessor. Build from source to use Koffi with a different ABI (softfp, soft).
-[^3]: The prebuilt binary uses the LP64D (double-precision float) ABI. The LP64 ABI is supported in theory if you build Koffi from source (untested), the LP64F ABI is not supported.
+[^3]: The prebuilt binary uses the LP64D (double-precision float) ABI. The LP64 ABI is supported in theory if you build Koffi from source but this is untested. The LP64F ABI is not supported.
 
 Go to the web site for more information: https://koffi.dev/
 

package/doc/callbacks.md

@@ -11,6 +11,7 @@ The function `koffi.proto()` was introduced in Koffi 2.4, it was called `koffi.c
 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
+// ES6 syntax: import koffi from 'koffi';
 const koffi = require('koffi');
 
 // With the classic syntax, this callback expects an integer and returns nothing
@@ -59,7 +60,9 @@ int TransferToJS(const char *name, int age, int (*cb)(const char *str, int age))
 ```
 
 ```js
+// ES6 syntax: import koffi from 'koffi';
 const koffi = require('koffi');
+
 const lib = koffi.load('./callbacks.so'); // Fake path
 
 const TransferCallback = koffi.proto('int TransferCallback(const char *str, int age)');
@@ -107,7 +110,9 @@ void SayIt(const char *name)
 ```
 
 ```js
+// ES6 syntax: import koffi from 'koffi';
 const koffi = require('koffi');
+
 const lib = koffi.load('./callbacks.so'); // Fake path
 
 const GetCallback = koffi.proto('const char *GetCallback(const char *name)');
@@ -158,7 +163,9 @@ Some arguments are optional and this function can be called in several ways:
 The following example sorts an array of strings (in-place) with `qsort()`:
 
 ```js
+// ES6 syntax: import koffi from 'koffi';
 const koffi = require('koffi');
+
 const lib = koffi.load('libc.so.6');
 
 const SortCallback = koffi.proto('int SortCallback(const void *first, const void *second)');

package/doc/functions.md

@@ -5,7 +5,9 @@
 To declare functions, start by loading the shared library with `koffi.load(filename)`.
 
 ```js
+// ES6 syntax: import koffi from 'koffi';
 const koffi = require('koffi');
+
 const lib = koffi.load('/path/to/shared/library'); // File extension depends on platforms: .so, .dll, .dylib, etc.
 ````
 
@@ -81,7 +83,9 @@ You can safely use these on non-x86 platforms, they are simply ignored.
 Below you can find a small example showing how to use a non-default calling convention, with the two syntaxes:
 
 ```js
+// ES6 syntax: import koffi from 'koffi';
 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)
@@ -116,7 +120,9 @@ printf('Integer %d, double %g, str %s', 'int', 6, 'double', 8.5, 'str', 'THE END
 You can issue asynchronous calls by calling the function through its async member. In this case, you need to provide a callback function as the last argument, with `(err, res)` parameters.
 
 ```js
+// ES6 syntax: import koffi from 'koffi';
 const koffi = require('koffi');
+
 const lib = koffi.load('libc.so.6');
 
 const atoi = lib.func('int atoi(const char *str)');

package/doc/misc.md

@@ -112,6 +112,8 @@ The standard POSIX error codes are available in `koffi.os.errno`, as in the exam
 
 ```js
 const assert = require('assert');
+
+// ES6 syntax: import koffi from 'koffi';
 const koffi = require('koffi');
 
 const lib = koffi.load('libc.so.6');

package/doc/parameters.md

@@ -28,7 +28,9 @@ The same can be done when declaring a function with a C-like prototype string, w
 This Windows example enumerate all Chrome windows along with their PID and their title. The `GetWindowThreadProcessId()` function illustrates how to get a primitive value from an output argument.
 
 ```js
+// ES6 syntax: import koffi from 'koffi';
 const koffi = require('koffi');
+
 const user32 = koffi.load('user32.dll');
 
 const DWORD = koffi.alias('DWORD', 'uint32_t');
@@ -82,7 +84,9 @@ for (let hwnd = null;;) {
 This example calls the POSIX function `gettimeofday()`, and uses the prototype-like syntax.
 
 ```js
+// ES6 syntax: import koffi from 'koffi';
 const koffi = require('koffi');
+
 const lib = koffi.load('libc.so.6');
 
 const timeval = koffi.struct('timeval', {
@@ -108,7 +112,9 @@ console.log(tv);
 This example opens an in-memory SQLite database, and uses the node-ffi-style function declaration syntax.
 
 ```js
+// ES6 syntax: import koffi from 'koffi';
 const koffi = require('koffi');
+
 const lib = koffi.load('sqlite3.so');
 
 const sqlite3 = koffi.opaque('sqlite3');
@@ -182,7 +188,9 @@ Koffi provides two features to deal with this:
 The example below shows the use of `koffi.as()` to read the header of a PNG file with `fread()`.
 
 ```js
+// ES6 syntax: import koffi from 'koffi';
 const koffi = require('koffi');
+
 const lib = koffi.load('libc.so.6');
 
 const FILE = koffi.opaque('FILE');
@@ -238,7 +246,9 @@ You can use buffers and typed arrays for output (and input/output) pointer param
 Once the native function returns, you can decode the content with `koffi.decode(value, type)` as in the following example:
 
 ```js
+// ES6 syntax: import koffi from 'koffi';
 const koffi = require('koffi');
+
 const lib = koffi.load('libc.so.6');
 
 const Vec3 = koffi.struct('Vec3', {
@@ -292,7 +302,9 @@ const ExplicitFree = koffi.disposable('HeapStr16', 'str16', koffi.free); // You
 The following example illustrates the use of a disposable type derived from *str*.
 
 ```js
+// ES6 syntax: import koffi from 'koffi';
 const koffi = require('koffi');
+
 const lib = koffi.load('libc.so.6');
 
 const HeapStr = koffi.disposable('str');
@@ -305,7 +317,9 @@ console.log(copy); // Prints Hello!
 When you declare functions with the [prototype-like syntax](functions.md#definition-syntax), you can either use named disposable types or use the '!' shortcut qualifier with compatibles types, as shown in the example below. This qualifier creates an anonymous disposable type that calls `koffi.free(ptr)`.
 
 ```js
+// ES6 syntax: import koffi from 'koffi';
 const koffi = require('koffi');
+
 const lib = koffi.load('libc.so.6');
 
 // You can also use: const strdup = lib.func('const char *! strdup(const char *str)')

package/doc/pointers.md

@@ -16,7 +16,9 @@ In C, pointer arguments are used for differenty purposes. It is important to dis
 The following Win32 example uses `GetCursorPos()` (with an output parameter) to retrieve and show the current cursor position.
 
 ```js
+// ES6 syntax: import koffi from 'koffi';
 const koffi = require('koffi');
+
 const lib = koffi.load('kernel32.dll');
 
 // Type declarations
@@ -115,7 +117,9 @@ int64_t ComputeTotalLength(const char **strings)
 ```
 
 ```js
+// ES6 syntax: import koffi from 'koffi';
 const koffi = require('koffi');
+
 const lib = koffi.load('./length.so');
 
 const ComputeTotalLength = lib.func('int64_t ComputeTotalLength(const char **strings)');

package/doc/start.md

@@ -8,10 +8,14 @@ You can install Koffi with npm:
 npm install koffi
 ```
 
-Once you have installed Koffi, you can start by loading it this way:
+Once you have installed Koffi, you can start by loading it:
 
 ```js
+// CommonJS syntax
 const koffi = require('koffi');
+
+// ES6 modules
+import koffi from 'koffi';
 ```
 
 Below you can find three examples:
@@ -26,6 +30,7 @@ This is a small example for Linux systems, which uses `gettimeofday()`, `localti
 It illustrates the use of output parameters.
 
 ```js
+// ES6 syntax: import koffi from 'koffi';
 const koffi = require('koffi');
 
 // Load the shared library
@@ -76,6 +81,7 @@ This is a small example targeting the Win32 API, using `MessageBox()` to show a
 It illustrates the use of the x86 stdcall calling convention, and the use of UTF-8 and UTF-16 string arguments.
 
 ```js
+// ES6 syntax: import koffi from 'koffi';
 const koffi = require('koffi');
 
 // Load the shared library

package/doc/types.md

@@ -278,7 +278,9 @@ const char *ConcatBuild(Concat *c)
 ```
 
 ```js
+// ES6 syntax: import koffi from 'koffi';
 const koffi = require('koffi');
+
 const lib = koffi.load('./handles.so');
 
 const Concat = koffi.opaque('Concat');
@@ -344,6 +346,7 @@ Koffi applies the following conversion rules when passing arrays to/from C:
 See the example below:
 
 ```js
+// ES6 syntax: import koffi from 'koffi';
 const koffi = require('koffi');
 
 // Those two structs are exactly the same, only the array conversion hint is different

package/doc/unions.md

@@ -58,6 +58,7 @@ DoSomething('string', { .str = 'Hello!' });
 The following example uses the [SendInput](https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-sendinput) Win32 API to emit the Win+D shortcut and hide windows (show the desktop).
 
 ```js
+// ES6 syntax: import koffi from 'koffi';
 const koffi = require('koffi');
 
 // Win32 type and functions

package/package.json

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

package/src/core/libcc/libcc.hh

@@ -3906,8 +3906,6 @@ enum class StatResult {
 
     MissingPath,
     AccessDenied,
-    PartialEnum,
-    CallbackFail,
     OtherError
 };
 

package/src/koffi/src/ffi.cc

@@ -228,11 +228,12 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
     TypeInfo *type = instance->types.AppendDefault();
     RG_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
 
-    std::string name = named ? info[0].As<Napi::String>() : std::string("<anonymous>");
+    Napi::String name = info[0].As<Napi::String>();
     Napi::Object obj = info[named].As<Napi::Object>();
     Napi::Array keys = obj.GetPropertyNames();
 
-    type->name = DuplicateString(name.c_str(), &instance->str_alloc).ptr;
+    type->name = named ? DuplicateString(name.Utf8Value().c_str(), &instance->str_alloc).ptr
+                       : Fmt(&instance->str_alloc, "<type_%1>", instance->types.len).ptr;
 
     type->primitive = PrimitiveKind::Record;
     type->align = 1;
@@ -356,11 +357,12 @@ static Napi::Value CreateUnionType(const Napi::CallbackInfo &info)
     TypeInfo *type = instance->types.AppendDefault();
     RG_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
 
-    std::string name = named ? info[0].As<Napi::String>() : std::string("<anonymous>");
+    Napi::String name = info[0].As<Napi::String>();
     Napi::Object obj = info[named].As<Napi::Object>();
     Napi::Array keys = obj.GetPropertyNames();
 
-    type->name = DuplicateString(name.c_str(), &instance->str_alloc).ptr;
+    type->name = named ? DuplicateString(name.Utf8Value().c_str(), &instance->str_alloc).ptr
+                       : Fmt(&instance->str_alloc, "<type_%1>", instance->types.len).ptr;
 
     type->primitive = PrimitiveKind::Union;
     type->align = 1;
@@ -485,12 +487,13 @@ static Napi::Value CreateOpaqueType(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    std::string name = named ? info[0].As<Napi::String>() : std::string("<anonymous>");
+    Napi::String name = info[0].As<Napi::String>();    
 
     TypeInfo *type = instance->types.AppendDefault();
     RG_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
 
-    type->name = DuplicateString(name.c_str(), &instance->str_alloc).ptr;
+    type->name = named ? DuplicateString(name.Utf8Value().c_str(), &instance->str_alloc).ptr
+                       : Fmt(&instance->str_alloc, "<type_%1>", instance->types.len).ptr;
 
     type->primitive = PrimitiveKind::Void;
     type->size = 0;
@@ -533,10 +536,6 @@ static Napi::Value CreatePointerType(const Napi::CallbackInfo &info)
     const TypeInfo *type = ResolveType(info[named]);
     if (!type)
         return env.Null();
-    if (type->dispose) {
-        ThrowError<Napi::TypeError>(env, "Cannot create pointer to disposable type '%1'", type->name);
-        return env.Null();
-    }
 
     int count = 0;
     if (info.Length() >= 2u + named) {
@@ -642,7 +641,7 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    std::string name = named ? info[0].As<Napi::String>() : std::string("<anonymous>");
+    Napi::String name = info[0].As<Napi::String>();
 
     const TypeInfo *src = ResolveType(info[named]);
     if (!src)
@@ -697,8 +696,11 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
     RG_DEFER_N(err_guard) { instance->types.RemoveLast(1); };
 
     memcpy((void *)type, (const void *)src, RG_SIZE(*src));
-    type->name = DuplicateString(name.c_str(), &instance->str_alloc).ptr;
     type->members.allocator = GetNullAllocator();
+
+    type->name = named ? DuplicateString(name.Utf8Value().c_str(), &instance->str_alloc).ptr
+                       : Fmt(&instance->str_alloc, "<type_%1>", instance->types.len).ptr;
+
     type->dispose = dispose;
     type->dispose_ref = Napi::Persistent(dispose_func);
 

package/src/koffi/src/util.cc

@@ -243,7 +243,7 @@ const TypeInfo *ResolveType(Napi::Env env, Span<const char> str, int *out_direct
             TypeInfo *copy = instance->types.AppendDefault();
 
             memcpy((void *)copy, (const void *)type, RG_SIZE(*type));
-            copy->name = "<anonymous>";
+            copy->name = Fmt(&instance->str_alloc, "<type_%1>", instance->types.len).ptr;
             copy->members.allocator = GetNullAllocator();
 
             copy->dispose = [](Napi::Env env, const TypeInfo *, const void *ptr) {