koffi 1.3.10 → 2.0.0

package/test/sync.js

@@ -64,7 +64,7 @@ const BFG = koffi.struct('BFG', {
     a: 'int8_t',
     b: 'int64_t',
     c: 'char',
-    d: 'str',
+    d: 'const char *',
     e: 'short',
     inner: koffi.struct({
         f: 'float',
@@ -75,13 +75,14 @@ const PackedBFG = koffi.pack('PackedBFG', {
     a: 'int8_t',
     b: 'int64_t',
     c: 'char',
-    d: 'str',
+    d: 'char *',
     e: 'short',
     inner: koffi.pack({
         f: 'float',
         g: 'double'
     })
 });
+const AliasBFG = koffi.alias('AliasBFG', PackedBFG);
 
 const FixedString = koffi.struct('FixedString', {
     buf: koffi.array('int8', 64)
@@ -106,9 +107,12 @@ const IntContainer = koffi.struct('IntContainer', {
     len: 'int'
 });
 
+const StrFree = koffi.disposable('str_free', koffi.types.str, koffi.free);
+const Str16Free = koffi.disposable('str16_free', 'str16');
+
 const StrStruct = koffi.struct('StrStruct', {
     str: 'str',
-    str16: 'str16'
+    str16: koffi.types.string16
 });
 
 main();
@@ -130,7 +134,7 @@ async function test() {
     const GetMinusOne1 = lib.func('int8_t GetMinusOne1(void)');
     const GetMinusOne2 = lib.func('int16_t GetMinusOne2(void)');
     const GetMinusOne4 = lib.func('int32_t GetMinusOne4(void)');
-    const GetMinusOne8 = lib.func('int64_t GetMinusOne8(void)');
+    const GetMinusOne8 = lib.func('int64_t GetMinusOne8(void *dummy)');
     const FillPack1 = lib.func('FillPack1', 'void', ['int', koffi.out(koffi.pointer(Pack1))]);
     const RetPack1 = lib.func('RetPack1', Pack1, ['int']);
     const AddPack1 = lib.fastcall('AddPack1', 'void', ['int', koffi.inout(koffi.pointer(Pack1))]);
@@ -155,12 +159,12 @@ async function test() {
     const ConcatenateToStr4 = lib.func('ConcatenateToStr4', 'str', [...Array(8).fill('int32_t'), koffi.pointer(koffi.struct('IJK4', {i: 'int32_t', j: 'int32_t', k: 'int32_t'})), 'int32_t']);
     const ConcatenateToStr8 = lib.func('ConcatenateToStr8', 'str', [...Array(8).fill('int64_t'), koffi.struct('IJK8', {i: 'int64_t', j: 'int64_t', k: 'int64_t'}), 'int64_t']);
     const MakeBFG = lib.func('BFG __stdcall MakeBFG(_Out_ BFG *p, int x, double y, const char *str)');
-    const MakePackedBFG = lib.func('PackedBFG __fastcall MakePackedBFG(int x, double y, _Out_ PackedBFG *p, const char *str)');
+    const MakePackedBFG = lib.func('AliasBFG __fastcall MakePackedBFG(int x, double y, _Out_ PackedBFG *p, const char *str)');
     const ReturnBigString = process.platform == 'win32' ?
-                            lib.stdcall(1, 'str', ['str']) :
+                            lib.stdcall(1, koffi.disposable('str', koffi.free), ['str']) :
                             lib.func('const char * __stdcall ReturnBigString(const char *str)');
-    const PrintFmt = lib.func('const char *PrintFmt(const char *fmt, ...)');
-    const Concat16 = lib.func('const char16_t *Concat16(const char16_t *str1, const char16_t *str2)')
+    const PrintFmt = lib.func('str_free PrintFmt(const char *fmt, ...)');
+    const Concat16 = lib.func('const char16_t *! Concat16(const char16_t *str1, const char16_t *str2)')
     const ReturnFixedStr = lib.func('FixedString ReturnFixedStr(FixedString str)');
     const ReturnFixedStr2 = lib.func('FixedString2 ReturnFixedStr(FixedString2 str)');
     const ReturnFixedWide = lib.func('FixedWide ReturnFixedWide(FixedWide str)');
@@ -187,7 +191,7 @@ async function test() {
     assert.equal(GetMinusOne1(), -1);
     assert.equal(GetMinusOne2(), -1);
     assert.equal(GetMinusOne4(), -1);
-    assert.equal(GetMinusOne8(), -1);
+    assert.equal(GetMinusOne8(null), -1);
 
     // Simple tests with Pack1
     {
@@ -320,30 +324,36 @@ async function test() {
 
     // Big numbers
     {
-        assert.equal(ThroughUInt32UU(4294967284), 4294967284);
-        assert.deepEqual(ThroughUInt32SS({ v: 4294967284 }), { v: 4294967284 });
-        assert.deepEqual(ThroughUInt32SU(4294967284), { v: 4294967284 });
-        assert.equal(ThroughUInt32US({ v: 4294967284 }), 4294967284);
-
-        assert.equal(ThroughUInt64UU(9007199254740989), 9007199254740989);
-        assert.deepEqual(ThroughUInt64SS({ v: 9007199254740989 }), { v: 9007199254740989 });
-        assert.deepEqual(ThroughUInt64SU(9007199254740989), { v: 9007199254740989 });
-        assert.equal(ThroughUInt64US({ v: 9007199254740989 }), 9007199254740989);
-
-        assert.equal(ThroughUInt64UU(18446744073709551598n), 18446744073709551598n);
-        assert.deepEqual(ThroughUInt64SS({ v: 18446744073709551598n }), { v: 18446744073709551598n });
-        assert.deepEqual(ThroughUInt64SU(18446744073709551598n), { v: 18446744073709551598n });
-        assert.equal(ThroughUInt64US({ v: 18446744073709551598n }), 18446744073709551598n);
-
-        assert.equal(ThroughInt64II(-9007199254740989), -9007199254740989);
-        assert.deepEqual(ThroughInt64SS({ v: -9007199254740989 }), { v: -9007199254740989 });
-        assert.deepEqual(ThroughInt64SI(-9007199254740989), { v: -9007199254740989 });
-        assert.equal(ThroughInt64IS({ v: -9007199254740989 }), -9007199254740989);
-
-        assert.equal(ThroughInt64II(-9223372036854775803n), -9223372036854775803n);
-        assert.deepEqual(ThroughInt64SS({ v: -9223372036854775803n }), { v: -9223372036854775803n });
-        assert.deepEqual(ThroughInt64SI(-9223372036854775803n), { v: -9223372036854775803n });
-        assert.equal(ThroughInt64IS({ v: -9223372036854775803n }), -9223372036854775803n);
+        assert.strictEqual(ThroughUInt32UU(4294967284), 4294967284);
+        assert.deepStrictEqual(ThroughUInt32SS({ v: 4294967284 }), { v: 4294967284 });
+        assert.deepStrictEqual(ThroughUInt32SU(4294967284), { v: 4294967284 });
+        assert.strictEqual(ThroughUInt32US({ v: 4294967284 }), 4294967284);
+
+        assert.strictEqual(ThroughUInt64UU(9007199254740992n), 9007199254740992);
+        assert.deepStrictEqual(ThroughUInt64SS({ v: 9007199254740992n }), { v: 9007199254740992 });
+        assert.deepStrictEqual(ThroughUInt64SU(9007199254740992n), { v: 9007199254740992 });
+        assert.strictEqual(ThroughUInt64US({ v: 9007199254740992n }), 9007199254740992);
+        assert.strictEqual(ThroughUInt64UU(9007199254740993n), 9007199254740993n);
+        assert.deepStrictEqual(ThroughUInt64SS({ v: 9007199254740993n }), { v: 9007199254740993n });
+        assert.deepStrictEqual(ThroughUInt64SU(9007199254740993n), { v: 9007199254740993n });
+        assert.strictEqual(ThroughUInt64US({ v: 9007199254740993n }), 9007199254740993n);
+        assert.strictEqual(ThroughUInt64UU(18446744073709551598n), 18446744073709551598n);
+        assert.deepStrictEqual(ThroughUInt64SS({ v: 18446744073709551598n }), { v: 18446744073709551598n });
+        assert.deepStrictEqual(ThroughUInt64SU(18446744073709551598n), { v: 18446744073709551598n });
+        assert.strictEqual(ThroughUInt64US({ v: 18446744073709551598n }), 18446744073709551598n);
+
+        assert.strictEqual(ThroughInt64II(-9007199254740992), -9007199254740992);
+        assert.deepStrictEqual(ThroughInt64SS({ v: -9007199254740992 }), { v: -9007199254740992 });
+        assert.deepStrictEqual(ThroughInt64SI(-9007199254740992), { v: -9007199254740992 });
+        assert.strictEqual(ThroughInt64IS({ v: -9007199254740992 }), -9007199254740992);
+        assert.strictEqual(ThroughInt64II(-9007199254740993n), -9007199254740993n);
+        assert.deepStrictEqual(ThroughInt64SS({ v: -9007199254740993n }), { v: -9007199254740993n });
+        assert.deepStrictEqual(ThroughInt64SI(-9007199254740993n), { v: -9007199254740993n });
+        assert.strictEqual(ThroughInt64IS({ v: -9007199254740993n }), -9007199254740993n);
+        assert.strictEqual(ThroughInt64II(-9223372036854775803n), -9223372036854775803n);
+        assert.deepStrictEqual(ThroughInt64SS({ v: -9223372036854775803n }), { v: -9223372036854775803n });
+        assert.deepStrictEqual(ThroughInt64SI(-9223372036854775803n), { v: -9223372036854775803n });
+        assert.strictEqual(ThroughInt64IS({ v: -9223372036854775803n }), -9223372036854775803n);
     }
 
     // Array pointers as input

package/vendor/libcc/libcc.cc

@@ -136,7 +136,7 @@ extern "C" void AssertMessage(const char *filename, int line, const char *cond)
 
 class MallocAllocator: public Allocator {
 protected:
-    void *Allocate(Size size, unsigned int flags = 0) override
+    void *Allocate(Size size, unsigned int flags) override
     {
         void *ptr = malloc((size_t)size);
         RG_CRITICAL(ptr, "Failed to allocate %1 of memory", FmtMemSize(size));
@@ -148,7 +148,7 @@ protected:
         return ptr;
     }
 
-    void Resize(void **ptr, Size old_size, Size new_size, unsigned int flags = 0) override
+    void Resize(void **ptr, Size old_size, Size new_size, unsigned int flags) override
     {
         if (!new_size) {
             Release(*ptr, old_size);
@@ -172,12 +172,25 @@ protected:
     }
 };
 
+class NullAllocator: public Allocator {
+protected:
+    void *Allocate(Size, unsigned int) override { RG_UNREACHABLE(); }
+    void Resize(void **, Size, Size, unsigned int) override { RG_UNREACHABLE(); }
+    void Release(void *, Size) override {}
+};
+
 Allocator *GetDefaultAllocator()
 {
     static Allocator *default_allocator = new RG_DEFAULT_ALLOCATOR;
     return default_allocator;
 }
 
+Allocator *GetNullAllocator()
+{
+    static Allocator *null_allocator = new NullAllocator;
+    return null_allocator;
+}
+
 LinkedAllocator& LinkedAllocator::operator=(LinkedAllocator &&other)
 {
     ReleaseAll();
@@ -639,13 +652,13 @@ TimeSpec DecomposeTime(int64_t time, TimeMode mode)
 #ifdef _WIN32
     __time64_t time64 = time / 1000;
 
-    struct tm ti = {0};
+    struct tm ti = {};
     int offset = INT_MAX;
     switch (mode) {
         case TimeMode::Local: {
             _localtime64_s(&ti, &time64);
 
-            struct tm utc = {0};
+            struct tm utc = {};
             _gmtime64_s(&utc, &time64);
 
             offset = (int)(_mktime64(&ti) - _mktime64(&utc) + (3600 * ti.tm_isdst));
@@ -660,7 +673,7 @@ TimeSpec DecomposeTime(int64_t time, TimeMode mode)
 #else
     time_t time64 = time / 1000;
 
-    struct tm ti = {0};
+    struct tm ti = {};
     int offset = 0;
     switch (mode) {
         case TimeMode::Local: {

package/vendor/libcc/libcc.hh

@@ -235,7 +235,7 @@ extern "C" void AssertMessage(const char *filename, int line, const char *cond);
             RG_DEBUG_BREAK(); \
             abort(); \
         } while (false)
-#elif defined(__GNUC__)
+#elif defined(__GNUC__) || defined(__clang__)
     #define RG_UNREACHABLE() __builtin_unreachable()
 #else
     #define RG_UNREACHABLE() __assume(0)
@@ -622,6 +622,7 @@ struct Vec3 {
 class Allocator;
 
 Allocator *GetDefaultAllocator();
+Allocator *GetNullAllocator();
 
 class Allocator {
     RG_DELETE_COPY(Allocator)
@@ -696,8 +697,8 @@ public:
     void ReleaseAll();
 
 protected:
-    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, unsigned int flags) override;
+    void Resize(void **ptr, Size old_size, Size new_size, unsigned int flags) override;
     void Release(void *ptr, Size size) override;
 
 private:
@@ -724,8 +725,8 @@ public:
     }
 
 protected:
-    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, unsigned int flags) override;
+    void Resize(void **ptr, Size old_size, Size new_size, unsigned int flags) override;
     void Release(void *ptr, Size size) override;
 
     void CopyFrom(BlockAllocatorBase *other);
@@ -2020,9 +2021,11 @@ public:
     Iterator<HashTable> end() { return Iterator<HashTable>(this, capacity); }
     Iterator<const HashTable> end() const { return Iterator<const HashTable>(this, capacity); }
 
-    ValueType *Find(const KeyType &key)
+    template <typename T = KeyType>
+    ValueType *Find(const T &key)
         { return (ValueType *)((const HashTable *)this)->Find(key); }
-    const ValueType *Find(const KeyType &key) const
+    template <typename T = KeyType>
+    const ValueType *Find(const T &key) const
     {
         if (!capacity)
             return nullptr;
@@ -2031,9 +2034,11 @@ public:
         Size idx = HashToIndex(hash);
         return Find(&idx, key);
     }
-    ValueType FindValue(const KeyType &key, const ValueType &default_value)
+    template <typename T = KeyType>
+    ValueType FindValue(const T &key, const ValueType &default_value)
         { return (ValueType)((const HashTable *)this)->FindValue(key, default_value); }
-    const ValueType FindValue(const KeyType &key, const ValueType &default_value) const
+    template <typename T = KeyType>
+    const ValueType FindValue(const T &key, const ValueType &default_value) const
     {
         const ValueType *it = Find(key);
         return it ? *it : default_value;
@@ -2104,7 +2109,8 @@ public:
         MarkEmpty(empty_idx);
         new (&data[empty_idx]) ValueType();
     }
-    void Remove(const KeyType &key) { Remove(Find(key)); }
+    template <typename T = KeyType>
+    void Remove(const T &key) { Remove(Find(key)); }
 
     void Trim()
     {
@@ -2126,9 +2132,11 @@ public:
     Size IsEmpty(Size idx) const { return IsEmpty(used, idx); }
 
 private:
-    ValueType *Find(Size *idx, const KeyType &key)
+    template <typename T = KeyType>
+    ValueType *Find(Size *idx, const T &key)
         { return (ValueType *)((const HashTable *)this)->Find(idx, key); }
-    const ValueType *Find(Size *idx, const KeyType &key) const
+    template <typename T = KeyType>
+    const ValueType *Find(Size *idx, const T &key) const
     {
 #if __cplusplus >= 201703L
         if constexpr(std::is_pointer<ValueType>::value) {
@@ -2341,6 +2349,16 @@ template <>
 class HashTraits<const char *> {
 public:
     // FNV-1a
+    static uint64_t Hash(Span<const char> key)
+    {
+        uint64_t hash = 0xCBF29CE484222325ull;
+        for (char c: key) {
+            hash ^= (uint64_t)c;
+            hash *= 0x100000001B3ull;
+        }
+
+        return hash;
+    }
     static uint64_t Hash(const char *key)
     {
         uint64_t hash = 0xCBF29CE484222325ull;
@@ -2353,6 +2371,7 @@ public:
     }
 
     static bool Test(const char *key1, const char *key2) { return !strcmp(key1, key2); }
+    static bool Test(const char *key1, Span<const char> key2) { return key2 == key1; }
 };
 
 template <>
@@ -2369,6 +2388,16 @@ public:
 
         return hash;
     }
+    static uint64_t Hash(const char *key)
+    {
+        uint64_t hash = 0xCBF29CE484222325ull;
+        for (Size i = 0; key[i]; i++) {
+            hash ^= (uint64_t)key[i];
+            hash *= 0x100000001B3ull;
+        }
+
+        return hash;
+    }
 
     static bool Test(Span<const char> key1, Span<const char> key2) { return key1 == key2; }
     static bool Test(Span<const char> key1, const char * key2) { return key1 == key2; }
@@ -2381,9 +2410,11 @@ public:
             { return (KeyType)(value.KeyMember); } \
         static KeyType GetKey(const ValueType *value) \
             { return (KeyType)(value->KeyMember); } \
-        static uint64_t HashKey(KeyType key) \
+        template <typename TestKey> \
+        static uint64_t HashKey(TestKey key) \
             { return HashFunc(key); } \
-        static bool TestKeys(KeyType key1, KeyType key2) \
+        template <typename TestKey> \
+        static bool TestKeys(KeyType key1, TestKey key2) \
             { return TestFunc((key1), (key2)); } \
     }
 #define RG_HASHTABLE_HANDLER_EX(ValueType, KeyType, KeyMember, HashFunc, TestFunc) \
@@ -2420,16 +2451,20 @@ public:
     void Clear() { table.Clear(); }
     void RemoveAll() { table.RemoveAll(); }
 
-    ValueType *Find(const KeyType &key)
+    template <typename T = KeyType>
+    ValueType *Find(const T &key)
         { return (ValueType *)((const HashMap *)this)->Find(key); }
-    const ValueType *Find(const KeyType &key) const
+    template <typename T = KeyType>
+    const ValueType *Find(const T &key) const
     {
         const Bucket *table_it = table.Find(key);
         return table_it ? &table_it->value : nullptr;
     }
-    ValueType FindValue(const KeyType &key, const ValueType &default_value)
+    template <typename T = KeyType>
+    ValueType FindValue(const T &key, const ValueType &default_value)
         { return (ValueType)((const HashMap *)this)->FindValue(key, default_value); }
-    const ValueType FindValue(const KeyType &key, const ValueType &default_value) const
+    template <typename T = KeyType>
+    const ValueType FindValue(const T &key, const ValueType &default_value) const
     {
         const ValueType *it = Find(key);
         return it ? *it : default_value;
@@ -2462,6 +2497,7 @@ public:
             return;
         table.Remove((Bucket *)((uint8_t *)it - RG_OFFSET_OF(Bucket, value)));
     }
+    template <typename T = KeyType>
     void Remove(const KeyType &key) { Remove(Find(key)); }
 
     void Trim() { table.Trim(); }
@@ -2493,18 +2529,23 @@ public:
     void Clear() { table.Clear(); }
     void RemoveAll() { table.RemoveAll(); }
 
-    ValueType *Find(const ValueType &value) { return table.Find(value); }
-    const ValueType *Find(const ValueType &value) const { return table.Find(value); }
-    ValueType FindValue(const ValueType &value, const ValueType &default_value)
+    template <typename T = ValueType>
+    ValueType *Find(const T &value) { return table.Find(value); }
+    template <typename T = ValueType>
+    const ValueType *Find(const T &value) const { return table.Find(value); }
+    template <typename T = ValueType>
+    ValueType FindValue(const T &value, const ValueType &default_value)
         { return table.FindValue(value, default_value); }
-    const ValueType FindValue(const ValueType &value, const ValueType &default_value) const
+    template <typename T = ValueType>
+    const ValueType FindValue(const T &value, const ValueType &default_value) const
         { return table.FindValue(value, default_value); }
 
     ValueType *Set(const ValueType &value) { return table.Set(value); }
     std::pair<ValueType *, bool> TrySet(const ValueType &value) { return table.TrySet(value); }
 
     void Remove(ValueType *it) { table.Remove(it); }
-    void Remove(const ValueType &value) { Remove(Find(value)); }
+    template <typename T = ValueType>
+    void Remove(const T &value) { Remove(Find(value)); }
 
     void Trim() { table.Trim(); }
 };
@@ -3363,6 +3404,8 @@ static inline bool TestStr(Span<const char> str1, const char *str2)
     }
     return (i == str1.len) && !str2[i];
 }
+static inline bool TestStr(const char *str1, Span<const char> str2)
+    { return TestStr(str2, str1); }
 static inline bool TestStr(const char *str1, const char *str2)
     { return !strcmp(str1, str2); }
 
@@ -3392,6 +3435,8 @@ static inline bool TestStrI(Span<const char> str1, const char *str2)
     }
     return (i == str1.len) && !str2[i];
 }
+static inline bool TestStrI(const char *str1, Span<const char> str2)
+    { return TestStr(str2, str1); }
 static inline bool TestStrI(const char *str1, const char *str2)
 {
     Size i = 0;
@@ -3431,6 +3476,8 @@ static inline int CmpStr(Span<const char> str1, const char *str2)
         return str1[i];
     }
 }
+static inline int CmpStr(const char *str1, Span<const char> str2)
+    { return -CmpStr(str2, str1); }
 static inline int CmpStr(const char *str1, const char *str2)
     { return strcmp(str1, str2); }