koffi 1.3.12 → 2.1.0-beta.1

package/test/misc.c

@@ -90,7 +90,7 @@ typedef struct IJK8 { int64_t i; int64_t j; int64_t k; } IJK8;
 
 typedef struct BFG {
     int8_t a;
-    int64_t b;
+    char _pad1[15]; int64_t b;
     signed char c;
     const char *d;
     short e;
@@ -399,6 +399,15 @@ EXPORT PackedBFG FASTCALL MakePackedBFG(int x, double y, PackedBFG *p, const cha
     return bfg;
 }
 
+EXPORT void MakePolymorphBFG(int type, int x, double y, const char *str, void *p)
+{
+    if (type == 0) {
+        MakeBFG(p, x, y, str);
+    } else if (type == 1) {
+        MakePackedBFG(x, y, p, str);
+    }
+}
+
 #ifdef _WIN32
 // Exported by DEF file
 const char *ReturnBigString(const char *str)
@@ -406,24 +415,21 @@ const char *ReturnBigString(const char *str)
 EXPORT const char *ReturnBigString(const char *str)
 #endif
 {
-    static char buf[16 * 1024 * 1024];
-
-    size_t len = strlen(str);
-    memcpy(buf, str, len + 1);
-
-    return buf;
+    const char *copy = strdup(str);
+    return copy;
 }
 
 EXPORT const char *PrintFmt(const char *fmt, ...)
 {
-    static char buf[256];
+    const int size = 256;
+    char *ptr = malloc(size);
 
     va_list ap;
     va_start(ap, fmt);
-    vsnprintf(buf, sizeof(buf), fmt, ap);
+    vsnprintf(ptr, size, fmt, ap);
     va_end(ap);
 
-    return buf;
+    return ptr;
 }
 
 size_t Length16(const char16_t *str)
@@ -437,16 +443,17 @@ size_t Length16(const char16_t *str)
 
 EXPORT const char16_t *Concat16(const char16_t *str1, const char16_t *str2)
 {
-    static char16_t buf[1024];
+    const int size = 1024;
+    char16_t *ptr = malloc(size * 2);
 
     size_t len1 = Length16(str1);
     size_t len2 = Length16(str2);
 
-    memcpy(buf, str1, len1 * 2);
-    memcpy(buf + len1, str2, len2 * 2);
-    buf[(len1 + len2) * 2] = 0;
+    memcpy(ptr, str1, len1 * 2);
+    memcpy(ptr + len1, str2, len2 * 2);
+    ptr[len1 + len2] = 0;
 
-    return buf;
+    return ptr;
 }
 
 EXPORT FixedString ReturnFixedStr(FixedString str)
@@ -549,6 +556,11 @@ EXPORT BFG ModifyBFG(int x, double y, const char *str, BFG (*func)(BFG bfg), BFG
     return bfg;
 }
 
+EXPORT void Recurse8(int i, void (*func)(int i, int v1, double v2, int v3, int v4, int v5, int v6, float v7, int v8))
+{
+    func(i, i, (double)(i * 2), i + 1, i * 2 + 1, 3 - i, 100 + i, (float)(i % 2), -i - 1);
+}
+
 EXPORT int ApplyStd(int a, int b, int c, ApplyCallback *func)
 {
     int ret = func(a, b, c);
@@ -618,3 +630,26 @@ EXPORT int ApplyStruct(int x, StructCallbacks callbacks)
 
     return x;
 }
+
+static IntCallback *callback;
+
+EXPORT void SetCallback(IntCallback *cb)
+{
+    callback = cb;
+}
+
+EXPORT int CallCallback(int x)
+{
+    return callback(x);
+}
+
+EXPORT void ReverseBytes(void *p, int len)
+{
+    uint8_t *bytes = (uint8_t *)p;
+
+    for (int i = 0; i < len / 2; i++) {
+        uint8_t tmp = bytes[i];
+        bytes[i] = bytes[len - i - 1];
+        bytes[len - i - 1] = tmp;
+    }
+}

package/test/raylib.js

@@ -55,7 +55,7 @@ const Rectangle = koffi.struct('Rectangle', {
 });
 
 const Texture = koffi.struct('Texture', {
-    id: 'uint',
+    id: 'unsigned  int', // Extra space is on purpose, leave it!
     width: 'int',
     height: 'int',
     mipmaps: 'int',
@@ -83,7 +83,7 @@ async function main() {
 }
 
 async function test() {
-    let lib_filename = path.dirname(__filename) + '/build/raylib' + koffi.extension;
+    let lib_filename = __dirname + '/build/raylib' + koffi.extension;
     let lib = koffi.load(lib_filename);
 
     const InitWindow = lib.func('InitWindow', 'void', ['int', 'int', 'str']);

package/test/sqlite.js

@@ -20,8 +20,8 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 
-const sqlite3_db = koffi.handle('sqlite3_db');
-const sqlite3_stmt = koffi.handle('sqlite3_stmt');
+const sqlite3 = koffi.opaque('sqlite3');
+const sqlite3_stmt = koffi.opaque('sqlite3_stmt');
 
 main();
 
@@ -36,20 +36,20 @@ async function main() {
 }
 
 async function test() {
-    let lib_filename = path.dirname(__filename) + '/build/sqlite3' + koffi.extension;
+    let lib_filename = __dirname + '/build/sqlite3' + koffi.extension;
     let lib = koffi.load(lib_filename);
 
-    const sqlite3_open_v2 = lib.func('sqlite3_open_v2', 'int', ['str', koffi.out(koffi.pointer(sqlite3_db)), 'int', 'str']);
-    const sqlite3_exec = lib.func('sqlite3_exec', 'int', [sqlite3_db, 'str', 'void *', 'void *', 'void *']);
-    const sqlite3_prepare_v2 = lib.func('sqlite3_prepare_v2', 'int', [sqlite3_db, 'str', 'int', koffi.out(koffi.pointer(sqlite3_stmt)), 'string']);
-    const sqlite3_reset = lib.func('sqlite3_reset', 'int', [sqlite3_stmt]);
-    const sqlite3_bind_text = lib.func('sqlite3_bind_text', 'int', [sqlite3_stmt, 'int', 'str', 'int', 'void *']);
-    const sqlite3_bind_int = lib.func('sqlite3_bind_int', 'int', [sqlite3_stmt, 'int', 'int']);
-    const sqlite3_column_text = lib.func('sqlite3_column_text', 'str', [sqlite3_stmt, 'int']);
-    const sqlite3_column_int = lib.func('sqlite3_column_int', 'int', [sqlite3_stmt, 'int']);
-    const sqlite3_step = lib.func('sqlite3_step', 'int', [sqlite3_stmt]);
-    const sqlite3_finalize = lib.func('sqlite3_finalize', 'int', [sqlite3_stmt]);
-    const sqlite3_close_v2 = lib.func('sqlite3_close_v2', 'int', [sqlite3_db]);
+    const sqlite3_open_v2 = lib.func('sqlite3_open_v2', 'int', ['str', koffi.out(koffi.pointer(sqlite3, 2)), 'int', 'str']);
+    const sqlite3_exec = lib.func('sqlite3_exec', 'int', [koffi.pointer(sqlite3), 'str', 'void *', 'void *', 'void *']);
+    const sqlite3_prepare_v2 = lib.func('sqlite3_prepare_v2', 'int', [koffi.pointer(sqlite3), 'str', 'int', koffi.out(koffi.pointer(sqlite3_stmt, 2)), 'string']);
+    const sqlite3_reset = lib.func('sqlite3_reset', 'int', [koffi.pointer(sqlite3_stmt)]);
+    const sqlite3_bind_text = lib.func('sqlite3_bind_text', 'int', [koffi.pointer(sqlite3_stmt), 'int', 'str', 'int', 'void *']);
+    const sqlite3_bind_int = lib.func('sqlite3_bind_int', 'int', [koffi.pointer(sqlite3_stmt), 'int', 'int']);
+    const sqlite3_column_text = lib.func('sqlite3_column_text', 'str', [koffi.pointer(sqlite3_stmt), 'int']);
+    const sqlite3_column_int = lib.func('sqlite3_column_int', 'int', [koffi.pointer(sqlite3_stmt), 'int']);
+    const sqlite3_step = lib.func('sqlite3_step', 'int', [koffi.pointer(sqlite3_stmt)]);
+    const sqlite3_finalize = lib.func('sqlite3_finalize', 'int', [koffi.pointer(sqlite3_stmt)]);
+    const sqlite3_close_v2 = lib.func('sqlite3_close_v2', 'int', [koffi.pointer(sqlite3)]);
 
     const SQLITE_OPEN_READWRITE = 0x2;
     const SQLITE_OPEN_CREATE = 0x4;
@@ -57,20 +57,27 @@ async function test() {
     const SQLITE_DONE = 101;
 
     let filename = await create_temporary_file(path.join(os.tmpdir(), 'test_sqlite'));
-    let db = {};
+    let db = null;
 
     let expected = Array.from(Array(200).keys()).map(i => [`TXT ${i}`, i % 7]);
 
     try {
-        if (sqlite3_open_v2(filename, db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, null) != 0)
+        let ptr = [null];
+
+        // Open database
+        if (sqlite3_open_v2(filename, ptr, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, null) != 0)
             throw new Error('Failed to open database');
+        db = ptr[0];
+
         if (sqlite3_exec(db, 'CREATE TABLE foo (id INTEGER PRIMARY KEY, bar TEXT, value INT);', null, null, null) != 0)
             throw new Error('Failed to create table');
 
-        let stmt = {};
+        let stmt = null;
 
-        if (sqlite3_prepare_v2(db, "INSERT INTO foo (bar, value) VALUES (?1, ?2)", -1, stmt, null) != 0)
+        if (sqlite3_prepare_v2(db, "INSERT INTO foo (bar, value) VALUES (?1, ?2)", -1, ptr, null) != 0)
             throw new Error('Failed to prepare insert statement for table foo');
+        stmt = ptr[0];
+
         for (let it of expected) {
             sqlite3_reset(stmt);
 
@@ -82,8 +89,9 @@ async function test() {
         }
         sqlite3_finalize(stmt);
 
-        if (sqlite3_prepare_v2(db, "SELECT id, bar, value FROM foo ORDER BY id", -1, stmt, null) != 0)
+        if (sqlite3_prepare_v2(db, "SELECT id, bar, value FROM foo ORDER BY id", -1, ptr, null) != 0)
             throw new Error('Failed to prepare select statement for table foo');
+        stmt = ptr[0];
         for (let i = 0; i < expected.length; i++) {
             let it = expected[i];
 

package/test/sync.js

@@ -15,7 +15,6 @@
 
 const koffi = require('./build/koffi.node');
 const assert = require('assert');
-const path = require('path');
 
 const Pack1 = koffi.struct('Pack1', {
     a: 'int'
@@ -62,9 +61,9 @@ const IntFloat = koffi.struct('IntFloat', {
 
 const BFG = koffi.struct('BFG', {
     a: 'int8_t',
-    b: 'int64_t',
+    b: [16, 'int64_t'],
     c: 'char',
-    d: 'str',
+    d: 'const char *',
     e: 'short',
     inner: koffi.struct({
         f: 'float',
@@ -75,13 +74,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 +106,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();
@@ -124,7 +127,7 @@ async function main() {
 }
 
 async function test() {
-    let lib_filename = path.dirname(__filename) + '/build/misc' + koffi.extension;
+    let lib_filename = __dirname + '/build/misc' + koffi.extension;
     let lib = koffi.load(lib_filename);
 
     const GetMinusOne1 = lib.func('int8_t GetMinusOne1(void)');
@@ -155,12 +158,13 @@ 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 MakePolymorphBFG = lib.func('void MakePolymorphBFG(int type, int x, double y, const char *str, _Out_ void *p)');
     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)');
@@ -182,6 +186,7 @@ async function test() {
     const MultiplyIntegers = lib.func('void MultiplyIntegers(int multiplier, _Inout_ int *values, int len)');
     const ThroughStr = lib.func('str ThroughStr(StrStruct s)');
     const ThroughStr16 = lib.func('str16 ThroughStr16(StrStruct s)');
+    const ReverseBytes = lib.func('void ReverseBytes(_Inout_ void *array, int len)');
 
     // Simple signed value returns
     assert.equal(GetMinusOne1(), -1);
@@ -291,6 +296,17 @@ async function test() {
         assert.deepEqual(out, bfg);
     }
 
+    // Polymorph pointer
+    {
+        let bfg = {};
+
+        MakePolymorphBFG(0, 2, 7, 'boo', koffi.as(bfg, 'BFG *'));
+        assert.deepEqual(bfg, { a: 2, b: 4, c: -25, d: 'X/boo/X', e: 54, inner: { f: 14, g: 5 }});
+
+        MakePolymorphBFG(1, 2, 7, 'bies', koffi.as(bfg, 'PackedBFG *'));
+        assert.deepEqual(bfg, { a: 2, b: 4, c: -25, d: 'X/bies/X', e: 54, inner: { f: 14, g: 5 }});
+    }
+
     // Big string
     {
         let str = 'fooBAR!'.repeat(1024 * 1024);
@@ -320,30 +336,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
@@ -362,10 +384,12 @@ async function test() {
         let out1 = Array(10);
         let out2 = new Int32Array(10);
         let mult = -3;
+        let ret = null;
 
         FillRange(2, 7, out1, out1.length);
-        FillRange(13, 3, out2, out2.length);
+        ret = FillRange(13, 3, out2, out2.length);
 
+        assert.strictEqual(ret, undefined);
         assert.deepEqual(out1, [2, 9, 16, 23, 30, 37, 44, 51, 58, 65]);
         assert.deepEqual(out2, new Int32Array([13, 16, 19, 22, 25, 28, 31, 34, 37, 40]));
 
@@ -382,4 +406,16 @@ async function test() {
         assert.equal(ThroughStr16({ str: null, str16: 'World!' }), 'World!');
         assert.equal(ThroughStr16({ str: 'World!', str16: null }), null);
     }
+
+    // Transparent typed arrays for void pointers
+    {
+        let arr8 = Uint8Array.from([1, 2, 3, 4, 5]);
+        let arr16 = Int16Array.from([1, 2, 3, 4, 5]);
+
+        ReverseBytes(arr8, arr8.byteLength);
+        assert.deepEqual(arr8, Uint8Array.from([5, 4, 3, 2, 1]));
+
+        ReverseBytes(arr16, arr16.byteLength);
+        assert.deepEqual(arr16, Int16Array.from([1280, 1024, 768, 512, 256]));
+    }
 }

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: {