koffi 2.16.1 → 3.0.0-alpha.2

package/lib/native/base/base.hh

@@ -140,7 +140,7 @@ static_assert(sizeof(double) == 8, "This code base is not designed to support si
 #define K_STRINGIFY(a) K_STRINGIFY_(a)
 #define K_CONCAT_(a, b) a ## b
 #define K_CONCAT(a, b) K_CONCAT_(a, b)
-#define K_UNIQUE_NAME(prefix) K_CONCAT(prefix, __LINE__)
+#define K_UNIQUE_NAME(prefix) K_CONCAT(prefix, __COUNTER__)
 #define K_FORCE_EXPAND(x) x
 #define K_IGNORE (void)!
 
@@ -564,19 +564,33 @@ class DeferGuard {
     K_DELETE_COPY(DeferGuard)
 
     Fun f;
-    bool enabled;
 
 public:
     DeferGuard() = delete;
-    DeferGuard(Fun f_, bool enable = true) : f(std::move(f_)), enabled(enable) {}
-    ~DeferGuard()
+    DeferGuard(Fun f_) : f(std::move(f_)) {}
+    ~DeferGuard() { f(); }
+
+    DeferGuard(DeferGuard &&other) : f(std::move(other.f)) {}
+};
+
+template <typename Fun>
+class NamedDeferGuard {
+    K_DELETE_COPY(NamedDeferGuard)
+
+    Fun f;
+    bool enabled;
+
+public:
+    NamedDeferGuard() = delete;
+    NamedDeferGuard(Fun f_, bool enable = true) : f(std::move(f_)), enabled(enable) {}
+    ~NamedDeferGuard()
     {
         if (enabled) {
             f();
         }
     }
 
-    DeferGuard(DeferGuard &&other)
+    NamedDeferGuard(NamedDeferGuard &&other)
         : f(std::move(other.f)), enabled(other.enabled)
     {
         other.enabled = false;
@@ -593,6 +607,12 @@ DeferGuard<Fun> operator+(DeferGuardHelper, Fun &&f)
 {
     return DeferGuard<Fun>(std::forward<Fun>(f));
 }
+struct NamedDeferGuardHelper {};
+template <typename Fun>
+NamedDeferGuard<Fun> operator+(NamedDeferGuardHelper, Fun &&f)
+{
+    return NamedDeferGuard<Fun>(std::forward<Fun>(f));
+}
 
 // Write 'DEFER { code };' to do something at the end of the current scope, you
 // can use DEFER_N(Name) if you need to disable the guard for some reason, and
@@ -600,11 +620,11 @@ DeferGuard<Fun> operator+(DeferGuardHelper, Fun &&f)
 #define K_DEFER \
     auto K_UNIQUE_NAME(defer) = K::DeferGuardHelper() + [&]()
 #define K_DEFER_N(Name) \
-    auto Name = K::DeferGuardHelper() + [&]()
+    auto Name = K::NamedDeferGuardHelper() + [&]()
 #define K_DEFER_C(...) \
     auto K_UNIQUE_NAME(defer) = K::DeferGuardHelper() + [&, __VA_ARGS__]()
 #define K_DEFER_NC(Name, ...) \
-    auto Name = K::DeferGuardHelper() + [&, __VA_ARGS__]()
+    auto Name = K::NamedDeferGuardHelper() + [&, __VA_ARGS__]()
 
 template <typename T>
 class NoDestroy {
@@ -1069,11 +1089,6 @@ static constexpr inline Strider<T> MakeStrider(T (&arr)[N])
     return Strider<T>(arr, K_SIZE(T));
 }
 
-enum class AllocFlag {
-    Zero = 1,
-    Resizable = 2
-};
-
 class Allocator {
     K_DELETE_COPY(Allocator)
 
@@ -1081,120 +1096,40 @@ public:
     Allocator() = default;
     virtual ~Allocator() = default;
 
-    virtual void *Allocate(Size size, unsigned int flags = 0) = 0;
-    virtual void *Resize(void *ptr, Size old_size, Size new_size, unsigned int flags = 0) = 0;
+    virtual void *Allocate(Size size) = 0;
+    virtual void *Resize(void *ptr, Size old_size, Size new_size) = 0;
     virtual void Release(const void *ptr, Size size) = 0;
 };
 
-Allocator *GetDefaultAllocator();
-Allocator *GetNullAllocator();
-
-static inline void *AllocateRaw(Allocator *alloc, Size size, unsigned int flags = 0)
-{
-    K_ASSERT(size >= 0);
-
-    if (!alloc) {
-        alloc = GetDefaultAllocator();
-    }
-
-    void *ptr = alloc->Allocate(size, flags);
-    return ptr;
-}
-
-template <typename T>
-T *AllocateOne(Allocator *alloc, unsigned int flags = 0)
-{
-    if (!alloc) {
-        alloc = GetDefaultAllocator();
-    }
-
-    Size size = K_SIZE(T);
-
-    T *ptr = (T *)alloc->Allocate(size, flags);
-    return ptr;
-}
-
-template <typename T>
-Span<T> AllocateSpan(Allocator *alloc, Size len, unsigned int flags = 0)
-{
-    K_ASSERT(len >= 0);
-
-    if (!alloc) {
-        alloc = GetDefaultAllocator();
-    }
-
-    Size size = len * K_SIZE(T);
-
-    T *ptr = (T *)alloc->Allocate(size, flags);
-    return MakeSpan(ptr, len);
-}
-
-static inline void *ResizeRaw(Allocator *alloc, void *ptr, Size old_size, Size new_size,
-                              unsigned int flags = 0)
-{
-    K_ASSERT(new_size >= 0);
-
-    if (!alloc) {
-        alloc = GetDefaultAllocator();
-    }
-
-    ptr = alloc->Resize(ptr, old_size, new_size, flags);
-    return ptr;
-}
-
-template <typename T>
-Span<T> ResizeSpan(Allocator *alloc, Span<T> mem, Size new_len,
-                   unsigned int flags = 0)
-{
-    K_ASSERT(new_len >= 0);
-
-    if (!alloc) {
-        alloc = GetDefaultAllocator();
-    }
-
-    Size old_size = mem.len * K_SIZE(T);
-    Size new_size = new_len * K_SIZE(T);
-
-    mem.ptr = (T *)alloc->Resize(mem.ptr, old_size, new_size, flags);
-    return MakeSpan(mem.ptr, new_len);
-}
-
-static inline void ReleaseRaw(Allocator *alloc, const void *ptr, Size size)
-{
-    if (!alloc) {
-        alloc = GetDefaultAllocator();
-    }
-
-    alloc->Release(ptr, size);
-}
-
-template<typename T>
-void ReleaseOne(Allocator *alloc, T *ptr)
-{
-    if (!alloc) {
-        alloc = GetDefaultAllocator();
-    }
-
-    alloc->Release((void *)ptr, K_SIZE(T));
-}
+class MallocAllocator final: public Allocator {
+public:
+    void *Allocate(Size size) override;
+    void *Resize(void *ptr, Size old_size, Size new_size) override;
+    void Release(const void *ptr, Size) override;
+};
 
-template<typename T>
-void ReleaseSpan(Allocator *alloc, Span<T> mem)
-{
-    if (!alloc) {
-        alloc = GetDefaultAllocator();
-    }
+class NullAllocator: public Allocator {
+public:
+    void *Allocate(Size) override { K_UNREACHABLE(); }
+    void *Resize(void *, Size, Size) override { K_UNREACHABLE(); }
 
-    Size size = mem.len * K_SIZE(T);
+    // This is the only useful method, switch to the null allocator (call GetNullAllocator())
+    // when you want to keep container memory around when it is destroyed. This can be used
+    // to leak HeapArray memory without resetting it, for example.
+    void Release(const void *, Size) override {}
+};
 
-    alloc->Release((void *)mem.ptr, size);
-}
+K_DEFAULT_ALLOCATOR *GetDefaultAllocator();
+Allocator *GetNullAllocator();
 
 class LinkedAllocator final: public Allocator {
     struct Bucket {
+#if defined(K_DEBUG)
+        Size size;
+#endif
         Bucket *prev;
         Bucket *next;
-        uint8_t data[];
+        alignas(16) uint8_t data[];
     };
 
     Allocator *allocator;
@@ -1202,7 +1137,7 @@ class LinkedAllocator final: public Allocator {
     Bucket *list = nullptr;
 
 public:
-    LinkedAllocator(Allocator *alloc = nullptr) : allocator(alloc) {}
+    LinkedAllocator(Allocator *alloc = nullptr) : allocator(alloc ? alloc : GetDefaultAllocator()) {}
     ~LinkedAllocator() override { ReleaseAll(); }
 
     LinkedAllocator(LinkedAllocator &&other) { *this = std::move(other); }
@@ -1211,8 +1146,8 @@ public:
     void ReleaseAll();
     void ReleaseAllExcept(void *ptr);
 
-    void *Allocate(Size size, unsigned int flags = 0) override;
-    void *Resize(void *ptr, Size old_size, Size new_size, unsigned int flags = 0) override;
+    void *Allocate(Size size) override;
+    void *Resize(void *ptr, Size old_size, Size new_size) override;
     void Release(const void *ptr, Size size) override;
 
     bool IsUsed() const { return list; }
@@ -1223,7 +1158,7 @@ private:
     static Bucket *PointerToBucket(void *ptr);
 };
 
-class BlockAllocator: public Allocator {
+class BlockAllocator final: public Allocator {
     struct Bucket {
         Size used;
         uint8_t data[];
@@ -1236,11 +1171,13 @@ class BlockAllocator: public Allocator {
     uint8_t *last_alloc = nullptr;
 
 public:
-    BlockAllocator(Size block_size = K_BLOCK_ALLOCATOR_DEFAULT_SIZE)
-        : block_size(block_size)
+    BlockAllocator(Allocator *alloc, Size block_size = K_BLOCK_ALLOCATOR_DEFAULT_SIZE)
+        : allocator(alloc), block_size(block_size)
     {
         K_ASSERT(block_size > 0);
     }
+    BlockAllocator(Size block_size = K_BLOCK_ALLOCATOR_DEFAULT_SIZE)
+        : BlockAllocator(nullptr, block_size) {}
 
     BlockAllocator(BlockAllocator &&other) { *this = std::move(other); }
     BlockAllocator& operator=(BlockAllocator &&other);
@@ -1248,8 +1185,8 @@ public:
     void Reset();
     void ReleaseAll();
 
-    void *Allocate(Size size, unsigned int flags = 0) override;
-    void *Resize(void *ptr, Size old_size, Size new_size, unsigned int flags = 0) override;
+    void *Allocate(Size size) override;
+    void *Resize(void *ptr, Size old_size, Size new_size) override;
     void Release(const void *ptr, Size size) override;
 
     bool IsUsed() const { return allocator.IsUsed(); }
@@ -1261,6 +1198,92 @@ private:
     bool AllocateSeparately(Size aligned_size) const { return aligned_size > block_size / 2; }
 };
 
+static inline void *AllocateRaw(Allocator *alloc, Size size)
+{
+    K_ASSERT(size >= 0);
+
+    alloc = alloc ? alloc : GetDefaultAllocator();
+
+    void *ptr = alloc->Allocate(size);
+
+    return ptr;
+}
+
+template <typename T>
+T *AllocateOne(Allocator *alloc)
+{
+    alloc = alloc ? alloc : GetDefaultAllocator();
+
+    Size size = K_SIZE(T);
+    T *ptr = (T *)alloc->Allocate(size);
+
+    return ptr;
+}
+
+template <typename T>
+Span<T> AllocateSpan(Allocator *alloc, Size len)
+{
+    K_ASSERT(len >= 0);
+    K_ASSERT(len <= K_SIZE_MAX / K_SIZE(T));
+
+    alloc = alloc ? alloc : GetDefaultAllocator();
+
+    Size size = len * K_SIZE(T);
+    T *ptr = (T *)alloc->Allocate(size);
+
+    return MakeSpan(ptr, len);
+}
+
+static inline void *ResizeRaw(Allocator *alloc, void *ptr, Size old_size, Size new_size)
+{
+    K_ASSERT(new_size >= 0);
+
+    alloc = alloc ? alloc : GetDefaultAllocator();
+
+    ptr = alloc->Resize(ptr, old_size, new_size);
+
+    return ptr;
+}
+
+template <typename T>
+Span<T> ResizeSpan(Allocator *alloc, Span<T> mem, Size new_len)
+{
+    K_ASSERT(new_len >= 0);
+    K_ASSERT(new_len <= K_SIZE_MAX / K_SIZE(T));
+
+    alloc = alloc ? alloc : GetDefaultAllocator();
+
+    Size old_size = mem.len * K_SIZE(T);
+    Size new_size = new_len * K_SIZE(T);
+
+    mem.ptr = (T *)alloc->Resize(mem.ptr, old_size, new_size);
+
+    return MakeSpan(mem.ptr, new_len);
+}
+
+static inline void ReleaseRaw(Allocator *alloc, const void *ptr, Size size)
+{
+    alloc = alloc ? alloc : GetDefaultAllocator();
+    alloc->Release(ptr, size);
+}
+
+template<typename T>
+void ReleaseOne(Allocator *alloc, T *ptr)
+{
+    alloc = alloc ? alloc : GetDefaultAllocator();
+    alloc->Release((void *)ptr, K_SIZE(T));
+}
+
+template<typename T>
+void ReleaseSpan(Allocator *alloc, Span<T> mem)
+{
+    alloc = alloc ? alloc : GetDefaultAllocator();
+
+    Size size = mem.len * K_SIZE(T);
+
+    alloc->Release((void *)mem.ptr, size);
+}
+
 void *AllocateSafe(Size len);
 void ReleaseSafe(void *ptr, Size len);
 void ZeroSafe(void *ptr, Size len);
@@ -2987,14 +3010,16 @@ private:
         Size old_capacity = capacity;
 
         if (new_capacity) {
-            used = (size_t *)AllocateRaw(allocator,
-                                         (new_capacity + (K_SIZE(size_t) * 8) - 1) / K_SIZE(size_t),
-                                         (int)AllocFlag::Zero);
+            Size used_size = (new_capacity + (K_SIZE(size_t) * 8) - 1) / K_SIZE(size_t);
+
+            used = (size_t *)AllocateRaw(allocator, used_size);
             data = (ValueType *)AllocateRaw(allocator, new_capacity * K_SIZE(ValueType));
+            capacity = new_capacity;
+
             for (Size i = 0; i < new_capacity; i++) {
                 new (&data[i]) ValueType();
             }
-            capacity = new_capacity;
+            MemSet(used, 0, used_size);
 
             for (Size i = 0; i < old_capacity; i++) {
                 if (!IsEmpty(old_used, i)) {
@@ -4721,34 +4746,34 @@ public:
     virtual void Run() = 0;
 };
 
-#define K_INIT_(ClassName, Name) \
-    class ClassName: public InitHelper { \
+#define K_INIT_(Cls, Name) \
+    class Cls: public InitHelper { \
     public: \
-        ClassName(): InitHelper(Name) {} \
+        Cls(): InitHelper(Name) {} \
         void Run() override; \
     }; \
-    static ClassName K_UNIQUE_NAME(init); \
-    void ClassName::Run()
-#define K_INIT(Name) K_INIT_(K_CONCAT(K_UNIQUE_NAME(InitHelper), Name), K_STRINGIFY(Name))
+    static Cls K_UNIQUE_NAME(init); \
+    void Cls::Run()
+#define K_INIT(Name) K_INIT_(InitHelper ## Name, K_STRINGIFY(Name))
 
-#define K_FINALIZE_(ClassName, Name) \
-    class ClassName: public FinalizeHelper { \
+#define K_FINALIZE_(Cls, Name) \
+    class Cls: public FinalizeHelper { \
     public: \
-        ClassName(): FinalizeHelper(Name) {} \
+        Cls(): FinalizeHelper(Name) {} \
         void Run() override; \
     }; \
-    static ClassName K_UNIQUE_NAME(finalize); \
-    void ClassName::Run()
-#define K_FINALIZE(Name) K_FINALIZE_(K_CONCAT(K_UNIQUE_NAME(FinalizeHelper), Name), K_STRINGIFY(Name))
+    static Cls K_UNIQUE_NAME(finalize); \
+    void Cls::Run()
+#define K_FINALIZE(Name) K_FINALIZE_(FinalizeHelper ## Name, K_STRINGIFY(Name))
 
-#define K_EXIT_(ClassName) \
-    class ClassName { \
+#define K_EXIT_(Cls) \
+    class Cls { \
     public: \
-        ~ClassName(); \
+        ~Cls(); \
     }; \
-    static ClassName K_UNIQUE_NAME(exit); \
-    ClassName::~ClassName()
-#define K_EXIT(Name) K_EXIT_(K_CONCAT(K_UNIQUE_NAME(ExitHelper), Name))
+    static Cls K_UNIQUE_NAME(exit); \
+    Cls::~Cls()
+#define K_EXIT(Name) K_EXIT_(ExitHelper ## Name)
 
 void InitApp();
 void ExitApp();
@@ -5207,13 +5232,14 @@ public:
     StreamDecompressorHelper(CompressionType type, CreateDecompressorFunc *func);
 };
 
-#define K_REGISTER_DECOMPRESSOR(Type, Cls) \
-    static StreamDecoder *K_UNIQUE_NAME(CreateDecompressor)(StreamReader *reader, CompressionType type) \
+#define K_REGISTER_DECOMPRESSOR_(Func, Type, Cls) \
+    static StreamDecoder *Func(StreamReader *reader, CompressionType type) \
     { \
         StreamDecoder *decompressor = new Cls(reader, type); \
         return decompressor; \
     } \
-    static StreamDecompressorHelper K_UNIQUE_NAME(CreateDecompressorHelper)((Type), K_UNIQUE_NAME(CreateDecompressor))
+    static StreamDecompressorHelper K_UNIQUE_NAME(decompressor_helper)((Type), Func)
+#define K_REGISTER_DECOMPRESSOR(Type, Cls) K_REGISTER_DECOMPRESSOR_(K_UNIQUE_NAME(CreateDecompressor), (Type), (Cls))
 
 class LineReader {
     K_DELETE_COPY(LineReader)
@@ -5419,13 +5445,14 @@ public:
     StreamCompressorHelper(CompressionType type, CreateCompressorFunc *func);
 };
 
-#define K_REGISTER_COMPRESSOR(Type, Cls) \
-    static StreamEncoder *K_UNIQUE_NAME(CreateCompressor)(StreamWriter *writer, CompressionType type, CompressionSpeed speed) \
+#define K_REGISTER_COMPRESSOR_(Func, Type, Cls) \
+    static StreamEncoder *Func(StreamWriter *writer, CompressionType type, CompressionSpeed speed) \
     { \
         StreamEncoder *compressor = new Cls(writer, type, speed); \
         return compressor; \
     } \
-    static StreamCompressorHelper K_UNIQUE_NAME(CreateCompressorHelper)((Type), K_UNIQUE_NAME(CreateCompressor))
+    static StreamCompressorHelper K_UNIQUE_NAME(compressor_helper)((Type), Func)
+#define K_REGISTER_COMPRESSOR(Type, Cls) K_REGISTER_COMPRESSOR_(K_UNIQUE_NAME(CreateCompressor), (Type), (Cls))
 
 bool SpliceStream(StreamReader *reader, int64_t max_len, StreamWriter *writer, Span<uint8_t> buf,
                   FunctionRef<void(int64_t, int64_t)> progress = [](int64_t, int64_t) {});

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "koffi",
-    "version": "2.16.1",
+    "version": "3.0.0-alpha.2",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [
         "foreign",
@@ -24,15 +24,14 @@
     "main": "./index.js",
     "types": "./index.d.ts",
     "scripts": {
-        "install": "node src/cnoke/cnoke.js -P . -D src/koffi --prebuild"
+        "install": "node src/build.js -P . -D src/koffi --prebuild --release"
     },
     "license": "MIT",
     "cnoke": {
         "api": "../../vendor/node-api-headers",
         "output": "build/koffi/{{ toolchain }}",
         "node": 16,
-        "napi": 8,
-        "require": "./index.js"
+        "napi": 8
     },
     "funding": "https://liberapay.com/Koromix"
 }