koffi 2.14.1 → 2.15.0

package/{src/core → lib/native}/base/base.hh

@@ -1,23 +1,5 @@
-// Copyright (C) 2025  Niels Martignène <niels.martignene@protonmail.com>
-
-// Permission is hereby granted, free of charge, to any person obtaining a copy of
-// this software and associated documentation files (the “Software”), to deal in
-// the Software without restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
-// Software, and to permit persons to whom the Software is furnished to do so,
-// subject to the following conditions:
-
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-
-// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2025 Niels Martignène <niels.martignene@protonmail.com>
 
 #pragma once
 
@@ -108,6 +90,8 @@ namespace K {
 #define K_PROGRESS_USED_NODES 100
 #define K_PROGRESS_TEXT_SIZE 64
 
+#define K_COMPLETE_PATH_LIMIT 256
+
 // ------------------------------------------------------------------------
 // Utility
 // ------------------------------------------------------------------------
@@ -1584,6 +1568,47 @@ static inline bool StartsWith(const char *str, const char *prefix)
     return !prefix[i];
 }
 
+static inline bool StartsWithI(Span<const char> str, Span<const char> prefix)
+{
+    Size i = 0;
+    while (i < str.len && i < prefix.len) {
+        if (LowerAscii(str[i]) != LowerAscii(prefix[i]))
+            return false;
+        i++;
+    }
+    return (i == prefix.len);
+}
+static inline bool StartsWithI(Span<const char> str, const char *prefix)
+{
+    Size i = 0;
+    while (i < str.len && prefix[i]) {
+        if (LowerAscii(str[i]) != LowerAscii(prefix[i]))
+            return false;
+        i++;
+    }
+    return !prefix[i];
+}
+static inline bool StartsWithI(const char *str, Span<const char> prefix)
+{
+    Size i = 0;
+    while (str[i] && i < prefix.len) {
+        if (LowerAscii(str[i]) != LowerAscii(prefix[i]))
+            return false;
+        i++;
+    }
+    return (i == prefix.len);
+}
+static inline bool StartsWithI(const char *str, const char *prefix)
+{
+    Size i = 0;
+    while (str[i] && prefix[i]) {
+        if (LowerAscii(str[i]) != LowerAscii(prefix[i]))
+            return false;
+        i++;
+    }
+    return !prefix[i];
+}
+
 static inline bool EndsWith(Span<const char> str, Span<const char> suffix)
 {
     Size i = str.len - 1;
@@ -1599,6 +1624,21 @@ static inline bool EndsWith(Span<const char> str, Span<const char> suffix)
 
     return j < 0;
 }
+static inline bool EndsWithI(Span<const char> str, Span<const char> suffix)
+{
+    Size i = str.len - 1;
+    Size j = suffix.len - 1;
+
+    while (i >= 0 && j >= 0) {
+        if (LowerAscii(str[i]) != LowerAscii(suffix[j]))
+            return false;
+
+        i--;
+        j--;
+    }
+
+    return j < 0;
+}
 
 static inline Size FindStr(Span<const char> str, Span<const char> needle)
 {
@@ -1902,6 +1942,9 @@ static inline Span<const char> TrimStrRight(Span<const char> str, const char *tr
 static inline Span<const char> TrimStr(Span<const char> str, const char *trim_chars = " \t\r\n")
     { return TrimStr(MakeSpan((char *)str.ptr, str.len), trim_chars); }
 
+int CmpNatural(Span<const char> str1, Span<const char> str2);
+int CmpNaturalI(Span<const char> str1, Span<const char> str2);
+
 // ------------------------------------------------------------------------
 // Collections
 // ------------------------------------------------------------------------
@@ -2787,7 +2830,7 @@ public:
         return ptr;
     }
 
-    ValueType *TrySet(const ValueType &value, bool *out_inserted = nullptr)
+    ValueType *InsertOrGet(const ValueType &value, bool *out_inserted = nullptr)
     {
         const KeyType &key = Handler::GetKey(value);
 
@@ -2803,7 +2846,7 @@ public:
         }
         return ptr;
     }
-    ValueType *TrySetDefault(const KeyType &key, bool *out_inserted = nullptr)
+    ValueType *InsertOrGetDefault(const KeyType &key, bool *out_inserted = nullptr)
     {
         bool inserted;
         ValueType *ptr = Insert(key, &inserted);
@@ -3247,15 +3290,15 @@ public:
         return table_it;
     }
 
