koffi 2.1.0 → 2.1.2

package/ChangeLog.md

@@ -2,12 +2,24 @@
 
 ## History
 
+### Koffi 2.1.2
+
+**Main changes:**
+
+- Support up to 8 output parameters (instead of 4)
+
+### Koffi 2.1.1
+
+**Main fixes:**
+
+- Fix potential memory allocation bugs
+
 ### Koffi 2.1.0
 
 **Main changes:**
 
 - Add [koffi.as()](functions.md#polymorphic-parameters) to support polymorphic APIs based on `void *` parameters
-- Add [endian-sensitive integer types](types.md#endian-sensitive-types): `intX_le_t`, `intX_be_t`
+- Add [endian-sensitive integer types](types.md#endian-sensitive-types): `intX_le_t`, `intX_be_t`, `uintX_le_t`, `uintX_be_t`
 - Accept typed arrays for `void *` parameters
 - Introduce `koffi.opaque()` to replace `koffi.handle()` (which remains supported until Koffi 3.0)
 - Support JS Array and TypedArray to fill struct and array pointer members

package/doc/templates/badges.html

@@ -1,4 +1,7 @@
 <div style="text-align: center; margin-top: 2em;">
     <a href="https://www.npmjs.com/package/koffi"><img src="https://img.shields.io/badge/NPM-{{ stable }}-brightgreen" alt="NPM"/></a>
     <a href="https://github.com/Koromix/luigi/tree/master/koffi"><img src="https://img.shields.io/badge/GitHub-Koffi-ff6600" alt="GitHub"/></a>
+
+    <br><br>
+    <iframe src="https://github.com/sponsors/Koromix/button" title="Sponsor Koromix" height="35" width="116" style="border: 0;"></iframe>
 </div>

package/package.json

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

package/src/abi_arm64.cc

@@ -142,6 +142,11 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 
     int gpr_avail = 8;
     int vec_avail = 8;
+#ifdef _M_ARM64EC
+    if (func->variadic) {
+        gpr_avail = 4;
+    }
+#endif
 
     for (ParameterInfo &param: func->parameters) {
         switch (param.type->primitive) {
@@ -179,6 +184,23 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
             case PrimitiveKind::Record: {
                 int hfa = IsHFA(param.type);
 
+#ifdef _M_ARM64EC
+                if (func->variadic) {
+                    if (IsRegularSize(param.type->size, 8) && gpr_avail) {
+                        param.gpr_count = 1;
+                        gpr_avail--;
+                    } else {
+                        if (gpr_avail) {
+                            param.gpr_count = 1;
+                            gpr_avail--;
+                        }
+                        param.use_memory = true;
+                    }
+
+                    break;
+                }
+#endif
+
 #if defined(_WIN32)
                 if (param.variadic) {
                     hfa = 0;
@@ -210,7 +232,7 @@ bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
                     // Big types (more than 16 bytes) are replaced by a pointer
                     if (gpr_avail) {
                         param.gpr_count = 1;
-                        gpr_avail -= 1;
+                        gpr_avail--;
                     }
                     param.use_memory = true;
                 }
@@ -265,6 +287,18 @@ bool CallData::Prepare(const Napi::CallbackInfo &info)
         gpr_ptr[8] = (uint64_t)return_ptr;
     }
 
+#ifdef _M_ARM64EC
+    if (func->variadic) {
+        gpr_ptr[4] = (uint64_t)args_ptr;
+        gpr_ptr[5] = 0;
+
+        for (Size i = 4; i < func->parameters.len; i++) {
+            const ParameterInfo &param = func->parameters[i];
+            gpr_ptr[5] += std::max((Size)8, param.type->size);
+        }
+    }
+#endif
+
 #ifdef __APPLE__
     #define PUSH_INTEGER(CType) \
         do { \

package/src/abi_x64_win.cc

@@ -109,18 +109,12 @@ RG_STATIC_ASSERT(RG_LEN(Trampolines) == MaxTrampolines * 2);
 
 static RG_THREAD_LOCAL CallData *exec_call;
 
-static inline bool IsRegular(Size size)
-{
-    bool regular = (size <= 8 && !(size & (size - 1)));
-    return regular;
-}
-
 bool AnalyseFunction(Napi::Env, InstanceData *, FunctionInfo *func)
 {
-    func->ret.regular = IsRegular(func->ret.type->size);
+    func->ret.regular = IsRegularSize(func->ret.type->size, 8);
 
     for (ParameterInfo &param: func->parameters) {
-        param.regular = IsRegular(param.type->size);
+        param.regular = IsRegularSize(param.type->size, 8);
         func->forward_fp |= IsFloat(param.type);
     }
 

package/src/abi_x86.cc

@@ -115,12 +115,6 @@ RG_STATIC_ASSERT(RG_LEN(Trampolines) == MaxTrampolines * 2);
 
 static RG_THREAD_LOCAL CallData *exec_call;
 
-static inline bool IsRegular(Size size)
-{
-    bool regular = (size <= 8 && !(size & (size - 1)));
-    return regular;
-}
-
 bool AnalyseFunction(Napi::Env env, InstanceData *instance, FunctionInfo *func)
 {
     if (!func->lib && func->convention != CallConvention::Cdecl &&
@@ -137,7 +131,7 @@ bool AnalyseFunction(Napi::Env env, InstanceData *instance, FunctionInfo *func)
         func->ret.trivial = true;
 #if defined(_WIN32) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
     } else {
-        func->ret.trivial = IsRegular(func->ret.type->size);
+        func->ret.trivial = IsRegularSize(func->ret.type->size, 8);
 #endif
     }
 #ifndef _WIN32

package/src/call.cc

@@ -70,7 +70,7 @@ bool CallData::PushString(Napi::Value value, const char **out_str)
             status = napi_get_value_string_utf8(env, value, nullptr, 0, &len);
             RG_ASSERT(status == napi_ok);
 
-            buf = AllocateMemory<char>(&call_alloc, (Size)len + 1);
+            buf = AllocateSpan<char>(&call_alloc, (Size)len + 1);
 
             status = napi_get_value_string_utf8(env, value, buf.ptr, (size_t)buf.len, &len);
             RG_ASSERT(status == napi_ok);
@@ -109,7 +109,7 @@ bool CallData::PushString16(Napi::Value value, const char16_t **out_str16)
             status = napi_get_value_string_utf16(env, value, nullptr, 0, &len);
             RG_ASSERT(status == napi_ok);
 
-            buf = AllocateMemory<char16_t>(&call_alloc, ((Size)len + 1) * 2);
+            buf = AllocateSpan<char16_t>(&call_alloc, ((Size)len + 1) * 2);
 
             status = napi_get_value_string_utf16(env, value, buf.ptr, (size_t)buf.len, &len);
             RG_ASSERT(status == napi_ok);

package/src/call.hh

@@ -161,7 +161,7 @@ inline T *CallData::AllocHeap(Size size, Size align)
         int flags = 0;
 #endif
 
-        ptr = AllocateMemory<uint8_t>(&call_alloc, size + align, flags).ptr;
+        ptr = (uint8_t *)AllocateRaw(&call_alloc, size + align, flags);
         ptr = AlignUp(ptr, align);
 
         return ptr;

package/src/ffi.hh

@@ -28,7 +28,7 @@ static const int DefaultMaxAsyncCalls = 64;
 
 static const int MaxAsyncCalls = 256;
 static const Size MaxParameters = 32;
-static const Size MaxOutParameters = 4;
+static const Size MaxOutParameters = 8;
 static const Size MaxTrampolines = 16;
 
 extern const int TypeInfoMarker;

package/src/util.hh

@@ -47,6 +47,12 @@ static inline bool IsFloat(const TypeInfo *type)
     return fp;
 }
 
+static inline bool IsRegularSize(Size size, Size max)
+{
+    bool regular = (size <= max && !(size & (size - 1)));
+    return regular;
+}
+
 const TypeInfo *ResolveType(Napi::Value value, int *out_directions = nullptr);
 const TypeInfo *ResolveType(InstanceData *instance, Span<const char> str, int *out_directions = nullptr);
 const TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *type, int count = 1);

package/test/raylib.js

@@ -75,14 +75,26 @@ main();
 
 async function main() {
     try {
-        await test();
+        let display = false;
+
+        for (let i = 2; i < process.argv.length; i++) {
+            let arg = process.argv[i];
+
+            if (arg == '-d' || arg == '--display') {
+                display = true;
+            } else if (arg[0] == '-') {
+                throw new Error(`Unknown option '${process.argv[i]}'`)
+            }
+        }
+
+        await test(display);
     } catch (err) {
         console.error(err);
         process.exit(1);
     }
 }
 
-async function test() {
+async function test(display) {
     let lib_filename = __dirname + '/build/raylib' + koffi.extension;
     let lib = koffi.load(lib_filename);
 
@@ -94,11 +106,20 @@ async function test() {
     const MeasureTextEx = lib.func('MeasureTextEx', Vector2, [Font, 'str', 'float', 'float']);
     const ImageDrawTextEx = lib.func('ImageDrawTextEx', 'void', [koffi.pointer(Image), Font, 'str', Vector2, 'float', 'float', Color]);
     const ExportImage = lib.func('ExportImage', 'bool', [Image, 'str']);
+    const DrawTextEx = lib.func('DrawTextEx', 'void', [Font, 'str', Vector2, 'float', 'float', Color]);
+    const BeginDrawing = lib.func('BeginDrawing', 'void', []);
+    const EndDrawing = lib.func('EndDrawing', 'void', []);
+    const ClearBackground = lib.func('ClearBackground', 'void', [Color]);
+    const LoadTextureFromImage = lib.func('LoadTextureFromImage', 'Texture', [Image]);
+    const DrawTexture = lib.func('DrawTexture', 'void', [Texture, 'int', 'int', Color]);
+    const WindowShouldClose = lib.func('WindowShouldClose', 'bool', []);
+    const PollInputEvents = lib.func('PollInputEvents', 'void', []);
 
     // We need to call InitWindow before using anything else (such as fonts)
     SetTraceLogLevel(4); // Warnings
-    SetWindowState(0x80); // Hidden
-    InitWindow(640, 480, "Raylib Test");
+    if (!display)
+        SetWindowState(0x80); // Hidden
+    InitWindow(800, 600, "Raylib Test");
 
     let img = GenImageColor(800, 600, { r: 0, g: 0, b: 0, a: 255 });
     let font = GetFontDefault();
@@ -122,6 +143,17 @@ async function test() {
         ImageDrawTextEx(img, font, text, pos, 10, 1, color);
     }
 
+    if (display) {
+        BeginDrawing();
+        ClearBackground({r: 0, g: 0, b: 0, a: 255});
+        let tex = LoadTextureFromImage(img);
+        DrawTexture(tex, 0, 0, {r: 255, g: 255, b: 255, a: 255});
+        EndDrawing();
+
+        while (!WindowShouldClose())
+            PollInputEvents();
+    }
+
     // In theory we could directly checksum the image data, but we can't do it easily right now
     // until koffi gives us something to transform a pointer to a buffer.
     let tmp_dir = fs.mkdtempSync(path.join(os.tmpdir(), 'raylib'));
@@ -144,7 +176,7 @@ async function test() {
                 reject(err);
             }
         });
-        let expected = '5ec23005377082582a14d261f5d07f51a6615b3bcdf5b91ada29aba65da22c5f';
+        let expected = '3cd12ec1cf3d001abe5526c8529fc445ebd2aa710e75cf277b33e59db1e51eb4';
 
         console.log('Computed checksum: ' + sha256);
         console.log('Expected: ' + expected);