koffi 1.3.0 → 1.3.3

package/src/abi_x64_sysv_fwd.S

@@ -35,13 +35,15 @@
 .global SYMBOL(ForwardCallXGD)
 .global SYMBOL(ForwardCallXDD)
 
+#define ENDBR64 .byte 0xf3, 0x0f, 0x1e, 0xfa
+
 # Copy function pointer to R11, in order to save it through argument forwarding.
 # Also make a copy of the SP to CallData::old_sp because the callback system might need it.
 # Save RSP in RBX (non-volatile), and use carefully assembled stack provided by caller.
 .macro prologue
     .cfi_startproc
     .cfi_def_cfa rsp, 8
-    endbr64
+    ENDBR64
     movq %rdi, %r11
     pushq %rbx
     .cfi_def_cfa rsp, 16
@@ -196,7 +198,7 @@ SYMBOL(ForwardCallXDD):
 .macro trampoline id
     .cfi_startproc
     .cfi_def_cfa rsp, 8
-    endbr64
+    ENDBR64
     subq $152, %rsp
     .cfi_def_cfa rsp, 160
     movq %rdi, 0(%rsp)
@@ -209,7 +211,11 @@ SYMBOL(ForwardCallXDD):
     movq %rsp, %rsi
     leaq 160(%rsp), %rdx
     leaq 112(%rsp), %rcx
+#ifdef __linux__
+    call *RelayCallback@GOTPCREL(%rip)
+#else
     call SYMBOL(RelayCallback)
+#endif
     movq 112(%rsp), %rax
     movq 120(%rsp), %rdx
     addq $152, %rsp
@@ -222,7 +228,7 @@ SYMBOL(ForwardCallXDD):
 .macro trampoline_xmm id
     .cfi_startproc
     .cfi_def_cfa rsp, 8
-    endbr64
+    ENDBR64
     subq $152, %rsp
     .cfi_def_cfa rsp, 160
     movq %rdi, 0(%rsp)
@@ -243,7 +249,11 @@ SYMBOL(ForwardCallXDD):
     movq %rsp, %rsi
     leaq 160(%rsp), %rdx
     leaq 112(%rsp), %rcx
+#ifdef __linux__
+    call *RelayCallback@GOTPCREL(%rip)
+#else
     call SYMBOL(RelayCallback)
+#endif
     movq 112(%rsp), %rax
     movq 120(%rsp), %rdx
     movsd 128(%rsp), %xmm0
@@ -328,7 +338,7 @@ SYMBOL(TrampolineX15):
 SYMBOL(CallSwitchStack):
     .cfi_startproc
     .cfi_def_cfa rsp, 8
-    endbr64
+    ENDBR64
     push %rbx
     .cfi_def_cfa rsp, 16
     movq %rsp, %rbx

package/src/abi_x64_win.cc

