koffi 2.1.4 → 2.2.0

package/src/koffi/test/callbacks.js

@@ -28,12 +28,19 @@ const BFG = koffi.struct('BFG', {
     })
 });
 
+const Vec2 = koffi.struct('Vec2', {
+    x: 'double',
+    y: 'double'
+});
+
 const SimpleCallback = koffi.callback('int SimpleCallback(const char *str)');
 const RecursiveCallback = koffi.callback('RecursiveCallback', 'float', ['int', 'str', 'double']);
 const BigCallback = koffi.callback('BFG BigCallback(BFG bfg)');
 const SuperCallback = koffi.callback('void SuperCallback(int i, int v1, double v2, int v3, int v4, int v5, int v6, float v7, int v8)');
 const ApplyCallback = koffi.callback('int __stdcall ApplyCallback(int a, int b, int c)');
 const IntCallback = koffi.callback('int IntCallback(int x)');
+const VectorCallback = koffi.callback('int VectorCallback(int len, Vec2 *vec)');
+const SortCallback = koffi.callback('int SortCallback(const void *ptr1, const void *ptr2)');
 
 const StructCallbacks = koffi.struct('StructCallbacks', {
     first: koffi.pointer(IntCallback),
@@ -66,6 +73,8 @@ async function test() {
     const ApplyStruct = lib.func('int ApplyStruct(int x, StructCallbacks callbacks)');
     const SetCallback = lib.func('void SetCallback(IntCallback *func)');
     const CallCallback = lib.func('int CallCallback(int x)');
+    const MakeVectors = lib.func('int MakeVectors(int len, VectorCallback *func)');
+    const CallQSort = lib.func('void CallQSort(_Inout_ void *base, size_t nmemb, size_t size, SortCallback *cb)');
 
     // Simple test similar to README example
     {
@@ -160,4 +169,65 @@ async function test() {
         assert.equal(koffi.unregister(cb), null);
         assert.throws(() => koffi.unregister(cb));
     }
+
+    // Register with binding
+    {
+        class Multiplier {
+            constructor(k) { this.k = k; }
+            multiply(x) { return this.k * x; }
+        }
+
+        let mult = new Multiplier(5);
+        let cb = koffi.register(mult, mult.multiply, 'IntCallback *');
+
+        SetCallback(cb);
+        assert.equal(CallCallback(42), 5 * 42);
+
+        assert.equal(koffi.unregister(cb), null);
+        assert.throws(() => koffi.unregister(cb));
+    }
+
+    // Test decoding callback pointers
+    {
+        assert.equal(koffi.offsetof('Vec2', 'x'), 0);
+        assert.equal(koffi.offsetof('Vec2', 'y'), 8);
+
+        let ret = MakeVectors(5, (len, ptr) => {
+            assert.equal(len, 5);
+
+            for (let i = 0; i < len; i++) {
+                let x = koffi.decode(ptr, i * koffi.sizeof('Vec2'), 'double');
+                let y = koffi.decode(ptr, i * koffi.sizeof('Vec2') + 8, 'double');
+
+                assert.equal(x, i);
+                assert.equal(y, -i);
+            }
+
+            for (let i = 0; i < len; i++) {
+                let vec = koffi.decode(ptr, i * koffi.sizeof('Vec2'), 'Vec2');
+                assert.deepEqual(vec, { x: i, y: -i });
+            }
+
+            let all = koffi.decode(ptr, koffi.array('double', 10, 'array'), 10);
+            assert.deepEqual(all, [0, 0, 1, -1, 2, -2, 3, -3, 4, -4]);
+
+            return 424242;
+        });
+
+        assert.equal(ret, 424242);
+    }
+
+    // Test koffi.as() and koffi.decode() with qsort
+    {
+        let array = ['foo', 'bar', '123', 'foobar'];
+
+        CallQSort(koffi.as(array, 'char **'), array.length, koffi.sizeof('void *'), (ptr1, ptr2) => {
+            let str1 = koffi.decode(ptr1, 'char *');
+            let str2 = koffi.decode(ptr2, 'char *');
+
+            return str1.localeCompare(str2);
+        });
+
+        assert.deepEqual(array, ['123', 'bar', 'foo', 'foobar']);
+    }
 }

package/src/koffi/test/misc.c

@@ -162,6 +162,14 @@ typedef struct BigText {
     char text[262145];
 } BigText;
 
+typedef struct Vec2 {
+    double x;
+    double y;
+} Vec2;
+
+typedef int VectorCallback(int len, Vec2 *vec);
+typedef int SortCallback(const void *ptr1, const void *ptr2);
+
 EXPORT int8_t GetMinusOne1(void)
 {
     return -1;
@@ -709,3 +717,62 @@ EXPORT BigText ReverseBigText(BigText buf)
     }
     return ret;
 }
+
+EXPORT int MakeVectors(int len, VectorCallback *func)
+{
+    Vec2 vectors[512];
+
+    for (int i = 0; i < len; i++) {
+        vectors[i].x = (double)i;
+        vectors[i].y = (double)-i;
+    }
+
+    int ret = func(len, vectors);
+
+    return ret;
+}
+
+EXPORT size_t UpperCaseStrAscii(const char *str, char *out)
+{
+    size_t len = 0;
+
+    while (str[len]) {
+        char c = str[len];
+
+        if (c >= 'a' && c <= 'z') {
+            out[len] = (char)(c - 32);
+        } else {
+            out[len] = c;
+        }
+
+        len++;
+    }
+    out[len] = 0;
+
+    return len;
+}
+
+EXPORT size_t UpperCaseStrAscii16(const char16_t *str, char16_t *out)
+{
+    size_t len = 0;
+
+    while (str[len]) {
+        char16_t c = str[len];
+
+        if (c >= 'a' && c <= 'z') {
+            out[len] = (char16_t)(c - 32);
+        } else {
+            out[len] = c;
+        }
+
+        len++;
+    }
+    out[len] = 0;
+
+    return len;
+}
+
+EXPORT void CallQSort(void *base, size_t nmemb, size_t size, SortCallback *cb)
+{
+    qsort(base, nmemb, size, cb);
+}

package/src/koffi/test/raylib.js

@@ -145,9 +145,9 @@ async function test(display) {
 
     if (display) {
         BeginDrawing();
-        ClearBackground({r: 0, g: 0, b: 0, a: 255});
+        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});
+        DrawTexture(tex, 0, 0, { r: 255, g: 255, b: 255, a: 255 });
         EndDrawing();
 
         while (!WindowShouldClose())

package/src/koffi/test/sqlite.js

@@ -36,7 +36,7 @@ async function main() {
 }
 
 async function test() {
-    let lib_filename = __dirname + '/build/sqlite3mc' + koffi.extension;
+    let lib_filename = __dirname + '/build/sqlite3' + koffi.extension;
     let lib = koffi.load(lib_filename);
 
     const sqlite3_open_v2 = lib.func('sqlite3_open_v2', 'int', ['str', koffi.out(koffi.pointer(sqlite3, 2)), 'int', 'str']);

package/src/koffi/test/sync.js

@@ -173,9 +173,9 @@ async function test() {
     const ConcatenateToInt1 = lib.func('ConcatenateToInt1', 'int64_t', Array(12).fill('int8_t'));
     const ConcatenateToInt4 = lib.func('ConcatenateToInt4', 'int64_t', Array(12).fill('int32_t'));
     const ConcatenateToInt8 = lib.func('ConcatenateToInt8', 'int64_t', Array(12).fill('int64_t'));
-    const ConcatenateToStr1 = lib.func('ConcatenateToStr1', 'str', [...Array(8).fill('int8_t'), koffi.struct('IJK1', {i: 'int8_t', j: 'int8_t', k: 'int8_t'}), 'int8_t']);
-    const ConcatenateToStr4 = lib.func('ConcatenateToStr4', 'str', [...Array(8).fill('int32_t'), koffi.pointer(koffi.struct('IJK4', {i: 'int32_t', j: 'int32_t', k: 'int32_t'})), 'int32_t']);
-    const ConcatenateToStr8 = lib.func('ConcatenateToStr8', 'str', [...Array(8).fill('int64_t'), koffi.struct('IJK8', {i: 'int64_t', j: 'int64_t', k: 'int64_t'}), 'int64_t']);
+    const ConcatenateToStr1 = lib.func('ConcatenateToStr1', 'str', [...Array(8).fill('int8_t'), koffi.struct('IJK1', { i: 'int8_t', j: 'int8_t', k: 'int8_t' }), 'int8_t']);
+    const ConcatenateToStr4 = lib.func('ConcatenateToStr4', 'str', [...Array(8).fill('int32_t'), koffi.pointer(koffi.struct('IJK4', { i: 'int32_t', j: 'int32_t', k: 'int32_t' })), 'int32_t']);
+    const ConcatenateToStr8 = lib.func('ConcatenateToStr8', 'str', [...Array(8).fill('int64_t'), koffi.struct('IJK8', { i: 'int64_t', j: 'int64_t', k: 'int64_t' }), 'int64_t']);
     const MakeBFG = lib.func('BFG __stdcall MakeBFG(_Out_ BFG *p, int x, double y, const char *str)');
     const MakePackedBFG = lib.func('AliasBFG __fastcall MakePackedBFG(int x, double y, _Out_ PackedBFG *p, const char *str)');
     const MakePolymorphBFG = lib.func('void MakePolymorphBFG(int type, int x, double y, const char *str, _Out_ void *p)');
@@ -224,6 +224,8 @@ async function test() {
     const ReturnEndianInt8UL = lib.func('uint64_le_t ReturnEndianInt8(uint64_be_t v)');
     const ReturnEndianInt8UB = lib.func('uint64_be_t ReturnEndianInt8(uint64_le_t v)');
     const ReverseBigText = lib.func('BigText ReverseBigText(BigText buf)');
+    const UpperCaseStrAscii = lib.func('size_t UpperCaseStrAscii(const char *str, _Out_ char *out)');
+    const UpperCaseStrAscii16 = lib.func('size_t UpperCaseStrAscii16(const char16_t *str16, _Out_ char16_t *out)');
 
     // Simple signed value returns
     assert.equal(GetMinusOne1(), -1);
@@ -312,9 +314,9 @@ async function test() {
         assert.equal(ConcatenateToInt1(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687);
         assert.equal(ConcatenateToInt4(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687);
         assert.equal(ConcatenateToInt8(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687);
-        assert.equal(ConcatenateToStr1(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');
-        assert.equal(ConcatenateToStr4(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');
-        assert.equal(ConcatenateToStr8(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');
+        assert.equal(ConcatenateToStr1(5, 6, 1, 2, 3, 9, 4, 4, { i: 0, j: 6, k: 8 }, 7), '561239440687');
+        assert.equal(ConcatenateToStr4(5, 6, 1, 2, 3, 9, 4, 4, { i: 0, j: 6, k: 8 }, 7), '561239440687');
+        assert.equal(ConcatenateToStr8(5, 6, 1, 2, 3, 9, 4, 4, { i: 0, j: 6, k: 8 }, 7), '561239440687');
     }
 
     // Big struct
@@ -516,4 +518,24 @@ async function test() {
         assert.equal(ret.len, big.len);
         assert.equal(Buffer.from(ret.text).toString(), expected);
     }
+
+    // Test output string arguments
+    {
+        let str = ['\0'.repeat(32)];
+
+        let len = UpperCaseStrAscii('fooBAR_1x3', str);
+
+        assert.equal(len, 10);
+        assert.equal(str[0], 'FOOBAR_1X3');
+    }
+
+    // Test output string16 arguments
+    {
+        let str = ['\0'.repeat(32)];
+
+        let len = UpperCaseStrAscii16('fooBAR_1x3', str);
+
+        assert.equal(len, 10);
+        assert.equal(str[0], 'FOOBAR_1X3');
+    }
 }

package/vendor/brotli/c/common/platform.h

@@ -280,6 +280,8 @@ OR:
 
 #if defined(BROTLI_BUILD_PORTABLE)
 #define BROTLI_ALIGNED_READ (!!1)
+#elif !defined(NDEBUG)
+#define BROTLI_ALIGNED_READ (!!1)
 #elif defined(BROTLI_TARGET_X86) || defined(BROTLI_TARGET_X64) || \
     defined(BROTLI_TARGET_ARMV7) || defined(BROTLI_TARGET_ARMV8_ANY) || \
     defined(BROTLI_TARGET_RISCV64)