-    ValueType *TrySet(const KeyType &key, const ValueType &value, bool *out_inserted = nullptr)
+    ValueType *InsertOrGet(const KeyType &key, const ValueType &value, bool *out_inserted = nullptr)
     {
-        Bucket *ptr = table.TrySet({ key, value }, out_inserted);
+        Bucket *ptr = table.InsertOrGet({ key, value }, out_inserted);
         return &ptr->value;
     }
-    Bucket *TrySetDefault(const KeyType &key, bool *out_inserted = nullptr)
+    Bucket *InsertOrGetDefault(const KeyType &key, bool *out_inserted = nullptr)
     {
         bool inserted;
-        Bucket *ptr = table.TrySetDefault(key, &inserted);
+        Bucket *ptr = table.InsertOrGetDefault(key, &inserted);
 
         if (inserted) {
             ptr->key = key;
@@ -3318,14 +3361,23 @@ public:
         { return table.FindValue(value, default_value); }
 
     ValueType *Set(const ValueType &value) { return table.Set(value); }
-    ValueType *TrySet(const ValueType &value, bool *out_inserted = nullptr)
-        { return table.TrySet(value, out_inserted); }
+
+    ValueType *InsertOrGet(const ValueType &value, bool *out_inserted = nullptr)
+        { return table.InsertOrGet(value, out_inserted); }
+    bool InsertOrFail(const ValueType &value)
+    {
+        bool inserted;
+        InsertOrGet(value, &inserted);
+        return inserted;
+    }
 
     void Remove(ValueType *it) { table.Remove(it); }
     template <typename T = ValueType>
     void Remove(const T &value) { Remove(Find(value)); }
 
     void Trim() { table.Trim(); }
+
+private:
 };
 
 // XXX: Switch to perfect hashing later on
@@ -3552,6 +3604,13 @@ static inline int64_t GetClockCounter()
     int64_t counter = ((int64_t)counter_high << 32) | counter_low;
     return counter;
 }