@@ -299,14 +299,14 @@ Napi::Value CallData::Complete()
     switch (func->ret.type->primitive) {
         case PrimitiveKind::Void: return env.Null();
         case PrimitiveKind::Bool: return Napi::Boolean::New(env, result.u32);
-        case PrimitiveKind::Int8:
-        case PrimitiveKind::UInt8:
-        case PrimitiveKind::Int16:
-        case PrimitiveKind::UInt16:
-        case PrimitiveKind::Int32:
+        case PrimitiveKind::Int8: return Napi::Number::New(env, (double)result.i8);
+        case PrimitiveKind::UInt8: return Napi::Number::New(env, (double)result.u8);
+        case PrimitiveKind::Int16: return Napi::Number::New(env, (double)result.i16);
+        case PrimitiveKind::UInt16: return Napi::Number::New(env, (double)result.u16);
+        case PrimitiveKind::Int32: return Napi::Number::New(env, (double)result.i32);
         case PrimitiveKind::UInt32: return Napi::Number::New(env, (double)result.u32);
-        case PrimitiveKind::Int64: return Napi::BigInt::New(env, (int64_t)result.u64);
-        case PrimitiveKind::UInt64: return Napi::BigInt::New(env, result.u64);
+        case PrimitiveKind::Int64: return NewBigInt(env, result.i64);
+        case PrimitiveKind::UInt64: return NewBigInt(env, result.u64);
         case PrimitiveKind::String: return result.ptr ? Napi::String::New(env, (const char *)result.ptr) : env.Null();
         case PrimitiveKind::String16: return result.ptr ? Napi::String::New(env, (const char16_t *)result.ptr) : env.Null();
         case PrimitiveKind::Pointer:
@@ -409,14 +409,14 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                 int64_t v = *(int64_t *)(j < 4 ? gpr_ptr + j : args_ptr);
                 args_ptr += (j >= 4);
 
-                Napi::Value arg = Napi::BigInt::New(env, v);
+                Napi::Value arg = NewBigInt(env, v);
                 arguments.Append(arg);
             } break;
             case PrimitiveKind::UInt64: {
                 uint64_t v = *(uint64_t *)(j < 4 ? gpr_ptr + j : args_ptr);
                 args_ptr += (j >= 4);
 
-                Napi::Value arg = Napi::BigInt::New(env, v);
+                Napi::Value arg = NewBigInt(env, v);
                 arguments.Append(arg);
             } break;
             case PrimitiveKind::String: {

package/src/abi_x86.cc

@@ -373,14 +373,14 @@ Napi::Value CallData::Complete()
     switch (func->ret.type->primitive) {
         case PrimitiveKind::Void: return env.Null();
         case PrimitiveKind::Bool: return Napi::Boolean::New(env, result.u32);
-        case PrimitiveKind::Int8:
-        case PrimitiveKind::UInt8:
-        case PrimitiveKind::Int16:
-        case PrimitiveKind::UInt16:
-        case PrimitiveKind::Int32:
+        case PrimitiveKind::Int8: return Napi::Number::New(env, (double)result.i8);
+        case PrimitiveKind::UInt8: return Napi::Number::New(env, (double)result.u8);
+        case PrimitiveKind::Int16: return Napi::Number::New(env, (double)result.i16);
+        case PrimitiveKind::UInt16: return Napi::Number::New(env, (double)result.u16);
+        case PrimitiveKind::Int32: return Napi::Number::New(env, (double)result.i32);
         case PrimitiveKind::UInt32: return Napi::Number::New(env, (double)result.u32);
-        case PrimitiveKind::Int64: return Napi::BigInt::New(env, (int64_t)result.u64);
-        case PrimitiveKind::UInt64: return Napi::BigInt::New(env, result.u64);
+        case PrimitiveKind::Int64: return NewBigInt(env, result.i64);
+        case PrimitiveKind::UInt64: return NewBigInt(env, result.u64);
         case PrimitiveKind::String: return result.ptr ? Napi::String::New(env, (const char *)result.ptr) : env.Null();
         case PrimitiveKind::String16: return result.ptr ? Napi::String::New(env, (const char16_t *)result.ptr) : env.Null();
         case PrimitiveKind::Pointer:
@@ -485,14 +485,14 @@ void CallData::Relay(Size idx, uint8_t *own_sp, uint8_t *caller_sp, BackRegister
                 int64_t v = *(int64_t *)args_ptr;
                 args_ptr += 2;
 
-                Napi::Value arg = Napi::BigInt::New(env, v);
+                Napi::Value arg = NewBigInt(env, v);
                 arguments.Append(arg);
             } break;
             case PrimitiveKind::UInt64: {
                 uint64_t v = *(uint64_t *)args_ptr;
                 args_ptr += 2;
 
-                Napi::Value arg = Napi::BigInt::New(env, v);
+                Napi::Value arg = NewBigInt(env, v);
                 arguments.Append(arg);
             } break;
             case PrimitiveKind::String: {

package/src/abi_x86_fwd.S

@@ -18,13 +18,15 @@
 .global ForwardCallRF
 .global ForwardCallRD
 
+#define ENDBR32 .byte 0xf3, 0x0f, 0x1e, 0xfb
+
 # Copy function pointer to EAX, in order to save it through argument forwarding.
 # Also make a copy of the SP to CallData::old_sp because the callback system might need it.
 # Save ESP in EBX (non-volatile), and use carefully assembled stack provided by caller.
 .macro prologue
     .cfi_startproc
     .cfi_def_cfa esp, 4
-    endbr32
+    ENDBR32
     push %ebx
     .cfi_def_cfa esp, 8
     movl %esp, %ebx
@@ -125,7 +127,7 @@ ForwardCallRD:
 .macro trampoline id
     .cfi_startproc
     .cfi_def_cfa esp, 4
-    endbr32
+    ENDBR32
     sub $44, %esp
     .cfi_def_cfa esp, 48
     movl $\id, 0(%esp)
@@ -153,7 +155,7 @@ ForwardCallRD:
 .macro trampoline_x87 id
     .cfi_startproc
     .cfi_def_cfa esp, 4
-    endbr32
+    ENDBR32
     sub $44, %esp
     .cfi_def_cfa esp, 48
     movl $\id, 0(%esp)
@@ -260,7 +262,7 @@ TrampolineX15:
 CallSwitchStack:
     .cfi_startproc
     .cfi_def_cfa esp, 4
-    endbr32
+    ENDBR32
     push %ebx
     .cfi_def_cfa esp, 8
     movl %esp, %ebx

package/src/call.cc

@@ -248,7 +248,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
             } break;
             case PrimitiveKind::Pointer: {
                 if (CheckValueTag(instance, value, member.type)) {
-                    Napi::External external = value.As<Napi::External<void>>();
+                    Napi::External<void> external = value.As<Napi::External<void>>();
                     void *ptr = external.Data();
                     *(void **)dest = ptr;
                 } else if (IsNullOrUndefined(value)) {
@@ -317,7 +317,7 @@ bool CallData::PushObject(Napi::Object obj, const TypeInfo *type, uint8_t *origi
                     if (RG_UNLIKELY(!ptr))
                         return false;
                 } else if (CheckValueTag(instance, value, member.type)) {
-                    Napi::External external = value.As<Napi::External<void>>();
+                    Napi::External<void> external = value.As<Napi::External<void>>();
                     ptr = external.Data();
                 } else if (IsNullOrUndefined(value)) {
                     ptr = nullptr;
@@ -452,7 +452,7 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *ref,
         case PrimitiveKind::Pointer: {
             PUSH_ARRAY(CheckValueTag(instance, value, ref) || IsNullOrUndefined(value), ref->name, {
                 if (!IsNullOrUndefined(value)) {
-                    Napi::External external = value.As<Napi::External<void>>();
+                    Napi::External<void> external = value.As<Napi::External<void>>();
                     *(void **)dest = external.Data();
                 } else {
                     *(void **)dest = nullptr;
@@ -528,7 +528,7 @@ bool CallData::PushNormalArray(Napi::Array array, Size len, const TypeInfo *ref,
                     if (RG_UNLIKELY(!ptr))
                         return false;
                 } else if (CheckValueTag(instance, value, ref)) {
-                    Napi::External external = value.As<Napi::External<void>>();
+                    Napi::External<void> external = value.As<Napi::External<void>>();
                     ptr = external.Data();
                 } else if (IsNullOrUndefined(value)) {
                     ptr = nullptr;
@@ -801,11 +801,11 @@ void CallData::PopObject(Napi::Object obj, const uint8_t *origin, const TypeInfo
             } break;
             case PrimitiveKind::Int64: {
                 int64_t v = *(int64_t *)src;
-                obj.Set(member.name, Napi::BigInt::New(env, v));
+                obj.Set(member.name, NewBigInt(env, v));
             } break;
             case PrimitiveKind::UInt64: {
                 uint64_t v = *(uint64_t *)src;
-                obj.Set(member.name, Napi::BigInt::New(env, v));
+                obj.Set(member.name, NewBigInt(env, v));
             } break;
             case PrimitiveKind::String: {
                 const char *str = *(const char **)src;
@@ -914,13 +914,13 @@ void CallData::PopNormalArray(Napi::Array array, const uint8_t *origin, const Ty
         case PrimitiveKind::Int64: {
             POP_ARRAY({
                 int64_t v = *(int64_t *)src;
-                array.Set(i, Napi::BigInt::New(env, v));
+                array.Set(i, NewBigInt(env, v));
             });
         } break;
         case PrimitiveKind::UInt64: {
             POP_ARRAY({
                 uint64_t v = *(uint64_t *)src;
-                array.Set(i, Napi::BigInt::New(env, v));
+                array.Set(i, NewBigInt(env, v));
             });
         } break;
         case PrimitiveKind::String: {
@@ -1078,13 +1078,13 @@ Napi::Value CallData::PopArray(const uint8_t *origin, const TypeInfo *type, int1
         case PrimitiveKind::Int64: {
             POP_ARRAY({
                 int64_t v = *(int64_t *)src;
-                array.Set(i, Napi::BigInt::New(env, v));
+                array.Set(i, NewBigInt(env, v));
             });
         } break;
         case PrimitiveKind::UInt64: {
             POP_ARRAY({
                 uint64_t v = *(uint64_t *)src;
-                array.Set(i, Napi::BigInt::New(env, v));
+                array.Set(i, NewBigInt(env, v));
             });
         } break;
         case PrimitiveKind::String: {

package/src/call.hh

@@ -50,7 +50,13 @@ class alignas(8) CallData {
     uint8_t *old_sp;
 
     union {
+        int8_t i8;
+        uint8_t u8;
+        int16_t i16;
+        uint16_t u16;
+        int32_t i32;
         uint32_t u32;
+        int64_t i64;
         uint64_t u64;
         float f;
         double d;

package/src/ffi.cc

@@ -116,7 +116,7 @@ static Napi::Value GetSetConfig(const Napi::CallbackInfo &info)
                     return env.Null();
                 }
 
-                instance->resident_async_pools = n;
+                instance->resident_async_pools = (int)n;
             } else {
                 ThrowError<Napi::Error>(env, "Unexpected config member '%1'", key.c_str());
                 return env.Null();
@@ -636,6 +636,8 @@ static InstanceMemory *AllocateMemory(InstanceData *instance, Size stack_size, S
 #endif
     RG_CRITICAL(mem->heap.ptr, "Failed to allocate %1 of memory", mem->heap.len);
 
+    mem->depth = 0;
+
     if (instance->memories.len <= instance->resident_async_pools) {
         instance->memories.Append(mem);
     } else {

package/src/parser.cc

@@ -44,7 +44,7 @@ bool PrototypeParser::Parse(const char *str, FunctionInfo *out_func)
     out_func->name = ParseIdentifier();
 
     Consume("(");
-    if (offset < tokens.len && tokens[offset] != ")") {
+    if (offset < tokens.len && tokens[offset] != ")" && !Match("void")) {
         for (;;) {
             ParameterInfo param = {};
 

package/src/util.hh

@@ -89,7 +89,7 @@ static inline bool IsObject(Napi::Value value)
 int GetTypedArrayType(const TypeInfo *type);
 
 template <typename T>
-T CopyNumber(const Napi::Value &value)
+T CopyNumber(Napi::Value value)
 {
     RG_ASSERT(value.IsNumber() || value.IsBigInt());
 
@@ -105,6 +105,26 @@ T CopyNumber(const Napi::Value &value)
     RG_UNREACHABLE();
 }
 
+static inline Napi::Value NewBigInt(Napi::Env env, int64_t value)
+{
+    if (value <= 9007199254740992ll && value >= -9007199254740992ll) {
+        double d = (double)value;
+        return Napi::Number::New(env, d);
+    } else {
+        return Napi::BigInt::New(env, value);
+    }
+}
+
+static inline Napi::Value NewBigInt(Napi::Env env, uint64_t value)
+{
+    if (value <= 9007199254740992ull) {
+        double d = (double)value;
+        return Napi::Number::New(env, d);
+    } else {
+        return Napi::BigInt::New(env, 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);

package/test/CMakeLists.txt

@@ -11,7 +11,7 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program. If not, see https://www.gnu.org/licenses/.
 
-cmake_minimum_required(VERSION 3.12)
+cmake_minimum_required(VERSION 3.6)
 project(koffi_test C CXX)
 
 if(NOT TARGET koffi)

package/test/misc.c

@@ -129,6 +129,26 @@ typedef struct IntContainer {
     int len;
 } IntContainer;
 
+EXPORT int8_t GetMinusOne1(void)
+{
+    return -1;
+}
+
+EXPORT int16_t GetMinusOne2(void)
+{
+    return -1;
+}
+
+EXPORT int32_t GetMinusOne4(void)
+{
+    return -1;
+}
+
+EXPORT int64_t GetMinusOne8(void)
+{
+    return -1;
+}
+
 EXPORT void FillPack1(int a, Pack1 *p)
 {
     p->a = a;

package/test/sync.js

@@ -122,6 +122,10 @@ async function test() {
     let lib_filename = path.dirname(__filename) + '/build/misc' + koffi.extension;
     let lib = koffi.load(lib_filename);
 
+    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 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))]);
@@ -172,6 +176,12 @@ async function test() {
     const FillRange = lib.func('void FillRange(int init, int step, _Out_ int *out, int len)');
     const MultiplyIntegers = lib.func('void MultiplyIntegers(int multiplier, _Inout_ int *values, int len)');
 
+    // Simple signed value returns
+    assert.equal(GetMinusOne1(), -1);
+    assert.equal(GetMinusOne2(), -1);
+    assert.equal(GetMinusOne4(), -1);
+    assert.equal(GetMinusOne8(), -1);
+
     // Simple tests with Pack1
     {
         let p = {};
@@ -250,9 +260,9 @@ async function test() {
 
     // Many parameters
     {
-        assert.equal(ConcatenateToInt1(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
-        assert.equal(ConcatenateToInt4(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
-        assert.equal(ConcatenateToInt8(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
+        assert.equal(ConcatenateToInt1(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687);
+        assert.equal(ConcatenateToInt4(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687);
+        assert.equal(ConcatenateToInt8(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687);
         assert.equal(ConcatenateToStr1(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');
         assert.equal(ConcatenateToStr4(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');
         assert.equal(ConcatenateToStr8(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');

package/vendor/libcc/libcc.cc

@@ -20,7 +20,7 @@
     #include "vendor/brotli/c/include/brotli/decode.h"
     #include "vendor/brotli/c/include/brotli/encode.h"
 #endif
-#if __has_include("vendor/dragonbox/include/dragonbox/dragonbox.h")
+#if __has_include("vendor/dragonbox/include/dragonbox/dragonbox.h") && __cplusplus >= 201703L
     #include "vendor/dragonbox/include/dragonbox/dragonbox.h"
 #endif
 
@@ -81,6 +81,9 @@
 
     extern char **environ;
 #endif
+#ifdef __linux__
+    #include <sys/syscall.h>
+#endif
 #ifdef __APPLE__
     #include <sys/random.h>
     #include <mach-o/dyld.h>
@@ -3741,8 +3744,8 @@ bool ExecuteCommandLine(const char *cmd_line, FunctionRef<Span<const uint8_t>()>
 #if defined(__OpenBSD__) || defined(__FreeBSD__)
 static const pthread_t main_thread = pthread_self();
 #endif
-static std::atomic_bool flag_interrupt = false;
-static std::atomic_bool explicit_interrupt = false;
+static std::atomic_bool flag_interrupt {false};
+static std::atomic_bool explicit_interrupt {false};
 static int interrupt_pfd[2] = {-1, -1};
 
 void SetSignalHandler(int signal, void (*func)(int), struct sigaction *prev)
@@ -4165,7 +4168,7 @@ void WaitDelay(int64_t delay)
 
 WaitForResult WaitForInterrupt(int64_t timeout)
 {
-    static std::atomic_bool message = false;
+    static std::atomic_bool message {false};
 
     flag_interrupt = true;
     SetSignalHandler(SIGUSR1, [](int) { message = true; });
@@ -4755,8 +4758,17 @@ void FillRandomSafe(void *out_buf, Size len)
         struct { uint32_t key[8]; uint32_t iv[2]; } buf;
 
         memset(rnd_state, 0, RG_SIZE(rnd_state));
-#ifdef _WIN32
+#if defined(_WIN32)
         RG_CRITICAL(RtlGenRandom(&buf, RG_SIZE(buf)), "RtlGenRandom() failed: %s", GetWin32ErrorString());
+#elif defined(__linux__)
+        {
+restart:
+            int ret = syscall(SYS_getrandom, &buf, RG_SIZE(buf), 0);
+            RG_CRITICAL(ret >= 0, "getentropy() failed: %s", strerror(errno));
+
+            if (ret < RG_SIZE(buf))
+                goto restart;
+        }
 #else
         RG_CRITICAL(getentropy(&buf, RG_SIZE(buf)) == 0, "getentropy() failed: %s", strerror(errno));
 #endif

package/vendor/libcc/libcc.hh

@@ -1204,7 +1204,11 @@ public:
     {
         RemoveFrom(0);
         Grow(other.capacity);
+#if __cplusplus >= 201703L
         if constexpr(!std::is_trivial<T>::value) {
+#else
+        if (true) {
+#endif
             for (Size i = 0; i < other.len; i++) {
                 ptr[i] = other.ptr[i];
             }
@@ -1308,7 +1312,11 @@ public:
         Grow(count);
 
         T *first = ptr + len;
+#if __cplusplus >= 201703L
         if constexpr(!std::is_trivial<T>::value) {
+#else
+        if (true) {
+#endif
             for (Size i = 0; i < count; i++) {
                 new (ptr + len) T();
                 len++;
@@ -1325,7 +1333,11 @@ public:
         Grow();
 
         T *first = ptr + len;
+#if __cplusplus >= 201703L
         if constexpr(!std::is_trivial<T>::value) {
+#else
+        if (true) {
+#endif
             new (ptr + len) T;
         }
         ptr[len++] = value;
@@ -1337,7 +1349,11 @@ public:
 
         T *first = ptr + len;
         for (const T &value: values) {
+#if __cplusplus >= 201703L
             if constexpr(!std::is_trivial<T>::value) {
+#else
+            if (true) {
+#endif
                 new (ptr + len) T;
             }
             ptr[len++] = value;
@@ -1349,7 +1365,11 @@ public:
     {
         RG_ASSERT(first >= 0 && first <= len);
 
+#if __cplusplus >= 201703L
         if constexpr(!std::is_trivial<T>::value) {
+#else
+        if (true) {
+#endif
             for (Size i = first; i < len; i++) {
                 ptr[i].~T();
             }
@@ -1655,7 +1675,11 @@ private:
     void DeleteValues([[maybe_unused]] iterator_type begin,
                       [[maybe_unused]] iterator_type end)
     {
+#if __cplusplus >= 201703L
         if constexpr(!std::is_trivial<T>::value) {
+#else
+        if (true) {
+#endif
             for (iterator_type it = begin; it != end; ++it) {
                 it->~T();
             }
@@ -1932,7 +1956,11 @@ public:
     }
     ~HashTable()
     {
+#if __cplusplus >= 201703L
         if constexpr(std::is_trivial<ValueType>::value) {
+#else
+        if (false) {
+#endif
             count = 0;
             Rehash(0);
         } else {
@@ -2102,7 +2130,11 @@ private:
         { return (ValueType *)((const HashTable *)this)->Find(idx, key); }
     const ValueType *Find(Size *idx, const KeyType &key) const
     {
+#if __cplusplus >= 201703L
         if constexpr(std::is_pointer<ValueType>::value) {
+#else
+        if (false) {
+#endif
             while (data[*idx]) {
                 const KeyType &it_key = Handler::GetKey(data[*idx]);
                 if (Handler::TestKeys(it_key, key))
@@ -3017,7 +3049,7 @@ public:
 
     int repeat = 1;
     int pad_len = 0;
-    char pad_char;
+    char pad_char = 0;
 
     FmtArg() = default;
     FmtArg(std::nullptr_t) : type(FmtType::Str1) { u.str1 = "(null)"; }