koffi 2.1.5 → 2.2.1

package/src/koffi/src/call.hh

@@ -65,7 +65,7 @@ class alignas(8) CallData {
     } result;
     uint8_t *return_ptr = nullptr;
 
-    LinkedAllocator call_alloc;
+    BlockAllocator call_alloc;
 
 public:
     CallData(Napi::Env env, InstanceData *instance, const FunctionInfo *func, InstanceMemory *mem);
@@ -97,20 +97,16 @@ private:
     template <typename T = uint8_t>
     T *AllocHeap(Size size, Size align);
 
-    bool PushString(Napi::Value value, const char **out_str);
-    bool PushString16(Napi::Value value, const char16_t **out_str16);
+    bool PushString(Napi::Value value, int directions, const char **out_str);
+    Size PushStringValue(Napi::Value value, const char **out_str);
+    bool PushString16(Napi::Value value, int directions, const char16_t **out_str16);
+    Size PushString16Value(Napi::Value value, const char16_t **out_str16);
     bool PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origin, int16_t realign = 0);
-    bool PushNormalArray(Napi::Array array, Size len, const TypeInfo *ref, uint8_t *origin, int16_t realign = 0);
-    bool PushTypedArray(Napi::TypedArray array, Size len, const TypeInfo *ref, uint8_t *origin, int16_t realign = 0);
+    bool PushNormalArray(Napi::Array array, Size len, const TypeInfo *type, uint8_t *origin, int16_t realign = 0);
+    bool PushTypedArray(Napi::TypedArray array, Size len, const TypeInfo *type, uint8_t *origin, int16_t realign = 0);
     bool PushStringArray(Napi::Value value, const TypeInfo *type, uint8_t *origin);
     bool PushPointer(Napi::Value value, const TypeInfo *type, int directions, void **out_ptr);
 
-    void PopObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type, int16_t realign = 0);
-    Napi::Object PopObject(const uint8_t *origin, const TypeInfo *type, int16_t realign = 0);
-    void PopNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo *ref, int16_t realign = 0);
-    void PopTypedArray(Napi::TypedArray array, const uint8_t *origin, const TypeInfo *ref, int16_t realign = 0);
-    Napi::Value PopArray(const uint8_t *origin, const TypeInfo *type, int16_t realign = 0);
-
     void PopOutArguments();
 
     void *ReserveTrampoline(const FunctionInfo *proto, Napi::Function func);

package/src/koffi/src/ffi.cc

@@ -271,7 +271,11 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
             ThrowError<Napi::Error>(env, "Struct '%1' size is too high (max = %2)", type->name, FmtMemSize(size));
             return env.Null();
         }