+#elif defined(__aarch64__)
+static inline int64_t GetClockCounter()
+{
+    uint64_t counter;
+    __asm__ __volatile__ ("mrs %0, cntvct_el0" : "=r" (counter));
+    return counter;
+}
 #endif
 
 struct TimeSpec {
@@ -3577,10 +3636,11 @@ int64_t ComposeTimeUTC(const TimeSpec &spec);
 // ------------------------------------------------------------------------
 
 enum class FmtType {
-    Str1,
-    Str2,
-    Buffer,
+    Str,
+    PadStr,
+    RepeatStr,
     Char,
+    Buffer,
     Custom,
     Bool,
     Integer,
@@ -3591,15 +3651,19 @@ enum class FmtType {
     Octal,
     BigHex,
     SmallHex,
+    BigBytes,
+    SmallBytes,
     MemorySize,
     DiskSize,
     Date,
     TimeISO,
     TimeNice,
-    Random,
+    List,
     FlagNames,
     FlagOptions,
-    Span
+    Random,
+    SafeStr,
+    SafeChar
 };
 
 template <typename T>
@@ -3649,14 +3713,18 @@ class FmtArg {
 public:
     FmtType type;
     union {
-        const char *str1;
-        Span<const char> str2;
+        Span<const char> str;
+        struct {
+            const char *str;
+            int count;
+        } repeat;
         char buf[32];
         char ch;
         FmtCustom custom;
         bool b;
         int64_t i;
         uint64_t u;
+        Span<const uint8_t> hex;
         struct {
             float value;
             int min_prec;
@@ -3684,68 +3752,123 @@ public:
                 Span<const struct OptionDesc> options;
             } u;
             const char *separator;
-        } flags;
-
-        struct {
-            FmtType type;
-            int type_len;
-            const void *ptr;
-            Size len;
-            const char *separator;
-        } span;
+        } list;
     } u;
 
-    int repeat = 1;
-    int pad_len = 0;
-    char pad_char = 0;
+    int pad = 0;
+    char padding = 0;
 
     FmtArg() = default;
-    FmtArg(std::nullptr_t) : type(FmtType::Str1) { u.str1 = "(null)"; }
-    FmtArg(const char *str) : type(FmtType::Str1) { u.str1 = str ? str : "(null)"; }
-    FmtArg(Span<const char> str) : type(FmtType::Str2) { u.str2 = str; }
-    FmtArg(char c) : type(FmtType::Char) { u.ch = c; }
-    FmtArg(const FmtCustom &custom) : type(FmtType::Custom) { u.custom = custom; }
-    FmtArg(bool b) : type(FmtType::Bool) { u.b = b; }
-    FmtArg(unsigned char i)  : type(FmtType::Unsigned) { u.u = i; }
-    FmtArg(short i) : type(FmtType::Integer) { u.i = i; }
-    FmtArg(unsigned short i) : type(FmtType::Unsigned) { u.u = i; }
-    FmtArg(int i) : type(FmtType::Integer) { u.i = i; }
-    FmtArg(unsigned int i) : type(FmtType::Unsigned) { u.u = i; }
-    FmtArg(long i) : type(FmtType::Integer) { u.i = i; }
-    FmtArg(unsigned long i) : type(FmtType::Unsigned) { u.u = i; }
-    FmtArg(long long i) : type(FmtType::Integer) { u.i = i; }
-    FmtArg(unsigned long long i) : type(FmtType::Unsigned) { u.u = i; }
-    FmtArg(float f) : type(FmtType::Float) { u.f = { f, 0, INT_MAX }; }
-    FmtArg(double d) : type(FmtType::Double) { u.d = { d, 0, INT_MAX }; }
-    FmtArg(const void *ptr) : type(FmtType::BigHex) { u.u = (uint64_t)ptr; }
-    FmtArg(const LocalDate &date) : type(FmtType::Date) { u.date = date; }
-
-    FmtArg &Repeat(int new_repeat) { repeat = new_repeat; return *this; }
-    FmtArg &Pad(int len, char c = ' ') { pad_char = c; pad_len = len; return *this; }
-    FmtArg &Pad0(int len) { return Pad(len, '0'); }
+    FmtArg(const FmtArg &other) = default;
+    FmtArg(std::nullptr_t) : FmtArg(FmtType::Str) { u.str = "(null)"; }
+    FmtArg(const char *str) : FmtArg(FmtType::Str) { u.str = str ? str : "(null)"; }
+    FmtArg(Span<const char> str) : FmtArg(FmtType::Str) { u.str = str; }
+    FmtArg(char c) : FmtArg(FmtType::Char) { u.ch = c; }
+    FmtArg(const FmtCustom &custom) : FmtArg(FmtType::Custom) { u.custom = custom; }
+    FmtArg(bool b) : FmtArg(FmtType::Bool) { u.b = b; }
+    FmtArg(unsigned char i) : FmtArg(FmtType::Unsigned) { u.u = i; }
+    FmtArg(short i) : FmtArg(FmtType::Integer) { u.i = i; }
+    FmtArg(unsigned short i) : FmtArg(FmtType::Unsigned) { u.u = i; }
+    FmtArg(int i) : FmtArg(FmtType::Integer) { u.i = i; }
+    FmtArg(unsigned int i) : FmtArg(FmtType::Unsigned) { u.u = i; }
+    FmtArg(long i) : FmtArg(FmtType::Integer) { u.i = i; }
+    FmtArg(unsigned long i) : FmtArg(FmtType::Unsigned) { u.u = i; }
+    FmtArg(long long i) : FmtArg(FmtType::Integer) { u.i = i; }
+    FmtArg(unsigned long long i) : FmtArg(FmtType::Unsigned) { u.u = i; }
+    FmtArg(float f) : FmtArg(FmtType::Float) { u.f = { f, 0, INT_MAX }; }
+    FmtArg(double d) : FmtArg(FmtType::Double) { u.d = { d, 0, INT_MAX }; }
+    FmtArg(const void *ptr) : FmtArg(FmtType::BigHex) { u.u = (uint64_t)ptr; }
+    FmtArg(const LocalDate &date) : FmtArg(FmtType::Date) { u.date = date; }
+
+protected:
+    FmtArg(FmtType type) : type(type) {}
+};
+
+class FmtSafe: public FmtArg {
+public:
+    FmtSafe() = default;
+    FmtSafe(FmtArg arg) : FmtArg(arg) {}
+    FmtSafe(std::nullptr_t) : FmtArg(FmtType::Str) { u.str = "(null)"; }
+    FmtSafe(const char *str) : FmtArg(FmtType::SafeStr) { u.str = str ? str : "(null)"; } // safe
+    FmtSafe(Span<const char> str) : FmtArg(FmtType::SafeStr) { u.str = str; } // safe
+    FmtSafe(char c) : FmtArg(FmtType::SafeChar) { u.ch = c; } // safe
+    FmtSafe(const FmtCustom &custom) : FmtArg(custom) {}
+    FmtSafe(bool b) : FmtArg(b) {}
+    FmtSafe(unsigned char i) : FmtArg(i) {}
+    FmtSafe(short i) : FmtArg(i) {}
+    FmtSafe(unsigned short i) : FmtArg(i) {}
+    FmtSafe(int i) : FmtArg(i) {}
+    FmtSafe(unsigned int i) : FmtArg(i) {}
+    FmtSafe(long i) : FmtArg(i) {}
+    FmtSafe(unsigned long i) : FmtArg(i) {}
+    FmtSafe(long long i) : FmtArg(i) {}
+    FmtSafe(unsigned long long i) : FmtArg(i) {}
+    FmtSafe(float f) : FmtArg(f) {}
+    FmtSafe(double d) : FmtArg(d) {}
+    FmtSafe(const void *ptr) : FmtArg(ptr) {}
+    FmtSafe(const LocalDate &date) : FmtArg(date) {}
 };
 
