koffi 2.3.4 → 2.3.6-beta.1

package/src/koffi/src/util.cc

@@ -20,6 +20,83 @@
 
 namespace RG {
 
+// Value does not matter, the tag system uses memory addresses
+const int TypeInfoMarker = 0xDEADBEEF;
+const int CastMarker = 0xDEADBEEF;
+const int MagicUnionMarker = 0xDEADBEEF;
+
+Napi::Function MagicUnion::InitClass(Napi::Env env, const TypeInfo *type)
+{
+    RG_ASSERT(type->primitive == PrimitiveKind::Union);
+
+    // node-addon-api wants std::vector
+    std::vector<Napi::ClassPropertyDescriptor<MagicUnion>> properties; 
+    properties.reserve(type->members.len);
+
+    for (Size i = 0; i < type->members.len; i++) {
+        const RecordMember &member = type->members[i];
+
+        napi_property_attributes attr = (napi_property_attributes)(napi_writable | napi_enumerable);
+        Napi::ClassPropertyDescriptor<MagicUnion> prop = InstanceAccessor(member.name, &MagicUnion::Getter,
+                                                                          &MagicUnion::Setter, attr, (void *)i);
+
+        properties.push_back(prop);
+    }
+
+    Napi::Function constructor = DefineClass(env, type->name, properties, (void *)type);
+    return constructor;
+}
+
+MagicUnion::MagicUnion(const Napi::CallbackInfo &info)
+    : Napi::ObjectWrap<MagicUnion>(info), type((const TypeInfo *)info.Data())
+{
+}
+
+void MagicUnion::SetRaw(const uint8_t *ptr)
+{
+    raw = ptr;
+
+    active_idx = -1;
+    Value().Set("__active", Env().Undefined());
+}
+
+Napi::Value MagicUnion::Getter(const Napi::CallbackInfo &info)
+{
+    Size idx = (Size)info.Data();
+    const RecordMember &member = type->members[idx];
+
+    Napi::Value value;
+
+    if (idx == active_idx) {
+        value = Value().Get("__active");
+    } else {
+        Napi::Env env = info.Env();
+
+        if (RG_UNLIKELY(!raw)) {
+            ThrowError<Napi::Error>(env, "Cannont convert %1 union value", active_idx < 0 ? "empty" : "assigned");
+            return env.Null();
+        }
+
+        value = Decode(env, raw, member.type);
+
+        Value().Set("__active", value);
+        active_idx = idx;
+    }
+
+    RG_ASSERT(!value.IsEmpty());
+    return value;
+}
+
+void MagicUnion::Setter(const Napi::CallbackInfo &info, const Napi::Value &value)
+{
+    Size idx = (Size)info.Data();
+
+    Value().Set("__active", value);
+    active_idx = idx;
+
+    raw = nullptr;
+}
+
 const TypeInfo *ResolveType(Napi::Value value, int *out_directions)
 {
     Napi::Env env = value.Env();
@@ -216,7 +293,7 @@ const TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *ref, int
 }
 
 static const TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len,
-                                     TypeInfo::ArrayHint hint, bool insert)
+                                     ArrayHint hint, bool insert)
 {
     RG_ASSERT(len > 0);
     RG_ASSERT(len <= instance->config.max_type_size / ref->size);
@@ -242,19 +319,19 @@ static const TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref
 
 const TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len)
 {
-    TypeInfo::ArrayHint hint = {};
+    ArrayHint hint = {};
 
     if (TestStr(ref->name, "char") || TestStr(ref->name, "char16") ||
                                              TestStr(ref->name, "char16_t")) {
-        hint = TypeInfo::ArrayHint::String;
+        hint = ArrayHint::String;
     } else {
-        hint = TypeInfo::ArrayHint::TypedArray;
+        hint = ArrayHint::Typed;
     }
 
     return MakeArrayType(instance, ref, len, hint, true);
 }
 