-        if (!members.TrySet(member.name).second) {
+
+        bool inserted;
+        members.TrySet(member.name, &inserted);
+
+        if (!inserted) {
             ThrowError<Napi::Error>(env, "Duplicate member '%1' in struct '%2'", member.name, type->name);
             return env.Null();
         }
@@ -287,9 +291,14 @@ static Napi::Value CreateStructType(const Napi::CallbackInfo &info, bool pad)
     type->size = (int32_t)size;
 
     // If the insert succeeds, we cannot fail anymore
-    if (named && !instance->types_map.TrySet(type->name, type).second) {
-        ThrowError<Napi::Error>(env, "Duplicate type name '%1'", type->name);
-        return env.Null();
+    if (named) {
+        bool inserted;
+        instance->types_map.TrySet(type->name, type, &inserted);
+
+        if (!inserted) {
+            ThrowError<Napi::Error>(env, "Duplicate type name '%1'", type->name);
+            return env.Null();
+        }
     }
     err_guard.Disable();
 
@@ -333,9 +342,14 @@ static Napi::Value CreateOpaqueType(const Napi::CallbackInfo &info)
     type->align = 0;
 
     // If the insert succeeds, we cannot fail anymore
-    if (named && !instance->types_map.TrySet(type->name, type).second) {
-        ThrowError<Napi::Error>(env, "Duplicate type name '%1'", type->name);
-        return env.Null();
+    if (named) {
+        bool inserted;
+        instance->types_map.TrySet(type->name, type, &inserted);
+
+        if (!inserted) {
+            ThrowError<Napi::Error>(env, "Duplicate type name '%1'", type->name);
+            return env.Null();
+        }
     }
     err_guard.Disable();
 
@@ -399,8 +413,11 @@ static Napi::Value CreatePointerType(const Napi::CallbackInfo &info)
         memcpy((void *)copy, type, RG_SIZE(*type));
         copy->name = DuplicateString(name.c_str(), &instance->str_alloc).ptr;
 
+        bool inserted;
+        instance->types_map.TrySet(copy->name, copy, &inserted);
+
         // If the insert succeeds, we cannot fail anymore
-        if (!instance->types_map.TrySet(copy->name, copy).second) {
+        if (!inserted) {
             ThrowError<Napi::Error>(env, "Duplicate type name '%1'", copy->name);
             return env.Null();
         }
@@ -532,9 +549,14 @@ static Napi::Value CreateDisposableType(const Napi::CallbackInfo &info)
     type->dispose_ref = Napi::Persistent(dispose_func);
 
     // If the insert succeeds, we cannot fail anymore
-    if (named && !instance->types_map.TrySet(type->name, type).second) {
-        ThrowError<Napi::Error>(env, "Duplicate type name '%1'", type->name);
-        return env.Null();
+    if (named) {
+        bool inserted;
+        instance->types_map.TrySet(type->name, type, &inserted);
+
+        if (!inserted) {
+            ThrowError<Napi::Error>(env, "Duplicate type name '%1'", type->name);
+            return env.Null();
+        }
     }
     err_guard.Disable();
 
@@ -688,13 +710,13 @@ static bool ParseClassicFunction(Napi::Env env, Napi::String name, Napi::Value r
         ParameterInfo param = {};
 
         param.type = ResolveType(parameters[j], &param.directions);
+
         if (!param.type)
             return false;
-        if (!CanPassType(param.type)) {
+        if (!CanPassType(param.type, param.directions)) {
             ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a parameter (maybe try %1 *)", param.type->name);
             return false;
         }
-
         if (func->parameters.len >= MaxParameters) {
             ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 parameters", MaxParameters);
             return false;
@@ -790,9 +812,10 @@ static Napi::Value CreateTypeAlias(const Napi::CallbackInfo &info)
     if (!type)
         return env.Null();
 
-    std::pair<const TypeInfo **, bool> ret = instance->types_map.TrySet(alias, type);
+    bool inserted;
+    instance->types_map.TrySet(alias, type, &inserted);
 
-    if (!ret.second) {
+    if (!inserted) {
         ThrowError<Napi::Error>(env, "Type name '%1' already exists", alias);
         return env.Null();
     }
@@ -835,6 +858,40 @@ static Napi::Value GetTypeAlign(const Napi::CallbackInfo &info)
     return Napi::Number::New(env, type->align);
 }
 
+static Napi::Value GetMemberOffset(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (info.Length() < 2) {
+        ThrowError<Napi::TypeError>(env, "Expected 2 arguments, got %1", info.Length());
+        return env.Null();
+    }
+    if (!info[1].IsString()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for member, expected string", GetValueType(instance, info[1]));
+        return env.Null();
+    }
+
+    const TypeInfo *type = ResolveType(info[0]);
+    if (!type)
+        return env.Null();
+    if (type->primitive != PrimitiveKind::Record) {
+        ThrowError<Napi::TypeError>(env, "The offsetof() function can only be used with record types");
+        return env.Null();
+    }
+
+    std::string name = info[1].As<Napi::String>();
+
+    const RecordMember *member = std::find_if(type->members.begin(), type->members.end(),
+        [&](const RecordMember &member) { return TestStr(member.name, name.c_str()); });
+    if (member == type->members.end()) {
+        ThrowError<Napi::Error>(env, "Record type %1 does not have member '%2'", type->name, name.c_str());
+        return env.Null();
+    }
+
+    return Napi::Number::New(env, member->offset);
+}
+
 static Napi::Value GetResolvedType(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
@@ -915,10 +972,16 @@ static Napi::Value GetTypeDefinition(const Napi::CallbackInfo &info)
                 Napi::Object members = Napi::Object::New(env);
 
                 for (const RecordMember &member: type->members) {
+                    Napi::Object obj = Napi::Object::New(env);
+
                     Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, (TypeInfo *)member.type);
                     SetValueTag(instance, external, &TypeInfoMarker);
 
-                    members.Set(member.name, external);
+                    obj.Set("name", member.name);
+                    obj.Set("type", external);
+                    obj.Set("offset", member.offset);
+
+                    members.Set(member.name, obj);
                 }
 
                 defn.Set("members", members);
@@ -1035,13 +1098,13 @@ static Napi::Value TranslateVariadicCall(const Napi::CallbackInfo &info)
         ParameterInfo param = {};
 
         param.type = ResolveType(info[i], &param.directions);
+
         if (RG_UNLIKELY(!param.type))
             return env.Null();
-        if (RG_UNLIKELY(!CanPassType(param.type))) {
+        if (RG_UNLIKELY(!CanPassType(param.type, param.directions))) {
             ThrowError<Napi::TypeError>(env, "Type %1 cannot be used as a parameter (maybe try %1 *)", param.type->name);
             return env.Null();
         }
-
         if (RG_UNLIKELY(func.parameters.len >= MaxParameters)) {
             ThrowError<Napi::TypeError>(env, "Functions cannot have more than %1 parameters", MaxParameters);
             return env.Null();
@@ -1327,18 +1390,21 @@ static Napi::Value RegisterCallback(const Napi::CallbackInfo &info)
     Napi::Env env = info.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
-    if (info.Length() < 2) {
-        ThrowError<Napi::TypeError>(env, "Expected 2 arguments, got %1", info.Length());
+    bool has_recv = (info.Length() >= 3 && info[1].IsFunction());
+
+    if (info.Length() < 2u + has_recv) {
+        ThrowError<Napi::TypeError>(env, "Expected 2 or 3 arguments, got %1", info.Length());
         return env.Null();
     }
-    if (!info[0].IsFunction()) {
-        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for func, expected function", GetValueType(instance, info[0]));
+    if (!info[0u + has_recv].IsFunction()) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for func, expected function", GetValueType(instance, info[0 + has_recv]));
         return env.Null();
     }
 
-    Napi::Function func = info[0].As<Napi::Function>();
+    Napi::Value recv = has_recv ? info[0] : env.Undefined();
+    Napi::Function func = info[0u + has_recv].As<Napi::Function>();
 
-    const TypeInfo *type = ResolveType(info[1]);
+    const TypeInfo *type = ResolveType(info[1u + has_recv]);
     if (!type)
         return env.Null();
     if (type->primitive != PrimitiveKind::Callback) {
@@ -1346,6 +1412,7 @@ static Napi::Value RegisterCallback(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
+
     int idx = CountTrailingZeros(~instance->registered_trampolines);
 
     if (RG_UNLIKELY(idx >= MaxTrampolines)) {
@@ -1360,6 +1427,11 @@ static Napi::Value RegisterCallback(const Napi::CallbackInfo &info)
 
     trampoline->proto = type->ref.proto;
     trampoline->func.Reset(func, 1);
+    if (!IsNullOrUndefined(recv)) {
+        trampoline->recv.Reset(recv, 1);
+    } else {
+        trampoline->recv.Reset();
+    }
     trampoline->generation = -1;
 
     void *ptr = GetTrampoline(idx, type->ref.proto);
@@ -1393,10 +1465,12 @@ static Napi::Value UnregisterCallback(const Napi::CallbackInfo &info)
         if (!(instance->registered_trampolines & (1u << i)))
             continue;
 
-        const TrampolineInfo &trampoline = instance->trampolines[idx];
+        TrampolineInfo *trampoline = &instance->trampolines[idx];
 
-        if (GetTrampoline(idx, trampoline.proto) == ptr) {
+        if (GetTrampoline(idx, trampoline->proto) == ptr) {
             instance->registered_trampolines &= ~(1u << i);
+            trampoline->recv.Reset();
+
             return env.Undefined();
         }
     }
@@ -1459,8 +1533,9 @@ static void RegisterPrimitiveType(Napi::Env env, Napi::Object map, std::initiali
     SetValueTag(instance, external, &TypeInfoMarker);
 
     for (const char *name: names) {
-        std::pair<const TypeInfo **, bool> ret = instance->types_map.TrySet(name, type);
-        RG_ASSERT(ret.second);
+        bool inserted;
+        instance->types_map.TrySet(name, type, &inserted);
+        RG_ASSERT(inserted);
 
         if (!EndsWith(name, "*")) {
             map.Set(name, external);
@@ -1546,7 +1621,8 @@ static Napi::Object InitBaseTypes(Napi::Env env)
     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);
+    instance->char_type = instance->types_map.FindValue("char", nullptr);
+    instance->char16_type = instance->types_map.FindValue("char16", nullptr);
 
     types.Freeze();
 
@@ -1630,6 +1706,128 @@ static Napi::Value CastValue(const Napi::CallbackInfo &info)
     return external;
 }
 
+static Napi::Value DecodeValue(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    bool has_offset = (info.Length() >= 2 && info[1].IsNumber());
+    bool has_len = (info.Length() >= 3u + has_offset && info[2u + has_offset].IsNumber());
+
+    if (RG_UNLIKELY(info.Length() < 2u + has_offset)) {
+        ThrowError<Napi::TypeError>(env, "Expected %1 to 4 arguments, got %2", 2 + has_offset, info.Length());
+        return env.Null();
+    }
+    if (RG_UNLIKELY(!info[0].IsExternal())) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for variable, expected pointer (external)", GetValueType(instance, info[0]));
+        return env.Null();
+    }
+    if (has_len && RG_UNLIKELY(!info[2u + has_offset].IsNumber())) {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for length, expected number", GetValueType(instance, info[2 + has_offset]));
+        return env.Null();
+    }
+
+    Napi::External<void> external = info[0].As<Napi::External<void>>();
+    int64_t offset = has_offset ? info[1].As<Napi::Number>().Int64Value() : 0;
+    const uint8_t *ptr = (const uint8_t *)external.Data() + offset;
+
+    if (!ptr)
+        return env.Null();
+
+    const TypeInfo *type = ResolveType(info[1u + has_offset]);
+    if (RG_UNLIKELY(!type))
+        return env.Null();
+
+    // Used for strings and arrays, ignored otherwise
+    int64_t len = has_len ? info[2u + has_offset].As<Napi::Number>().Int64Value() : -1;
+
+#define RETURN_INT(Type, NewCall) \
+        do { \
+            Type v = *(Type *)ptr; \
+            return NewCall(env, v); \
+        } while (false)
+#define RETURN_INT_SWAP(Type, NewCall) \
+        do { \
+            Type v = ReverseBytes(*(Type *)ptr); \
+            return NewCall(env, v); \
+        } while (false)
+
+    switch (type->primitive) {
+        case PrimitiveKind::Void: {
+            ThrowError<Napi::TypeError>(env, "Cannot decode value of type %1", type->name);
+            return env.Null();
+        } break;
+
+        case PrimitiveKind::Bool: {
+            bool v = *(bool *)ptr;
+            return Napi::Boolean::New(env, v);
+        } break;
+        case PrimitiveKind::Int8: { RETURN_INT(int8_t, Napi::Number::New); } break;
+        case PrimitiveKind::UInt8: { RETURN_INT(uint8_t, Napi::Number::New); } break;
+        case PrimitiveKind::Int16: { RETURN_INT(int16_t, Napi::Number::New); } break;
+        case PrimitiveKind::Int16S: { RETURN_INT_SWAP(int16_t, Napi::Number::New); } break;
+        case PrimitiveKind::UInt16: { RETURN_INT(uint16_t, Napi::Number::New); } break;
+        case PrimitiveKind::UInt16S: { RETURN_INT_SWAP(uint16_t, Napi::Number::New); } break;
+        case PrimitiveKind::Int32: { RETURN_INT(int32_t, Napi::Number::New); } break;
+        case PrimitiveKind::Int32S: { RETURN_INT_SWAP(int32_t, Napi::Number::New); } break;
+        case PrimitiveKind::UInt32: { RETURN_INT(uint32_t, Napi::Number::New); } break;
+        case PrimitiveKind::UInt32S: { RETURN_INT_SWAP(uint32_t, Napi::Number::New); } break;
+        case PrimitiveKind::Int64: { RETURN_INT(int64_t, NewBigInt); } break;
+        case PrimitiveKind::Int64S: { RETURN_INT_SWAP(int64_t, NewBigInt); } break;
+        case PrimitiveKind::UInt64: { RETURN_INT(uint64_t, NewBigInt); } break;
+        case PrimitiveKind::UInt64S: { RETURN_INT_SWAP(uint64_t, NewBigInt); } break;
+        case PrimitiveKind::String: {
+            if (len >= 0) {
+                const char *str = *(const char **)ptr;
+                return str ? Napi::String::New(env, str, len) : env.Null();
+            } else {
+                const char *str = *(const char **)ptr;
+                return str ? Napi::String::New(env, str) : env.Null();
+            }
+        } break;
+        case PrimitiveKind::String16: {
+            if (len >= 0) {
+                const char16_t *str16 = *(const char16_t **)ptr;
+                return str16 ? Napi::String::New(env, str16, len) : env.Null();
+            } else {
+                const char16_t *str16 = *(const char16_t **)ptr;
+                return str16 ? Napi::String::New(env, str16) : env.Null();
+            }
+        } break;
+        case PrimitiveKind::Pointer: 
+        case PrimitiveKind::Callback: {
+            void *ptr2 = *(void **)ptr;
+            return ptr2 ? Napi::External<void>::New(env, ptr2, [](Napi::Env, void *) {}) : env.Null();
+        } break;
+        case PrimitiveKind::Array: {
+            Napi::Value array = DecodeArray(env, ptr, type);
+            return array;
+        } break;
+        case PrimitiveKind::Record: {
+            Napi::Object obj = DecodeObject(env, ptr, type);
+            return obj;
+        } break;
+        case PrimitiveKind::Float32: {
+            float f = *(float *)ptr;
+            return Napi::Number::New(env, f);
+        } break;
+        case PrimitiveKind::Float64: {
+            double d = *(double *)ptr;
+            return Napi::Number::New(env, d);
+        } break;
+
+        case PrimitiveKind::Prototype: {
+            ThrowError<Napi::TypeError>(env, "Cannot decode value of type %1", type->name);
+            return env.Null();
+        } break;
+    }
+
+#undef RETURN_BIGINT
+#undef RETURN_INT
+
+    return env.Null();
+}
+
 template <typename Func>
 static void SetExports(Napi::Env env, Func func)
 {
@@ -1645,6 +1843,7 @@ static void SetExports(Napi::Env env, Func func)
 
     func("sizeof", Napi::Function::New(env, GetTypeSize));
     func("alignof", Napi::Function::New(env, GetTypeAlign));
+    func("offsetof", Napi::Function::New(env, GetMemberOffset));
     func("resolve", Napi::Function::New(env, GetResolvedType));
     func("introspect", Napi::Function::New(env, GetTypeDefinition));
 
@@ -1661,6 +1860,7 @@ static void SetExports(Napi::Env env, Func func)
     func("unregister", Napi::Function::New(env, UnregisterCallback));
 
     func("as", Napi::Function::New(env, CastValue));
+    func("decode", Napi::Function::New(env, DecodeValue));
 
 #if defined(_WIN32)
     func("extension", Napi::String::New(env, ".dll"));

package/src/koffi/src/ffi.hh

@@ -133,7 +133,7 @@ struct RecordMember {
 
 struct LibraryHolder {
     void *module = nullptr; // HMODULE on Windows
-    mutable std::atomic_int refcount {1};
+    mutable std::atomic_int refcount { 1 };
 
     LibraryHolder(void *module) : module(module) {}
     ~LibraryHolder();
@@ -192,7 +192,7 @@ struct ValueCast {
 
 // Also used for callbacks, even though many members are not used in this case
 struct FunctionInfo {
-    mutable std::atomic_int refcount {1};
+    mutable std::atomic_int refcount { 1 };
 
     const char *name;
     const char *decorated_name; // Only set for some platforms/calling conventions
@@ -236,6 +236,7 @@ struct InstanceMemory {
 struct TrampolineInfo {
     const FunctionInfo *proto;
     Napi::FunctionReference func;
+    Napi::Reference<Napi::Value> recv;
 
     int32_t generation;
 };
@@ -249,7 +250,10 @@ struct InstanceData {
 
     bool debug;
     uint64_t tag_lower;
+
     const TypeInfo *void_type;
+    const TypeInfo *char_type;
+    const TypeInfo *char16_type;
 
     LocalArray<InstanceMemory *, 9> memories;
     int temporaries = 0;

package/src/koffi/src/parser.cc

@@ -65,18 +65,11 @@ bool PrototypeParser::Parse(const char *str, FunctionInfo *out_func)
             }
 
             param.type = ParseType();
-            if (!CanPassType(param.type)) {
-                MarkError("Type %1 cannot be used as a parameter (maybe try %1 *)", param.type->name);
-                return false;
-            }
 
-            if ((param.directions & 2) && param.type->primitive != PrimitiveKind::Pointer) {
-                MarkError("Only pointers can be used for output parameters");
+            if (!CanPassType(param.type, param.directions)) {
+                MarkError("Type %1 cannot be used as a parameter (maybe try %1 *)", param.type->name);
                 return false;
             }
-
-            offset += (offset < tokens.len && IsIdentifier(tokens[offset]));
-
             if (out_func->parameters.len >= MaxParameters) {
                 MarkError("Functions cannot have more than %1 parameters", MaxParameters);
                 return false;
@@ -90,6 +83,7 @@ bool PrototypeParser::Parse(const char *str, FunctionInfo *out_func)
 
             out_func->parameters.Append(param);
 
+            offset += (offset < tokens.len && IsIdentifier(tokens[offset]));
             if (offset >= tokens.len || tokens[offset] != ",")
                 break;
             offset++;