-static inline FmtArg FmtBin(uint64_t u)
+static inline FmtArg FmtInt(long long i, int pad = 0, char padding = '0')
+{
+    FmtArg arg;
+    arg.type = FmtType::Integer;
+    arg.u.i = i;
+    arg.pad = pad;
+    arg.padding = padding;
+    return arg;
+}
+static inline FmtArg FmtInt(unsigned long long u, int pad = 0, char padding = '0')
+{
+    FmtArg arg;
+    arg.type = FmtType::Unsigned;
+    arg.u.u = u;
+    arg.pad = pad;
+    arg.padding = padding;
+    return arg;
+}
+static inline FmtArg FmtInt(unsigned char u, int pad = 0, char padding = '0') { return FmtInt((unsigned long long)u, pad, padding); }
+static inline FmtArg FmtInt(short i, int pad = 0, char padding = '0') { return FmtInt((long long)i, pad, padding); }
+static inline FmtArg FmtInt(unsigned short u, int pad = 0, char padding = '0') { return FmtInt((unsigned long long)u, pad, padding); }
+static inline FmtArg FmtInt(int i, int pad = 0, char padding = '0') { return FmtInt((long long)i, pad, padding); }
+static inline FmtArg FmtInt(unsigned int u, int pad = 0, char padding = '0') { return FmtInt((unsigned long long)u, pad, padding); }
+static inline FmtArg FmtInt(long i, int pad = 0, char padding = '0') { return FmtInt((long long)i, pad, padding); }
+static inline FmtArg FmtInt(unsigned long u, int pad = 0, char padding = '0') { return FmtInt((unsigned long long)u, pad, padding); }
+
+static inline FmtArg FmtBin(uint64_t u, int pad = 0, char padding = '0')
 {
     FmtArg arg;
     arg.type = FmtType::Binary;
     arg.u.u = u;
+    arg.pad = pad;
+    arg.padding = padding;
     return arg;
 }
-static inline FmtArg FmtOctal(uint64_t u)
+static inline FmtArg FmtOctal(uint64_t u, int pad = 0, char padding = '0')
 {
     FmtArg arg;
     arg.type = FmtType::Octal;
     arg.u.u = u;
+    arg.pad = pad;
+    arg.padding = padding;
     return arg;
 }
-static inline FmtArg FmtHex(uint64_t u, FmtType type = FmtType::BigHex)
+static inline FmtArg FmtHex(uint64_t u, int pad = 0, char padding = '0')
 {
-    K_ASSERT(type == FmtType::BigHex || type == FmtType::SmallHex);
-
     FmtArg arg;
-    arg.type = type;
+    arg.type = FmtType::BigHex;
     arg.u.u = u;
+    arg.pad = pad;
+    arg.padding = padding;
+    return arg;
+}
+static inline FmtArg FmtHexSmall(uint64_t u, int pad = 0, char padding = '0')
+{
+    FmtArg arg;
+    arg.type = FmtType::SmallHex;
+    arg.u.u = u;
+    arg.pad = pad;
+    arg.padding = padding;
     return arg;
 }
 
@@ -3806,61 +3929,76 @@ static inline FmtArg FmtTimeNice(TimeSpec spec, bool ms = false)
     return arg;
 }
 
