koffi 2.0.1 → 2.1.0-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koffi",
-  "version": "2.0.1",
+  "version": "2.1.0-beta.1",
   "description": "Fast and simple C FFI (foreign function interface) for Node.js",
   "keywords": [
     "foreign",
@@ -25,7 +25,7 @@
   },
   "license": "AGPL-3.0",
   "dependencies": {
-    "cnoke": "^3.1.4"
+    "cnoke": "^3.2.0"
   },
   "devDependencies": {
     "chalk": "^4.1.2",

package/qemu/qemu.js

@@ -42,7 +42,7 @@ let qemu_prefix = null;
 main();
 
 async function main() {
-    script_dir = fs.realpathSync(path.dirname(__filename));
+    script_dir = fs.realpathSync(__dirname);
     root_dir = fs.realpathSync(script_dir + '/../..');
 
     // All the code assumes we are working from the script directory

package/src/call.cc

@@ -567,24 +567,26 @@ bool CallData::PushTypedArray(Napi::TypedArray array, Size len, const TypeInfo *
         return false;
     }
 
-    Size offset = 0;
     const uint8_t *buf = (const uint8_t *)array.ArrayBuffer().Data();
 
-    if (RG_UNLIKELY(array.TypedArrayType() != GetTypedArrayType(ref))) {
+    if (RG_UNLIKELY(array.TypedArrayType() != GetTypedArrayType(ref) &&
+                    ref != instance->void_type)) {
         ThrowError<Napi::TypeError>(env, "Cannot use %1 value for %2 array", GetValueType(instance, array), ref->name);
         return false;
     }
 
     if (realign) {
+        Size offset = 0;
+        Size size = (Size)array.ElementSize();
+
         for (uint32_t i = 0; i < len; i++) {
-            int16_t align = std::max(ref->align, realign);
-            offset = AlignLen(offset, align);
+            offset = AlignLen(offset, realign);
 
             uint8_t *dest = origin + offset;
+            const uint8_t *src = buf + i * size;
 
-            memcpy(dest, buf + i * ref->size, ref->size);
-
-            offset += ref->size;
+            memcpy(dest, src, size);
+            offset += size;
         }
     } else {
         memcpy_safe(origin, buf, (size_t)array.ByteLength());
@@ -625,6 +627,16 @@ bool CallData::PushStringArray(Napi::Value obj, const TypeInfo *type, uint8_t *o
 
 bool CallData::PushPointer(Napi::Value value, const ParameterInfo &param, void **out_ptr)
 {
+    const TypeInfo *type = param.type;
+
+    if (CheckValueTag(instance, value, &CastMarker)) {
+        Napi::External<ValueCast> external = value.As<Napi::External<ValueCast>>();
+        ValueCast *cast = external.Data();
+
+        value = cast->ref.Value();
+        type = cast->type;
+    }
+
     switch (value.Type()) {
         case napi_undefined:
         case napi_null: {
@@ -633,9 +645,11 @@ bool CallData::PushPointer(Napi::Value value, const ParameterInfo &param, void *
         } break;
 
         case napi_external: {
-            RG_ASSERT(param.type->primitive == PrimitiveKind::Pointer);
+            RG_ASSERT(type->primitive == PrimitiveKind::Pointer);
 
-            if (RG_UNLIKELY(!CheckValueTag(instance, value, param.type->ref.marker)))
+            if (RG_UNLIKELY(!CheckValueTag(instance, value, type->ref.marker) &&
+                            !CheckValueTag(instance, value, instance->void_type) &&
+                            type->ref.type != instance->void_type))
                 goto unexpected;
 
             *out_ptr = value.As<Napi::External<uint8_t>>().Data();
@@ -649,12 +663,12 @@ bool CallData::PushPointer(Napi::Value value, const ParameterInfo &param, void *
                 Napi::Array array = value.As<Napi::Array>();
 
                 Size len = (Size)array.Length();
-                Size size = len * param.type->ref.type->size;
+                Size size = len * type->ref.type->size;
 
                 ptr = AllocHeap(size, 16);
 
                 if (param.directions & 1) {
-                    if (!PushNormalArray(array, len, param.type->ref.type, ptr))
+                    if (!PushNormalArray(array, len, type->ref.type, ptr))
                         return false;
                 } else {
                     memset(ptr, 0, size);
@@ -668,27 +682,28 @@ bool CallData::PushPointer(Napi::Value value, const ParameterInfo &param, void *
                 ptr = AllocHeap(size, 16);
 
                 if (param.directions & 1) {
-                    if (!PushTypedArray(array, len, param.type->ref.type, ptr))
+                    if (!PushTypedArray(array, len, type->ref.type, ptr))
                         return false;
                 } else {
-                    if (RG_UNLIKELY(array.TypedArrayType() != GetTypedArrayType(param.type->ref.type))) {
-                        ThrowError<Napi::TypeError>(env, "Cannot use %1 value for %2 array", GetValueType(instance, array), param.type->ref.type->name);
+                    if (RG_UNLIKELY(array.TypedArrayType() != GetTypedArrayType(type->ref.type) &&
+                                    type->ref.type != instance->void_type)) {
+                        ThrowError<Napi::TypeError>(env, "Cannot use %1 value for %2 array", GetValueType(instance, array), type->ref.type->name);
                         return false;
                     }
 
                     memset(ptr, 0, size);
                 }
-            } else if (RG_LIKELY(param.type->ref.type->primitive == PrimitiveKind::Record)) {
+            } else if (RG_LIKELY(type->ref.type->primitive == PrimitiveKind::Record)) {
                 Napi::Object obj = value.As<Napi::Object>();
                 RG_ASSERT(IsObject(value));
 
-                ptr = AllocHeap(param.type->ref.type->size, 16);
+                ptr = AllocHeap(type->ref.type->size, 16);
 
                 if (param.directions & 1) {
-                    if (!PushObject(obj, param.type->ref.type, ptr))
+                    if (!PushObject(obj, type->ref.type, ptr))
                         return false;
                 } else {
-                    memset(ptr, 0, param.type->size);
+                    memset(ptr, 0, type->size);
                 }
             } else {
                 goto unexpected;
@@ -701,7 +716,7 @@ bool CallData::PushPointer(Napi::Value value, const ParameterInfo &param, void *
                 RG_ASSERT(status == napi_ok);
 
                 out->ptr = ptr;
-                out->type = param.type->ref.type;
+                out->type = type->ref.type;
             }
 
             *out_ptr = ptr;
@@ -712,7 +727,7 @@ bool CallData::PushPointer(Napi::Value value, const ParameterInfo &param, void *
     }
 
 unexpected:
-    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected %3", GetValueType(instance, value), param.offset + 1, param.type->name);
+    ThrowError<Napi::TypeError>(env, "Unexpected %1 value for argument %2, expected %3", GetValueType(instance, value), param.offset + 1, type->name);
     return false;
 }
 
@@ -1016,24 +1031,25 @@ void CallData::PopNormalArray(Napi::Array array, const uint8_t *origin, const Ty
 void CallData::PopTypedArray(Napi::TypedArray array, const uint8_t *origin, const TypeInfo *ref, int16_t realign)
 {
     RG_ASSERT(array.IsTypedArray());
-    RG_ASSERT(GetTypedArrayType(ref) == array.TypedArrayType());
+    RG_ASSERT(GetTypedArrayType(ref) == array.TypedArrayType() ||
+              ref == instance->void_type);
 
     uint8_t *buf = (uint8_t *)array.ArrayBuffer().Data();
 
     if (realign) {
         Size offset = 0;
         Size len = (Size)array.ElementLength();
+        Size size = (Size)array.ElementSize();
 
         for (Size i = 0; i < len; i++) {
-            int16_t align = std::max(ref->align, realign);
-            offset = AlignLen(offset, align);
+            offset = AlignLen(offset, realign);
 
-            uint8_t *dest = buf + i * ref->size;
+            uint8_t *dest = buf + i * size;
             const uint8_t *src = origin + offset;
 
-            memcpy(dest, src, ref->size);
+            memcpy(dest, src, size);
 
-            offset += ref->size;
+            offset += size;
         }
     } else {
         memcpy_safe(buf, origin, (size_t)array.ByteLength());

package/src/call.hh

@@ -71,9 +71,21 @@ public:
     CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func, InstanceMemory *mem);
     ~CallData();
 
-    bool Prepare(const Napi::CallbackInfo &info);
-    void Execute();
-    Napi::Value Complete();
+#ifdef UNITY_BUILD
+    #ifdef _MSC_VER
+        #define INLINE_IF_UNITY __forceinline
+    #else
+        #define INLINE_IF_UNITY __attribute__((always_inline)) inline
+    #endif
+#else
+    #define INLINE_IF_UNITY
+#endif
+
+    INLINE_IF_UNITY bool Prepare(const Napi::CallbackInfo &info);
+    INLINE_IF_UNITY void Execute();
+    INLINE_IF_UNITY Napi::Value Complete();
+
+#undef INLINE_IF_UNITY
 
     void Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegisters *out_reg);
 

package/src/ffi.cc

@@ -42,6 +42,7 @@ namespace RG {
 
 // Value does not matter, the tag system uses memory addresses
 const int TypeInfoMarker = 0xDEADBEEF;
+const int CastMarker = 0xDEADBEEF;
 
 static bool ChangeMemorySize(const char *name, Napi::Value value, Size *out_size)
 {
@@ -209,18 +210,40 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
 
         std::string key = ((Napi::Value)keys[i]).As<Napi::String>();
         Napi::Value value = obj[key];
+        int16_t align = 0;
 
         member.name = DuplicateString(key.c_str(), &instance->str_alloc).ptr;
+
+        if (value.IsArray()) {
+            Napi::Array array = value.As<Napi::Array>();
+
+            if (array.Length() != 2 || !((Napi::Value)array[0u]).IsNumber()) {
+                ThrowError<Napi::Error>(env, "Member specifier array must contain alignement value and type");
+                return env.Null();
+            }
+
+            int64_t align64 = ((Napi::Value)array[0u]).As<Napi::Number>().Int64Value();
+
+            if (align64 < 1 || align64 > 64) {
+                ThrowError<Napi::Error>(env, "Alignment value must be between 1 and 64");
+                return env.Null();
+            }
+
+            value = array[1u];
+            align = (int16_t)align64;
+        }
+ 
         member.type = ResolveType(value);
         if (!member.type)
             return env.Null();
-        if (member.type->primitive == PrimitiveKind::Void ||
-                member.type->primitive == PrimitiveKind::Prototype) {
+        if (!CanStoreType(member.type)) {
             ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a member (maybe try %1 *)", member.type->name);
             return env.Null();
         }
 
-        int16_t align = pad ? member.type->align : 1;
+        if (!align) {
+            align = pad ? member.type->align : 1;
+        }
         member.offset = (int16_t)AlignLen(type->size, align);
 
         type->size = (int16_t)(member.offset + member.type->size);
@@ -264,7 +287,7 @@ static Napi::Value CreatePackedStructType(const Napi::CallbackInfo &info)
     return CreateStructType(info, false);
 }
 
-static Napi::Value CreateHandleType(const Napi::CallbackInfo &info)
+static Napi::Value CreateOpaqueType(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
@@ -618,8 +641,8 @@ static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value r
     func->ret.type = ResolveType(ret);
     if (!func->ret.type)
         return false;
-    if (func->ret.type->primitive == PrimitiveKind::Array) {
-        ThrowError<Napi::Error>(env, "You are not allowed to directly return fixed-size arrays");
+    if (!CanReturnType(func->ret.type)) {
+        ThrowError<Napi::TypeError>(env, "You are not allowed to directly return %1 values (maybe try %1 *)", func->ret.type->name);
         return false;
     }
 
@@ -645,9 +668,7 @@ static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value r
         param.type = ResolveType(parameters[j], &param.directions);
         if (!param.type)
             return false;
-        if (param.type->primitive == PrimitiveKind::Void ||
-                param.type->primitive == PrimitiveKind::Array ||
-                param.type->primitive == PrimitiveKind::Prototype) {
+        if (!CanPassType(param.type)) {
             ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a parameter (maybe try %1 *)", param.type->name);
             return false;
         }
@@ -988,9 +1009,7 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
         param.type = ResolveType(info[i], &param.directions);
         if (RG_UNLIKELY(!param.type))
             return env.Null();
-        if (RG_UNLIKELY(param.type->primitive == PrimitiveKind::Void ||
-                        param.type->primitive == PrimitiveKind::Array ||
-                        param.type->primitive == PrimitiveKind::Prototype)) {
+        if (RG_UNLIKELY(!CanPassType(param.type))) {
             ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a parameter (maybe try %1 *)", PrimitiveKindNames[(int)param.type->primitive]);
             return env.Null();
         }
@@ -1434,6 +1453,8 @@ static void RegisterPrimitiveType(Napi::Env env, Napi::Object map, std::initiali
 
 static Napi::Object InitBaseTypes(Napi::Env env)
 {
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
     Napi::Object types = Napi::Object::New(env);
 
     RegisterPrimitiveType(env, types, {"void"}, PrimitiveKind::Void, 0, 0);
@@ -1464,6 +1485,9 @@ static Napi::Object InitBaseTypes(Napi::Env env)
     RegisterPrimitiveType(env, types, {"char *", "str", "string"}, PrimitiveKind::String, RG_SIZE(void *), alignof(void *), "char");
     RegisterPrimitiveType(env, types, {"char16_t *", "char16 *", "str16", "string16"}, PrimitiveKind::String16, RG_SIZE(void *), alignof(void *), "char16_t");
 
+    instance->void_type = instance->types_map.FindValue("void", nullptr);
+    RG_ASSERT(instance->void_type);
+
     types.Freeze();
 
     return types;
@@ -1515,6 +1539,37 @@ InstanceData::~InstanceData()
     }
 }
 
+static Napi::Value CastValue(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (RG_UNLIKELY(info.Length() < 2)) {
+        ThrowError<Napi::TypeError>(env, "Expected 2 arguments, got %1", info.Length());
+        return env.Null();
+    }
+
+    Napi::Value value = info[0];
+
+    const TypeInfo *type = ResolveType(info[1]);
+    if (RG_UNLIKELY(!type))
+        return env.Null();
+    if (type->primitive != PrimitiveKind::Pointer) {
+        ThrowError<Napi::TypeError>(env, "Only pointer types can be used for casting");
+        return env.Null();
+    }
+
+    ValueCast *cast = new ValueCast;
+
+    cast->ref.Reset(value, 1);
+    cast->type = type;
+
+    Napi::External<ValueCast> external = Napi::External<ValueCast>::New(env, cast, [](Napi::Env, ValueCast *cast) { delete cast; });
+    SetValueTag(instance, external, &CastMarker);
+
+    return external;
+}
+
 template <typename Func>
 static void SetExports(Napi::Env env, Func func)
 {
@@ -1522,7 +1577,7 @@ static void SetExports(Napi::Env env, Func func)
 
     func("struct", Napi::Function::New(env, CreatePaddedStructType));
     func("pack", Napi::Function::New(env, CreatePackedStructType));
-    func("handle", Napi::Function::New(env, CreateHandleType));
+    func("opaque", Napi::Function::New(env, CreateOpaqueType));
     func("pointer", Napi::Function::New(env, CreatePointerType));
     func("array", Napi::Function::New(env, CreateArrayType));
     func("callback", Napi::Function::New(env, CreateCallbackType));
@@ -1545,6 +1600,8 @@ static void SetExports(Napi::Env env, Func func)
     func("register", Napi::Function::New(env, RegisterCallback));
     func("unregister", Napi::Function::New(env, UnregisterCallback));
 
+    func("as", Napi::Function::New(env, CastValue));
+
 #if defined(_WIN32)
     func("extension", Napi::String::New(env, ".dll"));
 #elif defined(__APPLE__)

package/src/ffi.hh

@@ -32,6 +32,7 @@ static const Size MaxOutParameters = 4;
 static const Size MaxTrampolines = 16;
 
 extern const int TypeInfoMarker;
+extern const int CastMarker;
 
 enum class PrimitiveKind {
     Void,
@@ -171,6 +172,11 @@ struct ParameterInfo {
 #endif
 };
 
+struct ValueCast {
+    Napi::Reference<Napi::Value> ref;
+    const TypeInfo *type;
+};
+
 // Also used for callbacks, even though many members are not used in this case
 struct FunctionInfo {
     mutable std::atomic_int refcount {1};
@@ -230,6 +236,7 @@ struct InstanceData {
 
     bool debug;
     uint64_t tag_lower;
+    const TypeInfo *void_type;
 
     LocalArray<InstanceMemory *, 9> memories;
     int temporaries = 0;

package/src/index.js

@@ -15,7 +15,9 @@
 
 'use strict';
 
-const path = require('path');
+const util = require('util');
 
-let filename = path.dirname(__filename) + '/../build/koffi.node';
+let filename = __dirname + '/../build/koffi.node';
 module.exports = require(filename);
+
+module.exports.handle = util.deprecate(module.exports.opaque, 'The koffi.handle() function was deprecated in Koffi 2.1, use koffi.opaque() instead', 'KOFFI001');

package/src/parser.cc

@@ -28,8 +28,8 @@ bool PrototypeParser::Parse(const char *str, FunctionInfo *out_func)
     Tokenize(str);
 
     out_func->ret.type = ParseType();
-    if (out_func->ret.type->primitive == PrimitiveKind::Array) {
-        MarkError("You are not allowed to directly return C arrays");
+    if (!CanReturnType(out_func->ret.type)) {
+        MarkError("You are not allowed to directly return %1 values (maybe try %1 *)", out_func->ret.type->name);
         return false;
     }
     if (Match("__cdecl")) {
@@ -65,9 +65,7 @@ bool PrototypeParser::Parse(const char *str, FunctionInfo *out_func)
             }
 
             param.type = ParseType();
-            if (param.type->primitive == PrimitiveKind::Void ||
-                    param.type->primitive == PrimitiveKind::Array ||
-                    param.type->primitive == PrimitiveKind::Prototype) {
+            if (!CanPassType(param.type)) {
                 MarkError("Type %1 cannot be used as a parameter (maybe try %1 *)", param.type->name);
                 return false;
             }

package/src/util.cc

@@ -170,10 +170,53 @@ const TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *ref, int
     return ref;
 }
 
+bool CanPassType(const TypeInfo *type)
+{
+    if (type->primitive == PrimitiveKind::Void)
+        return false;
+    if (type->primitive == PrimitiveKind::Array)
+        return false;
+    if (type->primitive == PrimitiveKind::Prototype)
+        return false;
+
+    return true;
+}
+
+bool CanReturnType(const TypeInfo *type)
+{
+    if (type->primitive == PrimitiveKind::Void && !TestStr(type->name, "void"))
+        return false;
+    if (type->primitive == PrimitiveKind::Array)
+        return false;
+    if (type->primitive == PrimitiveKind::Prototype)
+        return false;
+
+    return true;
+}
+
+bool CanStoreType(const TypeInfo *type)
+{
+    if (type->primitive == PrimitiveKind::Void)
+        return false;
+    if (type->primitive == PrimitiveKind::Prototype)
+        return false;
+
+    return true;
+}
+
 const char *GetValueType(const InstanceData *instance, Napi::Value value)
 {
+    if (CheckValueTag(instance, value, &CastMarker)) {
+        Napi::External<ValueCast> external = value.As<Napi::External<ValueCast>>();
+        ValueCast *cast = external.Data();
+
+        return cast->type->name;
+    }
+
+    if (CheckValueTag(instance, value, &TypeInfoMarker))
+        return "Type";
     for (const TypeInfo &type: instance->types) {
-        if (CheckValueTag(instance, value, type.ref.marker))
+        if (type.ref.marker && CheckValueTag(instance, value, type.ref.marker))
             return type.name;
     }
 

package/src/util.hh

@@ -71,6 +71,10 @@ 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);
 
+bool CanPassType(const TypeInfo *type);
+bool CanReturnType(const TypeInfo *type);
+bool CanStoreType(const TypeInfo *type);
+
 // Can be slow, only use for error messages
 const char *GetValueType(const InstanceData *instance, Napi::Value value);
 

package/test/async.js

@@ -15,7 +15,6 @@
 
 const koffi = require('./build/koffi.node');
 const assert = require('assert');
-const path = require('path');
 
 const PackedBFG = koffi.pack('PackedBFG', {
     a: 'int8_t',
@@ -42,7 +41,7 @@ async function main() {
 }
 
 async function test() {
-    const lib_filename = path.dirname(__filename) + '/build/misc' + koffi.extension;
+    const lib_filename = __dirname + '/build/misc' + koffi.extension;
     const lib = koffi.load(lib_filename);
 
     const ConcatenateToInt1 = lib.func('ConcatenateToInt1', 'int64_t', Array(12).fill('int8_t'));

package/test/callbacks.js

@@ -15,11 +15,10 @@
 
 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',
+    b: [16, 'int64_t'],
     c: 'char',
     d: 'str',
     e: 'short',
@@ -55,7 +54,7 @@ async function main() {
 }
 
 async function test() {
-    const lib_filename = path.dirname(__filename) + '/build/misc' + koffi.extension;
+    const lib_filename = __dirname + '/build/misc' + koffi.extension;
     const lib = koffi.load(lib_filename);
 
     const CallJS = lib.func('int CallJS(const char *str, SimpleCallback *cb)');

package/test/misc.c

@@ -90,7 +90,7 @@ typedef struct IJK8 { int64_t i; int64_t j; int64_t k; } IJK8;
 
 typedef struct BFG {
     int8_t a;
-    int64_t b;
+    char _pad1[15]; int64_t b;
     signed char c;
     const char *d;
     short e;
@@ -399,6 +399,15 @@ EXPORT PackedBFG FASTCALL MakePackedBFG(int x, double y, PackedBFG *p, const cha
     return bfg;
 }
 
+EXPORT void MakePolymorphBFG(int type, int x, double y, const char *str, void *p)
+{
+    if (type == 0) {
+        MakeBFG(p, x, y, str);
+    } else if (type == 1) {
+        MakePackedBFG(x, y, p, str);
+    }
+}
+
 #ifdef _WIN32
 // Exported by DEF file
 const char *ReturnBigString(const char *str)
@@ -633,3 +642,14 @@ EXPORT int CallCallback(int x)
 {
     return callback(x);
 }
+
+EXPORT void ReverseBytes(void *p, int len)
+{
+    uint8_t *bytes = (uint8_t *)p;
+
+    for (int i = 0; i < len / 2; i++) {
+        uint8_t tmp = bytes[i];
+        bytes[i] = bytes[len - i - 1];
+        bytes[len - i - 1] = tmp;
+    }
+}

package/test/raylib.js

@@ -83,7 +83,7 @@ async function main() {
 }
 
 async function test() {
-    let lib_filename = path.dirname(__filename) + '/build/raylib' + koffi.extension;
+    let lib_filename = __dirname + '/build/raylib' + koffi.extension;
     let lib = koffi.load(lib_filename);
 
     const InitWindow = lib.func('InitWindow', 'void', ['int', 'int', 'str']);

package/test/sqlite.js

@@ -20,8 +20,8 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 
-const sqlite3 = koffi.handle('sqlite3');
-const sqlite3_stmt = koffi.handle('sqlite3_stmt');
+const sqlite3 = koffi.opaque('sqlite3');
+const sqlite3_stmt = koffi.opaque('sqlite3_stmt');
 
 main();
 
@@ -36,7 +36,7 @@ async function main() {
 }
 
 async function test() {
-    let lib_filename = path.dirname(__filename) + '/build/sqlite3' + 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']);