koffi 3.0.1 → 3.1.0

package/src/koffi/src/util.hh

@@ -10,53 +10,6 @@
 
 namespace K {
 
-#if defined(_MSC_VER)
-    #define FORCE_INLINE __forceinline
-#else
-    #define FORCE_INLINE __attribute__((always_inline)) inline
-#endif
-#if defined(UNITY_BUILD)
-    #define INLINE_UNITY FORCE_INLINE
-#else
-    #define INLINE_UNITY
-#endif
-
-#if defined(__GNUC__) || defined(__clang__)
-    #if  __has_attribute(musttail) && __has_attribute(preserve_none)
-        #define MUST_TAIL __attribute__((musttail))
-        #define PRESERVE_NONE __attribute__((preserve_none))
-    #elif  __has_attribute(musttail) && !defined(__clang__)
-        // GCC regalloc seems better, so the generated code is not too bad even without preserve_none
-        #define MUST_TAIL __attribute__((musttail))
-        #define PRESERVE_NONE
-    #endif
-#endif
-
-extern const napi_type_tag LibraryHandleMarker;
-extern const napi_type_tag TypeObjectMarker;
-extern const napi_type_tag DirectionMarker;
-extern const napi_type_tag UnionValueMarker;
-extern const napi_type_tag CastMarker;
-
-#if !defined(EXTERNAL_TYPES)
-
-class TypeObject: public Napi::ObjectWrap<TypeObject> {
-    const TypeInfo *type;
-
-    mutable Napi::Object members;
-
-public:
-    static Napi::Function InitClass(Napi::Env env);
-
-    TypeObject(const Napi::CallbackInfo &info);
-
-    void Finalize(Napi::BasicEnv env) override;
-
-    const TypeInfo *GetType() { return type; }
-};
-
-#endif
-
 class UnionValue: public Napi::ObjectWrap<UnionValue> {
     InstanceData *instance;
     const TypeInfo *type;
@@ -66,7 +19,7 @@ class UnionValue: public Napi::ObjectWrap<UnionValue> {
     HeapArray<uint8_t> raw;
 
 public:
-    static Napi::Function InitClass(Napi::Env env, const TypeInfo *type);
+    static Napi::Function InitClass(InstanceData *instance, const TypeInfo *type);
 
     UnionValue(const Napi::CallbackInfo &info);
 
@@ -93,63 +46,17 @@ void ThrowError(Napi::Env env, const char *msg, Args... args)
     err.ThrowAsJavaScriptException();
 }
 
-static FORCE_INLINE bool IsInteger(const TypeInfo *type)
-{
-    bool integer = ((int)type->primitive >= (int)PrimitiveKind::Int8 &&
-                    (int)type->primitive <= (int)PrimitiveKind::UInt64);
-    return integer;
-}
-
-static FORCE_INLINE bool IsFloat(const TypeInfo *type)
-{
-    bool fp = (type->primitive == PrimitiveKind::Float32 ||
-               type->primitive == PrimitiveKind::Float64);
-    return fp;
-}
-
-static FORCE_INLINE bool IsRegularSize(Size size, Size max)
-{
-    bool regular = (size <= max && !(size & (size - 1)));
-    return regular;
-}
-
-int ResolveDirections(Span<const char> str);
-const TypeInfo *ResolveType(Napi::Value value, int *out_directions = nullptr);
-const TypeInfo *ResolveType(Napi::Env env, Span<const char> str);
-
-TypeInfo *MakePointerType(InstanceData *instance, const TypeInfo *ref, int count = 1);
-TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len);
-TypeInfo *MakeArrayType(InstanceData *instance, const TypeInfo *ref, Size len, ArrayHint hint);
-
-Napi::Value WrapType(Napi::Env env, const TypeInfo *type, bool freeze = true);
-
-const TypeInfo *ReshapeType(InstanceData *instance, const TypeInfo *type, int32_t stride, uint16_t flags);
-
-bool CanPassType(const TypeInfo *type, int directions);
-bool CanReturnType(const TypeInfo *type);
-bool CanStoreType(const TypeInfo *type);
-
 static FORCE_INLINE napi_valuetype GetKindOf(napi_env env, napi_value value)
 {
     napi_valuetype kind = napi_undefined;
-    napi_typeof(env, value, &kind);
+    NAPI_OK(napi_typeof(env, value, &kind));
 
     return kind;
 }
 
-static FORCE_INLINE napi_valuetype GetKindOf(Napi::Value value)
-{
-    return GetKindOf(value.Env(), value);
-}
-
-// Can be slow, only use for error messages
-const char *GetValueType(const InstanceData *instance, napi_value value);
-
 void SetValueTag(napi_env env, napi_value value, const void *marker);
 bool CheckValueTag(napi_env env, napi_value value, const void *marker);
 
-void DeleteReferenceSafe(napi_env env, napi_ref ref);
-
 static FORCE_INLINE bool IsNullOrUndefined(napi_valuetype kind)
 {
     return kind == napi_null || kind == napi_undefined;
@@ -203,9 +110,7 @@ static FORCE_INLINE bool IsBuffer(napi_env env, napi_value value)
 static FORCE_INLINE napi_value GetReferenceValue(napi_env env, napi_ref ref)
 {
     napi_value value;
-
-    napi_status status = napi_get_reference_value(env, ref, &value);
-    K_ASSERT(status == napi_ok);
+    NAPI_OK(napi_get_reference_value(env, ref, &value));
 
     return value;
 }
@@ -213,9 +118,7 @@ static FORCE_INLINE napi_value GetReferenceValue(napi_env env, napi_ref ref)
 static FORCE_INLINE uint32_t GetArrayLength(napi_env env, napi_value array)
 {
     uint32_t length = 0;
-
-    napi_status status = napi_get_array_length(env, array, &length);
-    K_ASSERT(status == napi_ok);
+    NAPI_OK(napi_get_array_length(env, array, &length));
 
     return length;
 }
@@ -307,6 +210,62 @@ static FORCE_INLINE bool TryPointer(napi_env env, napi_value value, void **out_p
     return false;
 }
 
+static FORCE_INLINE bool TryPointer(napi_env env, napi_value value, void **out_ptr, Size *out_len)
+{
+    // Fast path for BigInt
+    {
+        uint64_t u64;
+        bool lossless;
+        napi_status status = napi_get_value_bigint_uint64(env, value, &u64, &lossless);
+
+        if (status == napi_ok) {
+            *out_ptr = (void *)(uintptr_t)u64;
+            *out_len = -1;
+
+            return true;
+        }
+    }
+
+    if (size_t len = 0; node_api_get_buffer_info(env, value, out_ptr, &len) == napi_ok) {
+        *out_len = (Size)len;
+        return true;
+    }
+
+    napi_valuetype kind = GetKindOf(env, value);
+
+    if (IsNullOrUndefined(kind)) {
+        *out_ptr = nullptr;
+        *out_len = -1;
+
+        return true;
+    } else if (kind == napi_number) {
+        int64_t i;
+        napi_status status = napi_get_value_int64(env, value, &i);
+        K_ASSERT(status == napi_ok);
+
+        *out_ptr = (void *)(uintptr_t)i;
+        *out_len = -1;
+
+        return true;
+#if defined(EXTERNAL_POINTERS)
+    } else if (kind == napi_external) {
+        Napi::External<void> external = Napi::External<void>(env, value);
+
+        *out_ptr = (void *)external.Data();
+        *out_len = -1;
+
+        return true;
+#endif
+    }
+
+    if (size_t len = 0; napi_get_arraybuffer_info(env, value, out_ptr, &len) == napi_ok) {
+        *out_len = (Size)len;
+        return true;
+    }
+
+    return false;
+}
+
 static FORCE_INLINE bool TryPointer(napi_env env, napi_value value, void **out_ptr, napi_valuetype *out_kind)
 {
     // Fast path for BigInt
@@ -382,43 +341,6 @@ static FORCE_INLINE bool TryBuffer(napi_env env, napi_value value, Span<uint8_t>
 
 int GetTypedArrayType(const TypeInfo *type);
 
-template <typename T>
-Size NullTerminatedLength(const T *ptr)
-{
-    Size len = 0;
-    while (ptr[len]) {
-        len++;
-    }
-    return len;
-}
-template <typename T>
-Size NullTerminatedLength(const T *ptr, Size max)
-{
-    Size len = 0;
-    while (len < max && ptr[len]) {
-        len++;
-    }
-    return len;
-}
-
-Napi::String MakeStringFromUTF32(Napi::Env env, const char32_t *ptr, Size len);
-static inline Napi::String MakeStringFromUTF32(Napi::Env env, const char32_t *ptr)
-    { return MakeStringFromUTF32(env, ptr, NullTerminatedLength(ptr)); }
-
-napi_value DecodeObject(InstanceData *instance, const uint8_t *origin, const TypeInfo *type);
-void DecodeObject(InstanceData *instance, napi_value obj, const uint8_t *origin, const TypeInfo *type);
-
-napi_value DecodeArray(InstanceData *instance, const uint8_t *origin, const TypeInfo *type);
-napi_value DecodeArray(InstanceData *instance, const uint8_t *origin, const TypeInfo *type, uint32_t len);
-void DecodeElements(InstanceData *instance, napi_value array, const uint8_t *origin, const TypeInfo *type, uint32_t len);
-INLINE_UNITY void DecodeBuffer(Span<uint8_t> buffer, const uint8_t *origin, const TypeInfo *type);
-
-napi_value Decode(Napi::Value value, Size offset, const TypeInfo *type, const Size *len = nullptr);
-napi_value Decode(InstanceData *instance, const uint8_t *ptr, const TypeInfo *type, const Size *len = nullptr);
-
-bool Encode(Napi::Value ref, Size offset, Napi::Value value, const TypeInfo *type, const Size *len = nullptr);
-bool Encode(InstanceData *instance, uint8_t *ptr, Napi::Value value, const TypeInfo *type, const Size *len = nullptr);
-
 static FORCE_INLINE napi_value NewInt(Napi::Env env, char i) { napi_value value; napi_create_int32(env, (int32_t)i, &value); return value; }
 static FORCE_INLINE napi_value NewInt(Napi::Env env, signed char i) { napi_value value; napi_create_int32(env, (int32_t)i, &value); return value; }
 static FORCE_INLINE napi_value NewInt(Napi::Env env, unsigned char i) { napi_value value; napi_create_uint32(env, (uint32_t)i, &value); return value; }
@@ -436,25 +358,104 @@ static FORCE_INLINE napi_value NewInt(Napi::Env env, T i)
 {
     static_assert(sizeof(T) == 8);
 
+    napi_value value;
+
     if constexpr (std::is_signed_v<T>) {
         if (i <= 9007199254740992ll && i >= -9007199254740992ll) {
-            napi_value value;
-            napi_create_int64(env, (int64_t)i, &value);
-            return Napi::Value(env, value);
+            NAPI_OK(napi_create_int64(env, (int64_t)i, &value));
+            return value;
         }
 
-        return Napi::BigInt::New(env, (int64_t)i);
+        NAPI_OK(napi_create_bigint_int64(env, (int64_t)i, &value));
+        return value;
     } else {
         if (i <= 9007199254740992ull) {
-            napi_value value;
-            napi_create_int64(env, (int64_t)i, &value);
-            return Napi::Value(env, value);
+            NAPI_OK(napi_create_int64(env, (int64_t)i, &value));
+            return value;
         }
 
-        return Napi::BigInt::New(env, (uint64_t)i);
+        NAPI_OK(napi_create_bigint_uint64(env, (uint64_t)i, &value));
+        return value;
+    }
+}
+
+static FORCE_INLINE napi_value NewFloat(Napi::Env env, float f) { napi_value value; napi_create_double(env, (double)f, &value); return value; }
+static FORCE_INLINE napi_value NewFloat(Napi::Env env, double d) { napi_value value; napi_create_double(env, d, &value); return value; }
+
+template <typename T>
+static FORCE_INLINE Size NullTerminatedLength(const T *ptr)
+{
+    Size len = 0;
+    while (ptr[len]) {
+        len++;
+    }
+    return len;
+}
+template <typename T>
+static FORCE_INLINE Size NullTerminatedLength(const T *ptr, Size max)
+{
+    Size len = 0;
+    while (len < max && ptr[len]) {
+        len++;
+    }
+    return len;
+}
+
+static FORCE_INLINE napi_value NewString(Napi::Env env, const char *ptr, Size len)
+{
+    napi_value value;
+    if (ptr) {
+        NAPI_OK(napi_create_string_utf8(env, ptr, (size_t)len, &value));
+    } else {
+        NAPI_OK(napi_get_null(env, &value));
+    }
+    return value;
+}
+static FORCE_INLINE napi_value NewString(Napi::Env env, const char *ptr)
+{
+    napi_value value;
+    if (ptr) {
+        NAPI_OK(napi_create_string_utf8(env, ptr, NAPI_AUTO_LENGTH, &value));
+    } else {
+        NAPI_OK(napi_get_null(env, &value));
+    }
+    return value;
+}
+
+static FORCE_INLINE napi_value NewString(Napi::Env env, const char16_t *ptr, Size len)
+{
+    napi_value value;
+    if (ptr) {
+        NAPI_OK(napi_create_string_utf16(env, ptr, (size_t)len, &value));
+    } else {
+        NAPI_OK(napi_get_null(env, &value));
+    }
+    return value;
+}
+static FORCE_INLINE napi_value NewString(Napi::Env env, const char16_t *ptr)
+{
+    napi_value value;
+    if (ptr) {
+        NAPI_OK(napi_create_string_utf16(env, ptr, NAPI_AUTO_LENGTH, &value));
+    } else {
+        NAPI_OK(napi_get_null(env, &value));
     }
+    return value;
 }
 
+napi_value NewString(Napi::Env env, const char32_t *ptr, Size len);
+napi_value NewString(Napi::Env env, const char32_t *ptr);
+
+napi_value DecodeObject(InstanceData *instance, const uint8_t *origin, const TypeInfo *type);
+void DecodeObject(InstanceData *instance, napi_value obj, const uint8_t *origin, const TypeInfo *type);
+
+napi_value DecodeArray(InstanceData *instance, const uint8_t *origin, const TypeInfo *type);
+napi_value DecodeArray(InstanceData *instance, const uint8_t *origin, const TypeInfo *type, uint32_t len);
+void DecodeElements(InstanceData *instance, napi_value array, const uint8_t *origin, const TypeInfo *type, uint32_t len);
+INLINE_UNITY void DecodeBuffer(Span<uint8_t> buffer, const uint8_t *origin, const TypeInfo *type);
+
+napi_value Decode(InstanceData *instance, const uint8_t *ptr, const TypeInfo *type);
+
 static FORCE_INLINE Napi::Array GetOwnPropertyNames(napi_env env, napi_value obj)
 {
     K_ASSERT(IsObject(env, obj));
@@ -468,21 +469,22 @@ static FORCE_INLINE Napi::Array GetOwnPropertyNames(napi_env env, napi_value obj
     return Napi::Array(env, result);
 }
 
-Napi::Object DescribeFunction(Napi::Env env, const FunctionInfo *func);
-Napi::Function WrapFunction(Napi::Env env, const FunctionInfo *func);
-
-static FORCE_INLINE Napi::Value WrapPointer(Napi::Env env, const TypeInfo *ref, void *ptr)
+static FORCE_INLINE napi_value WrapPointer(Napi::Env env, const TypeInfo *, void *ptr)
 {
+    napi_value value;
+
+    if (ptr) {
 #if defined(EXTERNAL_POINTERS)
-    Napi::External<void> external = Napi::External<void>::New(env, ptr);
-    return external;
+        NAPI_OK(napi_create_external(env, ptr, nullptr, nullptr, &value));
 #else
-    Napi::BigInt big = Napi::BigInt::New(env, (uint64_t)(uintptr_t)ptr);
-    return big;
+        NAPI_OK(napi_create_bigint_uint64(env, (uint64_t)(uintptr_t)ptr, &value));
 #endif
-}
+    } else {
+        NAPI_OK(napi_get_null(env, &value));
+    }
 
-bool DetectCallConvention(Span<const char> name, CallConvention *out_convention);
+    return value;
+}
 
 int AnalyseFlat(const TypeInfo *type, FunctionRef<void(const TypeInfo *type, int offset, int count)> func);
 

package/src/koffi/src/uv.cc

@@ -1,19 +1,25 @@
 // SPDX-License-Identifier: MIT
 
-#include "uv.hh"
+#include "lib/native/base/base.hh"
+#include "type.hh"
 #include "util.hh"
+#include "uv.hh"
+
+#include <napi.h>
 
 namespace K {
 
-Napi::Function PollHandle::InitClass(Napi::Env env)
+Napi::Function PollHandle::InitClass(InstanceData *instance)
 {
+    Napi::Env env = instance->env;
+
     // node-addon-api wants std::vector
     std::vector<Napi::ClassPropertyDescriptor<PollHandle>> properties = {
-        InstanceMethod("start", &PollHandle::Start),
-        InstanceMethod("stop", &PollHandle::Stop),
-        InstanceMethod("close", &PollHandle::Close),
-        InstanceMethod("unref", &PollHandle::Unref),
-        InstanceMethod("ref", &PollHandle::Ref)
+        InstanceMethod("start", &PollHandle::Start, napi_default, instance),
+        InstanceMethod("stop", &PollHandle::Stop, napi_default, instance),
+        InstanceMethod("close", &PollHandle::Close, napi_default, instance),
+        InstanceMethod("unref", &PollHandle::Unref, napi_default, instance),
+        InstanceMethod("ref", &PollHandle::Ref, napi_default, instance)
     };
 
     if (Napi::Value dispose = env.RunScript("Symbol.dispose"); !IsNullOrUndefined(env, dispose)) {
@@ -21,7 +27,7 @@ Napi::Function PollHandle::InitClass(Napi::Env env)
         properties.push_back(prop);
     }
 
-    Napi::Function constructor = DefineClass(env, "PollHandle", properties);
+    Napi::Function constructor = DefineClass(env, "PollHandle", properties, instance);
     return constructor;
 }
 
@@ -62,7 +68,7 @@ PollHandle::PollHandle(const Napi::CallbackInfo &info)
 
 void PollHandle::Start(const Napi::CallbackInfo &info)
 {
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     bool has_opts = (info.Length() >= 2 && info[0].IsObject());
 
@@ -98,7 +104,7 @@ void PollHandle::Start(const Napi::CallbackInfo &info)
 
 void PollHandle::Finalize(Napi::BasicEnv env)
 {
-    DeleteReferenceSafe(env, *this);
+    node_api_delete_reference(env, *this);
     SuppressDestruct();
 
     Close();
@@ -165,7 +171,7 @@ void PollHandle::OnPoll(uv_poll_t *h, int status, int events)
 Napi::Value Poll(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    InstanceData *instance = env.GetInstanceData<InstanceData>();
+    InstanceData *instance = (InstanceData *)info.Data();
 
     bool has_opts = (info.Length() >= 3 && info[1].IsObject());
 

package/src/koffi/src/uv.hh

@@ -3,6 +3,7 @@
 #pragma once
 
 #include "lib/native/base/base.hh"
+#include "ffi.hh"
 
 #include <napi.h>
 
@@ -88,7 +89,7 @@ class PollHandle: public Napi::ObjectWrap<PollHandle> {
     Napi::FunctionReference callback;
 
 public:
-    static Napi::Function InitClass(Napi::Env env);
+    static Napi::Function InitClass(InstanceData *instance);
 
     PollHandle(const Napi::CallbackInfo &info);
 

package/vendor/node-addon-api/README.md

@@ -19,7 +19,7 @@ and exception handling semantics with low overhead.
 API references are available in the [doc](doc/README.md) directory.
 
 <!-- x-release-please-start-version -->
-## Current version: 8.5.0
+## Current version: 8.9.0
 <!-- x-release-please-end -->
 
 (See [CHANGELOG.md](CHANGELOG.md) for complete Changelog)