koffi 1.3.12 → 2.1.0-beta.1

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,
@@ -51,6 +52,7 @@ enum class PrimitiveKind {
     Array,
     Float32,
     Float64,
+    Prototype,
     Callback
 };
 static const char *const PrimitiveKindNames[] = {
@@ -71,6 +73,7 @@ static const char *const PrimitiveKindNames[] = {
     "Array",
     "Float32",
     "Float64",
+    "Prototype",
     "Callback"
 };
 
@@ -78,6 +81,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 +92,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 +115,7 @@ struct TypeInfo {
 struct RecordMember {
     const char *name;
     const TypeInfo *type;
-    int16_t align;
+    int16_t offset;
 };
 
 struct LibraryHolder {
@@ -161,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};
@@ -199,6 +215,7 @@ struct InstanceMemory {
     Span<uint8_t> heap;
 
     uint16_t generation; // Can wrap without risk
+
     int16_t depth;
     bool temporary;
 };
@@ -206,24 +223,28 @@ 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;
     uint64_t tag_lower;
+    const TypeInfo *void_type;
 
     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/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,8 @@ 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);
+            if (!CanPassType(param.type)) {
+                MarkError("Type %1 cannot be used as a parameter (maybe try %1 *)", param.type->name);
                 return false;
             }
 
@@ -144,60 +143,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,175 @@ 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;
+    }
+
+    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;
 
-        instance->types_map.Set(type);
+        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;
+}
+
+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))
+        if (type.ref.marker && CheckValueTag(instance, value, type.ref.marker))
             return type.name;
     }
 
@@ -130,6 +259,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 +268,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 +307,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,13 @@ 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);
+
+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',
@@ -32,13 +31,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();
@@ -54,15 +54,18 @@ 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)');
-    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 +99,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 +147,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));
+    }
 }