koffi 1.3.12 → 2.0.0

package/src/ffi.hh

@@ -51,6 +51,7 @@ enum class PrimitiveKind {
     Array,
     Float32,
     Float64,
+    Prototype,
     Callback
 };
 static const char *const PrimitiveKindNames[] = {
@@ -71,6 +72,7 @@ static const char *const PrimitiveKindNames[] = {
     "Array",
     "Float32",
     "Float64",
+    "Prototype",
     "Callback"
 };
 
@@ -78,6 +80,8 @@ struct TypeInfo;
 struct RecordMember;
 struct FunctionInfo;
 
+typedef void DisposeFunc (Napi::Env env, const TypeInfo *type, const void *ptr);
+
 struct TypeInfo {
     enum class ArrayHint {
         Array,
@@ -87,16 +91,22 @@ struct TypeInfo {
 
     const char *name;
 
-    Napi::ObjectReference defn;
-
     PrimitiveKind primitive;
     int16_t size;
     int16_t align;
 
+    DisposeFunc *dispose;
+    Napi::FunctionReference dispose_ref;
+
     HeapArray<RecordMember> members; // Record only
-    const TypeInfo *ref; // Pointer or array
+    union {
+        const void *marker;
+        const TypeInfo *type; // Pointer or array
+        const FunctionInfo *proto; // Callback only
+    } ref;
     ArrayHint hint; // Array only
-    const FunctionInfo *proto; // Callback only
+
+    mutable Napi::ObjectReference defn;
 
     RG_HASHTABLE_HANDLER(TypeInfo, name);
 };
@@ -104,7 +114,7 @@ struct TypeInfo {
 struct RecordMember {
     const char *name;
     const TypeInfo *type;
-    int16_t align;
+    int16_t offset;
 };
 
 struct LibraryHolder {
@@ -199,6 +209,7 @@ struct InstanceMemory {
     Span<uint8_t> heap;
 
     uint16_t generation; // Can wrap without risk
+
     int16_t depth;
     bool temporary;
 };
@@ -206,14 +217,15 @@ struct InstanceMemory {
 struct TrampolineInfo {
     const FunctionInfo *proto;
     Napi::FunctionReference func;
-    uint16_t generation;
+
+    int32_t generation;
 };
 
 struct InstanceData {
     ~InstanceData();
 
     BucketArray<TypeInfo> types;
-    HashTable<const char *, TypeInfo *> types_map;
+    HashMap<const char *, const TypeInfo *> types_map;
     BucketArray<FunctionInfo> callbacks;
 
     bool debug;
@@ -222,8 +234,10 @@ struct InstanceData {
     LocalArray<InstanceMemory *, 9> memories;
     int temporaries = 0;
 
-    TrampolineInfo trampolines[MaxTrampolines];
-    uint32_t free_trampolines = UINT32_MAX;
+    TrampolineInfo trampolines[MaxTrampolines * 2];
+    int16_t next_trampoline = 0;
+    int16_t temp_trampolines = 0;
+    uint32_t registered_trampolines = 0;
 
     BlockAllocator str_alloc;
 

package/src/parser.cc

@@ -66,8 +66,9 @@ bool PrototypeParser::Parse(const char *str, FunctionInfo *out_func)
 
             param.type = ParseType();
             if (param.type->primitive == PrimitiveKind::Void ||
-                    param.type->primitive == PrimitiveKind::Array) {
-                MarkError("Type %1 cannot be used as a parameter", param.type->name);
+                    param.type->primitive == PrimitiveKind::Array ||
+                    param.type->primitive == PrimitiveKind::Prototype) {
+                MarkError("Type %1 cannot be used as a parameter (maybe try %1 *)", param.type->name);
                 return false;
             }
 
@@ -144,60 +145,36 @@ void PrototypeParser::Tokenize(const char *str)
 
 const TypeInfo *PrototypeParser::ParseType()
 {
-    HeapArray<char> buf(&instance->str_alloc);
-
-    Size indirect = 0;
-
     Size start = offset;
-    while (offset < tokens.len && IsIdentifier(tokens[offset])) {
-        Span<const char> tok = tokens[offset++];
 
-        if (tok != "const") {
-            buf.Append(tok);
-            buf.Append(' ');
-        }
-    }
-    if (offset == start) {
-        if (offset < tokens.len) {
-            MarkError("Unexpected token '%1', expected type", tokens[offset]);
-        } else {
-            MarkError("Unexpected end of prototype, expected type");
-        }
+    if (offset >= tokens.len) {
+        MarkError("Unexpected end of prototype, expected type");
+        return instance->types_map.FindValue("void", nullptr);
+    } else if (!IsIdentifier(tokens[offset])) {
+        MarkError("Unexpected token '%1', expected type", tokens[offset]);
         return instance->types_map.FindValue("void", nullptr);
     }
-    while (offset < tokens.len && tokens[offset] == "*") {
+
+    while (offset < tokens.len && (IsIdentifier(tokens[offset]) ||
+                                   tokens[offset] == '*')) {
         offset++;
-        indirect++;
     }
-    buf.ptr[--buf.len] = 0;
+    offset += (offset < tokens.len && tokens[offset] == "!");
 
-    while (buf.len) {
-        const TypeInfo *type = instance->types_map.FindValue(buf.ptr, nullptr);
+    while (offset >= start) {
+        Span<const char> str = MakeSpan(tokens[start].ptr, tokens[offset].end() - tokens[start].ptr);
+        const TypeInfo *type = ResolveType(instance, str);
 
         if (type) {
-            for (Size i = 0; i < indirect; i++) {
-                type = GetPointerType(instance, type);
-                RG_ASSERT(type);
-            }
+            offset++;
             return type;
         }
 
-        // Truncate last token
-        {
-            Span<const char> remain;
-            SplitStrReverse(buf, ' ', &remain);
-            buf.len = remain.len;
-            buf.ptr[buf.len] = 0;
-        }
-
-        if (indirect) {
-            offset -= indirect;
-            indirect = 0;
-        }
         offset--;
     }
+    offset = start;
 
-    MarkError("Unknown type '%1'", tokens[start]);
+    MarkError("Unknown or invalid type name '%1'", tokens[offset]);
     return instance->types_map.FindValue("void", nullptr);
 }
 

package/src/util.cc

@@ -20,21 +20,20 @@
 
 namespace RG {
 
-const TypeInfo *ResolveType(const InstanceData *instance, Napi::Value value, int *out_directions)
+const TypeInfo *ResolveType(Napi::Value value, int *out_directions)
 {
+    Napi::Env env = value.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
     if (value.IsString()) {
         std::string str = value.As<Napi::String>();
-
-        const TypeInfo *type = instance->types_map.FindValue(str.c_str(), nullptr);
+        const TypeInfo *type = ResolveType(instance, str.c_str(), out_directions);
 
         if (!type) {
-            ThrowError<Napi::TypeError>(value.Env(), "Unknown type name '%1'", str.c_str());
+            ThrowError<Napi::TypeError>(env, "Unknown or invalid type name '%1'", str.c_str());
             return nullptr;
         }
 
-        if (out_directions) {
-            *out_directions = 1;
-        }
         return type;
     } else if (CheckValueTag(instance, value, &TypeInfoMarker)) {
         Napi::External<TypeInfo> external = value.As<Napi::External<TypeInfo>>();
@@ -49,45 +48,132 @@ const TypeInfo *ResolveType(const InstanceData *instance, Napi::Value value, int
         }
         return type;
     } else {
-        ThrowError<Napi::TypeError>(value.Env(), "Unexpected %1 value as type specifier, expected string or type", GetValueType(instance, value));
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value as type specifier, expected string or type", GetValueType(instance, value));
         return nullptr;
     }
 }
 
-const TypeInfo *GetPointerType(InstanceData *instance, const TypeInfo *ref)
+const TypeInfo *ResolveType(InstanceData *instance, Span<const char> str, int *out_directions)
 {
-    // Special cases
-    if (TestStr(ref->name, "char")) {
-        return instance->types_map.FindValue("string", nullptr);
-    } else if (TestStr(ref->name, "char16") || TestStr(ref->name, "char16_t")) {
-        return instance->types_map.FindValue("string16", nullptr);
+    Span<const char> remain = TrimStr(str);
+
+    int indirect = 0;
+    bool dispose = false;
+
+    while (remain.len >= 6 && StartsWith(remain, "const") && IsAsciiWhite(remain[5])) {
+        remain = remain.Take(6, remain.len - 6);
+        remain = TrimStr(remain);
     }
+    if (remain.len && remain[remain.len - 1] == '!') {
+        dispose = true;
 
-    char name_buf[256];
-    Fmt(name_buf, "%1%2*", ref->name, ref->primitive == PrimitiveKind::Pointer ? "" : " ");
+        remain = remain.Take(0, remain.len - 1);
+        remain = TrimStr(remain);
+    }
+    while (remain.len) {
+        if (remain[remain.len - 1] == '*') {
+            remain = remain.Take(0, remain.len - 1);
+            indirect++;
+        } else if (remain.len >= 6 && EndsWith(remain, "const") && IsAsciiWhite(remain[remain.len - 6])) {
+            remain = remain.Take(0, remain.len - 6);
+        } else {
+            break;
+        }
+        remain = TrimStr(remain);
+    }
 
-    TypeInfo *type = instance->types_map.FindValue(name_buf, nullptr);
+    const TypeInfo *type = instance->types_map.FindValue(remain, nullptr);
 
     if (!type) {
-        type = instance->types.AppendDefault();
+        // Try with cleaned up spaces
+        if (remain.len < 256) {
+            LocalArray<char, 256> buf;
+            for (Size i = 0; i < remain.len; i++) {
+                char c = remain[i];
+
+                if (IsAsciiWhite(c)) {
+                    buf.Append(' ');
+                    while (++i < remain.len && IsAsciiWhite(remain[i]));
+                    i--;
+                } else {
+                    buf.Append(c);
+                }
+            }
 
-        type->name = DuplicateString(name_buf, &instance->str_alloc).ptr;
+            type = instance->types_map.FindValue(buf, nullptr);
+        }
 
-        type->primitive = PrimitiveKind::Pointer;
-        type->size = RG_SIZE(void *);
-        type->align = RG_SIZE(void *);
-        type->ref = ref;
+        if (!type)
+            return nullptr;
+    }
 
-        instance->types_map.Set(type);
+    if (indirect) {
+        type = MakePointerType(instance, type, indirect);
+        RG_ASSERT(type);
     }
 
+    if (dispose) {
+        if (type->primitive != PrimitiveKind::String &&
+                type->primitive != PrimitiveKind::String16 &&
+                indirect != 1)
+            return nullptr;
+
+        TypeInfo *copy = instance->types.AppendDefault();
+
+        memcpy((void *)copy, (const void *)type, RG_SIZE(*type));
+        copy->name = "<anonymous>";
+        copy->members.allocator = GetNullAllocator();
+        copy->dispose = [](Napi::Env, const TypeInfo *, const void *ptr) { free((void *)ptr); };
+
+        type = copy;
+    }
+
+    if (out_directions) {
+        *out_directions = 1;
+    }
     return type;
 }
 
+const TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *ref, int count)
+{
+    RG_ASSERT(count >= 1);
+
+    for (int i = 0; i < count; i++) {
+        char name_buf[256];
+        Fmt(name_buf, "%1%2*", ref->name, EndsWith(ref->name, "*") ? "" : " ");
+
+        TypeInfo *type = (TypeInfo *)instance->types_map.FindValue(name_buf, nullptr);
+
+        if (!type) {
+            type = instance->types.AppendDefault();
+
+            type->name = DuplicateString(name_buf, &instance->str_alloc).ptr;
+
+            if (ref->primitive != PrimitiveKind::Prototype) {
+                type->primitive = PrimitiveKind::Pointer;
+                type->size = RG_SIZE(void *);
+                type->align = RG_SIZE(void *);
+                type->ref.type = ref;
+            } else {
+                type->primitive = PrimitiveKind::Callback;
+                type->size = RG_SIZE(void *);
+                type->align = RG_SIZE(void *);
+                type->ref.proto = ref->ref.proto;
+            }
+
+            instance->types_map.Set(type->name, type);
+        }
+
+        ref = type;
+    }
+
+    return ref;
+}
+
 const char *GetValueType(const InstanceData *instance, Napi::Value value)
 {
     for (const TypeInfo &type: instance->types) {
-        if (CheckValueTag(instance, value, &type))
+        if (CheckValueTag(instance, value, type.ref.marker))
             return type.name;
     }
 
@@ -130,6 +216,8 @@ const char *GetValueType(const InstanceData *instance, Napi::Value value)
 
 void SetValueTag(const InstanceData *instance, Napi::Value value, const void *marker)
 {
+    RG_ASSERT(marker);
+
     napi_type_tag tag = { instance->tag_lower, (uint64_t)marker };
     napi_status status = napi_type_tag_object(value.Env(), value, &tag);
     RG_ASSERT(status == napi_ok);
@@ -137,6 +225,8 @@ void SetValueTag(const InstanceData *instance, Napi::Value value, const void *ma
 
 bool CheckValueTag(const InstanceData *instance, Napi::Value value, const void *marker)
 {
+    RG_ASSERT(marker);
+
     bool match = false;
 
     if (!IsNullOrUndefined(value)) {
@@ -174,8 +264,8 @@ static int AnalyseFlatRec(const TypeInfo *type, int offset, int count, FunctionR
             }
         }
     } else if (type->primitive == PrimitiveKind::Array) {
-        count *= type->size / type->ref->size;
-        offset = AnalyseFlatRec(type->ref, offset, count, func);
+        count *= type->size / type->ref.type->size;
+        offset = AnalyseFlatRec(type->ref.type, offset, count, func);
     } else {
         func(type, offset, count);
         offset += count;

package/src/util.hh

@@ -67,8 +67,9 @@ static inline bool IsFloat(const TypeInfo *type)
     return fp;
 }
 
-const TypeInfo *ResolveType(const InstanceData *instance, Napi::Value value, int *out_directions = nullptr);
-const TypeInfo *GetPointerType(InstanceData *instance, const TypeInfo *type);
+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);
 
 // Can be slow, only use for error messages
 const char *GetValueType(const InstanceData *instance, Napi::Value value);

package/test/callbacks.js

@@ -32,13 +32,14 @@ const BFG = koffi.struct('BFG', {
 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 StructCallbacks = koffi.struct('StructCallbacks', {
-    first: IntCallback,
-    second: IntCallback,
-    third: IntCallback
+    first: koffi.pointer(IntCallback),
+    second: 'IntCallback *',
+    third: 'IntCallback *'
 });
 
 main();
@@ -57,12 +58,15 @@ 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)');
-    const ApplyStd = lib.func('int ApplyStd(int a, int b, int c, ApplyCallback func)');
-    const ApplyMany = lib.func('int ApplyMany(int x, IntCallback *funcs, int length)');
+    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)');
+    const Recurse8 = lib.func('void Recurse8(int i, SuperCallback *func)');
+    const ApplyStd = lib.func('int ApplyStd(int a, int b, int c, ApplyCallback *func)');
+    const ApplyMany = lib.func('int ApplyMany(int x, IntCallback **funcs, int length)');
     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)');
 
     // Simple test similar to README example
     {
@@ -96,6 +100,35 @@ async function test() {
         assert.deepEqual(out, { a: 2, b: 4, c: -25, d: 'X/Yo!/X', e: 54, inner: { f: 10, g: 3 } });
     }
 
+    // With many parameters
+    {
+        let a = [], b = [], c = [], d = [], e = [], f = [], g = [], h = [];
+
+        let fn = (i, v1, v2, v3, v4, v5, v6, v7, v8) => {
+            a.push(v1);
+            b.push(v2);
+            c.push(v3);
+            d.push(v4);
+            e.push(v5);
+            f.push(v6);
+            g.push(v7);
+            h.push(v8);
+
+            if (i)
+                Recurse8(i - 1, fn);
+        };
+        Recurse8(3, fn);
+
+        assert.deepEqual(a, [3, 2, 1, 0]);
+        assert.deepEqual(b, [6, 4, 2, 0]);
+        assert.deepEqual(c, [4, 3, 2, 1]);
+        assert.deepEqual(d, [7, 5, 3, 1]);
+        assert.deepEqual(e, [0, 1, 2, 3]);
+        assert.deepEqual(f, [103, 102, 101, 100]);
+        assert.deepEqual(g, [1, 0, 1, 0]);
+        assert.deepEqual(h, [-4, -3, -2, -1]);
+    }
+
     // Stdcall callbacks
     {
         let ret = ApplyStd(1, 5, 9, (a, b, c) => a + b * c);
@@ -115,4 +148,17 @@ async function test() {
         let ret = ApplyStruct(27, callbacks);
         assert.equal(ret, -177);
     }
+
+    // Persistent callback
+    {
+        SetCallback(x => -x);
+        assert.throws(() => CallCallback(27), { message: /non-registered callback/ });
+
+        let cb = koffi.register(x => -x, koffi.pointer(IntCallback));
+        SetCallback(cb);
+        assert.equal(CallCallback(27), -27);
+
+        assert.equal(koffi.unregister(cb), null);
+        assert.throws(() => koffi.unregister(cb));
+    }
 }

package/test/misc.c

@@ -406,24 +406,21 @@ const char *ReturnBigString(const char *str)
 EXPORT const char *ReturnBigString(const char *str)
 #endif
 {
-    static char buf[16 * 1024 * 1024];
-
-    size_t len = strlen(str);
-    memcpy(buf, str, len + 1);
-
-    return buf;
+    const char *copy = strdup(str);
+    return copy;
 }
 
 EXPORT const char *PrintFmt(const char *fmt, ...)
 {
-    static char buf[256];
+    const int size = 256;
+    char *ptr = malloc(size);
 
     va_list ap;
     va_start(ap, fmt);
-    vsnprintf(buf, sizeof(buf), fmt, ap);
+    vsnprintf(ptr, size, fmt, ap);
     va_end(ap);
 
-    return buf;
+    return ptr;
 }
 
 size_t Length16(const char16_t *str)
@@ -437,16 +434,17 @@ size_t Length16(const char16_t *str)
 
 EXPORT const char16_t *Concat16(const char16_t *str1, const char16_t *str2)
 {
-    static char16_t buf[1024];
+    const int size = 1024;
+    char16_t *ptr = malloc(size * 2);
 
     size_t len1 = Length16(str1);
     size_t len2 = Length16(str2);
 
-    memcpy(buf, str1, len1 * 2);
-    memcpy(buf + len1, str2, len2 * 2);
-    buf[(len1 + len2) * 2] = 0;
+    memcpy(ptr, str1, len1 * 2);
+    memcpy(ptr + len1, str2, len2 * 2);
+    ptr[len1 + len2] = 0;
 
-    return buf;
+    return ptr;
 }
 
 EXPORT FixedString ReturnFixedStr(FixedString str)
@@ -549,6 +547,11 @@ EXPORT BFG ModifyBFG(int x, double y, const char *str, BFG (*func)(BFG bfg), BFG
     return bfg;
 }
 
+EXPORT void Recurse8(int i, void (*func)(int i, int v1, double v2, int v3, int v4, int v5, int v6, float v7, int v8))
+{
+    func(i, i, (double)(i * 2), i + 1, i * 2 + 1, 3 - i, 100 + i, (float)(i % 2), -i - 1);
+}
+
 EXPORT int ApplyStd(int a, int b, int c, ApplyCallback *func)
 {
     int ret = func(a, b, c);
@@ -618,3 +621,15 @@ EXPORT int ApplyStruct(int x, StructCallbacks callbacks)
 
     return x;
 }
+
+static IntCallback *callback;
+
+EXPORT void SetCallback(IntCallback *cb)
+{
+    callback = cb;
+}
+
+EXPORT int CallCallback(int x)
+{
+    return callback(x);
+}

package/test/raylib.js

@@ -55,7 +55,7 @@ const Rectangle = koffi.struct('Rectangle', {
 });
 
 const Texture = koffi.struct('Texture', {
-    id: 'uint',
+    id: 'unsigned  int', // Extra space is on purpose, leave it!
     width: 'int',
     height: 'int',
     mipmaps: 'int',

package/test/sqlite.js

@@ -39,17 +39,17 @@ async function test() {
     let lib_filename = path.dirname(__filename) + '/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_db)), 'int', 'str']);
-    const sqlite3_exec = lib.func('sqlite3_exec', 'int', [sqlite3_db, 'str', 'void *', 'void *', 'void *']);
-    const sqlite3_prepare_v2 = lib.func('sqlite3_prepare_v2', 'int', [sqlite3_db, 'str', 'int', koffi.out(koffi.pointer(sqlite3_stmt)), 'string']);
-    const sqlite3_reset = lib.func('sqlite3_reset', 'int', [sqlite3_stmt]);
-    const sqlite3_bind_text = lib.func('sqlite3_bind_text', 'int', [sqlite3_stmt, 'int', 'str', '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', 'str', [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 sqlite3_open_v2 = lib.func('sqlite3_open_v2', 'int', ['str', koffi.out(koffi.pointer(sqlite3_db, 2)), 'int', 'str']);
+    const sqlite3_exec = lib.func('sqlite3_exec', 'int', [koffi.pointer(sqlite3_db), 'str', 'void *', 'void *', 'void *']);
+    const sqlite3_prepare_v2 = lib.func('sqlite3_prepare_v2', 'int', [koffi.pointer(sqlite3_db), 'str', 'int', koffi.out(koffi.pointer(sqlite3_stmt, 2)), 'string']);
+    const sqlite3_reset = lib.func('sqlite3_reset', 'int', [koffi.pointer(sqlite3_stmt)]);
+    const sqlite3_bind_text = lib.func('sqlite3_bind_text', 'int', [koffi.pointer(sqlite3_stmt), 'int', 'str', 'int', 'void *']);
+    const sqlite3_bind_int = lib.func('sqlite3_bind_int', 'int', [koffi.pointer(sqlite3_stmt), 'int', 'int']);
+    const sqlite3_column_text = lib.func('sqlite3_column_text', 'str', [koffi.pointer(sqlite3_stmt), 'int']);
+    const sqlite3_column_int = lib.func('sqlite3_column_int', 'int', [koffi.pointer(sqlite3_stmt), 'int']);
+    const sqlite3_step = lib.func('sqlite3_step', 'int', [koffi.pointer(sqlite3_stmt)]);
+    const sqlite3_finalize = lib.func('sqlite3_finalize', 'int', [koffi.pointer(sqlite3_stmt)]);
+    const sqlite3_close_v2 = lib.func('sqlite3_close_v2', 'int', [koffi.pointer(sqlite3_db)]);
 
     const SQLITE_OPEN_READWRITE = 0x2;
     const SQLITE_OPEN_CREATE = 0x4;
@@ -57,20 +57,27 @@ async function test() {
     const SQLITE_DONE = 101;
 
     let filename = await create_temporary_file(path.join(os.tmpdir(), 'test_sqlite'));
-    let db = {};
+    let db = null;
 
     let expected = Array.from(Array(200).keys()).map(i => [`TXT ${i}`, i % 7]);
 
     try {
-        if (sqlite3_open_v2(filename, db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, null) != 0)
+        let ptr = [null];
+
+        // Open database
+        if (sqlite3_open_v2(filename, ptr, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, null) != 0)
             throw new Error('Failed to open database');
+        db = ptr[0];
+
         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 = {};
+        let stmt = null;
 
-        if (sqlite3_prepare_v2(db, "INSERT INTO foo (bar, value) VALUES (?1, ?2)", -1, stmt, null) != 0)
+        if (sqlite3_prepare_v2(db, "INSERT INTO foo (bar, value) VALUES (?1, ?2)", -1, ptr, null) != 0)
             throw new Error('Failed to prepare insert statement for table foo');
+        stmt = ptr[0];
+
         for (let it of expected) {
             sqlite3_reset(stmt);
 
@@ -82,8 +89,9 @@ async function test() {
         }
         sqlite3_finalize(stmt);
 
-        if (sqlite3_prepare_v2(db, "SELECT id, bar, value FROM foo ORDER BY id", -1, stmt, null) != 0)
+        if (sqlite3_prepare_v2(db, "SELECT id, bar, value FROM foo ORDER BY id", -1, ptr, null) != 0)
             throw new Error('Failed to prepare select statement for table foo');
+        stmt = ptr[0];
         for (let i = 0; i < expected.length; i++) {
             let it = expected[i];