koffi 1.2.0-alpha.3 → 1.2.0-alpha.4

package/src/call.hh

@@ -70,7 +70,7 @@ public:
 
     void Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg);
 
-    void DumpDebug() const;
+    void DumpForward() const;
 
 private:
     template <typename T = void>
@@ -80,12 +80,12 @@ private:
 
     const char *PushString(const Napi::Value &value);
     const char16_t *PushString16(const Napi::Value &value);
-    bool PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t *dest, int16_t realign = 0);
-    bool PushArray(const Napi::Value &obj, const TypeInfo *type, uint8_t *dest, int16_t realign = 0);
+    bool PushObject(const Napi::Object &obj, const TypeInfo *type, uint8_t *origin, int16_t realign = 0);
+    bool PushArray(const Napi::Value &obj, const TypeInfo *type, uint8_t *origin, int16_t realign = 0);
 
-    void PopObject(Napi::Object obj, const uint8_t *src, const TypeInfo *type, int16_t realign = 0);
-    Napi::Object PopObject(const uint8_t *src, const TypeInfo *type, int16_t realign = 0);
-    Napi::Value PopArray(const uint8_t *src, const TypeInfo *type, int16_t realign = 0);
+    void PopObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type, int16_t realign = 0);
+    Napi::Object PopObject(const uint8_t *origin, const TypeInfo *type, int16_t realign = 0);
+    Napi::Value PopArray(const uint8_t *origin, const TypeInfo *type, int16_t realign = 0);
 
     Size ReserveTrampoline(const FunctionInfo *proto, Napi::Function func);
 };

package/src/ffi.cc

@@ -565,7 +565,7 @@ static Napi::Value TranslateNormalCall(const Napi::CallbackInfo &info)
         return env.Null();
 
     if (instance->debug) {
-        call.DumpDebug();
+        call.DumpForward();
     }
     call.Execute();
 
@@ -633,7 +633,7 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
         return env.Null();
 
     if (instance->debug) {
-        call.DumpDebug();
+        call.DumpForward();
     }
     call.Execute();
 
@@ -664,7 +664,7 @@ public:
 
         return prepared;
     }
-    void DumpDebug() { call.DumpDebug(); }
+    void DumpForward() { call.DumpForward(); }
 
     void Execute() override;
     void OnOK() override;
@@ -714,7 +714,7 @@ static Napi::Value TranslateAsyncCall(const Napi::CallbackInfo &info)
     AsyncCall *async = new AsyncCall(env, instance, func, mem, callback);
 
     if (async->Prepare(info) && instance->debug) {
-        async->DumpDebug();
+        async->DumpForward();
     }
     async->Queue();
 

package/src/util.cc

@@ -167,4 +167,21 @@ int IsHFA(const TypeInfo *type, int min, int max)
     return hfa ? count : 0;
 }
 
+void DumpMemory(const char *type, Span<const uint8_t> bytes)
+{
+    if (bytes.len) {
+        PrintLn(stderr, "%1 at 0x%2 (%3):", type, bytes.ptr, FmtMemSize(bytes.len));
+
+        for (const uint8_t *ptr = bytes.begin(); ptr < bytes.end();) {
+            Print(stderr, "  [0x%1 %2 %3]  ", FmtArg(ptr).Pad0(-16),
+                                              FmtArg((ptr - bytes.begin()) / sizeof(void *)).Pad(-4),
+                                              FmtArg(ptr - bytes.begin()).Pad(-4));
+            for (int i = 0; ptr < bytes.end() && i < (int)sizeof(void *); i++, ptr++) {
+                Print(stderr, " %1", FmtHex(*ptr).Pad0(-2));
+            }
+            PrintLn(stderr);
+        }
+    }
+}
+
 }

package/src/util.hh

