koffi 3.0.1 → 3.0.2

package/src/koffi/src/type.cc

@@ -0,0 +1,715 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2026 Niels Martignène <niels.martignene@protonmail.com>
+
+#include "lib/native/base/base.hh"
+#include "ffi.hh"
+#include "type.hh"
+#include "util.hh"
+
+#include <napi.h>
+
+namespace K {
+
+#if !defined(EXTERNAL_TYPES)
+
+Napi::Function TypeObject::InitClass(InstanceData *instance)
+{
+    Napi::Env env = instance->env;
+    Napi::Function constructor = DefineClass(env, "TypeObject", {}, instance);
+
+    return constructor;
+}
+
+TypeObject::TypeObject(const Napi::CallbackInfo &info)
+    : Napi::ObjectWrap<TypeObject>(info)
+{
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1 || !info[0u].IsExternal()) [[unlikely]] {
+        ThrowError<Napi::Error>(env, "Type objects cannot be constructed manually");
+        return;
+    }
+
+    Napi::External<TypeInfo> external = info[0u].As<Napi::External<TypeInfo>>();
+    type = external.Data();
+}
+
+void TypeObject::Finalize(Napi::BasicEnv env)
+{
+    DeleteReferenceSafe(env, *this);
+    SuppressDestruct();
+}
+
+#endif
+
+static inline bool IsIdentifierStart(char c)
+{
+    return IsAsciiAlpha(c) || c == '_';
+}
+
+static inline bool IsIdentifierChar(char c)
+{
+    return IsAsciiAlphaOrDigit(c) || c == '_';
+}
+
+static inline Span<const char> SplitIdentifier(Span<const char> str)
+{
+    Size offset = 0;
+
+    if (str.len && IsIdentifierStart(str[0])) {
+        offset++;
+
+        while (offset < str.len && IsIdentifierChar(str[offset])) {
+            offset++;
+        }
+    }
+
+    Span<const char> token = str.Take(0, offset);
+    return token;
+}
+
+int ResolveDirections(Span<const char> str)
+{
+    if (str == "_In_") {
+        return 1;
+    } else if (str == "_Out_") {
+        return 2;
+    } else if (str == "_Inout_") {
+        return 3;
+    } else {
+        return 0;
+    }
+}
+
+const TypeInfo *ResolveType(InstanceData *instance, napi_value value, int *out_directions)
+{
+    Napi::Env env = instance->env;
+
+    // String?
+    {
+        char str[1024];
+        size_t len;
+
+        napi_status status = napi_get_value_string_utf8(env, value, str, K_SIZE(str), &len);
+
+        if (status == napi_ok) {
+            Span<const char> remain = MakeSpan(str, (Size)len);
+
+            // Quick path for known types (int, float *, etc.)
+            const TypeInfo *type = instance->types_map.FindValue(remain.ptr, nullptr);
+
+            if (!type) {
+                if (out_directions) {
+                    Span<const char> prefix = SplitIdentifier(remain);
+                    int directions = ResolveDirections(prefix);
+
+                    if (directions) {
+                        remain = remain.Take(prefix.len, remain.len - prefix.len);
+                        remain = TrimStrLeft(remain);
+
+                        *out_directions = directions;
+                    } else {
+                        *out_directions = 1;
+                    }
+                }
+
+                type = ResolveType(instance, remain.ptr);
+
+                if (!type) {
+                    if (!env.IsExceptionPending()) {
+                        ThrowError<Napi::TypeError>(env, "Unknown or invalid type name '%1'", str);
+                    }
+                    return nullptr;
+                }
+
+                // Cache for quick future access
+                bool inserted;
+                auto bucket = instance->types_map.InsertOrGetDefault(remain.ptr, &inserted);
+
+                if (inserted) {
+                    bucket->key = DuplicateString(remain, &instance->str_alloc).ptr;
+                    bucket->value = type;
+                }
+            } else if (out_directions) {
+                *out_directions = 1;
+            }
+
+            return type;
+        }
+    }
+
+    napi_valuetype kind = GetKindOf(env, value);
+
+    if (kind == napi_external && CheckValueTag(env, value, &DirectionMarker)) {
+        Napi::External<TypeInfo> external = Napi::External<TypeInfo>(env, value);
+        const TypeInfo *raw = external.Data();
+
+        const TypeInfo *type = AlignDown(raw, 4);
+        K_ASSERT(type);
+
+        if (out_directions) {
+            Size delta = (uint8_t *)raw - (uint8_t *)type;
+            *out_directions = 1 + (int)delta;
+        }
+
+        return type;
+#if defined(EXTERNAL_TYPES)
+    } else if (kind == napi_external && CheckValueTag(env, value, &TypeObjectMarker)) {
+        Napi::External<TypeInfo> external = Napi::External<TypeInfo>(env, value);
+        const TypeInfo *type = external.Data();
+
+        if (out_directions) {
+            *out_directions = 1;
+        }
+        return type;
+#else
+    } else if (kind == napi_object && CheckValueTag(env, value, &TypeObjectMarker)) {
+        TypeObject *defn = nullptr;
+        NAPI_OK(napi_unwrap(env, value, (void **)&defn));
+
+        if (out_directions) {
+            *out_directions = 1;
+        }
+        return defn->GetType();
+#endif
+    } else {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value as type specifier, expected string or type", GetValueType(instance, value));
+        return nullptr;
+    }
+}
+
+const TypeInfo *ResolveType(InstanceData *instance, Span<const char> str)
+{
+    Napi::Env env = instance->env;
+
+    // Each item can be > 0 for array or 0 for a pointer
+    LocalArray<Size, 8> arrays;
+    uint8_t disposables = 0;
+
+    Span<const char> name;
+    Span<const char> after;
+    {
+        Span<const char> remain = str;
+
+        // Skip initial const qualifiers
+        remain = TrimStrLeft(remain);
+        while (SplitIdentifier(remain) == "const") {
+            remain = remain.Take(6, remain.len - 6);
+            remain = TrimStrLeft(remain);
+        }
+        remain = TrimStrLeft(remain);
+
+        after = remain;
+
+        // Consume one or more identifiers (e.g. unsigned int)
+        for (;;) {
+            after = TrimStrLeft(after);
+
+            Span<const char> token = SplitIdentifier(after);
+            if (!token.len)
+                break;
+            after = after.Take(token.len, after.len - token.len);
+        }
+
+        name = TrimStr(MakeSpan(remain.ptr, after.ptr - remain.ptr));
+    }
+
+    // Consume type indirections (pointer, array, etc.)
+    while (after.len) {
+        if (after[0] == '*') {
+            after = after.Take(1, after.len - 1);
+
+            if (!arrays.Available()) [[unlikely]] {
+                ThrowError<Napi::Error>(env, "Too many type indirections");
+                return nullptr;
+            }
+
+            arrays.Append(0);
+        } else if (after[0] == '!') {
+            after = after.Take(1, after.len - 1);
+            disposables |= (1u << arrays.len);
+        } else if (after[0] == '[') {
+            after = after.Take(1, after.len - 1);
+
+            Size len = 0;
+
+            after = TrimStrLeft(after);
+            if (!ParseInt(after, &len, 0, &after) || len < 0) [[unlikely]] {
+                ThrowError<Napi::Error>(env, "Invalid array length");
+                return nullptr;
+            }
+            after = TrimStrLeft(after);
+            if (!after.len || after[0] != ']') [[unlikely]] {
+                ThrowError<Napi::Error>(env, "Expected ']' after array length");
+                return nullptr;
+            }
+            after = after.Take(1, after.len - 1);
+
+            if (!arrays.Available()) [[unlikely]] {
+                ThrowError<Napi::Error>(env, "Too many type indirections");
+                return nullptr;
+            }
+
+            arrays.Append(len);
+        } else if (SplitIdentifier(after) == "const") {
+            after = after.Take(6, after.len - 6);
+        } else {
+            after = TrimStrRight(after);
+
+            if (after.len) [[unlikely]] {
+                ThrowError<Napi::Error>(env, "Unexpected character '%1' in type specifier", after[0]);
+                return nullptr;
+            }
+
+            break;
+        }
+
+        after = TrimStrLeft(after);
+    }
+
+    const TypeInfo *type = instance->types_map.FindValue(name, nullptr);
+
+    if (!type) {
+        // Try with cleaned up spaces
+        if (name.len < 256) {
+            LocalArray<char, 256> buf;
+            for (Size i = 0; i < name.len; i++) {
+                char c = name[i];
+
+                if (IsAsciiWhite(c)) {
+                    buf.Append(' ');
+                    while (++i < name.len && IsAsciiWhite(name[i]));
+                    i--;
+                } else {
+                    buf.Append(c);
+                }
+            }
+
+            type = instance->types_map.FindValue(buf, nullptr);
+        }
+
+        if (!type)
+            return nullptr;
+    }
+
+    for (int i = 0;; i++) {
+        if (disposables & (1u << i)) {
+            if (type->primitive != PrimitiveKind::Pointer &&
+                    type->primitive != PrimitiveKind::String &&
+                    type->primitive != PrimitiveKind::String16 &&
+                    type->primitive != PrimitiveKind::String32) [[unlikely]] {
+                ThrowError<Napi::Error>(env, "Cannot create disposable type for non-pointer");
+                return nullptr;
+            }
+
+            TypeInfo *copy = instance->types.AppendDefault();
+
+            memcpy((void *)copy, (const void *)type, K_SIZE(*type));
+            copy->name = Fmt(&instance->str_alloc, "<anonymous_%1>", instance->types.count).ptr;
+            copy->members.allocator = GetNullAllocator();
+            copy->members.allocator = GetNullAllocator();
+            memset((void *)&copy->defn, 0, K_SIZE(copy->defn));
+
+            static_assert(!std::is_polymorphic_v<Napi::ObjectReference>);
+
+            copy->dispose = [](Napi::Env env, const TypeInfo *, const void *ptr) {
+                InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+                free((void *)ptr);
+                instance->stats.disposed++;
+            };
+
+            type = copy;
+        }
+
+        if (i >= arrays.len)
+            break;
+        Size len = arrays[i];
+
+        if (len > 0) {
+            if (type->primitive == PrimitiveKind::Void) [[unlikely]] {
+                ThrowError<Napi::TypeError>(env, "Cannot make array of empty or incomplete type");
+                return nullptr;
+            }
+
+            if (len > instance->config.max_type_size / type->size) {
+                ThrowError<Napi::TypeError>(env, "Array length is too high (max = %1)", instance->config.max_type_size / type->size);
+                return nullptr;
+            }
+
+            type = MakeArrayType(instance, type, len);
+            K_ASSERT(type);
+        } else {
+            K_ASSERT(!len);
+
+            type = MakePointerType(instance, type);
+            K_ASSERT(type);
+        }
+    }
+
+    return type;
+}
+
+TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *ref, int count)
+{
+    K_ASSERT(count >= 1);
+
+    for (int i = 0; i < count; i++) {
+        char name_buf[256];
+        Fmt(name_buf, "%1%2*", ref->name, EndsWith(ref->name, "*") ? "" : " ");
+
+        bool inserted;
+        auto bucket = instance->types_map.InsertOrGetDefault(name_buf, &inserted);
+
+        if (inserted) {
+            TypeInfo *type = instance->types.AppendDefault();
+
+            type->name = DuplicateString(name_buf, &instance->str_alloc).ptr;
+
+            if (ref->primitive != PrimitiveKind::Prototype) {
+                type->primitive = PrimitiveKind::Pointer;
+                type->size = K_SIZE(void *);
+                type->align = K_SIZE(void *);
+                type->ref.type = ref;
+                type->ref.stride = ref->size;
+                type->hint = (ref->flags & (int)TypeFlag::HasTypedArray) ? ArrayHint::Typed : ArrayHint::Array;
+            } else {
+                type->primitive = PrimitiveKind::Callback;
+                type->size = K_SIZE(void *);
+                type->align = K_SIZE(void *);
+                type->ref.type = instance->void_type; // Dummy
+                type->proto = ref->proto;
+            }
+
+            bucket->key = type->name;
+            bucket->value = type;
+        }
+
+        ref = bucket->value;
+    }
+
+    return (TypeInfo *)ref;
+}
+
+static TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len, ArrayHint hint, bool insert)
+{
+    K_ASSERT(len >= 0);
+    K_ASSERT(len <= instance->config.max_type_size / ref->size);
+
+    TypeInfo *type = instance->types.AppendDefault();
+
+    type->name = Fmt(&instance->str_alloc, "%1[%2]", ref->name, len).ptr;
+
+    type->primitive = PrimitiveKind::Array;
+    type->align = ref->align;
+    type->size = (int32_t)(len * ref->size);
+    type->ref.type = ref;
+    type->ref.stride = ref->size;
+    type->hint = hint;
+
+    if (insert) {
+        bool inserted;
+        type = (TypeInfo *)*instance->types_map.InsertOrGet(type->name, type, &inserted);
+        instance->types.RemoveLast(!inserted);
+    }
+
+    return type;
+}
+
+TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len)
+{
+    ArrayHint hint = {};
+
+    if (ref->flags & (int)TypeFlag::IsCharLike) {
+        hint = ArrayHint::String;
+    } else if (ref->flags & (int)TypeFlag::HasTypedArray) {
+        hint = ArrayHint::Typed;
+    } else {
+        hint = ArrayHint::Array;
+    }
+
+    return MakeArrayType(instance, ref, len, hint, true);
+}
+
+TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len, ArrayHint hint)
+{
+    return MakeArrayType(instance, ref, len, hint, false);
+}
+
+napi_value WrapType(Napi::Env env, const TypeInfo *type, bool freeze)
+{
+    if (type->defn.IsEmpty()) {
+#if defined(EXTERNAL_TYPES)
+        Napi::Object defn = Napi::Object::New(env);
+#else
+        InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+        Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, (TypeInfo *)type);
+        Napi::Object defn = instance->construct_type.New({ external });
+        SetValueTag(env, defn, &TypeObjectMarker);
+#endif
+
+        defn.Set("name", Napi::String::New(env, type->name));
+        defn.Set("primitive", PrimitiveKindNames[(int)type->primitive]);
+        defn.Set("size", Napi::Number::New(env, (double)type->size));
+        defn.Set("alignment", Napi::Number::New(env, (double)type->align));
+        defn.Set("disposable", Napi::Boolean::New(env, !!type->dispose));
+
+        // Assign before to avoid possible recursion crash
+        type->defn = Napi::Persistent(defn);
+
+        switch (type->primitive) {
+            case PrimitiveKind::Void:
+            case PrimitiveKind::Bool:
+            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::String32:
+            case PrimitiveKind::Float32:
+            case PrimitiveKind::Float64: {} break;
+
+            case PrimitiveKind::Array: {
+                uint32_t len = type->size / type->ref.type->size;
+                defn.Set("length", Napi::Number::New(env, (double)len));
+                defn.Set("hint", ArrayHintNames[(int)type->hint]);
+            } [[fallthrough]];
+            case PrimitiveKind::Pointer: {
+                napi_value value = WrapType(env, type->ref.type);
+                defn.Set("ref", value);
+            } break;
+            case PrimitiveKind::Record:
+            case PrimitiveKind::Union: {
+                Napi::Object members = Napi::Object::New(env);
+
+                for (const RecordMember &member: type->members) {
+                    Napi::Object obj = Napi::Object::New(env);
+
+                    obj.Set("name", member.name);
+                    obj.Set("type", WrapType(env, member.type));
+                    obj.Set("offset", member.offset);
+
+                    members.Set(member.name, obj);
+                }
+
+                members.Freeze();
+                defn.Set("members", members);
+            } break;
+
+            case PrimitiveKind::Prototype:
+            case PrimitiveKind::Callback: {
+                napi_value meta = DescribeFunction(env, type->proto);
+                defn.Set("proto", meta);
+            } break;
+        }
+
+        if (freeze) {
+            defn.Freeze();
+        }
+    }
+
+#if defined(EXTERNAL_TYPES)
+    Napi::External<TypeInfo> external = Napi::External<TypeInfo>::New(env, (TypeInfo *)type);
+    SetValueTag(env, external, &TypeObjectMarker);
+
+    return external;
+#else
+    return type->defn.Value();
+#endif
+}
+
+const TypeInfo *ReshapeType(InstanceData *instance, const TypeInfo *type, int32_t stride, uint16_t flags)
+{
+    K_ASSERT(!type->defn.IsEmpty());
+
+    if (!type->reshaped) {
+        TypeInfo *reshaped = nullptr;
+
+        switch (type->primitive) {
+            case PrimitiveKind::Record: {
+                reshaped = instance->types.AppendDefault();
+
+                memcpy((void *)reshaped, (const void *)type, K_SIZE(*type));
+                memset((void *)&reshaped->members, 0, K_SIZE(reshaped->members));
+                reshaped->members.Reserve(type->members.len);
+                reshaped->size = 0;
+                reshaped->flags |= flags;
+                memset((void *)&reshaped->defn, 0, K_SIZE(reshaped->defn));
+
+                Napi::Object defn = type->defn.Value();
+                reshaped->defn = Napi::Persistent(defn);
+
+                for (RecordMember member: type->members) {
+                    member.offset = reshaped->size;
+                    member.type = ReshapeType(instance, member.type, stride, flags);
+
+                    reshaped->members.Append(member);
+                    reshaped->size += AlignLen(member.type->size, stride);
+                }
+            } break;
+
+            case PrimitiveKind::Array: {
+                reshaped = instance->types.AppendDefault();
+
+                memcpy((void *)reshaped, (const void *)type, K_SIZE(*type));
+                reshaped->ref.stride = stride;
+                reshaped->size = (type->size / type->ref.stride) * stride;
+                memset((void *)&reshaped->defn, 0, K_SIZE(reshaped->defn));
+                reshaped->flags |= flags;
+
+                Napi::Object defn = type->defn.Value();
+                reshaped->defn = Napi::Persistent(defn);
+            } break;
+
+            default: { reshaped = (TypeInfo *)type; } break;
+        }
+
+        type->reshaped = reshaped;
+    }
+
+    return type->reshaped;
+}
+
+bool CanPassType(const TypeInfo *type, int directions)
+{
+    if (type->countedby)
+        return false;
+
+    if (directions & 2) {
+        if (type->primitive == PrimitiveKind::Pointer)
+            return true;
+        if (type->primitive == PrimitiveKind::String)
+            return true;
+        if (type->primitive == PrimitiveKind::String16)
+            return true;
+        if (type->primitive == PrimitiveKind::String32)
+            return true;
+
+        return false;
+    } else {
+        if (type->primitive == PrimitiveKind::Void)
+            return false;
+        if (type->primitive == PrimitiveKind::Array)
+            return false;
+        if (type->primitive == PrimitiveKind::Prototype)
+            return false;
+        if (type->primitive == PrimitiveKind::Callback && type->proto->variadic)
+            return false;
+
+        return true;
+    }
+}
+
+bool CanReturnType(const TypeInfo *type)
+{
+    if (type->countedby)
+        return false;
+
+    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;
+    if (type->primitive == PrimitiveKind::Callback && type->proto->variadic)
+        return false;
+
+    return true;
+}
+
+const char *GetValueType(const InstanceData *instance, napi_value value)
+{
+    Napi::Env env = instance->env;
+    napi_valuetype kind = GetKindOf(env, value);
+
+    if (kind == napi_external) {
+        if (CheckValueTag(env, value, &CastMarker)) {
+            Napi::External<ValueCast> external = Napi::External<ValueCast>(env, value);
+            ValueCast *cast = external.Data();
+
+            return cast->type->name;
+        }
+
+        if (CheckValueTag(env, value, &LibraryHandleMarker))
+            return "LibraryHandle";
+        if (CheckValueTag(env, value, &TypeObjectMarker))
+            return "TypeObject";
+
+        if (CheckValueTag(env, value, &UnionValueMarker)) {
+            UnionValue *u = nullptr;
+            napi_unwrap(env, value, (void **)&u);
+
+            return u->GetType()->name;
+        }
+
+        for (const TypeInfo &type: instance->types) {
+            if (type.ref.type && CheckValueTag(env, value, type.ref.type))
+                return type.name;
+        }
+    }
+
+    if (IsArray(env, value)) {
+        return "Array";
+    } else if (IsTypedArray(env, value)) {
+        Napi::TypedArray array = Napi::TypedArray(env, value);
+
+        switch (array.TypedArrayType()) {
+            case napi_int8_array: return "Int8Array";
+            case napi_uint8_array: return "Uint8Array";
+            case napi_uint8_clamped_array: return "Uint8ClampedArray";
+            case napi_int16_array: return "Int16Array";
+            case napi_uint16_array: return "Uint16Array";
+            case napi_int32_array: return "Int32Array";
+            case napi_uint32_array: return "Uint32Array";
+            case napi_float16_array: return "Float16Array";
+            case napi_float32_array: return "Float32Array";
+            case napi_float64_array: return "Float64Array";
+            case napi_bigint64_array: return "BigInt64Array";
+            case napi_biguint64_array: return "BigUint64Array";
+        }
+    } else if (IsArrayBuffer(env, value)) {
+        return "ArrayBuffer";
+    } else if (IsBuffer(env, value)) {
+        return "Buffer";
+    }
+
+    switch (kind) {
+        case napi_undefined: return "Undefined";
+        case napi_null: return "Null";
+        case napi_boolean: return "Boolean";
+        case napi_number: return "Number";
+        case napi_string: return "String";
+        case napi_symbol: return "Symbol";
+        case napi_object: return "Object";
+        case napi_function: return "Function";
+        case napi_external: return "External";
+        case napi_bigint: return "BigInt";
+    }
+
+    // This should not be possible, but who knows...
+    return "Unknown";
+}
+
+}