koffi 1.3.6 → 1.3.7

package/src/ffi.cc

@@ -1075,9 +1075,12 @@ static void RegisterPrimitiveType(InstanceData *instance, const char *name, Prim
     instance->types_map.Set(type);
 }
 
-static inline PrimitiveKind GetLongPrimitive(bool sign)
+template <typename T>
+static inline PrimitiveKind GetIntegerPrimitive(bool sign)
 {
-    switch (RG_SIZE(long)) {
+    switch (RG_SIZE(T)) {
+        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;
     }
@@ -1121,9 +1124,13 @@ static Napi::Object InitBaseTypes(Napi::Env env)
     RegisterPrimitiveType(instance, "int64_t", PrimitiveKind::Int64, 8, alignof(int64_t));
     RegisterPrimitiveType(instance, "uint64", PrimitiveKind::UInt64, 8, alignof(int64_t));
     RegisterPrimitiveType(instance, "uint64_t", PrimitiveKind::UInt64, 8, alignof(int64_t));
-    RegisterPrimitiveType(instance, "long", GetLongPrimitive(true), RG_SIZE(long), alignof(long));
-    RegisterPrimitiveType(instance, "ulong", GetLongPrimitive(false), RG_SIZE(long), alignof(long));
-    RegisterPrimitiveType(instance, "unsigned long", GetLongPrimitive(false), RG_SIZE(long), alignof(long));
+    RegisterPrimitiveType(instance, "intptr", GetIntegerPrimitive<intptr_t>(true), RG_SIZE(intptr_t), alignof(intptr_t));
+    RegisterPrimitiveType(instance, "intptr_t", GetIntegerPrimitive<intptr_t>(true), RG_SIZE(intptr_t), alignof(intptr_t));
+    RegisterPrimitiveType(instance, "uintptr", GetIntegerPrimitive<intptr_t>(false), RG_SIZE(intptr_t), alignof(intptr_t));
+    RegisterPrimitiveType(instance, "uintptr_t", GetIntegerPrimitive<intptr_t>(false), RG_SIZE(intptr_t), alignof(intptr_t));
+    RegisterPrimitiveType(instance, "long", GetIntegerPrimitive<long>(true), RG_SIZE(long), alignof(long));
+    RegisterPrimitiveType(instance, "ulong", GetIntegerPrimitive<long>(false), RG_SIZE(long), alignof(long));
+    RegisterPrimitiveType(instance, "unsigned long", GetIntegerPrimitive<long>(false), RG_SIZE(long), alignof(long));
     RegisterPrimitiveType(instance, "longlong", PrimitiveKind::Int64, RG_SIZE(int64_t), alignof(int64_t));
     RegisterPrimitiveType(instance, "long long", PrimitiveKind::Int64, RG_SIZE(int64_t), alignof(int64_t));
     RegisterPrimitiveType(instance, "ulonglong", PrimitiveKind::UInt64, RG_SIZE(uint64_t), alignof(uint64_t));
@@ -1134,6 +1141,8 @@ static Napi::Object InitBaseTypes(Napi::Env env)
     RegisterPrimitiveType(instance, "double", PrimitiveKind::Float64, 8, alignof(double));
     RegisterPrimitiveType(instance, "string", PrimitiveKind::String, RG_SIZE(void *), alignof(void *));
     RegisterPrimitiveType(instance, "string16", PrimitiveKind::String16, RG_SIZE(void *), alignof(void *));
+    RegisterPrimitiveType(instance, "str", PrimitiveKind::String, RG_SIZE(void *), alignof(void *));
+    RegisterPrimitiveType(instance, "str16", PrimitiveKind::String16, RG_SIZE(void *), alignof(void *));
 
     Napi::Object types = Napi::Object::New(env);
     for (TypeInfo &type: instance->types) {

package/src/ffi.hh

@@ -86,7 +86,6 @@ struct TypeInfo {
     };
 
     const char *name;
-    napi_type_tag tag;
 
     Napi::ObjectReference defn;
 

package/src/util.cc

@@ -28,7 +28,7 @@ const TypeInfo *ResolveType(const InstanceData *instance, Napi::Value value, int
         const TypeInfo *type = instance->types_map.FindValue(str.c_str(), nullptr);
 
         if (!type) {
-            ThrowError<Napi::TypeError>(value.Env(), "Unknown type string '%1'", str.c_str());
+            ThrowError<Napi::TypeError>(value.Env(), "Unknown type name '%1'", str.c_str());
             return nullptr;
         }
 

package/test/async.js

@@ -21,7 +21,7 @@ const PackedBFG = koffi.pack('PackedBFG', {
     a: 'int8_t',
     b: 'int64_t',
     c: 'char',
-    d: 'string',
+    d: 'str',
     e: 'short',
     inner: koffi.pack({
         f: 'float',

package/test/callbacks.js

@@ -21,7 +21,7 @@ const BFG = koffi.struct('BFG', {
     a: 'int8_t',
     b: 'int64_t',
     c: 'char',
-    d: 'string',
+    d: 'str',
     e: 'short',
     inner: koffi.struct({
         f: 'float',
@@ -30,9 +30,16 @@ const BFG = koffi.struct('BFG', {
 });
 
 const SimpleCallback = koffi.callback('int SimpleCallback(const char *str)');
-const RecursiveCallback = koffi.callback('RecursiveCallback', 'float', ['int', 'string', 'double']);
+const RecursiveCallback = koffi.callback('RecursiveCallback', 'float', ['int', 'str', 'double']);
 const BigCallback = koffi.callback('BFG BigCallback(BFG bfg)');
 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
+});
 
 main();
 
@@ -54,6 +61,8 @@ async function test() {
     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 ApplyStruct = lib.func('int ApplyStruct(int x, StructCallbacks callbacks)');
 
     // Simple test similar to README example
     {
@@ -92,4 +101,18 @@ async function test() {
         let ret = ApplyStd(1, 5, 9, (a, b, c) => a + b * c);
         assert.equal(ret, 46);
     }
+
+    // Array of callbacks
+    {
+        let callbacks = [x => x * 5, x => x - 42, x => -x];
+        let ret = ApplyMany(27, callbacks, callbacks.length);
+        assert.equal(ret, -93);
+    }
+
+    // Struct of callbacks
+    {
+        let callbacks = { first: x => -x, second: x => x * 5, third: x => x - 42 };
+        let ret = ApplyStruct(27, callbacks);
+        assert.equal(ret, -177);
+    }
 }

package/test/misc.c

@@ -129,6 +129,20 @@ typedef struct IntContainer {
     int len;
 } IntContainer;
 
+typedef struct StrStruct {
+    const char *str;
+    const char16_t *str16;
+} StrStruct;
+
+typedef int STDCALL ApplyCallback(int a, int b, int c);
+typedef int IntCallback(int x);
+
+typedef struct StructCallbacks {
+    IntCallback *first;
+    IntCallback *second;
+    IntCallback *third;
+} StructCallbacks;
+
 EXPORT int8_t GetMinusOne1(void)
 {
     return -1;
@@ -535,8 +549,6 @@ EXPORT BFG ModifyBFG(int x, double y, const char *str, BFG (*func)(BFG bfg), BFG
     return bfg;
 }
 
-typedef int STDCALL ApplyCallback(int a, int b, int c);
-
 EXPORT int ApplyStd(int a, int b, int c, ApplyCallback *func)
 {
     int ret = func(a, b, c);
@@ -568,3 +580,41 @@ EXPORT void MultiplyIntegers(int multiplier, int *values, int len)
         values[i] *= multiplier;
     }
 }
+
+EXPORT const char *ThroughStr(StrStruct s)
+{
+    return s.str;
+}
+
+EXPORT const char16_t *ThroughStr16(StrStruct s)
+{
+    return s.str16;
+}
+
+EXPORT const char *ThroughStrStar(StrStruct *s)
+{
+    return s->str;
+}
+
+EXPORT const char16_t *ThroughStrStar16(StrStruct *s)
+{
+    return s->str16;
+}
+
+EXPORT int ApplyMany(int x, IntCallback **callbacks, int length)
+{
+    for (int i = 0; i < length; i++) {
+        x = (callbacks[i])(x);
+    }
+
+    return x;
+}
+
+EXPORT int ApplyStruct(int x, StructCallbacks callbacks)
+{
+    x = callbacks.first(x);
+    x = callbacks.second(x);
+    x = callbacks.third(x);
+
+    return x;
+}

package/test/raylib.js

@@ -86,14 +86,14 @@ async function test() {
     let lib_filename = path.dirname(__filename) + '/build/raylib' + koffi.extension;
     let lib = koffi.load(lib_filename);
 
-    const InitWindow = lib.func('InitWindow', 'void', ['int', 'int', 'string']);
+    const InitWindow = lib.func('InitWindow', 'void', ['int', 'int', 'str']);
     const SetTraceLogLevel = lib.func('SetTraceLogLevel', 'void', ['int']);
     const SetWindowState = lib.func('SetWindowState', 'void', ['uint']);
     const GenImageColor = lib.func('GenImageColor', Image, ['int', 'int', Color]);
     const GetFontDefault = lib.func('GetFontDefault', Font, []);
-    const MeasureTextEx = lib.func('MeasureTextEx', Vector2, [Font, 'string', 'float', 'float']);
-    const ImageDrawTextEx = lib.func('ImageDrawTextEx', 'void', [koffi.pointer(Image), Font, 'string', Vector2, 'float', 'float', Color]);
-    const ExportImage = lib.func('ExportImage', 'bool', [Image, 'string']);
+    const MeasureTextEx = lib.func('MeasureTextEx', Vector2, [Font, 'str', 'float', 'float']);
+    const ImageDrawTextEx = lib.func('ImageDrawTextEx', 'void', [koffi.pointer(Image), Font, 'str', Vector2, 'float', 'float', Color]);
+    const ExportImage = lib.func('ExportImage', 'bool', [Image, 'str']);
 
     // We need to call InitWindow before using anything else (such as fonts)
     SetTraceLogLevel(4); // Warnings

package/test/sqlite.js

@@ -39,13 +39,13 @@ 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', ['string', koffi.out(koffi.pointer(sqlite3_db)), 'int', 'string']);
-    const sqlite3_exec = lib.func('sqlite3_exec', 'int', [sqlite3_db, 'string', 'void *', 'void *', 'void *']);
-    const sqlite3_prepare_v2 = lib.func('sqlite3_prepare_v2', 'int', [sqlite3_db, 'string', 'int', koffi.out(koffi.pointer(sqlite3_stmt)), 'string']);
+    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', 'string', 'int', 'void *']);
+    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', 'string', [sqlite3_stmt, '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]);

package/test/sync.js

@@ -64,7 +64,7 @@ const BFG = koffi.struct('BFG', {
     a: 'int8_t',
     b: 'int64_t',
     c: 'char',
-    d: 'string',
+    d: 'str',
     e: 'short',
     inner: koffi.struct({
         f: 'float',
@@ -75,7 +75,7 @@ const PackedBFG = koffi.pack('PackedBFG', {
     a: 'int8_t',
     b: 'int64_t',
     c: 'char',
-    d: 'string',
+    d: 'str',
     e: 'short',
     inner: koffi.pack({
         f: 'float',
@@ -106,6 +106,11 @@ const IntContainer = koffi.struct('IntContainer', {
     len: 'int'
 });
 
+const StrStruct = koffi.struct('StrStruct', {
+    str: 'str',
+    str16: 'str16'
+});
+
 main();
 
 async function main() {
@@ -146,13 +151,13 @@ 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', 'string', [...Array(8).fill('int8_t'), koffi.struct('IJK1', {i: 'int8_t', j: 'int8_t', k: 'int8_t'}), 'int8_t']);
-    const ConcatenateToStr4 = lib.func('ConcatenateToStr4', 'string', [...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', 'string', [...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('PackedBFG __fastcall MakePackedBFG(int x, double y, _Out_ PackedBFG *p, const char *str)');
     const ReturnBigString = process.platform == 'win32' ?
-                            lib.stdcall(1, 'string', ['string']) :
+                            lib.stdcall(1, 'str', ['str']) :
                             lib.func('const char * __stdcall ReturnBigString(const char *str)');
     const PrintFmt = lib.func('const char *PrintFmt(const char *fmt, ...)');
     const Concat16 = lib.func('const char16_t *Concat16(const char16_t *str1, const char16_t *str2)')
@@ -175,6 +180,8 @@ async function test() {
     const ArrayToStruct = lib.func('IntContainer ArrayToStruct(int *ptr, int len)');
     const FillRange = lib.func('void FillRange(int init, int step, _Out_ int *out, int len)');
     const MultiplyIntegers = lib.func('void MultiplyIntegers(int multiplier, _Inout_ int *values, int len)');
+    const ThroughStr = lib.func('str ThroughStr(StrStruct s)');
+    const ThroughStr16 = lib.func('str16 ThroughStr16(StrStruct s)');
 
     // Simple signed value returns
     assert.equal(GetMinusOne1(), -1);
@@ -292,7 +299,7 @@ async function test() {
 
     // Variadic
     {
-        let str = PrintFmt('foo %d %g %s', 'int', 200, 'double', 1.5, 'string', 'BAR');
+        let str = PrintFmt('foo %d %g %s', 'int', 200, 'double', 1.5, 'str', 'BAR');
         assert.equal(str, 'foo 200 1.5 BAR');
     }
 
@@ -367,4 +374,12 @@ async function test() {
         assert.deepEqual(out1, [-2, -9, -16, -23, -30, -37, -44, -51, 58, 65]);
         assert.deepEqual(out2, new Int32Array([3 * 13, 3 * 16, 3 * 19, 3 * 22, 3 * 25, 3 * 28, 3 * 31, 34, 37, 40]));
     }
+
+    // Test struct strings
+    {
+        assert.equal(ThroughStr({ str: 'Hello', str16: null }), 'Hello');
+        assert.equal(ThroughStr({ str: null, str16: 'Hello' }), null);
+        assert.equal(ThroughStr16({ str: null, str16: 'World!' }), 'World!');
+        assert.equal(ThroughStr16({ str: 'World!', str16: null }), null);
+    }
 }