@@ -107,4 +107,6 @@ int AnalyseFlat(const TypeInfo *type, FunctionRef<void(const TypeInfo *type, int
 
 int IsHFA(const TypeInfo *type, int min, int max);
 
+void DumpMemory(const char *type, Span<const uint8_t> bytes);
+
 }

package/test/async.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see https://www.gnu.org/licenses/.
+
+const koffi = require('./build/koffi.node');
+const assert = require('assert');
+const path = require('path');
+
+const PackedBFG = koffi.pack('PackedBFG', {
+    a: 'int8_t',
+    b: 'int64_t',
+    c: 'char',
+    d: 'string',
+    e: 'short',
+    inner: koffi.pack({
+        f: 'float',
+        g: 'double'
+    })
+});
+
+main();
+
+async function main() {
+    try {
+        await test();
+        console.log('Success!');
+    } catch (err) {
+        console.error(err);
+        process.exit(1);
+    }
+}
+
+async function test() {
+    const lib_filename = path.dirname(__filename) + '/build/misc' + koffi.extension;
+    const lib = koffi.load(lib_filename);
+
+    const ConcatenateToInt1 = lib.func('ConcatenateToInt1', 'int64_t', Array(12).fill('int8_t'));
+    const MakePackedBFG = lib.func('PackedBFG __fastcall MakePackedBFG(int x, double y, _Out_ PackedBFG *p, const char *str)');
+
+    let promises = [];
+
+    // Issue several async calls
+    for (let i = 0; i < 64; i++) {
+        let p = new Promise((resolve, reject) => {
+            try {
+                ConcatenateToInt1.async(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7, (err, res) => {
+                    assert.equal(err, null);
+                    assert.equal(res, 561239440687n);
+                });
+                resolve();
+            } catch (err) {
+                reject(err);
+            }
+        });
+        promises.push(p);
+    }
+
+    // Make a few synchronous calls while the asynchronous ones are still in the air
+    assert.equal(ConcatenateToInt1(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
+    assert.equal(ConcatenateToInt1(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
+    assert.equal(ConcatenateToInt1(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
+
+    // Async complex call
+    {
+        let out = {};
+        let p = new Promise((resolve, reject) => {
+            try {
+                MakePackedBFG.async(2, 7, out, '__Hello123456789++++foobarFOOBAR!__', (err, res) => {
+                    assert.deepEqual(res, { a: 2, b: 4, c: -25, d: 'X/__Hello123456789++++foobarFOOBAR!__/X', e: 54, inner: { f: 14, g: 5 } });
+                    assert.deepEqual(out, res);
+                });
+                resolve();
+            } catch (err) {
+                reject(err);
+            }
+        });
+        promises.push(p);
+    }
+
+    await Promise.all(promises);
+}

package/test/callbacks.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see https://www.gnu.org/licenses/.
+
+const koffi = require('./build/koffi.node');
+const assert = require('assert');
+const path = require('path');
+
+const BFG = koffi.struct('BFG', {
+    a: 'int8_t',
+    b: 'int64_t',
+    c: 'char',
+    d: 'string',
+    e: 'short',
+    inner: koffi.struct({
+        f: 'float',
+        g: 'double'
+    })
+});
+
+const SimpleCallback = koffi.callback('int SimpleCallback(const char *str)');
+const RecursiveCallback = koffi.callback('RecursiveCallback', 'float', ['int', 'string', 'double']);
+const BigCallback = koffi.callback('BFG BigCallback(BFG bfg)');
+
+main();
+
+async function main() {
+    try {
+        await test();
+        console.log('Success!');
+    } catch (err) {
+        console.error(err);
+        process.exit(1);
+    }
+}
+
+async function test() {
+    const lib_filename = path.dirname(__filename) + '/build/misc' + koffi.extension;
+    const lib = koffi.load(lib_filename);
+
+    const CallJS = lib.func('int CallJS(const char *str, SimpleCallback cb)');
+    const CallRecursiveJS = lib.func('float CallRecursiveJS(int i, RecursiveCallback func)');
+    const ModifyBFG = lib.func('BFG ModifyBFG(int x, double y, const char *str, BigCallback func, _Out_ BFG *p)');
+
+    // Simple test similar to README example
+    {
+        let ret = CallJS('Niels', str => {
+            assert.equal(str, 'Hello Niels!');
+            return 42;
+        });
+        assert.equal(ret, 42);
+    }
+
+    // Test with recursion
+    {
+        let recurse = (i, str, d) => {
+            assert.equal(str, 'Hello!');
+            assert.equal(d, 42.0);
+            return i + (i ? CallRecursiveJS(i - 1, recurse) : 0);
+        };
+        let total = CallRecursiveJS(9, recurse);
+        assert.equal(total, 45);
+    }
+
+    // And now, with a complex struct
+    {
+        let out = {};
+        let bfg = ModifyBFG(2, 5, "Yo!", bfg => {
+            bfg.inner.f *= -1;
+            bfg.d = "New!";
+            return bfg;
+        }, out);
+        assert.deepEqual(bfg, { a: 2, b: 4, c: -25, d: 'New!', e: 54, inner: { f: -10, g: 3 } });
+        assert.deepEqual(out, { a: 2, b: 4, c: -25, d: 'X/Yo!/X', e: 54, inner: { f: 10, g: 3 } });
+    }
+}

package/test/misc.c

@@ -472,15 +472,35 @@ EXPORT int64_t ThroughInt64IS(SingleI64 s)
     return s.v;
 }
 
-EXPORT float CallSimpleJS(int i, float (*func)(int i, const char *str, double d))
+EXPORT int CallJS(const char *str, int (*cb)(const char *str))
+{
+    char buf[64];
+    snprintf(buf, sizeof(buf), "Hello %s!", str);
+    return cb(buf);
+}
+
+EXPORT float CallRecursiveJS(int i, float (*func)(int i, const char *str, double d))
 {
     float f = func(i, "Hello!", 42.0);
     return f;
 }
 
-EXPORT int TransferToJS(const char *str, int (*cb)(const char *str))
+EXPORT BFG ModifyBFG(int x, double y, const char *str, BFG (*func)(BFG bfg), BFG *p)
 {
-    char buf[64];
-    snprintf(buf, sizeof(buf), "Hello %s!", str);
-    return cb(buf);
+    BFG bfg;
+
+    static char buf[64];
+    snprintf(buf, sizeof(buf), "X/%s/X", str);
+
+    bfg.a = x;
+    bfg.b = x * 2;
+    bfg.c = x - 27;
+    bfg.d = buf;
+    bfg.e = x * 27;
+    bfg.inner.f = (float)y * x;
+    bfg.inner.g = (double)y - x;
+    *p = bfg;
+
+    bfg = func(bfg);
+    return bfg;
 }

package/test/sqlite.js

@@ -45,32 +45,61 @@ async function test() {
     const sqlite3_reset = lib.func('sqlite3_reset', 'int', [sqlite3_stmt]);
     const sqlite3_bind_text = lib.func('sqlite3_bind_text', 'int', [sqlite3_stmt, 'int', 'string', 'int', 'void *']);
     const sqlite3_bind_int = lib.func('sqlite3_bind_int', 'int', [sqlite3_stmt, 'int', 'int']);
+    const sqlite3_column_text = lib.func('sqlite3_column_text', 'string', [sqlite3_stmt, 'int']);
+    const sqlite3_column_int = lib.func('sqlite3_column_int', 'int', [sqlite3_stmt, 'int']);
     const sqlite3_step = lib.func('sqlite3_step', 'int', [sqlite3_stmt]);
     const sqlite3_finalize = lib.func('sqlite3_finalize', 'int', [sqlite3_stmt]);
     const sqlite3_close_v2 = lib.func('sqlite3_close_v2', 'int', [sqlite3_db]);
 
+    const SQLITE_OPEN_READWRITE = 0x2;
+    const SQLITE_OPEN_CREATE = 0x4;
+    const SQLITE_ROW = 100;
+    const SQLITE_DONE = 101;
+
     let filename = await create_temporary_file(path.join(os.tmpdir(), 'test_sqlite'));
     let db = {};
 
+    let expected = Array.from(Array(200).keys()).map(i => [`TXT ${i}`, i % 7]);
+
     try {
-        if (sqlite3_open_v2(filename, db, 0x2 | 0x4, null) != 0)
+        if (sqlite3_open_v2(filename, db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, null) != 0)
             throw new Error('Failed to open database');
         if (sqlite3_exec(db, 'CREATE TABLE foo (id INTEGER PRIMARY KEY, bar TEXT, value INT);', null, null, null) != 0)
             throw new Error('Failed to create table');
 
         let stmt = {};
+
         if (sqlite3_prepare_v2(db, "INSERT INTO foo (bar, value) VALUES (?1, ?2)", -1, stmt, null) != 0)
             throw new Error('Failed to prepare insert statement for table foo');
-        for (let i = 0; i < 200; i++) {
+        for (let it of expected) {
             sqlite3_reset(stmt);
 
-            sqlite3_bind_text(stmt, 1, `TXT ${i}`, -1, null);
-            sqlite3_bind_int(stmt, 2, i * 2);
+            sqlite3_bind_text(stmt, 1, it[0], -1, null);
+            sqlite3_bind_int(stmt, 2, it[1]);
 
-            if (sqlite3_step(stmt) != 101)
+            if (sqlite3_step(stmt) != SQLITE_DONE)
                 throw new Erorr('Failed to insert new test row');
         }
         sqlite3_finalize(stmt);
+
+        if (sqlite3_prepare_v2(db, "SELECT id, bar, value FROM foo ORDER BY id", -1, stmt, null) != 0)
+            throw new Error('Failed to prepare select statement for table foo');
+        for (let i = 0; i < expected.length; i++) {
+            let it = expected[i];
+
+            if (sqlite3_step(stmt) != SQLITE_ROW)
+                throw new Error('Missing row');
+
+            if (sqlite3_column_int(stmt, 0) != i + 1)
+                throw new Error('Invalid data');
+            if (sqlite3_column_text(stmt, 1) != it[0])
+                throw new Error('Invalid data');
+            if (sqlite3_column_int(stmt, 2) != it[1])
+                throw new Error('Invalid data');
+        }
+        if (sqlite3_step(stmt) != SQLITE_DONE)
+            throw new Error('Unexpected end of statement');
+        sqlite3_finalize(stmt);
     } finally {
         sqlite3_close_v2(db);
         fs.unlinkSync(filename);