koffi 2.0.1 → 2.1.0-beta.3

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>();
@@ -387,7 +410,7 @@ static Napi::Value EncodePointerDirection(const Napi::CallbackInfo &info, int di
         return env.Null();
 
     if (type->primitive != PrimitiveKind::Pointer) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 type, expected pointer type", PrimitiveKindNames[(int)type->primitive]);
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 type, expected pointer type", type->name);
         return env.Null();
     }
 
@@ -440,7 +463,7 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
     if (src->primitive != PrimitiveKind::String &&
             src->primitive != PrimitiveKind::String16 &&
             src->primitive != PrimitiveKind::Pointer) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 type, expected pointer or string type", PrimitiveKindNames[(int)src->primitive]);
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 type, expected pointer or string type", src->name);
         return env.Null();
     }
     if (src->dispose) {
@@ -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;
         }
@@ -840,11 +861,17 @@ static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
             case PrimitiveKind::Int8:
             case PrimitiveKind::UInt8:
             case PrimitiveKind::Int16:
+            case PrimitiveKind::Int16S:
             case PrimitiveKind::UInt16:
+            case PrimitiveKind::UInt16S:
             case PrimitiveKind::Int32:
+            case PrimitiveKind::Int32S:
             case PrimitiveKind::UInt32:
+            case PrimitiveKind::UInt32S:
             case PrimitiveKind::Int64:
+            case PrimitiveKind::Int64S:
             case PrimitiveKind::UInt64:
+            case PrimitiveKind::UInt64S:
             case PrimitiveKind::String:
             case PrimitiveKind::String16:
             case PrimitiveKind::Float32:
@@ -988,10 +1015,8 @@ 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)) {
-            ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a parameter (maybe try %1 *)", PrimitiveKindNames[(int)param.type->primitive]);
+        if (RG_UNLIKELY(!CanPassType(param.type))) {
+            ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a parameter (maybe try %1 *)", param.type->name);
             return env.Null();
         }
 
@@ -1384,17 +1409,6 @@ void LibraryHolder::Unref() const
     }
 }
 
-static inline PrimitiveKind GetIntegerPrimitive(Size len, bool sign)
-{
-    switch (len) {
-        case 1: return sign ? PrimitiveKind::Int8 : PrimitiveKind::UInt8;
-        case 2: return sign ? PrimitiveKind::Int16 : PrimitiveKind::UInt16;
-        case 4: return sign ? PrimitiveKind::Int32 : PrimitiveKind::UInt32;
-        case 8: return sign ? PrimitiveKind::Int64 : PrimitiveKind::UInt64;
-    }
-
-    RG_UNREACHABLE();
-}
 
 static void RegisterPrimitiveType(Napi::Env env, Napi::Object map, std::initializer_list<const char *> names,
                                   PrimitiveKind primitive, int16_t size, int16_t align, const char *ref = nullptr)
@@ -1432,8 +1446,34 @@ static void RegisterPrimitiveType(Napi::Env env, Napi::Object map, std::initiali
     }
 }
 
+static inline PrimitiveKind GetSignPrimitive(Size len, bool sign)
+{
+    switch (len) {
+        case 1: return sign ? PrimitiveKind::Int8 : PrimitiveKind::UInt8;
+        case 2: return sign ? PrimitiveKind::Int16 : PrimitiveKind::UInt16;
+        case 4: return sign ? PrimitiveKind::Int32 : PrimitiveKind::UInt32;
+        case 8: return sign ? PrimitiveKind::Int64 : PrimitiveKind::UInt64;
+    }
+
+    RG_UNREACHABLE();
+}
+
+static inline PrimitiveKind GetLittleEndianPrimitive(PrimitiveKind kind)
+{
+    // Sensitive to endianness
+    return kind;
+}
+
+static inline PrimitiveKind GetBigEndianPrimitive(PrimitiveKind kind)
+{
+    // Sensitive to endianness
+    return (PrimitiveKind)((int)kind + 1);
+}
+
 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);
@@ -1444,19 +1484,32 @@ static Napi::Object InitBaseTypes(Napi::Env env)
     RegisterPrimitiveType(env, types, {"unsigned char", "uchar"}, PrimitiveKind::UInt8, 1, 1);
     RegisterPrimitiveType(env, types, {"char16_t", "char16"}, PrimitiveKind::Int16, 2, 2);
     RegisterPrimitiveType(env, types, {"int16_t", "int16"}, PrimitiveKind::Int16, 2, 2);