-const TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len, TypeInfo::ArrayHint hint)
+const TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len, ArrayHint hint)
 {
     return MakeArrayType(instance, ref, len, hint, false);
 }
@@ -402,14 +479,27 @@ int GetTypedArrayType(const TypeInfo *type)
     RG_UNREACHABLE();
 }
 
-Napi::Object DecodeObject(Napi::Env env, const uint8_t *origin, const TypeInfo *type, int16_t realign)
+Napi::Object DecodeObject(Napi::Env env, const uint8_t *origin, const TypeInfo *type)
 {
+    // We can't decode unions because we don't know which member is valid
+    if (type->primitive == PrimitiveKind::Union) {
+        InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+        Napi::Object wrapper = type->construct.New({}).As<Napi::Object>();
+        SetValueTag(instance, wrapper, &MagicUnionMarker);
+
+        MagicUnion *u = MagicUnion::Unwrap(wrapper);
+        u->SetRaw(origin);
+
+        return wrapper;
+    }
+
     Napi::Object obj = Napi::Object::New(env);
-    DecodeObject(obj, origin, type, realign);
+    DecodeObject(obj, origin, type);
     return obj;
 }
 
-void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type, int16_t realign)
+void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type)
 {
     Napi::Env env = obj.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
@@ -419,8 +509,7 @@ void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type,
     for (Size i = 0; i < type->members.len; i++) {
         const RecordMember &member = type->members[i];
 
-        Size offset = realign ? (i * realign) : member.offset;
-        const uint8_t *src = origin + offset;
+        const uint8_t *src = origin + member.offset;
 
         switch (member.type->primitive) {
             case PrimitiveKind::Void: { RG_UNREACHABLE(); } break;
@@ -526,12 +615,13 @@ void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type,
                     member.type->dispose(env, member.type, ptr2);
                 }
             } break;
-            case PrimitiveKind::Record: {
-                Napi::Object obj2 = DecodeObject(env, src, member.type, realign);
+            case PrimitiveKind::Record:
+            case PrimitiveKind::Union: {
+                Napi::Object obj2 = DecodeObject(env, src, member.type);
                 obj.Set(member.name, obj2);
             } break;
             case PrimitiveKind::Array: {
-                Napi::Value value = DecodeArray(env, src, member.type, realign);
+                Napi::Value value = DecodeArray(env, src, member.type);
                 obj.Set(member.name, value);
             } break;
             case PrimitiveKind::Float32: {
@@ -559,7 +649,7 @@ static Size WideStringLength(const char16_t *str16, Size max)
     return len;
 }
 
-Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *type, int16_t realign)
+Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *type)
 {
     InstanceData *instance = env.GetInstanceData<InstanceData>();
 
@@ -573,8 +663,7 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
             Napi::Array array = Napi::Array::New(env); \
              \
             for (uint32_t i = 0; i < len; i++) { \
-                int16_t align = std::max(realign, type->ref.type->align); \
-                offset = AlignLen(offset, align); \
+                offset = AlignLen(offset, type->ref.type->align); \
                  \
                 const uint8_t *src = origin + offset; \
                  \
@@ -587,7 +676,7 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
         } while (false)
 #define POP_NUMBER_ARRAY(TypedArrayType, CType) \
         do { \
-            if (type->hint == TypeInfo::ArrayHint::Array) { \
+            if (type->hint == ArrayHint::Array) { \
                 POP_ARRAY({ \
                     double d = (double)*(CType *)src; \
                     array.Set(i, Napi::Number::New(env, d)); \
@@ -596,14 +685,14 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
                 Napi::TypedArrayType array = Napi::TypedArrayType::New(env, len); \
                 Span<uint8_t> buffer = MakeSpan((uint8_t *)array.ArrayBuffer().Data(), (Size)len * RG_SIZE(CType)); \
                  \
-                DecodeBuffer(buffer, origin, type->ref.type, realign); \
+                DecodeBuffer(buffer, origin, type->ref.type); \
                  \
                 return array; \
             } \
         } while (false)
 #define POP_NUMBER_ARRAY_SWAP(TypedArrayType, CType) \
         do { \
-            if (type->hint == TypeInfo::ArrayHint::Array) { \
+            if (type->hint == ArrayHint::Array) { \
                 POP_ARRAY({ \
                     CType v = *(CType *)src; \
                     double d = (double)ReverseBytes(v); \
@@ -613,7 +702,7 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
                 Napi::TypedArrayType array = Napi::TypedArrayType::New(env, len); \
                 Span<uint8_t> buffer = MakeSpan((uint8_t *)array.ArrayBuffer().Data(), (Size)len * RG_SIZE(CType)); \
                  \
-                DecodeBuffer(buffer, origin, type->ref.type, realign); \
+                DecodeBuffer(buffer, origin, type->ref.type); \
                  \
                 return array; \
             } \
@@ -629,9 +718,7 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
             });
         } break;
         case PrimitiveKind::Int8: {
-            if (type->hint == TypeInfo::ArrayHint::String) {
-                RG_ASSERT(!realign);
-
+            if (type->hint == ArrayHint::String) {
                 const char *ptr = (const char *)origin;
                 size_t count = strnlen(ptr, (size_t)len);
 
@@ -643,9 +730,7 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
         } break;
         case PrimitiveKind::UInt8: { POP_NUMBER_ARRAY(Uint8Array, uint8_t); } break;
         case PrimitiveKind::Int16: {
-            if (type->hint == TypeInfo::ArrayHint::String) {
-                RG_ASSERT(!realign);
-
+            if (type->hint == ArrayHint::String) {
                 const char16_t *ptr = (const char16_t *)origin;
                 Size count = WideStringLength(ptr, len);
 
@@ -713,15 +798,16 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
                 }
             });
         } break;
-        case PrimitiveKind::Record: {
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union: {
             POP_ARRAY({
-                Napi::Object obj = DecodeObject(env, src, type->ref.type, realign);
+                Napi::Object obj = DecodeObject(env, src, type->ref.type);
                 array.Set(i, obj);
             });
         } break;
         case PrimitiveKind::Array: {
             POP_ARRAY({
-                Napi::Value value = DecodeArray(env, src, type->ref.type, realign);
+                Napi::Value value = DecodeArray(env, src, type->ref.type);
                 array.Set(i, value);
             });
         } break;
@@ -738,7 +824,7 @@ Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *ty
     RG_UNREACHABLE();
 }
 
-void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo *ref, int16_t realign)
+void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo *ref)
 {
     Napi::Env env = array.Env();
     InstanceData *instance = env.GetInstanceData<InstanceData>();
@@ -751,8 +837,7 @@ void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo
 #define POP_ARRAY(SetCode) \
         do { \
             for (uint32_t i = 0; i < len; i++) { \
-                int16_t align = std::max(realign, ref->align); \
-                offset = AlignLen(offset, align); \
+                offset = AlignLen(offset, ref->align); \
                  \
                 const uint8_t *src = origin + offset; \
                  \
@@ -859,15 +944,16 @@ void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo
                 }
             });
         } break;
-        case PrimitiveKind::Record: {
+        case PrimitiveKind::Record:
+        case PrimitiveKind::Union: {
             POP_ARRAY({
-                Napi::Object obj = DecodeObject(env, src, ref, realign);
+                Napi::Object obj = DecodeObject(env, src, ref);
                 array.Set(i, obj);
             });
         } break;
         case PrimitiveKind::Array: {
             POP_ARRAY({
-                Napi::Value value = DecodeArray(env, src, ref, realign);
+                Napi::Value value = DecodeArray(env, src, ref);
                 array.Set(i, value);
             });
         } break;
@@ -882,24 +968,10 @@ void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo
 #undef POP_ARRAY
 }
 
-void DecodeBuffer(Span<uint8_t> buffer, const uint8_t *origin, const TypeInfo *ref, int16_t realign)
+void DecodeBuffer(Span<uint8_t> buffer, const uint8_t *origin, const TypeInfo *ref)
 {
-    if (realign) {
-        Size offset = 0;
-        Size step = ref->size;
-
-        for (Size i = 0; i < buffer.len; i += step) {
-            offset = AlignLen(offset, realign);
-
-            uint8_t *dest = buffer.ptr + i;
-            const uint8_t *src = origin + offset;
-
-            memcpy(dest, src, step);
-            offset += step;
-        }
-    } else {
-        memcpy_safe(buffer.ptr, origin, (size_t)buffer.len);
-    }
+    // Go fast brrrrr!
+    memcpy_safe(buffer.ptr, origin, (size_t)buffer.len);
 
 #define SWAP(CType) \
         do { \
@@ -922,6 +994,136 @@ void DecodeBuffer(Span<uint8_t> buffer, const uint8_t *origin, const TypeInfo *r
 #undef SWAP
 }
 
+Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, Size len)
+{
+    Napi::Env env = value.Env();
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    const uint8_t *ptr = nullptr;
+
+    if (value.IsExternal()) {
+        Napi::External<void> external = value.As<Napi::External<void>>();
+        ptr = (const uint8_t *)external.Data();
+    } else if (IsRawBuffer(value)) {
+        Span<uint8_t> buffer = GetRawBuffer(value);
+
+        if (RG_UNLIKELY(buffer.len - offset < type->size)) {
+            ThrowError<Napi::Error>(env, "Expected buffer with size superior or equal to type %1 (%2 bytes)",
+                                    type->name, type->size + offset);
+            return env.Null();
+        }
+
+        ptr = (const uint8_t *)buffer.ptr;
+    } else {
+        ThrowError<Napi::TypeError>(env, "Unexpected %1 value for variable, expected external or TypedArray", GetValueType(instance, value));
+        return env.Null();
+    }
+
+    if (!ptr)
+        return env.Null();
+    ptr += offset;
+
+    Napi::Value ret = Decode(env, ptr, type, len);
+    return ret;
+}
+
+Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, Size len)
+{
+    InstanceData *instance = env.GetInstanceData<InstanceData>();
+
+    if (len >= 0 && type->primitive != PrimitiveKind::String &&
+                    type->primitive != PrimitiveKind::String16) {
+        type = MakeArrayType(instance, type, len);
+    }
+
+#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::Record:
+        case PrimitiveKind::Union: {
+            Napi::Object obj = DecodeObject(env, ptr, type);
+            return obj;
+        } break;
+        case PrimitiveKind::Array: {
+            Napi::Value array = DecodeArray(env, ptr, type);
+            return array;
+        } 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();
+}
+
 static int AnalyseFlatRec(const TypeInfo *type, int offset, int count, FunctionRef<void(const TypeInfo *type, int offset, int count)> func)
 {
     if (type->primitive == PrimitiveKind::Record) {
@@ -930,6 +1132,13 @@ static int AnalyseFlatRec(const TypeInfo *type, int offset, int count, FunctionR
                 offset = AnalyseFlatRec(member.type, offset, 1, func);
             }
         }
+    } else if (type->primitive == PrimitiveKind::Union) {
+        for (int i = 0; i < count; i++) {
+            for (const RecordMember &member: type->members) {
+                AnalyseFlatRec(member.type, offset, 1, func);
+            }
+        }
+        offset += count;
     } else if (type->primitive == PrimitiveKind::Array) {
         count *= type->size / type->ref.type->size;
         offset = AnalyseFlatRec(type->ref.type, offset, count, func);
@@ -946,23 +1155,6 @@ int AnalyseFlat(const TypeInfo *type, FunctionRef<void(const TypeInfo *type, int
     return AnalyseFlatRec(type, 0, 1, func);
 }
 
-int IsHFA(const TypeInfo *type, int min, int max)
-{
-    uint32_t primitives = 0;
-    int count = 0;
-
-    count = AnalyseFlat(type, [&](const TypeInfo *type, int, int) {
-        if (IsFloat(type)) {
-            primitives |= 1u << (int)type->primitive;
-        } else {
-            primitives = UINT32_MAX;
-        }
-    });
-
-    bool hfa = (count >= min && count <= max && PopCount(primitives) == 1);
-    return hfa ? count : 0;
-}
-
 void DumpMemory(const char *type, Span<const uint8_t> bytes)
 {
     if (bytes.len) {

package/src/koffi/src/util.hh

@@ -23,6 +23,31 @@ struct InstanceData;
 struct TypeInfo;
 struct FunctionInfo;
 
+extern const int TypeInfoMarker;
+extern const int CastMarker;
+extern const int MagicUnionMarker;
+
+class MagicUnion: public Napi::ObjectWrap<MagicUnion> {
+    const TypeInfo *type;
+
+    Size active_idx = -1;
+    const uint8_t *raw = nullptr;
+
+public:
+    static Napi::Function InitClass(Napi::Env env, const TypeInfo *type);
+
+    MagicUnion(const Napi::CallbackInfo &info);
+
+    const RecordMember *GetMember() const { return (active_idx >= 0) ? &type->members[active_idx] : nullptr; }
+
+    void SetRaw(const uint8_t *ptr);
+    const uint8_t *GetRaw() const { return raw; }
+
+private:
+    Napi::Value Getter(const Napi::CallbackInfo &info);
+    void Setter(const Napi::CallbackInfo &info, const Napi::Value &value);
+};
+
 template <typename T, typename... Args>
 void ThrowError(Napi::Env env, const char *msg, Args... args)
 {
@@ -58,7 +83,7 @@ const TypeInfo *ResolveType(Napi::Env env, Span<const char> str, int *out_direct
 
 const TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *ref, int count = 1);
 const TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len);
-const TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len, TypeInfo::ArrayHint hint);
+const TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len, ArrayHint hint);
 
 bool CanPassType(const TypeInfo *type, int directions);
 bool CanReturnType(const TypeInfo *type);
@@ -121,11 +146,14 @@ T GetNumber(Napi::Value value)
     RG_UNREACHABLE();
 }
 
-Napi::Object DecodeObject(Napi::Env env, const uint8_t *origin, const TypeInfo *type, int16_t realign = 0);
-void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type, int16_t realign = 0);
-Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *type, int16_t realign = 0);
-void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo *ref, int16_t realign = 0);
-void DecodeBuffer(Span<uint8_t> buffer, const uint8_t *origin, const TypeInfo *ref, int16_t realign = 0);
+Napi::Object DecodeObject(Napi::Env env, const uint8_t *origin, const TypeInfo *type);
+void DecodeObject(Napi::Object obj, const uint8_t *origin, const TypeInfo *type);
+Napi::Value DecodeArray(Napi::Env env, const uint8_t *origin, const TypeInfo *type);
+void DecodeNormalArray(Napi::Array array, const uint8_t *origin, const TypeInfo *ref);
+void DecodeBuffer(Span<uint8_t> buffer, const uint8_t *origin, const TypeInfo *ref);
+
+Napi::Value Decode(Napi::Value value, Size offset, const TypeInfo *type, Size len = -1);
+Napi::Value Decode(Napi::Env env, const uint8_t *ptr, const TypeInfo *type, Size len = -1);
 
 static inline Napi::Value NewBigInt(Napi::Env env, int64_t value)
 {
@@ -149,8 +177,6 @@ static inline Napi::Value NewBigInt(Napi::Env env, uint64_t value)
 
 int AnalyseFlat(const TypeInfo *type, FunctionRef<void(const TypeInfo *type, int offset, int count)> func);
 
-int IsHFA(const TypeInfo *type, int min, int max);
-
 void DumpMemory(const char *type, Span<const uint8_t> bytes);
 
 }