-static inline FmtArg FmtRandom(Size len, const char *chars = nullptr)
+static inline FmtArg FmtList(Span<const char *const> names, const char *sep = ", ")
 {
-    K_ASSERT(len < 256);
-    len = std::min(len, (Size)256);
-
     FmtArg arg;
-    arg.type = FmtType::Random;
-    arg.u.random.len = len;
-    arg.u.random.chars = chars;
+    arg.type = FmtType::List;
+    arg.u.list.u.names = names;
+    arg.u.list.separator = sep;
     return arg;
 }
-
 static inline FmtArg FmtFlags(uint64_t flags, Span<const char *const> names, const char *sep = ", ")
 {
     FmtArg arg;
     arg.type = FmtType::FlagNames;
-    arg.u.flags.flags = flags & ((1ull << names.len) - 1);
-    arg.u.flags.u.names = names;
-    arg.u.flags.separator = sep;
+    arg.u.list.flags = flags & ((1ull << names.len) - 1);
+    arg.u.list.u.names = names;
+    arg.u.list.separator = sep;
     return arg;
 }
-
 static inline FmtArg FmtFlags(uint64_t flags, Span<const struct OptionDesc> options, const char *sep = ", ")
 {
     FmtArg arg;
     arg.type = FmtType::FlagOptions;
-    arg.u.flags.flags = flags & ((1ull << options.len) - 1);
-    arg.u.flags.u.options = options;
-    arg.u.flags.separator = sep;
+    arg.u.list.flags = flags & ((1ull << options.len) - 1);
+    arg.u.list.u.options = options;
+    arg.u.list.separator = sep;
     return arg;
 }
 
-template <typename T>
-FmtArg FmtSpan(Span<T> arr, FmtType type, const char *sep = ", ")
+static inline FmtArg FmtPad(Span<const char> str, int pad, char padding = ' ')
 {
     FmtArg arg;
-    arg.type = FmtType::Span;
-    arg.u.span.type = type;
-    arg.u.span.type_len = K_SIZE(T);
-    arg.u.span.ptr = (const void *)arr.ptr;
-    arg.u.span.len = arr.len;
-    arg.u.span.separator = sep;
+    arg.type = FmtType::PadStr;
+    arg.u.str = str;
+    arg.pad = pad;
+    arg.padding = padding;
+    return arg;
+}
+static inline FmtArg FmtRepeat(const char *str, int count)
+{
+    FmtArg arg;
+    arg.type = FmtType::RepeatStr;
+    arg.u.repeat.str = str;
+    arg.u.repeat.count = count;
+    return arg;
+}
+
+static inline FmtArg FmtHex(Span<const uint8_t> buf)
+{
+    FmtArg arg;
+    arg.type = FmtType::BigBytes;
+    arg.u.hex = buf;
+    return arg;
+}
+static inline FmtArg FmtHexSmall(Span<const uint8_t> buf)
+{
+    FmtArg arg;
+    arg.type = FmtType::SmallBytes;
+    arg.u.hex = buf;
     return arg;
 }
-template <typename T>
-FmtArg FmtSpan(Span<T> arr, const char *sep = ", ") { return FmtSpan(arr, FmtArg(T()).type, sep); }
-template <typename T, Size N>
-FmtArg FmtSpan(T (&arr)[N], FmtType type, const char *sep = ", ") { return FmtSpan(MakeSpan(arr), type, sep); }
-template <typename T, Size N>
-FmtArg FmtSpan(T (&arr)[N], const char *sep = ", ") { return FmtSpan(MakeSpan(arr), sep); }
 
-static inline FmtArg FmtHex(Span<const uint8_t> buf, FmtType type = FmtType::BigHex)
+static inline FmtArg FmtRandom(Size len, const char *chars = nullptr)
 {
-    K_ASSERT(type == FmtType::BigHex || type == FmtType::SmallHex);
-    return FmtSpan(buf, type, "").Pad0(-2);
+    K_ASSERT(len < 256);
+    len = std::min(len, (Size)256);
+
+    FmtArg arg;
+    arg.type = FmtType::Random;
+    arg.u.random.len = len;
+    arg.u.random.chars = chars;
+    return arg;
 }
 
 class FmtUpperAscii {
@@ -3883,23 +4021,34 @@ public:
     operator FmtArg() const { return FmtCustom(*this); }
 };
 
