koffi 2.1.1 → 2.1.3

package/ChangeLog.md

@@ -2,6 +2,18 @@
 
 ## History
 
+### Koffi 2.1.3
+
+**Main changes:**
+
+- Support up to 16 output parameters (instead of 8)
+
+### Koffi 2.1.2
+
+**Main changes:**
+
+- Support up to 8 output parameters (instead of 4)
+
 ### Koffi 2.1.1
 
 **Main fixes:**

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.1",
-  "stable": "2.1.1",
+  "version": "2.1.3",
+  "stable": "2.1.3",
   "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/ffi.cc

@@ -684,7 +684,7 @@ static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value r
             return false;
         }
         if ((param.directions & 2) && ++func->out_parameters >= MaxOutParameters) {
-            ThrowError<Napi::TypeError>(env, "Functions cannot have more than out %1 parameters", MaxOutParameters);
+            ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 output parameters", MaxOutParameters);
             return false;
         }
 
@@ -1031,7 +1031,7 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
             return env.Null();
         }
         if (RG_UNLIKELY((param.directions & 2) && ++func.out_parameters >= MaxOutParameters)) {
-            ThrowError<Napi::TypeError>(env, "Functions cannot have more than out %1 parameters", MaxOutParameters);
+            ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 output parameters", MaxOutParameters);
             return env.Null();
         }
 

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 = 16;
 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);