+    RegisterPrimitiveType(env, types, {"int16_le_t", "int16_le"}, GetLittleEndianPrimitive(PrimitiveKind::Int16), 2, 2);
+    RegisterPrimitiveType(env, types, {"int16_be_t", "int16_be"}, GetBigEndianPrimitive(PrimitiveKind::Int16), 2, 2);
     RegisterPrimitiveType(env, types, {"uint16_t", "uint16"}, PrimitiveKind::UInt16, 2, 2);
+    RegisterPrimitiveType(env, types, {"uint16_le_t", "uint16_le"}, GetLittleEndianPrimitive(PrimitiveKind::UInt16), 2, 2);
+    RegisterPrimitiveType(env, types, {"uint16_be_t", "uint16_be"}, GetBigEndianPrimitive(PrimitiveKind::UInt16), 2, 2);
     RegisterPrimitiveType(env, types, {"short"}, PrimitiveKind::Int16, 2, 2);
     RegisterPrimitiveType(env, types, {"unsigned short", "ushort"}, PrimitiveKind::UInt16, 2, 2);
     RegisterPrimitiveType(env, types, {"int32_t", "int32"}, PrimitiveKind::Int32, 4, 4);
+    RegisterPrimitiveType(env, types, {"int32_le_t", "int32_le"}, GetLittleEndianPrimitive(PrimitiveKind::Int32), 4, 4);
+    RegisterPrimitiveType(env, types, {"int32_be_t", "int32_be"}, GetBigEndianPrimitive(PrimitiveKind::Int32), 4, 4);
     RegisterPrimitiveType(env, types, {"uint32_t", "uint32"}, PrimitiveKind::UInt32, 4, 4);
+    RegisterPrimitiveType(env, types, {"uint32_le_t", "uint32_le"}, GetLittleEndianPrimitive(PrimitiveKind::UInt32), 4, 4);
+    RegisterPrimitiveType(env, types, {"uint32_be_t", "uint32_be"}, GetBigEndianPrimitive(PrimitiveKind::UInt32), 4, 4);
     RegisterPrimitiveType(env, types, {"int"}, PrimitiveKind::Int32, 4, 4);
     RegisterPrimitiveType(env, types, {"unsigned int", "uint"}, PrimitiveKind::UInt32, 4, 4);
     RegisterPrimitiveType(env, types, {"int64_t", "int64"}, PrimitiveKind::Int64, 8, alignof(int64_t));
+    RegisterPrimitiveType(env, types, {"int64_le_t", "int64_le"}, GetLittleEndianPrimitive(PrimitiveKind::Int64), 8, alignof(int64_t));
+    RegisterPrimitiveType(env, types, {"int64_be_t", "int64_be"}, GetBigEndianPrimitive(PrimitiveKind::Int64), 8, alignof(int64_t));
     RegisterPrimitiveType(env, types, {"uint64_t", "uint64"}, PrimitiveKind::UInt64, 8, alignof(int64_t));