-class FmtEscape {
+class FmtUrlSafe {
     Span<const char> str;
+    const char *passthrough;
 
 public:
-    FmtEscape(Span<const char> str) : str(str) {}
+    FmtUrlSafe(Span<const char> str, const char *passthrough)
+        : str(str), passthrough(passthrough) {}
 
     void Format(FunctionRef<void(Span<const char>)> append) const;
     operator FmtArg() const { return FmtCustom(*this); }
 };
 
-class FmtUrlSafe {
+class FmtHtmlSafe {
     Span<const char> str;
-    const char *passthrough;
 
 public:
-    FmtUrlSafe(Span<const char> str, const char *passthrough)
-        : str(str), passthrough(passthrough) {}
+    FmtHtmlSafe(Span<const char> str) : str(str) {}
+
+    void Format(FunctionRef<void(Span<const char>)> append) const;
+    operator FmtArg() const { return FmtCustom(*this); }
+};
+
+class FmtEscape {
+    Span<const char> str;
+    char quote;
+
+public:
+    FmtEscape(Span<const char> str, char quote) : str(str), quote(quote) {}
 
     void Format(FunctionRef<void(Span<const char>)> append) const;
     operator FmtArg() const { return FmtCustom(*this); }
@@ -4004,7 +4153,7 @@ static inline void Log(LogLevel level, const char *ctx, const char *fmt)
 template <typename... Args>
 static inline void Log(LogLevel level, const char *ctx, const char *fmt, Args... args)
 {
-    const FmtArg fmt_args[] = { FmtArg(args)... };
+    const FmtArg fmt_args[] = { FmtSafe(args)... };
     LogFmt(level, ctx, fmt, fmt_args);
 }
 
@@ -4215,11 +4364,11 @@ static const char *const CompressionTypeExtensions[] = {
 Span<const char> GetPathDirectory(Span<const char> filename);
 Span<const char> GetPathExtension(Span<const char> filename,
                                   CompressionType *out_compression_type = nullptr);
-CompressionType GetPathCompression(Span<const char> filename);
 
 enum class NormalizeFlag {
     EndWithSeparator = 1 << 0,
-    ForceSlash = 1 << 1
+    ForceSlash = 1 << 1,
+    NoExpansion = 1 << 2
 };
 
 Span<char> NormalizePath(Span<const char> path, Span<const char> root_directory, unsigned int flags, Allocator *alloc);
@@ -4233,6 +4382,7 @@ static inline Span<char> NormalizePath(Span<const char> path, Allocator *alloc)
 bool PathIsAbsolute(const char *path);
 bool PathIsAbsolute(Span<const char> path);
 bool PathContainsDotDot(const char *path);
+bool PathContainsDotDot(Span<const char> path);
 
 enum class StatFlag {
     SilentMissing = 1 << 0,
@@ -4305,7 +4455,20 @@ static inline RenameResult RenameFile(const char *src_filename, const char *dest
     { return RenameFile(src_filename, dest_filename, 0, flags); }
 
 bool ResizeFile(int fd, const char *filename, int64_t len);
-bool SetFileMetaData(int fd, const char *filename, int64_t mtime, int64_t ctime, uint32_t mode);
+
+#if !defined(_WIN32)
+bool SetFileMode(int fd, const char *filename, uint32_t mode);
+static inline bool SetFileMode(const char *filename, uint32_t mode)
+    { return SetFileMode(-1, filename, mode); }
+
+bool SetFileOwner(int fd, const char *filename, uint32_t uid, uint32_t gid);
+static inline bool SetFileOwner(const char *filename, uint32_t uid, uint32_t gid)
+    { return SetFileOwner(-1, filename, uid, gid); }
+#endif
+
+bool SetFileTimes(int fd, const char *filename, int64_t mtime, int64_t ctime);
+static inline bool SetFileTimes(const char *filename, int64_t mtime, int64_t ctime)
+    { return SetFileTimes(-1, filename, mtime, ctime); }
 
 struct VolumeInfo {
     int64_t total;
@@ -4430,7 +4593,7 @@ void CloseHandleSafe(void **handle_ptr); // HANDLE
 #else
 void SetSignalHandler(int signal, void (*func)(int), struct sigaction *prev = nullptr);
 
-bool CreatePipe(int pfd[2]);
+bool CreatePipe(bool block, int out_pfd[2]);
 void CloseDescriptorSafe(int *fd_ptr);
 #endif
 
@@ -4454,7 +4617,7 @@ bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                         HeapArray<uint8_t> *out_buf, int *out_code);
 
 // Simple variants
-static inline bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,int *out_code)
+static inline bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info, int *out_code)
     { return ExecuteCommandLine(cmd_line, info, {}, {}, out_code); }
 static inline bool ExecuteCommandLine(const char *cmd_line, const ExecuteInfo &info,
                                       Span<const uint8_t> in_buf,
@@ -4499,35 +4662,29 @@ enum class WaitResult {
     Timeout,
     Interrupt,
     Message,
-    Exit,
-    Error
+    Exit
 };
 
-#if defined(_WIN32)
-typedef void * WaitHandle; // HANDLE
-#else
-typedef int WaitHandle;
-#endif
-
 struct WaitSource {
 #if defined(_WIN32)
     // Special-cased on Windows: set to NULL to wait for the Win32 message pump too
     void *handle; // HANDLE
+    int timeout;
 #else
     int fd;
-    int events;
-#endif
-
     int timeout;
+    int events = 0;
+#endif
 };
 
 // After WaitEvents() has been called once (even with timeout 0), a few signals (such as SIGINT, SIGHUP)
 // and their Windows equivalent will be permanently ignored.
-// Beware, on Unix platforms, this may not work correctly if not called from the main thread.
+// Only the main thread (running main) will get WaitResult::Message events (and SIGUSR1).
 WaitResult WaitEvents(Span<const WaitSource> sources, int64_t timeout, uint64_t *out_ready = nullptr);
 WaitResult WaitEvents(int64_t timeout);
 
-void InterruptWait();
+void PostWaitMessage();
+void PostTerminate();
 
 #endif
 
@@ -4833,12 +4990,10 @@ bool InitWinsock();
 
 int CreateSocket(SocketType type, int flags);
 
-bool BindIPSocket(int sock, SocketType type, int port);
+bool BindIPSocket(int sock, SocketType type, const char *addr, int port);
 bool BindUnixSocket(int sock, const char *path);
-
-int OpenIPSocket(SocketType type, int port, int flags);
-int OpenUnixSocket(const char *path, int flags);
-int ConnectToUnixSocket(const char *path, int flags);
+bool ConnectIPSocket(int sock, const char *addr, int port);
+bool ConnectUnixSocket(int sock, const char *path);
 
 // Only for sockets on Windows
 void SetDescriptorNonBlock(int fd, bool enable);
@@ -4898,10 +5053,6 @@ enum class CompressionSpeed {
 class StreamDecoder;
 class StreamEncoder;
 
-enum class StreamReaderFlag {
-    LazyFill = 1 << 0
-};
-
 class StreamReader {
     K_DELETE_COPY(StreamReader)
 
@@ -4912,7 +5063,6 @@ class StreamReader {
     };
 
     const char *filename = nullptr;
-    bool lazy = false;
     bool error = true;
 
     int64_t read_total = 0;
@@ -4952,30 +5102,24 @@ class StreamReader {
 
 public:
     StreamReader() { Close(true); }
-    StreamReader(Span<const uint8_t> buf, const char *filename, unsigned int flags = 0,
-                 CompressionType compression_type = CompressionType::None)
-        : StreamReader() { Open(buf, filename, flags, compression_type); }
-    StreamReader(int fd, const char *filename, unsigned int flags = 0,
+    StreamReader(Span<const uint8_t> buf, const char *filename, CompressionType compression_type = CompressionType::None)
+        : StreamReader() { Open(buf, filename, compression_type); }
+    StreamReader(int fd, const char *filename, CompressionType compression_type = CompressionType::None)
+        : StreamReader() { Open(fd, filename, compression_type); }
+    StreamReader(const char *filename, CompressionType compression_type = CompressionType::None)
+        : StreamReader() { Open(filename, compression_type); }
+    StreamReader(const std::function<Size(Span<uint8_t>)> &func, const char *filename,
                  CompressionType compression_type = CompressionType::None)
-        : StreamReader() { Open(fd, filename, flags, compression_type); }
-    StreamReader(const char *filename, unsigned int flags = 0,
-                 CompressionType compression_type = CompressionType::None)
-        : StreamReader() { Open(filename, flags, compression_type); }
-    StreamReader(const std::function<Size(Span<uint8_t>)> &func, const char *filename, unsigned int flags = 0,
-                 CompressionType compression_type = CompressionType::None)
-        : StreamReader() { Open(func, filename, flags, compression_type); }
+        : StreamReader() { Open(func, filename, compression_type); }
     ~StreamReader() { Close(true); }
 
     // Call before Open. Takes ownership and deletes the decoder at the end.
     void SetDecoder(StreamDecoder *decoder);
 
-    bool Open(Span<const uint8_t> buf, const char *filename, unsigned int flags = 0,
-              CompressionType compression_type = CompressionType::None);
-    bool Open(int fd, const char *filename, unsigned int flags = 0,
-              CompressionType compression_type = CompressionType::None);
-    OpenResult Open(const char *filename, unsigned int flags = 0,
-                    CompressionType compression_type = CompressionType::None);
-    bool Open(const std::function<Size(Span<uint8_t>)> &func, const char *filename, unsigned int flags = 0,
+    bool Open(Span<const uint8_t> buf, const char *filename, CompressionType compression_type = CompressionType::None);
+    bool Open(int fd, const char *filename, CompressionType compression_type = CompressionType::None);
+    OpenResult Open(const char *filename, CompressionType compression_type = CompressionType::None);
+    bool Open(const std::function<Size(Span<uint8_t>)> &func, const char *filename,
               CompressionType compression_type = CompressionType::None);
     bool Close() { return Close(false); }
 
@@ -4995,7 +5139,11 @@ public:
     // Thread safe methods
     Size Read(Span<uint8_t> out_buf);
     Size Read(Span<char> out_buf) { return Read(out_buf.As<uint8_t>()); }
-    Size Read(Size buf_len, void *out_buf) { return Read(MakeSpan((uint8_t *)out_buf, buf_len)); }
+
+    // Thread safe methods
+    Size ReadFill(Span<uint8_t> out_buf);
+    Size ReadFill(Span<char> out_buf) { return ReadFill(out_buf.As<uint8_t>()); }
+    Size ReadFill(Size buf_len, void *out_buf) { return ReadFill(MakeSpan((uint8_t *)out_buf, buf_len)); }
 
     Size ReadAll(Size max_len, HeapArray<uint8_t> *out_buf);
     Size ReadAll(Size max_len, HeapArray<char> *out_buf)
@@ -5017,12 +5165,12 @@ private:
 static inline Size ReadFile(const char *filename, Span<uint8_t> out_buf)
 {
     StreamReader st(filename);
-    return st.Read(out_buf);
+    return st.ReadFill(out_buf);
 }
 static inline Size ReadFile(const char *filename, Span<char> out_buf)
 {
     StreamReader st(filename);
-    return st.Read(out_buf);
+    return st.ReadFill(out_buf);
 }
 static inline Size ReadFile(const char *filename, Size max_len, HeapArray<uint8_t> *out_buf)
 {
@@ -5626,10 +5774,23 @@ bool OptionToFlagI(Span<const OptionDesc> options, Span<const char> str, T *out_
 // ------------------------------------------------------------------------
 
 struct PromptChoice {
-    char c;
     const char *str;
+    char c;
+};
+
+enum class CompleteResult {
+    Success,
+    TooMany,
+    Error
 };
 
+struct CompleteChoice {
+    const char *name;
+    const char *value;
+};
+
+typedef CompleteResult CompleteFunc(Span<const char> value, Allocator *alloc, HeapArray<CompleteChoice> *out_choices);
+
 class ConsolePrompter {
     int prompt_columns = 0;
 
@@ -5651,6 +5812,7 @@ class ConsolePrompter {
 public:
     const char *prompt = ">>>";
     const char *mask = nullptr;
+    std::function<CompleteFunc> complete = {};
 
     HeapArray<char> str;
 
@@ -5695,6 +5857,13 @@ static inline const char *Prompt(const char *prompt, Allocator *alloc)
 Size PromptEnum(const char *prompt, Span<const PromptChoice> choices, Size value = 0);
 Size PromptEnum(const char *prompt, Span<const char *const> strings, Size value = 0);
 
+// Returns -1 if cancelled, otherwise it's 1 for Yes and or 0 for No
+int PromptYN(const char *prompt);
+
+const char *PromptPath(const char *prompt, const char *default_path, Span<const char> root_directory, Allocator *alloc);
+static inline const char *PromptPath(const char *prompt, Allocator *alloc)
+    { return PromptPath(prompt, nullptr, GetWorkingDirectory(), alloc); }
+
 // ------------------------------------------------------------------------
 // Mime types
 // ------------------------------------------------------------------------