koffi 2.5.0 → 2.5.1

package/CHANGELOG.md

@@ -4,6 +4,13 @@
 
 ### Koffi 2.5
 
+#### Koffi 2.5.1
+
+**Main changes:**
+
+- Fix crash with some struct types in System V 64 ABI
+- Always use direct passthrough for buffer arguments
+
 #### Koffi 2.5.0
 
 **New features:**

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "koffi",
-    "version": "2.5.0",
-    "stable": "2.5.0",
+    "version": "2.5.1",
+    "stable": "2.5.1",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [
         "foreign",

package/src/core/libcc/brotli.cc

@@ -130,7 +130,7 @@ bool BrotliCompressor::Init(CompressionType, CompressionSpeed speed)
     if (!state)
         throw std::bad_alloc();
 
-    RG_STATIC_ASSERT(BROTLI_MIN_QUALITY == 0 && BROTLI_MAX_QUALITY == 11);
+    static_assert(BROTLI_MIN_QUALITY == 0 && BROTLI_MAX_QUALITY == 11);
 
     switch (speed) {
         case CompressionSpeed::Default: { BrotliEncoderSetParameter(state, BROTLI_PARAM_QUALITY, 6); } break;

package/src/core/libcc/libcc.cc

@@ -21,7 +21,7 @@
 
 #include "libcc.hh"
 
-#if __has_include("vendor/dragonbox/include/dragonbox/dragonbox.h") && __cplusplus >= 201703L
+#if __has_include("vendor/dragonbox/include/dragonbox/dragonbox.h")
     #include "vendor/dragonbox/include/dragonbox/dragonbox.h"
 #endif
 
@@ -445,13 +445,13 @@ LocalDate LocalDate::Parse(Span<const char> date_str, unsigned int flags,
             int digit = c - '0';
             if ((unsigned int)digit < 10) {
                 parts[i] = (parts[i] * 10) + digit;
-                if (RG_UNLIKELY(++lengths[i] > 5))
+                if (++lengths[i] > 5) [[unlikely]]
                     goto malformed;
             } else if (!lengths[i] && c == '-' && mult == 1 && i != 1) {
                 mult = -1;
-            } else if (RG_UNLIKELY(i == 2 && !(flags & (int)ParseFlag::End) && c != '/' && c != '-')) {
+            } else if (i == 2 && !(flags & (int)ParseFlag::End) && c != '/' && c != '-') [[unlikely]] {
                 break;
-            } else if (RG_UNLIKELY(!lengths[i] || (c != '/' && c != '-'))) {
+            } else if (!lengths[i] || (c != '/' && c != '-')) [[unlikely]] {
                 goto malformed;
             } else {
                 offset++;
@@ -464,9 +464,9 @@ LocalDate LocalDate::Parse(Span<const char> date_str, unsigned int flags,
     if ((flags & (int)ParseFlag::End) && offset < date_str.len)
         goto malformed;
 
-    if (RG_UNLIKELY((unsigned int)lengths[1] > 2))
+    if ((unsigned int)lengths[1] > 2) [[unlikely]]
         goto malformed;
-    if (RG_UNLIKELY((lengths[0] > 2) == (lengths[2] > 2))) {
+    if ((lengths[0] > 2) == (lengths[2] > 2)) [[unlikely]] {
         if (flags & (int)ParseFlag::Log) {
             LogError("Ambiguous date string '%1'", date_str);
         }
@@ -474,7 +474,7 @@ LocalDate LocalDate::Parse(Span<const char> date_str, unsigned int flags,
     } else if (lengths[2] > 2) {
         std::swap(parts[0], parts[2]);
     }
-    if (RG_UNLIKELY(parts[0] < -INT16_MAX || parts[0] > INT16_MAX || (unsigned int)parts[2] > 99))
+    if (parts[0] < -INT16_MAX || parts[0] > INT16_MAX || (unsigned int)parts[2] > 99) [[unlikely]]
         goto malformed;
 
     date.st.year = (int16_t)parts[0];
@@ -722,13 +722,13 @@ bool CopyString(const char *str, Span<char> buf)
 #ifdef RG_DEBUG
     RG_ASSERT(buf.len > 0);
 #else
-    if (RG_UNLIKELY(!buf.len))
+    if (!buf.len) [[unlikely]]
         return false;
 #endif
 
     Size i = 0;
     for (; str[i]; i++) {
-        if (RG_UNLIKELY(i >= buf.len - 1)) {
+        if (i >= buf.len - 1) [[unlikely]] {
             buf[buf.len - 1] = 0;
             return false;
         }
@@ -744,11 +744,11 @@ bool CopyString(Span<const char> str, Span<char> buf)
 #ifdef RG_DEBUG
     RG_ASSERT(buf.len > 0);
 #else
-    if (RG_UNLIKELY(!buf.len))
+    if (!buf.len) [[unlikely]]
         return false;
 #endif
 
-    if (RG_UNLIKELY(str.len > buf.len - 1))
+    if (str.len > buf.len - 1) [[unlikely]]
         return false;
 
     memcpy_safe(buf.ptr, str.ptr, str.len);
@@ -1684,7 +1684,7 @@ static void WriteStdComplete(Span<const char> buf, FILE *fp)
 {
     while (buf.len) {
         Size write_len = (Size)fwrite(buf.ptr, 1, (size_t)buf.len, fp);
-        if (RG_UNLIKELY(!write_len))
+        if (!write_len) [[unlikely]]
             break;
         buf = buf.Take(write_len, buf.len - write_len);
     }
@@ -1965,7 +1965,7 @@ Size ConvertUtf8ToWin32Wide(Span<const char> str, Span<wchar_t> out_str_w)
 {
     RG_ASSERT(out_str_w.len >= 2);
 
-    if (RG_UNLIKELY(!str.len)) {
+    if (!str.len) [[unlikely]] {
         out_str_w[0] = 0;
         return 0;
     }
@@ -2230,7 +2230,7 @@ EnumResult EnumerateDirectory(const char *dirname, const char *filter, Size max_
                 (find_data.cFileName[0] == '.' && find_data.cFileName[1] == '.' && !find_data.cFileName[2]))
             continue;
 
-        if (RG_UNLIKELY(count++ >= max_files && max_files >= 0)) {
+        if (count++ >= max_files && max_files >= 0) [[unlikely]] {
             LogError("Partial enumation of directory '%1'", dirname);
             return EnumResult::PartialEnum;
         }
@@ -2292,7 +2292,7 @@ static FileType FileModeToType(mode_t mode)
 
 StatResult StatFile(const char *filename, unsigned int flags, FileInfo *out_info)
 {
-#if defined(__linux__) && !defined(LIBCC_NO_STATX)
+#if defined(__linux__) && defined(STATX_TYPE) && !defined(LIBCC_NO_STATX)
     int stat_flags = (flags & (int)StatFlag::FollowSymlink) ? 0 : AT_SYMLINK_NOFOLLOW;
     int stat_mask = STATX_TYPE | STATX_MODE | STATX_MTIME | STATX_BTIME | STATX_SIZE;
 
@@ -2468,7 +2468,7 @@ EnumResult EnumerateDirectory(const char *dirname, const char *filter, Size max_
             continue;
 
         if (!filter || !fnmatch(filter, dent->d_name, FNM_PERIOD)) {
-            if (RG_UNLIKELY(count++ >= max_files && max_files >= 0)) {
+            if (count++ >= max_files && max_files >= 0) [[unlikely]] {
                 LogError("Partial enumation of directory '%1'", dirname);
                 return EnumResult::PartialEnum;
             }
@@ -2738,7 +2738,7 @@ bool FindExecutableInPath(Span<const char> paths, const char *name, Allocator *a
         static const Span<const char> extensions[] = {".com", ".exe", ".bat", ".cmd"};
 
         for (Span<const char> ext: extensions) {
-            if (RG_LIKELY(ext.len < buf.Available() - 1)) {
+            if (ext.len < buf.Available() - 1) [[likely]] {
                 memcpy_safe(buf.end(), ext.ptr, ext.len + 1);
 
                 if (TestFile(buf.data)) {
@@ -2750,7 +2750,7 @@ bool FindExecutableInPath(Span<const char> paths, const char *name, Allocator *a
             }
         }
 #else
-        if (RG_LIKELY(buf.len < RG_SIZE(buf.data) - 1) && TestFile(buf.data)) {
+        if (buf.len < RG_SIZE(buf.data) - 1 && TestFile(buf.data)) {
             if (out_path) {
                 *out_path = DuplicateString(buf.data, alloc).ptr;
             }
@@ -3643,7 +3643,7 @@ bool MakeDirectory(const char *directory, bool error_if_exists)
 bool MakeDirectoryRec(Span<const char> directory)
 {
     char buf[4096];
-    if (RG_UNLIKELY(directory.len >= RG_SIZE(buf))) {
+    if (directory.len >= RG_SIZE(buf)) [[unlikely]] {
         LogError("Path '%1' is too large", directory);
         return false;
     }
@@ -4321,7 +4321,7 @@ bool ExecuteCommandLine(const char *cmd_line, Span<const uint8_t> in_buf, Size m
     {
         Size memory_max = RG_SIZE_MAX - out_buf->len - 1;
 
-        if (RG_UNLIKELY(memory_max <= 0)) {
+        if (memory_max <= 0) [[unlikely]] {
             LogError("Exhausted memory limit");
             return false;
         }
@@ -4830,7 +4830,7 @@ static const char *CreateUniquePath(Span<const char> directory, const char *pref
 
     for (Size i = 0; i < 1000; i++) {
         // We want to show an error on last try
-        if (RG_UNLIKELY(i == 999)) {
+        if (i == 999) [[unlikely]] {
             PopLogFilter();
             log_guard.Disable();
         }
@@ -5664,7 +5664,7 @@ Fiber::~Fiber()
 
 void Fiber::SwitchTo()
 {
-    if (RG_UNLIKELY(!fiber))
+    if (!fiber) [[unlikely]]
         return;
 
     if (!done) {
@@ -5675,7 +5675,7 @@ void Fiber::SwitchTo()
 
 bool Fiber::Finalize()
 {
-    if (RG_UNLIKELY(!fiber))
+    if (!fiber) [[unlikely]]
         return false;
 
     if (!done) {
@@ -5746,7 +5746,7 @@ Fiber::~Fiber()
 
 void Fiber::SwitchTo()
 {
-    if (RG_UNLIKELY(!ucp.uc_stack.ss_sp))
+    if (!ucp.uc_stack.ss_sp) [[unlikely]]
         return;
 
     if (!done) {
@@ -5757,7 +5757,7 @@ void Fiber::SwitchTo()
 
 bool Fiber::Finalize()
 {
-    if (RG_UNLIKELY(!ucp.uc_stack.ss_sp))
+    if (!ucp.uc_stack.ss_sp) [[unlikely]]
         return false;
 
     if (!done) {
@@ -6025,7 +6025,7 @@ bool StreamReader::Close(bool implicit)
 
 bool StreamReader::Rewind()
 {
-    if (RG_UNLIKELY(error))
+    if (error) [[unlikely]]
         return false;
 
     switch (source.type) {
@@ -6077,7 +6077,7 @@ int StreamReader::GetDescriptor() const
 
 Size StreamReader::Read(Span<uint8_t> out_buf)
 {
-    if (RG_UNLIKELY(error))
+    if (error) [[unlikely]]
         return -1;
 
     Size read_len = 0;
@@ -6093,7 +6093,7 @@ Size StreamReader::Read(Span<uint8_t> out_buf)
         eof = source.eof;
     }
 
-    if (RG_UNLIKELY(!error && read_max >= 0 && read_len > read_max - read_total)) {
+    if (!error && read_max >= 0 && read_len > read_max - read_total) [[unlikely]] {
         LogError("Exceeded max stream size of %1", FmtDiskSize(read_max));
         error = true;
         return -1;
@@ -6105,7 +6105,7 @@ Size StreamReader::Read(Span<uint8_t> out_buf)
 
 Size StreamReader::ReadAll(Size max_len, HeapArray<uint8_t> *out_buf)
 {
-    if (RG_UNLIKELY(error))
+    if (error) [[unlikely]]
         return -1;
 
     RG_DEFER_NC(buf_guard, buf_len = out_buf->len) { out_buf->RemoveFrom(buf_len); };
@@ -6114,7 +6114,7 @@ Size StreamReader::ReadAll(Size max_len, HeapArray<uint8_t> *out_buf)
     {
         Size memory_max = RG_SIZE_MAX - out_buf->len - 1;
 
-        if (RG_UNLIKELY(memory_max <= 0)) {
+        if (memory_max <= 0) [[unlikely]] {
             LogError("Exhausted memory limit reading file '%1'", filename);
             return -1;
         }
@@ -6154,7 +6154,7 @@ Size StreamReader::ReadAll(Size max_len, HeapArray<uint8_t> *out_buf)
             if (read_len < 0)
                 return -1;
 
-            if (RG_UNLIKELY(read_len > max_len - total_len)) {
+            if (read_len > max_len - total_len) [[unlikely]] {
                 LogError("File '%1' is too large (limit = %2)", filename, FmtDiskSize(max_len));
                 return -1;
             }
@@ -6170,7 +6170,7 @@ Size StreamReader::ReadAll(Size max_len, HeapArray<uint8_t> *out_buf)
 
 int64_t StreamReader::ComputeRawLen()
 {
-    if (RG_UNLIKELY(error))
+    if (error) [[unlikely]]
         return -1;
     if (raw_read || raw_len >= 0)
         return raw_len;
@@ -6289,7 +6289,7 @@ bool LineReader::Next(Span<char> *out_line)
         line_number = 0;
         return false;
     }
-    if (RG_UNLIKELY(error))
+    if (error) [[unlikely]]
         return false;
 
     for (;;) {
@@ -6466,7 +6466,7 @@ bool StreamWriter::Open(const std::function<bool(Span<const uint8_t>)> &func, co
 
 bool StreamWriter::Flush()
 {
-    if (RG_UNLIKELY(error))
+    if (error) [[unlikely]]
         return false;
 
     switch (dest.type) {
@@ -6504,7 +6504,7 @@ int StreamWriter::GetDescriptor() const
 
 bool StreamWriter::Write(Span<const uint8_t> buf)
 {
-    if (RG_UNLIKELY(error))
+    if (error) [[unlikely]]
         return false;
 
     if (compressor) {
@@ -6688,7 +6688,7 @@ bool SpliceStream(StreamReader *reader, int64_t max_len, StreamWriter *writer)
         if (buf.len < 0)
             return false;
 
-        if (RG_UNLIKELY(max_len >= 0 && buf.len > max_len - total_len)) {
+        if (max_len >= 0 && buf.len > max_len - total_len) [[unlikely]] {
             LogError("File '%1' is too large (limit = %2)", reader->GetFileName(), FmtDiskSize(max_len));
             return false;
         }
@@ -6724,7 +6724,7 @@ static bool CheckIniKey(Span<const char> key)
 
 IniParser::LineType IniParser::FindNextLine(IniProperty *out_prop)
 {
-    if (RG_UNLIKELY(error))
+    if (error) [[unlikely]]
         return LineType::Exit;
 
     RG_DEFER_N(err_guard) { error = true; };
@@ -6921,7 +6921,7 @@ static bool assets_ready;
 
 void InitPackedMap(Span<const AssetInfo> assets)
 {
-    if (RG_LIKELY(!assets_ready)) {
+    if (!assets_ready) [[likely]] {
         for (const AssetInfo &asset: assets) {
             PackedAssets_map.Set(&asset);
         }
@@ -6933,39 +6933,27 @@ void InitPackedMap(Span<const AssetInfo> assets)
 bool PatchFile(StreamReader *reader, StreamWriter *writer,
                FunctionRef<void(Span<const char>, StreamWriter *)> func)
 {
-    char c;
-    while (reader->Read(1, &c) == 1) {
-        if (c == '{') {
-            char name[33] = {};
-            Size name_len = reader->Read(1, &name[0]);
-            RG_ASSERT(name_len >= 0);
+    LineReader splitter(reader);
 
-            if (IsAsciiAlpha(name[0]) || name[0] == '_') {
-                do {
-                    Size read_len = reader->Read(1, &name[name_len]);
-                    RG_ASSERT(read_len >= 0);
+    Span<const char> line;
+    while (splitter.Next(&line) && writer->IsValid()) {
+        while (line.len) {
+            Span<const char> before = SplitStr(line, "{{", &line);
 
-                    if (name[name_len] == '}') {
-                        name[name_len] = 0;
+            writer->Write(before);
 
-                        Span<const char> key = MakeSpan(name, name_len);
-                        func(key, writer);
+            if (before.end() < line.ptr) {
+                Span<const char> expr = SplitStr(line, "}}", &line);
 
-                        break;
-                    } else if (!IsAsciiAlphaOrDigit(name[name_len]) && name[name_len] != '_') {
-                        writer->Write('{');
-                        writer->Write(name, name_len + 1);
-
-                        break;
-                    }
-                } while (++name_len < RG_SIZE(name));
-            } else {
-                writer->Write('{');
-                writer->Write(name[0]);
+                if (expr.end() < line.ptr) {
+                    func(expr, writer);
+                } else {
+                    Print(writer, "{{%1", expr);
+                }
             }
-        } else {
-            writer->Write(c);
         }
+
+        writer->Write('\n');
     }
 
     if (!reader->IsValid())

package/src/core/libcc/libcc.hh

@@ -162,8 +162,6 @@ static_assert(sizeof(double) == 8, "This code base is not designed to support si
     #else
         #define RG_THREAD_LOCAL __thread
     #endif
-    #define RG_LIKELY(Cond) __builtin_expect(!!(Cond), 1)
-    #define RG_UNLIKELY(Cond) __builtin_expect(!!(Cond), 0)
 
     #ifndef SCNd8
         #define SCNd8 "hhd"
@@ -179,8 +177,6 @@ static_assert(sizeof(double) == 8, "This code base is not designed to support si
     #define RG_POP_NO_WARNINGS __pragma(warning(pop))
 
     #define RG_THREAD_LOCAL thread_local
-    #define RG_LIKELY(Cond) (Cond)
-    #define RG_UNLIKELY(Cond) (Cond)
 #else
     #error Compiler not supported
 #endif
@@ -217,7 +213,7 @@ extern "C" void AssertMessage(const char *filename, int line, const char *cond);
 
 #define RG_CRITICAL(Cond, ...) \
     do { \
-        if (RG_UNLIKELY(!(Cond))) { \
+        if (!(Cond)) [[unlikely]] { \
             PrintLn(stderr, __VA_ARGS__); \
             abort(); \
         } \
@@ -225,7 +221,7 @@ extern "C" void AssertMessage(const char *filename, int line, const char *cond);
 #ifdef RG_DEBUG
     #define RG_ASSERT(Cond) \
         do { \
-            if (RG_UNLIKELY(!(Cond))) { \
+            if (!(Cond)) [[unlikely]] { \
                 RG::AssertMessage(__FILE__, __LINE__, RG_STRINGIFY(Cond)); \
                 RG_DEBUG_BREAK(); \
                 abort(); \
@@ -237,8 +233,6 @@ extern "C" void AssertMessage(const char *filename, int line, const char *cond);
             (void)sizeof(Cond); \
         } while (false)
 #endif
-#define RG_STATIC_ASSERT(Cond) \
-    static_assert((Cond), RG_STRINGIFY(Cond))
 
 #if defined(RG_DEBUG)
     #define RG_UNREACHABLE() \
@@ -2104,7 +2098,7 @@ public:
 
     void RemoveAll()
     {
-        RG_STATIC_ASSERT(!std::is_pointer<ValueType>::value);
+        static_assert(!std::is_pointer<ValueType>::value);
 
         for (Size i = 0; i < capacity; i++) {
             if (!IsEmpty(i)) {
@@ -3436,6 +3430,53 @@ static inline Span<const char> SplitStr(Span<const char> str, char split_char, S
 static inline Span<const char> SplitStr(const char *str, char split_char, const char **out_remainder = nullptr)
     { return SplitStr((char *)str, split_char, (char **)out_remainder); }
 
+static inline Span<char> SplitStr(Span<char> str, const char *split_str, Span<char> *out_remainder = nullptr)
+{
+    RG_ASSERT(split_str[0]);
+
+    Size part_len = 0;
+    while (part_len < str.len) {
+        if (StartsWith(str.Take(part_len, str.len - part_len), split_str)) {
+            if (out_remainder) {
+                Size split_len = strlen(split_str);
+                *out_remainder = str.Take(part_len + split_len, str.len - part_len - split_len);
+            }
+            return str.Take(0, part_len);
+        }
+        part_len++;
+    }
+
+    if (out_remainder) {
+        *out_remainder = str.Take(str.len, 0);
+    }
+    return str;
+}
+static inline Span<char> SplitStr(char *str, const char *split_str, char **out_remainder = nullptr)
+{
+    RG_ASSERT(split_str[0]);
+
+    Size part_len = 0;
+    while (str[part_len]) {
+        if (StartsWith(str + part_len, split_str)) {
+            if (out_remainder) {
+                Size split_len = strlen(split_str);
+                *out_remainder = str + part_len + split_len;
+            }
+            return MakeSpan(str, part_len);
+        }
+        part_len++;
+    }
+
+    if (out_remainder) {
+        *out_remainder = str + part_len;
+    }
+    return MakeSpan(str, part_len);
+}
+static inline Span<const char> SplitStr(Span<const char> str, const char *split_str, Span<const char> *out_remainder = nullptr)
+    { return SplitStr(MakeSpan((char *)str.ptr, str.len), split_str, (Span<char> *)out_remainder); }
+static inline Span<const char> SplitStr(const char *str, const char *split_str, const char **out_remainder = nullptr)
+    { return SplitStr((char *)str, split_str, (char **)out_remainder); }
+
 static inline Span<char> SplitStrLine(Span<char> str, Span<char> *out_remainder = nullptr)
 {
     Span<char> part = SplitStr(str, '\n', out_remainder);
@@ -3603,7 +3644,7 @@ template <typename T>
 bool ParseInt(Span<const char> str, T *out_value, unsigned int flags = RG_DEFAULT_PARSE_FLAGS,
               Span<const char> *out_remaining = nullptr)
 {
-    if (RG_UNLIKELY(!str.len)) {
+    if (!str.len) [[unlikely]] {
         if (flags & (int)ParseFlag::Log) {
             LogError("Cannot convert empty string to integer");
         }
@@ -3625,7 +3666,7 @@ bool ParseInt(Span<const char> str, T *out_value, unsigned int flags = RG_DEFAUL
 
     for (; pos < str.len; pos++) {
         unsigned int digit = (unsigned int)(str[pos] - '0');
-        if (RG_UNLIKELY(digit > 9)) {
+        if (digit > 9) [[unlikely]] {
             if (!pos || flags & (int)ParseFlag::End) {
                 if (flags & (int)ParseFlag::Log) {
                     LogError("Malformed integer number '%1'", str);
@@ -3637,11 +3678,11 @@ bool ParseInt(Span<const char> str, T *out_value, unsigned int flags = RG_DEFAUL
         }
 
         uint64_t new_value = (value * 10) + digit;
-        if (RG_UNLIKELY(new_value < value))
+        if (new_value < value) [[unlikely]]
             goto overflow;
         value = new_value;
     }
-    if (RG_UNLIKELY(value > (uint64_t)std::numeric_limits<T>::max()))
+    if (value > (uint64_t)std::numeric_limits<T>::max()) [[unlikely]]
         goto overflow;
     value = ((value ^ neg) - neg);
 
@@ -3704,18 +3745,18 @@ static inline Size DecodeUtf8(const char *str, int32_t *out_c)
     if (ptr[0] < 0x80) {
         *out_c = ptr[0];
         return 1;
-    } else if (RG_UNLIKELY(ptr[0] - 0xC2 > 0xF4 - 0xC2)) {
+    } else if (ptr[0] - 0xC2 > 0xF4 - 0xC2) [[unlikely]] {
         return 0;
-    } else if (RG_LIKELY(ptr[1])) {
+    } else if (ptr[1]) [[likely]] {
         if (ptr[0] < 0xE0 && (ptr[1] & 0xC0) == 0x80) {
             *out_c = ((ptr[0] & 0x1F) << 6) | (ptr[1] & 0x3F);
             return 2;
-        } else if (RG_LIKELY(ptr[2])) {
+        } else if (ptr[2]) [[likely]] {
             if (ptr[0] < 0xF0 && (ptr[1] & 0xC0) == 0x80 &&
                                  (ptr[2] & 0xC0) == 0x80) {
                 *out_c = ((ptr[0] & 0xF) << 12) | ((ptr[1] & 0x3F) << 6) | (ptr[2] & 0x3F);
                 return 3;
-            } else if (RG_LIKELY(ptr[3])) {
+            } else if (ptr[3]) [[likely]] {
                 if ((ptr[1] & 0xC0) == 0x80 &&
                         (ptr[2] & 0xC0) == 0x80 &&
                         (ptr[3] & 0xC0) == 0x80) {
@@ -3739,20 +3780,18 @@ static inline Size DecodeUtf8(Span<const char> str, Size offset, int32_t *out_c)
     if (ptr[0] < 0x80) {
         *out_c = ptr[0];
         return 1;
-    } else if (RG_UNLIKELY(ptr[0] - 0xC2 > 0xF4 - 0xC2)) {
+    } else if (ptr[0] - 0xC2 > 0xF4 - 0xC2) [[unlikely]] {
         return 0;
-    } else if (ptr[0] < 0xE0 &&
-               RG_LIKELY(available >= 2 && (ptr[1] & 0xC0) == 0x80)) {
+    } else if (ptr[0] < 0xE0 && available >= 2 && (ptr[1] & 0xC0) == 0x80) {
         *out_c = ((ptr[0] & 0x1F) << 6) | (ptr[1] & 0x3F);
         return 2;
-    } else if (ptr[0] < 0xF0 &&
-               RG_LIKELY(available >= 3 && (ptr[1] & 0xC0) == 0x80 &&
-                                           (ptr[2] & 0xC0) == 0x80)) {
+    } else if (ptr[0] < 0xF0 && available >= 3 && (ptr[1] & 0xC0) == 0x80 &&
+                                                  (ptr[2] & 0xC0) == 0x80) {
         *out_c = ((ptr[0] & 0xF) << 12) | ((ptr[1] & 0x3F) << 6) | (ptr[2] & 0x3F);
         return 3;
-    } else if (RG_LIKELY(available >= 4 && (ptr[1] & 0xC0) == 0x80 &&
-                                           (ptr[2] & 0xC0) == 0x80 &&
-                                           (ptr[3] & 0xC0) == 0x80)) {
+    } else if (available >= 4 && (ptr[1] & 0xC0) == 0x80 &&
+                                 (ptr[2] & 0xC0) == 0x80 &&
+                                 (ptr[3] & 0xC0) == 0x80) {
         *out_c = ((ptr[0] & 0x7) << 18) | ((ptr[1] & 0x3F) << 12) | ((ptr[2] & 0x3F) << 6) | (ptr[3] & 0x3F);
         return 4;
     } else {
@@ -4092,8 +4131,8 @@ private:
 
 template <int Min = 0, int Max = INT_MAX>
 class FastRandomInt {
-    RG_STATIC_ASSERT(Min >= 0);
-    RG_STATIC_ASSERT(Max > Min);
+    static_assert(Min >= 0);
+    static_assert(Max > Min);
 
     FastRandom rng;
 

package/src/core/libcc/miniz.cc

@@ -54,7 +54,7 @@ public:
 
 bool MinizDecompressor::Init(CompressionType type)
 {
-    RG_STATIC_ASSERT(RG_SIZE(out_buf) >= TINFL_LZ_DICT_SIZE);
+    static_assert(RG_SIZE(out_buf) >= TINFL_LZ_DICT_SIZE);
 
     tinfl_init(&inflator);
     is_gzip = (type == CompressionType::Gzip);
@@ -177,7 +177,7 @@ Size MinizDecompressor::Read(Size max_len, void *user_buf)
                     // Gzip footer (CRC and size check)
                     if (is_gzip) {
                         uint32_t footer[2];
-                        RG_STATIC_ASSERT(RG_SIZE(footer) == 8);
+                        static_assert(RG_SIZE(footer) == 8);
 
                         if (in_len < RG_SIZE(footer)) {
                             memcpy_safe(footer, in_ptr, (size_t)in_len);

package/src/koffi/CMakeLists.txt

@@ -28,11 +28,7 @@ include(CheckCXXCompilerFlag)
 
 find_package(CNoke)
 
-if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.8.0")
-    set(CMAKE_CXX_STANDARD 17)
-else()
-    set(CMAKE_CXX_STANDARD 14)
-endif()
+set(CMAKE_CXX_STANDARD 17)
 if(MSVC)
     set(CMAKE_MSVC_RUNTIME_LIBRARY MultiThreaded)