-    RegisterPrimitiveType(env, types, {"intptr_t", "intptr"}, GetIntegerPrimitive(RG_SIZE(intptr_t), true), RG_SIZE(intptr_t), alignof(intptr_t));
-    RegisterPrimitiveType(env, types, {"uintptr_t", "uintptr"}, GetIntegerPrimitive(RG_SIZE(intptr_t), false), RG_SIZE(intptr_t), alignof(intptr_t));
-    RegisterPrimitiveType(env, types, {"long"}, GetIntegerPrimitive(RG_SIZE(long), true), RG_SIZE(long), alignof(long));
-    RegisterPrimitiveType(env, types, {"unsigned long", "ulong"}, GetIntegerPrimitive(RG_SIZE(long), false), RG_SIZE(long), alignof(long));
+    RegisterPrimitiveType(env, types, {"uint64_le_t", "uint64_le"}, GetLittleEndianPrimitive(PrimitiveKind::UInt64), 8, alignof(int64_t));
+    RegisterPrimitiveType(env, types, {"uint64_be_t", "uint64_be"}, GetBigEndianPrimitive(PrimitiveKind::UInt64), 8, alignof(int64_t));
+    RegisterPrimitiveType(env, types, {"intptr_t", "intptr"}, GetSignPrimitive(RG_SIZE(intptr_t), true), RG_SIZE(intptr_t), alignof(intptr_t));
+    RegisterPrimitiveType(env, types, {"uintptr_t", "uintptr"}, GetSignPrimitive(RG_SIZE(intptr_t), false), RG_SIZE(intptr_t), alignof(intptr_t));
+    RegisterPrimitiveType(env, types, {"size_t"}, GetSignPrimitive(RG_SIZE(size_t), false), RG_SIZE(size_t), alignof(size_t));
+    RegisterPrimitiveType(env, types, {"long"}, GetSignPrimitive(RG_SIZE(long), true), RG_SIZE(long), alignof(long));
+    RegisterPrimitiveType(env, types, {"unsigned long", "ulong"}, GetSignPrimitive(RG_SIZE(long), false), RG_SIZE(long), alignof(long));
     RegisterPrimitiveType(env, types, {"long long", "longlong"}, PrimitiveKind::Int64, RG_SIZE(int64_t), alignof(int64_t));
     RegisterPrimitiveType(env, types, {"unsigned long long", "ulonglong"}, PrimitiveKind::UInt64, RG_SIZE(uint64_t), alignof(uint64_t));
     RegisterPrimitiveType(env, types, {"float", "float32"}, PrimitiveKind::Float32, 4, alignof(float));
@@ -1464,6 +1517,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 +1571,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 +1609,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 +1632,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,
@@ -39,11 +40,17 @@ enum class PrimitiveKind {
     Int8,
     UInt8,
     Int16,
+    Int16S,
     UInt16,
+    UInt16S,
     Int32,
+    Int32S,
     UInt32,
+    UInt32S,
     Int64,
+    Int64S,
     UInt64,
+    UInt64S,
     String,
     String16,
     Pointer,
@@ -60,11 +67,17 @@ static const char *const PrimitiveKindNames[] = {
     "Int8",
     "UInt8",
     "Int16",
+    "Int16S",
     "UInt16",
+    "UInt16S",
     "Int32",
+    "Int32S",
     "UInt32",
+    "UInt32S",
     "Int64",
+    "Int64S",
     "UInt64",
+    "UInt64S",
     "String",
     "String16",
     "Pointer",
@@ -171,6 +184,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 +248,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;
@@ -143,6 +143,21 @@ typedef struct StructCallbacks {
     IntCallback *third;
 } StructCallbacks;
 
+typedef struct EndianInts {
+    int16_t i16le;
+    int16_t i16be;
+    uint16_t u16le;
+    uint16_t u16be;
+    int32_t i32le;
+    int32_t i32be;
+    uint32_t u32le;
+    uint32_t u32be;
+    int64_t i64le;
+    int64_t i64be;
+    uint64_t u64le;
+    uint64_t u64be;
+} EndianInts;
+
 EXPORT int8_t GetMinusOne1(void)
 {
     return -1;
@@ -399,6 +414,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 +657,42 @@ 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;
+    }
+}
+
+EXPORT void CopyEndianInts1(EndianInts ints, uint8_t buf[56])
+{
+    memcpy(buf, &ints, sizeof(ints));
+}
+
+EXPORT void CopyEndianInts2(int16_t i16le, int16_t i16be, uint16_t u16le, uint16_t u16be,
+                            int32_t i32le, int32_t i32be, uint32_t u32le, uint32_t u32be,
+                            int64_t i64le, int64_t i64be, uint64_t u64le, uint64_t u64be,
+                            EndianInts *out)
+{
+    out->i16le = i16le;
+    out->i16be = i16be;
+    out->u16le = u16le;
+    out->u16be = u16be;
+    out->i32le = i32le;
+    out->i32be = i32be;
+    out->u32le = u32le;
+    out->u32be = u32be;
+    out->i64le = i64le;
+    out->i64be = i64be;
+    out->u64le = u64le;
+    out->u64be = u64be;
+}
+
+EXPORT uint16_t ReturnEndianInt2(uint16_t v) { return v; }
+EXPORT uint32_t ReturnEndianInt4(uint32_t v) { return v; }
+EXPORT uint64_t ReturnEndianInt8(uint64_t v) { return v; }

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']);