koffi 2.1.0 → 2.1.2

package/vendor/libcc/libcc.hh

@@ -84,7 +84,7 @@ namespace RG {
 
 #define RG_LINE_READER_STEP_SIZE 65536
 
-#define RG_ASYNC_MAX_THREADS 256
+#define RG_ASYNC_MAX_THREADS 2048
 #define RG_ASYNC_MAX_IDLE_TIME 10000
 #define RG_FIBER_DEFAULT_STACK_SIZE Kibibytes(128)
 
@@ -622,7 +622,7 @@ T ApplyMask(T value, U mask, bool enable)
     if (enable) {
         return value | (T)mask;
     } else {
-        return value & (T)~mask;
+        return value & ~(T)mask;
     }
 }
 
@@ -824,28 +824,27 @@ static inline constexpr Strider<T> MakeStrider(T (&arr)[N])
     return Strider<T>(arr, RG_SIZE(T));
 }
 
+enum class AllocFlag {
+    Zero = 1,
+    Resizable = 2
+};
+
 class Allocator {
     RG_DELETE_COPY(Allocator)
 
 public:
-    enum class Flag {
-        Zero = 1,
-        Resizable = 2
-    };
-
     Allocator() = default;
     virtual ~Allocator() = default;
 
     virtual void *Allocate(Size size, unsigned int flags = 0) = 0;
-    virtual void Resize(void **ptr, Size old_size, Size new_size, unsigned int flags = 0) = 0;
-    virtual void Release(void *ptr, Size size) = 0;
+    virtual void *Resize(void *ptr, Size old_size, Size new_size, unsigned int flags = 0) = 0;
+    virtual void Release(const void *ptr, Size size) = 0;
 };
 
 Allocator *GetDefaultAllocator();
 Allocator *GetNullAllocator();
 
-template <typename T>
-Span<T> AllocateMemory(Allocator *alloc, Size size, unsigned int flags = 0)
+static inline void *AllocateRaw(Allocator *alloc, Size size, unsigned int flags = 0)
 {
     RG_ASSERT(size >= 0);
 
@@ -853,13 +852,40 @@ Span<T> AllocateMemory(Allocator *alloc, Size size, unsigned int flags = 0)
         alloc = GetDefaultAllocator();
     }
 
+    void *ptr = alloc->Allocate(size, flags);
+    return ptr;
+}
+
+template <typename T>
+T *AllocateOne(Allocator *alloc, unsigned int flags = 0)
+{
+    if (!alloc) {
+        alloc = GetDefaultAllocator();
+    }
+
+    Size size = RG_SIZE(T);
+
     T *ptr = (T *)alloc->Allocate(size, flags);
-    return MakeSpan(ptr, size);
+    return ptr;
 }
 
 template <typename T>
-Span<T> ResizeMemory(Allocator *alloc, T *ptr, Size old_size, Size new_size,
-                         unsigned int flags = 0)
+Span<T> AllocateSpan(Allocator *alloc, Size len, unsigned int flags = 0)
+{
+    RG_ASSERT(len >= 0);
+
+    if (!alloc) {
+        alloc = GetDefaultAllocator();
+    }
+
+    Size size = len * RG_SIZE(T);
+
+    T *ptr = (T *)alloc->Allocate(size, flags);
+    return MakeSpan(ptr, len);
+}
+
+static inline void *ResizeRaw(Allocator *alloc, void *ptr, Size old_size, Size new_size,
+                              unsigned int flags = 0)
 {
     RG_ASSERT(new_size >= 0);
 
@@ -867,28 +893,56 @@ Span<T> ResizeMemory(Allocator *alloc, T *ptr, Size old_size, Size new_size,
         alloc = GetDefaultAllocator();
     }
 
-    alloc->Resize((void **)&ptr, old_size, new_size, flags);
-    return MakeSpan(ptr, new_size);
+    ptr = alloc->Resize(ptr, old_size, new_size, flags);
+    return ptr;
+}
+
+template <typename T>
+Span<T> ResizeSpan(Allocator *alloc, Span<T> mem, Size new_len,
+                   unsigned int flags = 0)
+{
+    RG_ASSERT(new_len >= 0);
+
+    if (!alloc) {
+        alloc = GetDefaultAllocator();
+    }
+
+    Size old_size = mem.len * RG_SIZE(T);
+    Size new_size = new_len * RG_SIZE(T);
+
+    mem.ptr = (T *)alloc->Resize(mem.ptr, old_size, new_size, flags);
+    return MakeSpan(mem.ptr, new_len);
+}
+
+static inline void ReleaseRaw(Allocator *alloc, const void *ptr, Size size)
+{
+    if (!alloc) {
+        alloc = GetDefaultAllocator();
+    }
+
+    alloc->Release(ptr, size);
 }
 
 template<typename T>
-void ReleaseMemory(Allocator *alloc, Span<T> mem)
+void ReleaseOne(Allocator *alloc, T *ptr)
 {
     if (!alloc) {
         alloc = GetDefaultAllocator();
     }
 
-    alloc->Release((void *)mem.ptr, mem.len);
+    alloc->Release((void *)ptr, RG_SIZE(T));
 }
 
 template<typename T>
-void ReleaseMemory(Allocator *alloc, T *ptr, Size size)
+void ReleaseSpan(Allocator *alloc, Span<T> mem)
 {
     if (!alloc) {
         alloc = GetDefaultAllocator();
     }
 
-    alloc->Release((void *)ptr, size);
+    Size size = mem.len * RG_SIZE(T);
+
+    alloc->Release((void *)mem.ptr, size);
 }
 
 class LinkedAllocator final: public Allocator {
@@ -899,7 +953,7 @@ class LinkedAllocator final: public Allocator {
     struct Bucket {
          // Keep head first or stuff will break
         Node head;
-        uint8_t data[8]; // Extra size is used to align pointer
+        uint8_t data[];
     };
 
     Allocator *allocator;
@@ -917,18 +971,17 @@ public:
     void ReleaseAll();
 
     void *Allocate(Size size, unsigned int flags = 0) override;
-    void Resize(void **ptr, Size old_size, Size new_size, unsigned int flags = 0) override;
-    void Release(void *ptr, Size size) override;
+    void *Resize(void *ptr, Size old_size, Size new_size, unsigned int flags = 0) override;
+    void Release(const void *ptr, Size size) override;
 
 private:
-    static Bucket *PointerToBucket(void *ptr)
-        { return (Bucket *)((uint8_t *)ptr - RG_OFFSET_OF(Bucket, data)); }
+    static Bucket *PointerToBucket(void *ptr);
 };
 
 class BlockAllocatorBase: public Allocator {
     struct Bucket {
         Size used;
-        uint8_t data[8]; // Extra size is used to align pointer
+        uint8_t data[];
     };
 
     Size block_size;
@@ -944,8 +997,8 @@ public:
     }
 
     void *Allocate(Size size, unsigned int flags = 0) override;
-    void Resize(void **ptr, Size old_size, Size new_size, unsigned int flags = 0) override;
-    void Release(void *ptr, Size size) override;
+    void *Resize(void *ptr, Size old_size, Size new_size, unsigned int flags = 0) override;
+    void Release(const void *ptr, Size size) override;
 
 protected:
     void CopyFrom(BlockAllocatorBase *other);
@@ -1315,7 +1368,7 @@ public:
                 len = new_capacity;
             }
 
-            ptr = ResizeMemory(allocator, ptr, capacity * RG_SIZE(T), new_capacity * RG_SIZE(T)).ptr;
+            ptr = (T *)ResizeRaw(allocator, ptr, capacity * RG_SIZE(T), new_capacity * RG_SIZE(T));
             capacity = new_capacity;
         }
     }
@@ -1327,7 +1380,7 @@ public:
         }
     }
 
-    void Grow(Size reserve_capacity = 1)
+    T *Grow(Size reserve_capacity = 1)
     {
         RG_ASSERT(capacity >= 0);
         RG_ASSERT(reserve_capacity >= 0);
@@ -1345,6 +1398,8 @@ public:
 
             SetCapacity(new_capacity);
         }
+
+        return ptr + len;
     }
 
     void Trim(Size extra_capacity = 0) { SetCapacity(len + extra_capacity); }
@@ -1612,9 +1667,9 @@ public:
         Size bucket_offset = (offset + len) % BucketSize;
 
         if (bucket_idx >= buckets.len) {
-            Bucket *new_bucket = AllocateMemory<Bucket>(buckets.allocator, RG_SIZE(Bucket)).ptr;
+            Bucket *new_bucket = AllocateOne<Bucket>(buckets.allocator);
             new (&new_bucket->allocator) AllocatorType();
-            new_bucket->values = AllocateMemory<T>(&new_bucket->allocator, BucketSize * RG_SIZE(T)).ptr;
+            new_bucket->values = (T *)AllocateRaw(&new_bucket->allocator, BucketSize * RG_SIZE(T));
 
             buckets.Append(new_bucket);
         }
@@ -1731,7 +1786,7 @@ private:
     void DeleteBucket(Bucket *bucket)
     {
         bucket->allocator.~AllocatorType();
-        ReleaseMemory(buckets.allocator, bucket, RG_SIZE(Bucket));
+        ReleaseOne(buckets.allocator, bucket);
     }
 };
 
@@ -2244,10 +2299,10 @@ private:
         Size old_capacity = capacity;
 
         if (new_capacity) {
-            used = AllocateMemory<size_t>(allocator,
-                                                 (new_capacity + (RG_SIZE(size_t) * 8) - 1) / RG_SIZE(size_t),
-                                                 (int)Allocator::Flag::Zero).ptr;
-            data = AllocateMemory<ValueType>(allocator, new_capacity * RG_SIZE(ValueType)).ptr;
+            used = (size_t *)AllocateRaw(allocator,
+                                         (new_capacity + (RG_SIZE(size_t) * 8) - 1) / RG_SIZE(size_t),
+                                         (int)AllocFlag::Zero);
+            data = (ValueType *)AllocateRaw(allocator, new_capacity * RG_SIZE(ValueType));
             for (Size i = 0; i < new_capacity; i++) {
                 new (&data[i]) ValueType();
             }
@@ -2269,9 +2324,8 @@ private:
             capacity = 0;
         }
 
-        ReleaseMemory(allocator, old_used,
-                           (old_capacity + (RG_SIZE(size_t) * 8) - 1) / RG_SIZE(size_t));
-        ReleaseMemory(allocator, old_data, old_capacity * RG_SIZE(ValueType));
+        ReleaseRaw(allocator, old_used, (old_capacity + (RG_SIZE(size_t) * 8) - 1) / RG_SIZE(size_t));
+        ReleaseRaw(allocator, old_data, old_capacity * RG_SIZE(ValueType));
     }
 
     void MarkUsed(Size idx)
@@ -2742,723 +2796,411 @@ static const char *const TimeModeNames[] = {
 TimeSpec DecomposeTime(int64_t time, TimeMode mode = TimeMode::Local);
 
 // ------------------------------------------------------------------------
-// Streams
+// Format
 // ------------------------------------------------------------------------
 
-enum class CompressionType {
-    None,
-    Zlib,
-    Gzip,
-    Brotli
-};
-static const char *const CompressionTypeNames[] = {
-    "None",
-    "Zlib",
-    "Gzip",
-    "Brotli"
-};
+class StreamWriter;
 
-enum class CompressionSpeed {
-    Default,
-    Slow,
-    Fast
+enum class FmtType {
+    Str1,
+    Str2,
+    Buffer,
+    Char,
+    Bool,
+    Integer,
+    Unsigned,
+    Float,
+    Double,
+    Binary,
+    BigHex,
+    SmallHex,
+    MemorySize,
+    DiskSize,
+    Date,
+    TimeISO,
+    TimeNice,
+    Random,
+    FlagNames,
+    FlagOptions,
+    Span
 };
 
-class StreamReader {
-    RG_DELETE_COPY(StreamReader)
-
-    enum class SourceType {
-        Memory,
-        File,
-        Function
-    };
-
-    const char *filename = nullptr;
-    bool error = true;
-
-    struct {
-        SourceType type = SourceType::Memory;
-        union U {
-            struct {
-                Span<const uint8_t> buf;
-                Size pos;
-            } memory;
-            struct {
-                FILE *fp;
-                bool owned;
-            } file;
-            std::function<Size(Span<uint8_t> buf)> func;
-
-            // StreamReader deals with func destructor
-            U() {}
-            ~U() {}
-        } u;
-
-        bool eof = false;
-    } source;
-
-    struct {
-        CompressionType type = CompressionType::None;
-        union {
-            struct MinizInflateContext *miniz;
-            struct BrotliDecompressContext *brotli;
-        } u;
-    } compression;
-
-    int64_t raw_len = -1;
-    Size raw_read = 0;
-    bool eof = false;
-
-    BlockAllocator str_alloc;
-
+class FmtArg {
 public:
-    StreamReader() { Close(true); }
-    StreamReader(Span<const uint8_t> buf, const char *filename = nullptr,
-                 CompressionType compression_type = CompressionType::None)
-        : StreamReader() { Open(buf, filename, compression_type); }
-    StreamReader(FILE *fp, const char *filename,
-                 CompressionType compression_type = CompressionType::None)
-        : StreamReader() { Open(fp, 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 = nullptr,
-                 CompressionType compression_type = CompressionType::None)
-        : StreamReader() { Open(func, filename, compression_type); }
-    ~StreamReader() { Close(true); }
-
-    bool Open(Span<const uint8_t> buf, const char *filename = nullptr,
-              CompressionType compression_type = CompressionType::None);
-    bool Open(FILE *fp, const char *filename,
-              CompressionType compression_type = CompressionType::None);
-    bool Open(const char *filename, CompressionType compression_type = CompressionType::None);
-    bool Open(const std::function<Size(Span<uint8_t>)> &func, const char *filename = nullptr,
-              CompressionType compression_type = CompressionType::None);
-    bool Close() { return Close(false); }
-
-    // File-specific
-    bool Rewind();
-
-    const char *GetFileName() const { return filename; }
-    CompressionType GetCompressionType() const { return compression.type; }
-    bool IsValid() const { return filename && !error; }
-    bool IsEOF() const { return eof; }
-
-    Size Read(Span<uint8_t> out_buf);
-    Size Read(Span<char> out_buf) { return Read(out_buf.As<uint8_t>()); }
-    Size Read(Size max_len, void *out_buf) { return Read(MakeSpan((uint8_t *)out_buf, max_len)); }
-
-    Size ReadAll(Size max_len, HeapArray<uint8_t> *out_buf);
-    Size ReadAll(Size max_len, HeapArray<char> *out_buf)
-        { return ReadAll(max_len, (HeapArray<uint8_t> *)out_buf); }
-
-    int64_t ComputeRawLen();
+    FmtType type;
+    union {
+        const char *str1;
+        Span<const char> str2;
+        char buf[32];
+        char ch;
+        bool b;
+        int64_t i;
+        uint64_t u;
+        struct {
+            float value;
+            int min_prec;
+            int max_prec;
+        } f;
+        struct {
+            double value;
+            int min_prec;
+            int max_prec;
+        } d;
+        const void *ptr;
+        LocalDate date;
+        struct {
+            TimeSpec spec;
+            bool ms;
+        } time;
+        struct {
+            Size len;
+            const char *chars;
+        } random;
+        struct {
+            uint64_t flags;
+            union {
+                Span<const char *const> names;
+                Span<const struct OptionDesc> options;
+            } u;
+            const char *separator;
+        } flags;
 
-private:
-    bool Close(bool implicit);
+        struct {
+            FmtType type;
+            int type_len;
+            const void *ptr;
+            Size len;
+            const char *separator;
+        } span;
+    } u;
 
-    bool InitDecompressor(CompressionType type);
+    int repeat = 1;
+    int pad_len = 0;
+    char pad_char = 0;
 
-    Size ReadInflate(Size max_len, void *out_buf);
-    Size ReadBrotli(Size max_len, void *out_buf);
+    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(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; }
 
-    Size ReadRaw(Size max_len, void *out_buf);
+    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'); }
 };
 
-static inline Size ReadFile(const char *filename, CompressionType compression_type, Span<uint8_t> out_buf)
+static inline FmtArg FmtBin(uint64_t u)
 {
-    StreamReader st(filename, compression_type);
-    return st.Read(out_buf);
+    FmtArg arg;
+    arg.type = FmtType::Binary;
+    arg.u.u = u;
+    return arg;
 }
-static inline Size ReadFile(const char *filename, Span<uint8_t> out_buf)
+static inline FmtArg FmtHex(uint64_t u, FmtType type = FmtType::BigHex)
 {
-    StreamReader st(filename);
-    return st.Read(out_buf);
+    RG_ASSERT(type == FmtType::BigHex || type == FmtType::SmallHex);
+
+    FmtArg arg;
+    arg.type = type;
+    arg.u.u = u;
+    return arg;
 }
-static inline Size ReadFile(const char *filename, CompressionType compression_type, Span<char> out_buf)
-{
-    StreamReader st(filename, compression_type);
-    return st.Read(out_buf);
-}
-static inline Size ReadFile(const char *filename, Span<char> out_buf)
+
+static inline FmtArg FmtFloat(float f, int min_prec, int max_prec)
 {
-    StreamReader st(filename);
-    return st.Read(out_buf);
+    FmtArg arg;
+    arg.type = FmtType::Float;
+    arg.u.f.value = f;
+    arg.u.f.min_prec = min_prec;
+    arg.u.f.max_prec = max_prec;
+    return arg;
 }
+static inline FmtArg FmtFloat(float f, int prec) { return FmtFloat(f, prec, prec); }
+static inline FmtArg FmtFloat(float f) { return FmtFloat(f, 0, INT_MAX); }
 
-static inline Size ReadFile(const char *filename, Size max_len, CompressionType compression_type,
-                            HeapArray<uint8_t> *out_buf)
+static inline FmtArg FmtDouble(double d, int min_prec, int max_prec)
 {
-    StreamReader st(filename, compression_type);
-    return st.ReadAll(max_len, out_buf);
+    FmtArg arg;
+    arg.type = FmtType::Double;
+    arg.u.d.value = d;
+    arg.u.d.min_prec = min_prec;
+    arg.u.d.max_prec = max_prec;
+    return arg;
 }
-static inline Size ReadFile(const char *filename, Size max_len, HeapArray<uint8_t> *out_buf)
+static inline FmtArg FmtDouble(double d, int prec) { return FmtDouble(d, prec, prec); }
+static inline FmtArg FmtDouble(double d) { return FmtDouble(d, 0, INT_MAX); }
+
+static inline FmtArg FmtMemSize(int64_t size)
 {
-    StreamReader st(filename);
-    return st.ReadAll(max_len, out_buf);
+    FmtArg arg;
+    arg.type = FmtType::MemorySize;
+    arg.u.i = size;
+    return arg;
 }
-static inline Size ReadFile(const char *filename, Size max_len, CompressionType compression_type,
-                            HeapArray<char> *out_buf)
+static inline FmtArg FmtDiskSize(int64_t size)
 {
-    StreamReader st(filename, compression_type);
-    return st.ReadAll(max_len, out_buf);
+    FmtArg arg;
+    arg.type = FmtType::DiskSize;
+    arg.u.i = size;
+    return arg;
 }
-static inline Size ReadFile(const char *filename, Size max_len, HeapArray<char> *out_buf)
+
+static inline FmtArg FmtTimeISO(TimeSpec spec, bool ms = false)
 {
-    StreamReader st(filename);
-    return st.ReadAll(max_len, out_buf);
+    FmtArg arg;
+    arg.type = FmtType::TimeISO;
+    arg.u.time.spec = spec;
+    arg.u.time.ms = ms;
+    return arg;
 }
 
-class LineReader {
-    RG_DELETE_COPY(LineReader)
-
-    HeapArray<char> buf;
-    Span<char> view = {};
+static inline FmtArg FmtTimeNice(TimeSpec spec, bool ms = false)
+{
+    FmtArg arg;
+    arg.type = FmtType::TimeNice;
+    arg.u.time.spec = spec;
+    arg.u.time.ms = ms;
+    return arg;
+}
 
-    StreamReader *st;
-    bool error;
-    bool eof = false;
+static inline FmtArg FmtRandom(Size len, const char *chars = nullptr)
+{
+    RG_ASSERT(len < 256);
+    len = std::min(len, (Size)256);
 
-    Span<char> line = {};
-    int line_number = 0;
+    FmtArg arg;
+    arg.type = FmtType::Random;
+    arg.u.random.len = len;
+    arg.u.random.chars = chars;
+    return arg;
+}
 
-public:
-    LineReader(StreamReader *st) : st(st), error(!st->IsValid()) {}
+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;
+    return arg;
+}
 
-    const char *GetFileName() const { return st->GetFileName(); }
-    int GetLineNumber() const { return line_number; }
-    bool IsValid() const { return !error; }
-    bool IsEOF() const { return eof; }
+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;
+    return arg;
+}
 
-    bool Next(Span<char> *out_line);
-    bool Next(Span<const char> *out_line) { return Next((Span<char> *)out_line); }
+template <typename T>
+FmtArg FmtSpan(Span<T> arr, FmtType type, const char *sep = ", ")
+{
+    FmtArg arg;
+    arg.type = FmtType::Span;
+    arg.u.span.type = type;
+    arg.u.span.type_len = RG_SIZE(T);
+    arg.u.span.ptr = (const void *)arr.ptr;
+    arg.u.span.len = arr.len;
+    arg.u.span.separator = sep;
+    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); }
 
-    void PushLogFilter();
+enum class LogLevel {
+    Debug,
+    Info,
+    Warning,
+    Error
 };
 
-enum class StreamWriterFlag {
-    Exclusive = 1 << 0,
-    Atomic = 1 << 1
-};
+Span<char> FmtFmt(const char *fmt, Span<const FmtArg> args, Span<char> out_buf);
+Span<char> FmtFmt(const char *fmt, Span<const FmtArg> args, HeapArray<char> *out_buf);
+Span<char> FmtFmt(const char *fmt, Span<const FmtArg> args, Allocator *alloc);
+void PrintFmt(const char *fmt, Span<const FmtArg> args, StreamWriter *out_st);
+void PrintFmt(const char *fmt, Span<const FmtArg> args, FILE *out_fp);
+void PrintLnFmt(const char *fmt, Span<const FmtArg> args, StreamWriter *out_st);
+void PrintLnFmt(const char *fmt, Span<const FmtArg> args, FILE *out_fp);
 
-class StreamWriter {
-    RG_DELETE_COPY(StreamWriter)
+#define DEFINE_FMT_VARIANT(Name, Ret, Type) \
+    static inline Ret Name(Type out, const char *fmt) \
+    { \
+        return Name##Fmt(fmt, {}, out); \
+    } \
+    template <typename... Args> \
+    Ret Name(Type out, const char *fmt, Args... args) \
+    { \
+        const FmtArg fmt_args[] = { FmtArg(args)... }; \
+        return Name##Fmt(fmt, fmt_args, out); \
+    }
 
-    enum class DestinationType {
-        Memory,
-        File,
-        Function
-    };
+DEFINE_FMT_VARIANT(Fmt, Span<char>, Span<char>)
+DEFINE_FMT_VARIANT(Fmt, Span<char>, HeapArray<char> *)
+DEFINE_FMT_VARIANT(Fmt, Span<char>, Allocator *)
+DEFINE_FMT_VARIANT(Print, void, StreamWriter *)
+DEFINE_FMT_VARIANT(Print, void, FILE *)
+DEFINE_FMT_VARIANT(PrintLn, void, StreamWriter *)
+DEFINE_FMT_VARIANT(PrintLn, void, FILE *)
 
-    const char *filename = nullptr;
-    bool error = true;
+#undef DEFINE_FMT_VARIANT
 
-    struct {
-        DestinationType type = DestinationType::Memory;
-        union U {
-            struct {
-                HeapArray<uint8_t> *memory;
-                Size start;
-            } mem;
-            struct {
-                FILE *fp;
-                bool owned;
+// Print formatted strings to stdout
+template <typename... Args>
+void Print(const char *fmt, Args... args)
+{
+    Print(stdout, fmt, args...);
+}
+template <typename... Args>
+void PrintLn(const char *fmt, Args... args)
+{
+    PrintLn(stdout, fmt, args...);
+}
 
-                // Atomic write mode
-                const char *tmp_filename;
-                bool tmp_exclusive;
-            } file;
-            std::function<bool(Span<const uint8_t>)> func;
+// PrintLn variants without format strings
+void PrintLn(StreamWriter *out_st);
+void PrintLn(FILE *out_fp);
+void PrintLn();
 
-            // StreamWriter deals with func destructor
-            U() {}
-            ~U() {}
-        } u;
+// ------------------------------------------------------------------------
+// Debug and errors
+// ------------------------------------------------------------------------
 
-        bool vt100;
-    } dest;
+typedef void LogFunc(LogLevel level, const char *ctx, const char *msg);
+typedef void LogFilterFunc(LogLevel level, const char *ctx, const char *msg,
+                           FunctionRef<LogFunc> func);
 
-    struct {
-        CompressionType type = CompressionType::None;
-        CompressionSpeed speed = CompressionSpeed::Default;
-        union {
-            struct MinizDeflateContext *miniz;
-            struct BrotliEncoderStateStruct *brotli;
-        } u;
-    } compression;
+const char *GetQualifiedEnv(const char *name);
+bool GetDebugFlag(const char *name);
 
-    BlockAllocator str_alloc;
+void LogFmt(LogLevel level, const char *ctx, const char *fmt, Span<const FmtArg> args);
 
-public:
-    StreamWriter() { Close(true); }
-    StreamWriter(HeapArray<uint8_t> *mem, const char *filename = nullptr,
-                 CompressionType compression_type = CompressionType::None,
-                 CompressionSpeed compression_speed = CompressionSpeed::Default)
-        : StreamWriter() { Open(mem, filename, compression_type, compression_speed); }
-    StreamWriter(FILE *fp, const char *filename,
-                 CompressionType compression_type = CompressionType::None,
-                 CompressionSpeed compression_speed = CompressionSpeed::Default)
-        : StreamWriter() { Open(fp, filename, compression_type, compression_speed); }
-    StreamWriter(const char *filename, unsigned int flags = 0,
-                 CompressionType compression_type = CompressionType::None,
-                 CompressionSpeed compression_speed = CompressionSpeed::Default)
-        : StreamWriter() { Open(filename, flags, compression_type, compression_speed); }
-    StreamWriter(const std::function<bool(Span<const uint8_t>)> &func, const char *filename = nullptr,
-                 CompressionType compression_type = CompressionType::None,
-                 CompressionSpeed compression_speed = CompressionSpeed::Default)
-        : StreamWriter() { Open(func, filename, compression_type, compression_speed); }
-    ~StreamWriter() { Close(true); }
+static inline void Log(LogLevel level, const char *ctx)
+{
+    LogFmt(level, ctx, "", {});
+}
+static inline void Log(LogLevel level, const char *ctx, const char *fmt)
+{
+    LogFmt(level, ctx, fmt, {});
+}
+template <typename... Args>
+static inline void Log(LogLevel level, const char *ctx, const char *fmt, Args... args)
+{
+    const FmtArg fmt_args[] = { FmtArg(args)... };
+    LogFmt(level, ctx, fmt, fmt_args);
+}
 
-    bool Open(HeapArray<uint8_t> *mem, const char *filename = nullptr,
-              CompressionType compression_type = CompressionType::None,
-              CompressionSpeed compression_speed = CompressionSpeed::Default);
-    bool Open(FILE *fp, const char *filename,
-              CompressionType compression_type = CompressionType::None,
-              CompressionSpeed compression_speed = CompressionSpeed::Default);
-    bool Open(const char *filename, unsigned int flags = 0,
-              CompressionType compression_type = CompressionType::None,
-              CompressionSpeed compression_speed = CompressionSpeed::Default);
-    bool Open(const std::function<bool(Span<const uint8_t>)> &func, const char *filename = nullptr,
-              CompressionType compression_type = CompressionType::None,
-              CompressionSpeed compression_speed = CompressionSpeed::Default);
-    bool Close() { return Close(false); }
-
-    // For compressed streams, Flush may not be complete and only Close() can finalize the file.
-    bool Flush();
-
-    const char *GetFileName() const { return filename; }
-    CompressionType GetCompressionType() const { return compression.type; }
-    bool IsVt100() const { return dest.vt100; }
-    bool IsValid() const { return filename && !error; }
-
-    bool Write(Span<const uint8_t> buf);
-    bool Write(Span<const char> buf) { return Write(buf.As<const uint8_t>()); }
-    bool Write(char buf) { return Write(MakeSpan(&buf, 1)); }
-    bool Write(const void *buf, Size len) { return Write(MakeSpan((const uint8_t *)buf, len)); }
-
-private:
-    bool Close(bool implicit);
-
-    bool InitCompressor(CompressionType type, CompressionSpeed speed);
-
-    bool WriteDeflate(Span<const uint8_t> buf);
-    bool WriteBrotli(Span<const uint8_t> buf);
-
-    bool WriteRaw(Span<const uint8_t> buf);
-};
+// Shortcut log functions
+#ifdef RG_DEBUG
+template <typename... Args>
+static inline void LogDebug(Args... args) { Log(LogLevel::Debug, "Debug", args...); }
+#else
+template <typename... Args>
+static inline void LogDebug(Args...) {}
+#endif
+template <typename... Args>
+static inline void LogInfo(Args... args) { Log(LogLevel::Info, nullptr, args...); }
+template <typename... Args>
+static inline void LogWarning(Args... args) { Log(LogLevel::Warning, "Warning", args...); }
+template <typename... Args>
+static inline void LogError(Args... args) { Log(LogLevel::Error, "Error", args...); }
 
-static inline bool WriteFile(Span<const uint8_t> buf, const char *filename, unsigned int flags = 0,
-                             CompressionType compression_type = CompressionType::None)
-{
-    StreamWriter st(filename, flags, compression_type);
-    st.Write(buf);
-    return st.Close();
-}
-static inline bool WriteFile(Span<const char> buf, const char *filename, unsigned int flags = 0,
-                             CompressionType compression_type = CompressionType::None)
-{
-    StreamWriter st(filename, flags, compression_type);
-    st.Write(buf);
-    return st.Close();
-}
+void SetLogHandler(const std::function<LogFunc> &func);
+void DefaultLogHandler(LogLevel level, const char *ctx, const char *msg);
 
-bool SpliceStream(StreamReader *reader, int64_t max_len, StreamWriter *writer);
+void PushLogFilter(const std::function<LogFilterFunc> &func);
+void PopLogFilter();
 
-// For convenience, don't close them
-extern StreamReader stdin_st;
-extern StreamWriter stdout_st;
-extern StreamWriter stderr_st;
+#ifdef _WIN32
+bool RedirectLogToWindowsEvents(const char *name);
+#endif
 
 // ------------------------------------------------------------------------
-// Format
+// Strings
 // ------------------------------------------------------------------------
 
-enum class FmtType {
-    Str1,
-    Str2,
-    Buffer,
-    Char,
-    Bool,
-    Integer,
-    Unsigned,
-    Float,
-    Double,
-    Binary,
-    Hexadecimal,
-    MemorySize,
-    DiskSize,
-    Date,
-    TimeISO,
-    TimeNice,
-    Random,
-    FlagNames,
-    FlagOptions,
-    Span
-};
-
-class FmtArg {
-public:
-    FmtType type;
-    union {
-        const char *str1;
-        Span<const char> str2;
-        char buf[32];
-        char ch;
-        bool b;
-        int64_t i;
-        uint64_t u;
-        struct {
-            float value;
-            int min_prec;
-            int max_prec;
-        } f;
-        struct {
-            double value;
-            int min_prec;
-            int max_prec;
-        } d;
-        const void *ptr;
-        LocalDate date;
-        TimeSpec time;
-        Size random_len;
-        struct {
-            uint64_t flags;
-            union {
-                Span<const char *const> names;
-                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;
-    } u;
-
-    int repeat = 1;
-    int pad_len = 0;
-    char pad_char = 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(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::Hexadecimal) { 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'); }
-};
+bool CopyString(const char *str, Span<char> buf);
+bool CopyString(Span<const char> str, Span<char> buf);
+Span<char> DuplicateString(Span<const char> str, Allocator *alloc);
 
-static inline FmtArg FmtBin(uint64_t u)
+static inline bool IsAsciiAlpha(int c)
 {
-    FmtArg arg;
-    arg.type = FmtType::Binary;
-    arg.u.u = u;
-    return arg;
+    return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
 }
-static inline FmtArg FmtHex(uint64_t u)
+static inline bool IsAsciiDigit(int c)
 {
-    FmtArg arg;
-    arg.type = FmtType::Hexadecimal;
-    arg.u.u = u;
-    return arg;
+    return (c >= '0' && c <= '9');
 }
-
-static inline FmtArg FmtFloat(float f, int min_prec, int max_prec)
+static inline bool IsAsciiAlphaOrDigit(int c)
 {
-    FmtArg arg;
-    arg.type = FmtType::Float;
-    arg.u.f.value = f;
-    arg.u.f.min_prec = min_prec;
-    arg.u.f.max_prec = max_prec;
-    return arg;
+    return IsAsciiAlpha(c) || IsAsciiDigit(c);
 }
-static inline FmtArg FmtFloat(float f, int prec) { return FmtFloat(f, prec, prec); }
-static inline FmtArg FmtFloat(float f) { return FmtFloat(f, 0, INT_MAX); }
-
-static inline FmtArg FmtDouble(double d, int min_prec, int max_prec)
+static inline bool IsAsciiWhite(int c)
 {
-    FmtArg arg;
-    arg.type = FmtType::Double;
-    arg.u.d.value = d;
-    arg.u.d.min_prec = min_prec;
-    arg.u.d.max_prec = max_prec;
-    return arg;
+    return c == ' ' || c == '\t' || c == '\v' ||
+           c == '\n' || c == '\r' || c == '\f';
 }
-static inline FmtArg FmtDouble(double d, int prec) { return FmtDouble(d, prec, prec); }
-static inline FmtArg FmtDouble(double d) { return FmtDouble(d, 0, INT_MAX); }
 
-static inline FmtArg FmtMemSize(int64_t size)
+static inline char UpperAscii(int c)
 {
-    FmtArg arg;
-    arg.type = FmtType::MemorySize;
-    arg.u.i = size;
-    return arg;
+    if (c >= 'a' && c <= 'z') {
+        return (char)(c - 32);
+    } else {
+        return (char)c;
+    }
 }
-static inline FmtArg FmtDiskSize(int64_t size)
+static inline char LowerAscii(int c)
 {
-    FmtArg arg;
-    arg.type = FmtType::DiskSize;
-    arg.u.i = size;
-    return arg;
+    if (c >= 'A' && c <= 'Z') {
+        return (char)(c + 32);
+    } else {
+        return (char)c;
+    }
 }
 
-static inline FmtArg FmtTimeISO(TimeSpec spec)
+static inline bool TestStr(Span<const char> str1, Span<const char> str2)
 {
-    FmtArg arg;
-    arg.type = FmtType::TimeISO;
-    arg.u.time = spec;
-    return arg;
+    if (str1.len != str2.len)
+        return false;
+    for (Size i = 0; i < str1.len; i++) {
+        if (str1[i] != str2[i])
+            return false;
+    }
+    return true;
 }
-
-static inline FmtArg FmtTimeNice(TimeSpec spec)
+static inline bool TestStr(Span<const char> str1, const char *str2)
 {
-    FmtArg arg;
-    arg.type = FmtType::TimeNice;
-    arg.u.time = spec;
-    return arg;
+    Size i;
+    for (i = 0; i < str1.len && str2[i]; i++) {
+        if (str1[i] != str2[i])
+            return false;
+    }
+    return (i == str1.len) && !str2[i];
 }
-
-static inline FmtArg FmtRandom(Size len)
-{
-    RG_ASSERT(len < 256);
-    len = std::min(len, (Size)256);
-
-    FmtArg arg;
-    arg.type = FmtType::Random;
-    arg.u.random_len = len;
-    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;
-    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;
-    return arg;
-}
-
-template <typename T>
-FmtArg FmtSpan(Span<T> arr, FmtType type, const char *sep = ", ")
-{
-    FmtArg arg;
-    arg.type = FmtType::Span;
-    arg.u.span.type = type;
-    arg.u.span.type_len = RG_SIZE(T);
-    arg.u.span.ptr = (const void *)arr.ptr;
-    arg.u.span.len = arr.len;
-    arg.u.span.separator = sep;
-    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); }
-
-enum class LogLevel {
-    Debug,
-    Info,
-    Warning,
-    Error
-};
-
-Span<char> FmtFmt(const char *fmt, Span<const FmtArg> args, Span<char> out_buf);
-Span<char> FmtFmt(const char *fmt, Span<const FmtArg> args, HeapArray<char> *out_buf);
-Span<char> FmtFmt(const char *fmt, Span<const FmtArg> args, Allocator *alloc);
-void PrintFmt(const char *fmt, Span<const FmtArg> args, StreamWriter *out_st);
-void PrintFmt(const char *fmt, Span<const FmtArg> args, FILE *out_fp);
-void PrintLnFmt(const char *fmt, Span<const FmtArg> args, StreamWriter *out_st);
-void PrintLnFmt(const char *fmt, Span<const FmtArg> args, FILE *out_fp);
-
-#define DEFINE_FMT_VARIANT(Name, Ret, Type) \
-    static inline Ret Name(Type out, const char *fmt) \
-    { \
-        return Name##Fmt(fmt, {}, out); \
-    } \
-    template <typename... Args> \
-    Ret Name(Type out, const char *fmt, Args... args) \
-    { \
-        const FmtArg fmt_args[] = { FmtArg(args)... }; \
-        return Name##Fmt(fmt, fmt_args, out); \
-    }
-
-DEFINE_FMT_VARIANT(Fmt, Span<char>, Span<char>)
-DEFINE_FMT_VARIANT(Fmt, Span<char>, HeapArray<char> *)
-DEFINE_FMT_VARIANT(Fmt, Span<char>, Allocator *)
-DEFINE_FMT_VARIANT(Print, void, StreamWriter *)
-DEFINE_FMT_VARIANT(Print, void, FILE *)
-DEFINE_FMT_VARIANT(PrintLn, void, StreamWriter *)
-DEFINE_FMT_VARIANT(PrintLn, void, FILE *)
-
-#undef DEFINE_FMT_VARIANT
-
-// Print formatted strings to stdout
-template <typename... Args>
-void Print(const char *fmt, Args... args)
-{
-    Print(stdout, fmt, args...);
-}
-template <typename... Args>
-void PrintLn(const char *fmt, Args... args)
-{
-    PrintLn(stdout, fmt, args...);
-}
-
-// PrintLn variants without format strings
-static inline void PrintLn(StreamWriter *out_st) { out_st->Write('\n'); }
-static inline void PrintLn(FILE *out_fp) { fputc('\n', out_fp); }
-static inline void PrintLn() { putchar('\n'); }
-
-// ------------------------------------------------------------------------
-// Debug and errors
-// ------------------------------------------------------------------------
-
-typedef void LogFunc(LogLevel level, const char *ctx, const char *msg);
-typedef void LogFilterFunc(LogLevel level, const char *ctx, const char *msg,
-                           FunctionRef<LogFunc> func);
-
-const char *GetQualifiedEnv(const char *name);
-bool GetDebugFlag(const char *name);
-
-void LogFmt(LogLevel level, const char *ctx, const char *fmt, Span<const FmtArg> args);
-
-static inline void Log(LogLevel level, const char *ctx)
-{
-    LogFmt(level, ctx, "", {});
-}
-static inline void Log(LogLevel level, const char *ctx, const char *fmt)
-{
-    LogFmt(level, ctx, fmt, {});
-}
-template <typename... Args>
-static inline void Log(LogLevel level, const char *ctx, const char *fmt, Args... args)
-{
-    const FmtArg fmt_args[] = { FmtArg(args)... };
-    LogFmt(level, ctx, fmt, fmt_args);
-}
-
-// Shortcut log functions
-#ifdef RG_DEBUG
-template <typename... Args>
-static inline void LogDebug(Args... args) { Log(LogLevel::Debug, "Debug", args...); }
-#else
-template <typename... Args>
-static inline void LogDebug(Args...) {}
-#endif
-template <typename... Args>
-static inline void LogInfo(Args... args) { Log(LogLevel::Info, nullptr, args...); }
-template <typename... Args>
-static inline void LogError(Args... args) { Log(LogLevel::Error, "Error", args...); }
-
-void SetLogHandler(const std::function<LogFunc> &func);
-void DefaultLogHandler(LogLevel level, const char *ctx, const char *msg);
-
-void PushLogFilter(const std::function<LogFilterFunc> &func);
-void PopLogFilter();
-
-#ifdef _WIN32
-bool RedirectLogToWindowsEvents(const char *name);
-#endif
-
-// ------------------------------------------------------------------------
-// Strings
-// ------------------------------------------------------------------------
-
-bool CopyString(const char *str, Span<char> buf);
-bool CopyString(Span<const char> str, Span<char> buf);
-Span<char> DuplicateString(Span<const char> str, Allocator *alloc);
-
-static inline bool IsAsciiAlpha(int c)
-{
-    return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
-}
-static inline bool IsAsciiDigit(int c)
-{
-    return (c >= '0' && c <= '9');
-}
-static inline bool IsAsciiAlphaOrDigit(int c)
-{
-    return IsAsciiAlpha(c) || IsAsciiDigit(c);
-}
-static inline bool IsAsciiWhite(int c)
-{
-    return c == ' ' || c == '\t' || c == '\v' ||
-           c == '\n' || c == '\r' || c == '\f';
-}
-
-static inline char UpperAscii(int c)
-{
-    if (c >= 'a' && c <= 'z') {
-        return (char)(c - 32);
-    } else {
-        return (char)c;
-    }
-}
-static inline char LowerAscii(int c)
-{
-    if (c >= 'A' && c <= 'Z') {
-        return (char)(c + 32);
-    } else {
-        return (char)c;
-    }
-}
-
-static inline bool TestStr(Span<const char> str1, Span<const char> str2)
-{
-    if (str1.len != str2.len)
-        return false;
-    for (Size i = 0; i < str1.len; i++) {
-        if (str1[i] != str2[i])
-            return false;
-    }
-    return true;
-}
-static inline bool TestStr(Span<const char> str1, const char *str2)
-{
-    Size i;
-    for (i = 0; i < str1.len && str2[i]; i++) {
-        if (str1[i] != str2[i])
-            return false;
-    }
-    return (i == str1.len) && !str2[i];
-}
-static inline bool TestStr(const char *str1, Span<const char> str2)
-    { return TestStr(str2, str1); }
-static inline bool TestStr(const char *str1, const char *str2)
-    { return !strcmp(str1, str2); }
+static inline bool TestStr(const char *str1, Span<const char> str2)
+    { return TestStr(str2, str1); }
+static inline bool TestStr(const char *str1, const char *str2)
+    { return !strcmp(str1, str2); }
 
 // Allow direct Span<const char> equality comparison
 inline bool Span<const char>::operator==(Span<const char> other) const
@@ -3563,729 +3305,1173 @@ static inline Size StartsWith(const char *str, const char *prefix)
         if (str[i] != prefix[i])
             return 0;
 
-        i++;
-    }
+        i++;
+    }
+
+    return !prefix[i] ? i : 0;
+}
+
+static inline bool EndsWith(Span<const char> str, const char *suffix)
+{
+    Size i = str.len - 1;
+    Size j = (Size)strlen(suffix) - 1;
+    while (i >= 0 && j >= 0) {
+        if (str[i] != suffix[j])
+            return false;
+
+        i--;
+        j--;
+    }
+
+    return j < 0;
+}
+
+static inline Size FindStr(Span<const char> str, Span<const char> needle)
+{
+    if (!needle.len)
+        return 0;
+    if (needle.len > str.len)
+        return -1;
+
+    Size end = str.len - needle.len;
+
+    for (Size i = 0; i <= end; i++) {
+        if (!memcmp(str.ptr + i, needle.ptr, (size_t)needle.len))
+            return i; 
+    }
+
+    return -1;
+}
+static inline Size FindStr(const char *str, const char *needle)
+{
+    const char *ret = strstr(str, needle);
+    return ret ? ret - str : -1;
+}
+
+static inline Span<char> SplitStr(Span<char> str, char split_char, Span<char> *out_remainder = nullptr)
+{
+    Size part_len = 0;
+    while (part_len < str.len) {
+        if (str[part_len] == split_char) {
+            if (out_remainder) {
+                *out_remainder = str.Take(part_len + 1, str.len - part_len - 1);
+            }
+            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, char split_char, char **out_remainder = nullptr)
+{
+    Size part_len = 0;
+    while (str[part_len]) {
+        if (str[part_len] == split_char) {
+            if (out_remainder) {
+                *out_remainder = str + part_len + 1;
+            }
+            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, char split_char, Span<const char> *out_remainder = nullptr)
+    { return SplitStr(MakeSpan((char *)str.ptr, str.len), split_char, (Span<char> *)out_remainder); }
+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> SplitStrLine(Span<char> str, Span<char> *out_remainder = nullptr)
+{
+    Span<char> part = SplitStr(str, '\n', out_remainder);
+    if (part.len < str.len && part.len && part[part.len - 1] == '\r') {
+        part.len--;
+    }
+    return part;
+}
+static inline Span<char> SplitStrLine(char *str, char **out_remainder = nullptr)
+{
+    Span<char> part = SplitStr(str, '\n', out_remainder);
+    if (str[part.len] && part.len && part[part.len - 1] == '\r') {
+        part.len--;
+    }
+    return part;
+}
+static inline Span<const char> SplitStrLine(Span<const char> str, Span<const char> *out_remainder = nullptr)
+    { return SplitStrLine(MakeSpan((char *)str.ptr, str.len), (Span<char> *)out_remainder); }
+static inline Span<const char> SplitStrLine(const char *str, const char **out_remainder = nullptr)
+    { return SplitStrLine((char *)str, (char **)out_remainder); }
+
+static inline Span<char> SplitStrAny(Span<char> str, const char *split_chars, Span<char> *out_remainder = nullptr)
+{
+    Bitset<256> split_mask;
+    for (Size i = 0; split_chars[i]; i++) {
+        uint8_t c = (uint8_t)split_chars[i];
+        split_mask.Set(c);
+    }
+
+    Size part_len = 0;
+    while (part_len < str.len) {
+        uint8_t c = (uint8_t)str[part_len];
+
+        if (split_mask.Test(c)) {
+            if (out_remainder) {
+                *out_remainder = str.Take(part_len + 1, str.len - part_len - 1);
+            }
+            return str.Take(0, part_len);
+        }
+        part_len++;
+    }
+
+    if (out_remainder) {
+        *out_remainder = str.Take(str.len, 0);
+    }
+    return str;
+}
+static inline Span<char> SplitStrAny(char *str, const char *split_chars, char **out_remainder = nullptr)
+{
+    Bitset<256> split_mask;
+    for (Size i = 0; split_chars[i]; i++) {
+        uint8_t c = (uint8_t)split_chars[i];
+        split_mask.Set(c);
+    }
+
+    Size part_len = 0;
+    while (str[part_len]) {
+        uint8_t c = (uint8_t)str[part_len];
+
+        if (split_mask.Test(c)) {
+            if (out_remainder) {
+                *out_remainder = str + part_len + 1;
+            }
+            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> SplitStrAny(Span<const char> str, const char *split_chars, Span<const char> *out_remainder = nullptr)
+    { return SplitStrAny(MakeSpan((char *)str.ptr, str.len), split_chars, (Span<char> *)out_remainder); }
+static inline Span<const char> SplitStrAny(const char *str, const char *split_chars, const char **out_remainder = nullptr)
+    { return SplitStrAny((char *)str, split_chars, (char **)out_remainder); }
+
+static inline Span<const char> SplitStrReverse(Span<const char> str, char split_char,
+                                               Span<const char> *out_remainder = nullptr)
+{
+    Size remainder_len = str.len - 1;
+    while (remainder_len >= 0) {
+        if (str[remainder_len] == split_char) {
+            if (out_remainder) {
+                *out_remainder = str.Take(0, remainder_len);
+            }
+            return str.Take(remainder_len + 1, str.len - remainder_len - 1);
+        }
+        remainder_len--;
+    }
+
+    if (out_remainder) {
+        *out_remainder = str.Take(0, 0);
+    }
+    return str;
+}
+static inline Span<const char> SplitStrReverse(const char *str, char split_char,
+                                               Span<const char> *out_remainder = nullptr)
+    { return SplitStrReverse(MakeSpan(str, strlen(str)), split_char, out_remainder); }
+
+static inline Span<const char> SplitStrReverseAny(Span<const char> str, const char *split_chars,
+                                                  Span<const char> *out_remainder = nullptr)
+{
+    Bitset<256> split_mask;
+    for (Size i = 0; split_chars[i]; i++) {
+        uint8_t c = (uint8_t)split_chars[i];
+        split_mask.Set(c);
+    }
+
+    Size remainder_len = str.len - 1;
+    while (remainder_len >= 0) {
+        uint8_t c = (uint8_t)str[remainder_len];
+
+        if (split_mask.Test(c)) {
+            if (out_remainder) {
+                *out_remainder = str.Take(0, remainder_len);
+            }
+            return str.Take(remainder_len + 1, str.len - remainder_len - 1);
+        }
+        remainder_len--;
+    }
+
+    if (out_remainder) {
+        *out_remainder = str.Take(0, 0);
+    }
+    return str;
+}
+static inline Span<const char> SplitStrReverseAny(const char *str, const char *split_chars,
+                                                  Span<const char> *out_remainder = nullptr)
+    { return SplitStrReverseAny(MakeSpan(str, strlen(str)), split_chars, out_remainder); }
+
+static inline Span<char> TrimStrLeft(Span<char> str, const char *trim_chars = " \t\r\n")
+{
+    while (str.len && strchr(trim_chars, str[0]) && str[0]) {
+        str.ptr++;
+        str.len--;
+    }
+
+    return str;
+}
+static inline Span<char> TrimStrRight(Span<char> str, const char *trim_chars = " \t\r\n")
+{
+    while (str.len && strchr(trim_chars, str[str.len - 1]) && str[str.len - 1]) {
+        str.len--;
+    }
+
+    return str;
+}
+static inline Span<char> TrimStr(Span<char> str, const char *trim_chars = " \t\r\n")
+{
+    str = TrimStrRight(str, trim_chars);
+    str = TrimStrLeft(str, trim_chars);
+
+    return str;
+}
+static inline Span<const char> TrimStrLeft(Span<const char> str, const char *trim_chars = " \t\r\n")
+    { return TrimStrLeft(MakeSpan((char *)str.ptr, str.len), trim_chars); }
+static inline Span<const char> TrimStrRight(Span<const char> str, const char *trim_chars = " \t\r\n")
+    { return TrimStrRight(MakeSpan((char *)str.ptr, str.len), trim_chars); }
+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); }
+
+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 (flags & (int)ParseFlag::Log) {
+            LogError("Cannot convert empty string to integer");
+        }
+        return false;
+    }
+
+    uint64_t value = 0;
+
+    Size pos = 0;
+    uint64_t neg = 0;
+    if (str.len >= 2) {
+        if (std::numeric_limits<T>::min() < 0 && str[0] == '-') {
+            pos = 1;
+            neg = UINT64_MAX;
+        } else if (str[0] == '+') {
+            pos = 1;
+        }
+    }
+
+    for (; pos < str.len; pos++) {
+        unsigned int digit = (unsigned int)(str[pos] - '0');
+        if (RG_UNLIKELY(digit > 9)) {
+            if (!pos || flags & (int)ParseFlag::End) {
+                if (flags & (int)ParseFlag::Log) {
+                    LogError("Malformed integer number '%1'", str);
+                }
+                return false;
+            } else {
+                break;
+            }
+        }
+
+        uint64_t new_value = (value * 10) + digit;
+        if (RG_UNLIKELY(new_value < value))
+            goto overflow;
+        value = new_value;
+    }
+    if (RG_UNLIKELY(value > (uint64_t)std::numeric_limits<T>::max()))
+        goto overflow;
+    value = ((value ^ neg) - neg);
+
+    if (out_remaining) {
+        *out_remaining = str.Take(pos, str.len - pos);
+    }
+    *out_value = (T)value;
+    return true;
+
+overflow:
+    if (flags & (int)ParseFlag::Log) {
+        LogError("Integer overflow for number '%1' (max = %2)", str,
+                std::numeric_limits<T>::max());
+    }
+    return false;
+}
+
+bool ParseBool(Span<const char> str, bool *out_value, unsigned int flags = RG_DEFAULT_PARSE_FLAGS,
+               Span<const char> *out_remaining = nullptr);
+
+static inline Size EncodeUtf8(int32_t c, char out_buf[4])
+{
+    if (c < 0x80) {
+        out_buf[0] = (char)c;
+        return 1;
+    } else if (c < 0x800) {
+        out_buf[0] = (char)(0xC0 | (c >> 6));
+        out_buf[1] = (char)(0x80 | (c & 0x3F));
+        return 2;
+    } else if (c >= 0xD800 && c < 0xE000) {
+        return 0;
+    } else if (c < 0x10000) {
+        out_buf[0] = (char)(0xE0 | (c >> 12));
+        out_buf[1] = (char)(0x80 | ((c >> 6) & 0x3F));
+        out_buf[2] = (char)(0x80 | (c & 0x3F));
+        return 3;
+    } else if (c < 0x110000) {
+        out_buf[0] = (char)(0xF0 | (c >> 18));
+        out_buf[1] = (char)(0x80 | ((c >> 12) & 0x3F));
+        out_buf[2] = (char)(0x80 | ((c >> 6) & 0x3F));
+        out_buf[3] = (char)(0x80 | (c & 0x3F));
+        return 4;
+    } else {
+        return 0;
+    }
+}
+
+static inline int CountUtf8Bytes(char c)
+{
+    int ones = CountLeadingZeros((uint32_t)~c << 24);
+    return std::min(std::max(ones, 1), 4);
+}
+
+static inline Size DecodeUtf8(const char *str, int32_t *out_c)
+{
+    RG_ASSERT(str[0]);
+
+    const uint8_t *ptr = (const uint8_t *)str;
+
+    if (ptr[0] < 0x80) {
+        *out_c = ptr[0];
+        return 1;
+    } else if (RG_UNLIKELY(ptr[0] - 0xC2 > 0xF4 - 0xC2)) {
+        return 0;
+    } else if (RG_LIKELY(ptr[1])) {
+        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])) {
+            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])) {
+                if ((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;
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
+static inline Size DecodeUtf8(Span<const char> str, Size offset, int32_t *out_c)
+{
+    RG_ASSERT(offset < str.len);
+
+    const uint8_t *ptr = (const uint8_t *)(str.ptr + offset);
+    Size available = str.len - offset;
+
+    if (ptr[0] < 0x80) {
+        *out_c = ptr[0];
+        return 1;
+    } else if (RG_UNLIKELY(ptr[0] - 0xC2 > 0xF4 - 0xC2)) {
+        return 0;
+    } else if (ptr[0] < 0xE0 &&
+               RG_LIKELY(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)) {
+        *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)) {
+        *out_c = ((ptr[0] & 0x7) << 18) | ((ptr[1] & 0x3F) << 12) | ((ptr[2] & 0x3F) << 6) | (ptr[3] & 0x3F);
+        return 4;
+    } else {
+        return 0;
+    }
+}
+
+// ------------------------------------------------------------------------
+// System
+// ------------------------------------------------------------------------
+
+#ifdef _WIN32
+    #define RG_PATH_SEPARATORS "\\/"
+    #define RG_PATH_DELIMITER ';'
+    #define RG_SHARED_LIBRARY_EXTENSION ".dll"
+#else
+    #define RG_PATH_SEPARATORS "/"
+    #define RG_PATH_DELIMITER ':'
+    #define RG_SHARED_LIBRARY_EXTENSION ".so"
+#endif
+
+#ifdef _WIN32
+bool IsWin32Utf8();
+Size ConvertUtf8ToWin32Wide(Span<const char> str, Span<wchar_t> out_str_w);
+Size ConvertWin32WideToUtf8(const wchar_t *str_w, Span<char> out_str);
+char *GetWin32ErrorString(uint32_t error_code = UINT32_MAX);
+#endif
+
+void SetEnvironmentVar(const char *name, const char *value);
+void DeleteEnvironmentVar(const char *name);
+
+static inline bool IsPathSeparator(char c)
+{
+#ifdef _WIN32
+    return c == '/' || c == '\\';
+#else
+    return c == '/';
+#endif
+}
+
+enum class CompressionType {
+    None,
+    Zlib,
+    Gzip,
+    Brotli
+};
+static const char *const CompressionTypeNames[] = {
+    "None",
+    "Zlib",
+    "Gzip",
+    "Brotli"
+};
+
+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);
+
+Span<char> NormalizePath(Span<const char> path, Span<const char> root_directory, Allocator *alloc);
+static inline Span<char> NormalizePath(Span<const char> path, Allocator *alloc)
+    { return NormalizePath(path, {}, alloc); }
+
+bool PathIsAbsolute(const char *path);
+bool PathIsAbsolute(Span<const char> path);
+bool PathContainsDotDot(const char *path);
+
+enum class StatFlag {
+    IgnoreMissing = 1 << 0,
+    FollowSymlink = 1 << 1
+};
+
+enum class FileType {
+    Directory,
+    File,
+    Link,
+    Device,
+    Pipe,
+    Socket
+};
+static const char *const FileTypeNames[] = {
+    "Directory",
+    "File",
+    "Link",
+    "Device",
+    "Pipe",
+    "Socket"
+};
+
+struct FileInfo {
+    FileType type;
+
+    int64_t size;
+    int64_t mtime;
+    unsigned int mode;
+};
+
+enum class StatResult {
+    Success,
+
+    MissingPath,
+    AccessDenied,
+    PartialEnum,
+    CallbackFail,
+    OtherError
+};
+
+StatResult StatFile(const char *filename, unsigned int flags, FileInfo *out_info);
+static inline StatResult StatFile(const char *filename, FileInfo *out_info)
+    { return StatFile(filename, 0, out_info); }
+
+enum class RenameFlag {
+    Overwrite = 1 << 0,
+    Sync = 1 << 1
+};
+
+// Sync failures are logged but not reported as errors (function returns true)
+bool RenameFile(const char *src_filename, const char *dest_filename, unsigned int flags);
+
+enum class EnumResult {
+    Success,
+
+    MissingPath,
+    AccessDenied,
+    PartialEnum,
+    CallbackFail,
+    OtherError
+};
+
+EnumResult EnumerateDirectory(const char *dirname, const char *filter, Size max_files,
+                              FunctionRef<bool(const char *, FileType)> func);
+bool EnumerateFiles(const char *dirname, const char *filter, Size max_depth, Size max_files,
+                    Allocator *str_alloc, HeapArray<const char *> *out_files);
+bool IsDirectoryEmpty(const char *dirname);
+
+bool TestFile(const char *filename);
+bool TestFile(const char *filename, FileType type);
+
+bool MatchPathName(const char *path, const char *spec);
+bool MatchPathSpec(const char *path, const char *spec);
+
+bool FindExecutableInPath(const char *path, const char *name,
+                          Allocator *alloc = nullptr, const char **out_path = nullptr);
+bool FindExecutableInPath(const char *name, Allocator *alloc = nullptr,
+                          const char **out_path = nullptr);
 
-    return !prefix[i] ? i : 0;
-}
+bool SetWorkingDirectory(const char *directory);
+const char *GetWorkingDirectory();
 
-static inline bool EndsWith(Span<const char> str, const char *suffix)
-{
-    Size i = str.len - 1;
-    Size j = (Size)strlen(suffix) - 1;
-    while (i >= 0 && j >= 0) {
-        if (str[i] != suffix[j])
-            return false;
+const char *GetApplicationExecutable(); // Can be NULL (EmSDK)
+const char *GetApplicationDirectory(); // Can be NULL (EmSDK)
 
-        i--;
-        j--;
-    }
+bool MakeDirectory(const char *directory, bool error_if_exists = true);
+bool MakeDirectoryRec(Span<const char> directory);
+bool UnlinkDirectory(const char *directory, bool error_if_missing = false);
+bool UnlinkFile(const char *filename, bool error_if_missing = false);
+bool EnsureDirectoryExists(const char *filename);
 
-    return j < 0;
-}
+enum class OpenFlag {
+    Read = 1 << 0,
+    Write = 1 << 1,
+    Append = 1 << 2,
 
-static inline Size FindStr(Span<const char> str, Span<const char> needle)
-{
-    if (!needle.len)
-        return 0;
-    if (needle.len > str.len)
-        return -1;
+    Exclusive = 1 << 3
+};
 
-    Size end = str.len - needle.len;
+enum class OpenResult {
+    Success = 0,
 
-    for (Size i = 0; i <= end; i++) {
-        if (!memcmp(str.ptr + i, needle.ptr, (size_t)needle.len))
-            return i; 
-    }
+    MissingPath = 1 << 0,
+    FileExists = 1 << 1,
+    AccessDenied = 1 << 2,
+    OtherError = 1 << 3
+};
 
-    return -1;
+OpenResult OpenDescriptor(const char *filename, unsigned int flags, unsigned int silent, int *out_fd);
+OpenResult OpenFile(const char *filename, unsigned int flags, unsigned int silent, FILE **out_fp);
+
+static inline OpenResult OpenDescriptor(const char *filename, unsigned int flags, int *out_fd)
+    { return OpenDescriptor(filename, flags, 0, out_fd); }
+static inline OpenResult OpenFile(const char *filename, unsigned int flags, FILE **out_fp)
+    { return OpenFile(filename, flags, 0, out_fp); }
+static inline int OpenDescriptor(const char *filename, unsigned int flags)
+{
+    int fd = -1;
+    if (OpenDescriptor(filename, flags, &fd) != OpenResult::Success)
+        return -1;
+    return fd;
 }
-static inline Size FindStr(const char *str, const char *needle)
+static inline FILE *OpenFile(const char *filename, unsigned int flags)
 {
-    const char *ret = strstr(str, needle);
-    return ret ? ret - str : -1;
+    FILE *fp;
+    if (OpenFile(filename, flags, &fp) != OpenResult::Success)
+        return nullptr;
+    return fp;
 }
 
-static inline Span<char> SplitStr(Span<char> str, char split_char, Span<char> *out_remainder = nullptr)
-{
-    Size part_len = 0;
-    while (part_len < str.len) {
-        if (str[part_len] == split_char) {
-            if (out_remainder) {
-                *out_remainder = str.Take(part_len + 1, str.len - part_len - 1);
-            }
-            return str.Take(0, part_len);
-        }
-        part_len++;
-    }
+bool FlushFile(int fd, const char *filename);
+bool FlushFile(FILE *fp, const char *filename);
 
-    if (out_remainder) {
-        *out_remainder = str.Take(str.len, 0);
-    }
-    return str;
+bool FileIsVt100(FILE *fp);
+
+#ifdef _WIN32
+enum class PipeMode {
+    Byte,
+    Message
+};
+
+bool CreateOverlappedPipe(bool overlap0, bool overlap1, PipeMode mode, void *out_handles[2]); // HANDLE
+void CloseHandleSafe(void **handle_ptr); // HANDLE
+#else
+void SetSignalHandler(int signal, void (*func)(int), struct sigaction *prev = nullptr);
+
+bool CreatePipe(int pfd[2]);
+void CloseDescriptorSafe(int *fd_ptr);
+#endif
+
+bool ExecuteCommandLine(const char *cmd_line, FunctionRef<Span<const uint8_t>()> in_func,
+                        FunctionRef<void(Span<uint8_t> buf)> out_func, int *out_code);
+bool ExecuteCommandLine(const char *cmd_line, Span<const uint8_t> in_buf, Size max_len,
+                        HeapArray<uint8_t> *out_buf, int *out_code);
+static inline bool ExecuteCommandLine(const char *cmd_line, int *out_code) {
+    return ExecuteCommandLine(cmd_line, {}, {}, out_code);
 }
-static inline Span<char> SplitStr(char *str, char split_char, char **out_remainder = nullptr)
+static inline bool ExecuteCommandLine(const char *cmd_line, Span<const uint8_t> in_buf,
+                                      FunctionRef<void(Span<uint8_t> buf)> out_func, int *out_code)
 {
-    Size part_len = 0;
-    while (str[part_len]) {
-        if (str[part_len] == split_char) {
-            if (out_remainder) {
-                *out_remainder = str + part_len + 1;
-            }
-            return MakeSpan(str, part_len);
-        }
-        part_len++;
-    }
+    const auto read_once = [&]() {
+        Span<const uint8_t> buf = in_buf;
+        in_buf = {};
+        return buf;
+    };
 
-    if (out_remainder) {
-        *out_remainder = str + part_len;
-    }
-    return MakeSpan(str, part_len);
+    return ExecuteCommandLine(cmd_line, read_once, out_func, out_code);
 }
-static inline Span<const char> SplitStr(Span<const char> str, char split_char, Span<const char> *out_remainder = nullptr)
-    { return SplitStr(MakeSpan((char *)str.ptr, str.len), split_char, (Span<char> *)out_remainder); }
-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> SplitStrLine(Span<char> str, Span<char> *out_remainder = nullptr)
+static inline bool ExecuteCommandLine(const char *cmd_line, Span<const char> in_buf,
+                                      FunctionRef<void(Span<char> buf)> out_func, int *out_code)
 {
-    Span<char> part = SplitStr(str, '\n', out_remainder);
-    if (part.len < str.len && part.len && part[part.len - 1] == '\r') {
-        part.len--;
-    }
-    return part;
+    const auto write = [&](Span<uint8_t> buf) { out_func(buf.As<char>()); };
+
+    return ExecuteCommandLine(cmd_line, in_buf.As<const uint8_t>(), write, out_code);
 }
-static inline Span<char> SplitStrLine(char *str, char **out_remainder = nullptr)
+static inline bool ExecuteCommandLine(const char *cmd_line, Span<const char> in_buf, Size max_len,
+                                      HeapArray<char> *out_buf, int *out_code)
 {
-    Span<char> part = SplitStr(str, '\n', out_remainder);
-    if (str[part.len] && part.len && part[part.len - 1] == '\r') {
-        part.len--;
-    }
-    return part;
+    return ExecuteCommandLine(cmd_line, in_buf.As<const uint8_t>(), max_len,
+                              (HeapArray<uint8_t> *)out_buf, out_code);
 }
-static inline Span<const char> SplitStrLine(Span<const char> str, Span<const char> *out_remainder = nullptr)
-    { return SplitStrLine(MakeSpan((char *)str.ptr, str.len), (Span<char> *)out_remainder); }
-static inline Span<const char> SplitStrLine(const char *str, const char **out_remainder = nullptr)
-    { return SplitStrLine((char *)str, (char **)out_remainder); }
 
-static inline Span<char> SplitStrAny(Span<char> str, const char *split_chars, Span<char> *out_remainder = nullptr)
-{
-    Bitset<256> split_mask;
-    for (Size i = 0; split_chars[i]; i++) {
-        uint8_t c = (uint8_t)split_chars[i];
-        split_mask.Set(c);
-    }
+void WaitDelay(int64_t delay);
 
-    Size part_len = 0;
-    while (part_len < str.len) {
-        uint8_t c = (uint8_t)str[part_len];
+enum class WaitForResult {
+    Interrupt,
+    Message,
+    Timeout
+};
 
-        if (split_mask.Test(c)) {
-            if (out_remainder) {
-                *out_remainder = str.Take(part_len + 1, str.len - part_len - 1);
-            }
-            return str.Take(0, part_len);
-        }
-        part_len++;
-    }
+// After WaitForInterrupt() 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.
+WaitForResult WaitForInterrupt(int64_t timeout = -1);
+void SignalWaitFor();
 
-    if (out_remainder) {
-        *out_remainder = str.Take(str.len, 0);
-    }
-    return str;
-}
-static inline Span<char> SplitStrAny(char *str, const char *split_chars, char **out_remainder = nullptr)
-{
-    Bitset<256> split_mask;
-    for (Size i = 0; split_chars[i]; i++) {
-        uint8_t c = (uint8_t)split_chars[i];
-        split_mask.Set(c);
-    }
+int GetCoreCount();
 
-    Size part_len = 0;
-    while (str[part_len]) {
-        uint8_t c = (uint8_t)str[part_len];
+#ifndef _WIN32
+bool DropRootIdentity();
+#endif
+#ifdef __linux__
+bool NotifySystemd();
+#endif
 
-        if (split_mask.Test(c)) {
-            if (out_remainder) {
-                *out_remainder = str + part_len + 1;
-            }
-            return MakeSpan(str, part_len);
-        }
-        part_len++;
-    }
+#ifndef _WIN32
+    #define RG_POSIX_RESTART_EINTR(CallCode, ErrorCond) \
+        ([&]() { \
+            decltype(CallCode) ret; \
+            while ((ret = (CallCode)) ErrorCond && errno == EINTR); \
+            return ret; \
+        })()
+#endif
 
-    if (out_remainder) {
-        *out_remainder = str + part_len;
-    }
-    return MakeSpan(str, part_len);
-}
-static inline Span<const char> SplitStrAny(Span<const char> str, const char *split_chars, Span<const char> *out_remainder = nullptr)
-    { return SplitStrAny(MakeSpan((char *)str.ptr, str.len), split_chars, (Span<char> *)out_remainder); }
-static inline Span<const char> SplitStrAny(const char *str, const char *split_chars, const char **out_remainder = nullptr)
-    { return SplitStrAny((char *)str, split_chars, (char **)out_remainder); }
+// ------------------------------------------------------------------------
+// Standard paths
+// ------------------------------------------------------------------------
 
-static inline Span<const char> SplitStrReverse(Span<const char> str, char split_char,
-                                               Span<const char> *out_remainder = nullptr)
-{
-    Size remainder_len = str.len - 1;
-    while (remainder_len >= 0) {
-        if (str[remainder_len] == split_char) {
-            if (out_remainder) {
-                *out_remainder = str.Take(0, remainder_len);
-            }
-            return str.Take(remainder_len + 1, str.len - remainder_len - 1);
-        }
-        remainder_len--;
-    }
+const char *GetUserConfigPath(const char *name, Allocator *alloc);
+const char *GetUserCachePath(const char *name, Allocator *alloc);
+const char *GetTemporaryDirectory();
+
+const char *FindConfigFile(const char *name, Allocator *alloc, LocalArray<const char *, 4> *out_possibilities = nullptr);
+
+const char *CreateUniqueFile(Span<const char> directory, const char *prefix, const char *extension,
+                             Allocator *alloc, FILE **out_fp = nullptr);
+const char *CreateUniqueDirectory(Span<const char> directory, const char *prefix, Allocator *alloc);
+
+// ------------------------------------------------------------------------
+// Random
+// ------------------------------------------------------------------------
+
+class FastRandom {
+    uint64_t state[4];
+
+public:
+    FastRandom();
+    FastRandom(uint64_t seed);
 
-    if (out_remainder) {
-        *out_remainder = str.Take(0, 0);
-    }
-    return str;
-}
-static inline Span<const char> SplitStrReverse(const char *str, char split_char,
-                                               Span<const char> *out_remainder = nullptr)
-    { return SplitStrReverse(MakeSpan(str, strlen(str)), split_char, out_remainder); }
+    void Fill(void *buf, Size len);
+    void Fill(Span<uint8_t> buf) { Fill(buf.ptr, buf.len); }
 
-static inline Span<const char> SplitStrReverseAny(Span<const char> str, const char *split_chars,
-                                                  Span<const char> *out_remainder = nullptr)
-{
-    Bitset<256> split_mask;
-    for (Size i = 0; split_chars[i]; i++) {
-        uint8_t c = (uint8_t)split_chars[i];
-        split_mask.Set(c);
-    }
+    int GetInt(int min, int max);
 
-    Size remainder_len = str.len - 1;
-    while (remainder_len >= 0) {
-        uint8_t c = (uint8_t)str[remainder_len];
+private:
+    uint64_t Next();
+};
 
-        if (split_mask.Test(c)) {
-            if (out_remainder) {
-                *out_remainder = str.Take(0, remainder_len);
-            }
-            return str.Take(remainder_len + 1, str.len - remainder_len - 1);
-        }
-        remainder_len--;
-    }
+template <int Min = 0, int Max = INT_MAX>
+class FastRandomInt {
+    RG_STATIC_ASSERT(Min >= 0);
+    RG_STATIC_ASSERT(Max > Min);
 
-    if (out_remainder) {
-        *out_remainder = str.Take(0, 0);
-    }
-    return str;
-}
-static inline Span<const char> SplitStrReverseAny(const char *str, const char *split_chars,
-                                                  Span<const char> *out_remainder = nullptr)
-    { return SplitStrReverseAny(MakeSpan(str, strlen(str)), split_chars, out_remainder); }
+    FastRandom rng;
 
-static inline Span<char> TrimStrLeft(Span<char> str, const char *trim_chars = " \t\r\n")
-{
-    while (str.len && strchr(trim_chars, str[0])) {
-        str.ptr++;
-        str.len--;
-    }
+public:
+    typedef int result_type;
 
-    return str;
-}
-static inline Span<char> TrimStrRight(Span<char> str, const char *trim_chars = " \t\r\n")
-{
-    while (str.len && strchr(trim_chars, str[str.len - 1])) {
-        str.len--;
-    }
+    static constexpr int min() { return Min; }
+    static constexpr int max() { return Max; }
 
-    return str;
-}
-static inline Span<char> TrimStr(Span<char> str, const char *trim_chars = " \t\r\n")
-{
-    str = TrimStrRight(str, trim_chars);
-    str = TrimStrLeft(str, trim_chars);
+    int operator()() { return rng.GetInt(Min, Max); }
+};
 
-    return str;
-}
-static inline Span<const char> TrimStrLeft(Span<const char> str, const char *trim_chars = " \t\r\n")
-    { return TrimStrLeft(MakeSpan((char *)str.ptr, str.len), trim_chars); }
-static inline Span<const char> TrimStrRight(Span<const char> str, const char *trim_chars = " \t\r\n")
-    { return TrimStrRight(MakeSpan((char *)str.ptr, str.len), trim_chars); }
-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); }
+void ZeroMemorySafe(void *ptr, Size len);
+void FillRandomSafe(void *buf, Size len);
+static inline void FillRandomSafe(Span<uint8_t> buf) { FillRandomSafe(buf.ptr, buf.len); }
+int GetRandomIntSafe(int min, int max);
 
-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 (flags & (int)ParseFlag::Log) {
-            LogError("Cannot convert empty string to integer");
-        }
-        return false;
-    }
+// ------------------------------------------------------------------------
+// Sockets
+// ------------------------------------------------------------------------
 
-    uint64_t value = 0;
+enum class SocketType {
+    Dual,
+    IPv4,
+    IPv6,
+    Unix
+};
+static const char *const SocketTypeNames[] = {
+    "Dual",
+    "IPv4",
+    "IPv6",
+    "Unix"
+};
 
-    Size pos = 0;
-    uint64_t neg = 0;
-    if (str.len >= 2) {
-        if (std::numeric_limits<T>::min() < 0 && str[0] == '-') {
-            pos = 1;
-            neg = UINT64_MAX;
-        } else if (str[0] == '+') {
-            pos = 1;
-        }
-    }
+enum class SocketMode {
+    Stream,
+    Messages
+};
 
-    for (; pos < str.len; pos++) {
-        unsigned int digit = (unsigned int)(str[pos] - '0');
-        if (RG_UNLIKELY(digit > 9)) {
-            if (!pos || flags & (int)ParseFlag::End) {
-                if (flags & (int)ParseFlag::Log) {
-                    LogError("Malformed integer number '%1'", str);
-                }
-                return false;
-            } else {
-                break;
-            }
-        }
+int OpenIPSocket(SocketType type, int port, SocketMode mode = SocketMode::Stream);
 
-        uint64_t new_value = (value * 10) + digit;
-        if (RG_UNLIKELY(new_value < value))
-            goto overflow;
-        value = new_value;
-    }
-    if (RG_UNLIKELY(value > (uint64_t)std::numeric_limits<T>::max()))
-        goto overflow;
-    value = ((value ^ neg) - neg);
+int OpenUnixSocket(const char *path, SocketMode mode = SocketMode::Stream);
+int ConnectToUnixSocket(const char *path, SocketMode mode = SocketMode::Stream);
 
-    if (out_remaining) {
-        *out_remaining = str.Take(pos, str.len - pos);
-    }
-    *out_value = (T)value;
-    return true;
+void CloseSocket(int fd);
 
-overflow:
-    if (flags & (int)ParseFlag::Log) {
-        LogError("Integer overflow for number '%1' (max = %2)", str,
-                std::numeric_limits<T>::max());
-    }
-    return false;
-}
+// ------------------------------------------------------------------------
+// Tasks
+// ------------------------------------------------------------------------
 
-bool ParseBool(Span<const char> str, bool *out_value, unsigned int flags = RG_DEFAULT_PARSE_FLAGS,
-               Span<const char> *out_remaining = nullptr);
+class Async {
+    RG_DELETE_COPY(Async)
 
-static inline Size EncodeUtf8(int32_t c, char out_buf[4])
-{
-    if (c < 0x80) {
-        out_buf[0] = (char)c;
-        return 1;
-    } else if (c < 0x800) {
-        out_buf[0] = (char)(0xC0 | (c >> 6));
-        out_buf[1] = (char)(0x80 | (c & 0x3F));
-        return 2;
-    } else if (c >= 0xD800 && c < 0xE000) {
-        return 0;
-    } else if (c < 0x10000) {
-        out_buf[0] = (char)(0xE0 | (c >> 12));
-        out_buf[1] = (char)(0x80 | ((c >> 6) & 0x3F));
-        out_buf[2] = (char)(0x80 | (c & 0x3F));
-        return 3;
-    } else if (c < 0x110000) {
-        out_buf[0] = (char)(0xF0 | (c >> 18));
-        out_buf[1] = (char)(0x80 | ((c >> 12) & 0x3F));
-        out_buf[2] = (char)(0x80 | ((c >> 6) & 0x3F));
-        out_buf[3] = (char)(0x80 | (c & 0x3F));
-        return 4;
-    } else {
-        return 0;
-    }
-}
+    bool stop_after_error;
+    std::atomic_bool success {true};
+    std::atomic_int remaining_tasks {0};
 
-static inline int CountUtf8Bytes(char c)
-{
-    int ones = CountLeadingZeros((uint32_t)~c << 24);
-    return std::min(std::max(ones, 1), 4);
-}
+    class AsyncPool *pool;
 
-static inline Size DecodeUtf8(Span<const char> str, Size offset, int32_t *out_c)
-{
-    RG_ASSERT(offset < str.len);
+public:
+    Async(int threads = -1, bool stop_after_error = true);
+    Async(Async *parent, bool stop_after_error = true);
+    ~Async();
 
-    const uint8_t *ptr = (const uint8_t *)(str.ptr + offset);
-    Size available = str.len - offset;
+    void Run(const std::function<bool()> &f);
+    bool Sync();
 
-    if (ptr[0] < 0x80) {
-        *out_c = ptr[0];
-        return 1;
-    } else if (RG_UNLIKELY(ptr[0] - 0xC2 > 0xF4 - 0xC2)) {
-        return 0;
-    } else if (ptr[0] < 0xE0 &&
-               RG_LIKELY(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)) {
-        *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)) {
-        *out_c = ((ptr[0] & 0x7) << 18) | ((ptr[1] & 0x3F) << 12) | ((ptr[2] & 0x3F) << 6) | (ptr[3] & 0x3F);
-        return 4;
-    } else {
-        return 0;
-    }
-}
+    int CountPendingTasks();
 
-static inline void FormatSha256(Span<const uint8_t> hash, char out_sha256[65])
-{
-    RG_ASSERT(hash.len == 32);
-    Fmt(MakeSpan(out_sha256, 65), "%1", FmtSpan(hash, FmtType::Hexadecimal, "").Pad0(-2));
-}
+    static bool IsTaskRunning();
+    static int GetWorkerIdx();
+    static int GetWorkerCount();
+
+    friend class AsyncPool;
+};
 
 // ------------------------------------------------------------------------
-// System
+// Fibers
 // ------------------------------------------------------------------------
 
-#ifdef _WIN32
-    #define RG_PATH_SEPARATORS "\\/"
-    #define RG_PATH_DELIMITER ';'
-    #define RG_SHARED_LIBRARY_EXTENSION ".dll"
-#else
-    #define RG_PATH_SEPARATORS "/"
-    #define RG_PATH_DELIMITER ':'
-    #define RG_SHARED_LIBRARY_EXTENSION ".so"
-#endif
-
-#ifdef _WIN32
-bool IsWin32Utf8();
-Size ConvertUtf8ToWin32Wide(Span<const char> str, Span<wchar_t> out_str_w);
-Size ConvertWin32WideToUtf8(const wchar_t *str_w, Span<char> out_str);
-char *GetWin32ErrorString(uint32_t error_code = UINT32_MAX);
-#endif
+class Fiber {
+    RG_DELETE_COPY(Fiber)
 
-void SetEnvironmentVar(const char *name, const char *value);
-void DeleteEnvironmentVar(const char *name);
+    std::function<bool()> f;
 
-static inline bool IsPathSeparator(char c)
-{
 #ifdef _WIN32
-    return c == '/' || c == '\\';
+    void *fiber = nullptr;
+#elif defined(RG_FIBER_USE_UCONTEXT)
+    ucontext_t ucp = {};
 #else
-    return c == '/';
+    std::thread thread;
+
+    std::mutex mutex;
+    std::condition_variable cv;
+    std::unique_lock<std::mutex> lock { mutex };
+    int toggle = 1;
 #endif
-}
 
-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);
+    bool done = true;
+    bool success = false;
 
-Span<char> NormalizePath(Span<const char> path, Span<const char> root_directory, Allocator *alloc);
-static inline Span<char> NormalizePath(Span<const char> path, Allocator *alloc)
-    { return NormalizePath(path, {}, alloc); }
+public:
+    Fiber(const std::function<bool()> &f, Size stack_size = RG_FIBER_DEFAULT_STACK_SIZE);
+    ~Fiber();
 
-bool PathIsAbsolute(const char *path);
-bool PathIsAbsolute(Span<const char> path);
-bool PathContainsDotDot(const char *path);
+    void SwitchTo();
+    bool Finalize();
 
-enum class StatFlag {
-    IgnoreMissing = 1 << 0,
-    FollowSymlink = 1 << 1
-};
+    static bool SwitchBack();
 
-enum class FileType {
-    Directory,
-    File,
-    Link,
-    Device,
-    Pipe,
-    Socket
+private:
+#if defined(_WIN64)
+    static void FiberCallback(void *udata);
+#elif defined(_WIN32)
+    static void __stdcall FiberCallback(void *udata);
+#elif defined(RG_FIBER_USE_UCONTEXT)
+    static void FiberCallback(unsigned int high, unsigned int low);
+#else
+    static void ThreadCallback(void *udata);
+    void Toggle(int to, std::unique_lock<std::mutex> *lock);
+#endif
 };
 
-struct FileInfo {
-    FileType type;
-
-    int64_t size;
-    int64_t mtime;
-};
+// ------------------------------------------------------------------------
+// Streams
+// ------------------------------------------------------------------------
 
-enum class EnumStatus {
-    Error,
-    Partial,
-    Stopped,
-    Complete
+enum class CompressionSpeed {
+    Default,
+    Slow,
+    Fast
 };
 
-bool StatFile(const char *filename, unsigned int flags, FileInfo *out_info);
-static inline bool StatFile(const char *filename, FileInfo *out_info)
-    { return StatFile(filename, 0, out_info); }
+class StreamReader {
+    RG_DELETE_COPY(StreamReader)
 
-// Sync failures are logged but not reported as errors (function returns true)
-bool RenameFile(const char *src_filename, const char *dest_filename, bool overwrite, bool sync = true);
+    enum class SourceType {
+        Memory,
+        File,
+        Function
+    };
 
-EnumStatus EnumerateDirectory(const char *dirname, const char *filter, Size max_files,
-                              FunctionRef<bool(const char *, FileType)> func);
-bool EnumerateFiles(const char *dirname, const char *filter, Size max_depth, Size max_files,
-                    Allocator *str_alloc, HeapArray<const char *> *out_files);
-bool IsDirectoryEmpty(const char *dirname);
+    const char *filename = nullptr;
+    bool error = true;
 
-bool TestFile(const char *filename);
-bool TestFile(const char *filename, FileType type);
+    struct {
+        SourceType type = SourceType::Memory;
+        union U {
+            struct {
+                Span<const uint8_t> buf;
+                Size pos;
+            } memory;
+            struct {
+                FILE *fp;
+                bool owned;
+            } file;
+            std::function<Size(Span<uint8_t> buf)> func;
 
-bool MatchPathName(const char *path, const char *spec);
-bool MatchPathSpec(const char *path, const char *spec);
+            // StreamReader deals with func destructor
+            U() {}
+            ~U() {}
+        } u;
 
-bool FindExecutableInPath(const char *path, const char *name,
-                          Allocator *alloc = nullptr, const char **out_path = nullptr);
-bool FindExecutableInPath(const char *name, Allocator *alloc = nullptr,
-                          const char **out_path = nullptr);
+        bool eof = false;
+    } source;
 
-bool SetWorkingDirectory(const char *directory);
-const char *GetWorkingDirectory();
+    struct {
+        CompressionType type = CompressionType::None;
+        union {
+            struct MinizInflateContext *miniz;
+            struct BrotliDecompressContext *brotli;
+        } u;
+    } compression;
 
-const char *GetApplicationExecutable(); // Can be NULL (EmSDK)
-const char *GetApplicationDirectory(); // Can be NULL (EmSDK)
+    int64_t raw_len = -1;
+    Size raw_read = 0;
+    bool eof = false;
 
-bool MakeDirectory(const char *directory, bool error_if_exists = true);
-bool MakeDirectoryRec(Span<const char> directory);
-bool UnlinkDirectory(const char *directory, bool error_if_missing = false);
-bool UnlinkFile(const char *filename, bool error_if_missing = false);
-bool EnsureDirectoryExists(const char *filename);
+    BlockAllocator str_alloc;
 
-enum class OpenFileFlag {
-    Read = 1 << 0,
-    Write = 1 << 1,
-    Append = 1 << 2,
+public:
+    StreamReader() { Close(true); }
+    StreamReader(Span<const uint8_t> buf, const char *filename = nullptr,
+                 CompressionType compression_type = CompressionType::None)
+        : StreamReader() { Open(buf, filename, compression_type); }
+    StreamReader(FILE *fp, const char *filename,
+                 CompressionType compression_type = CompressionType::None)
+        : StreamReader() { Open(fp, 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 = nullptr,
+                 CompressionType compression_type = CompressionType::None)
+        : StreamReader() { Open(func, filename, compression_type); }
+    ~StreamReader() { Close(true); }
 
-    Exclusive = 1 << 3
-};
+    bool Open(Span<const uint8_t> buf, const char *filename = nullptr,
+              CompressionType compression_type = CompressionType::None);
+    bool Open(FILE *fp, 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 = nullptr,
+              CompressionType compression_type = CompressionType::None);
+    bool Close() { return Close(false); }
 
-int OpenDescriptor(const char *filename, unsigned int flags);
-FILE *OpenFile(const char *filename, unsigned int flags);
-bool FlushFile(FILE *fp, const char *filename);
+    // File-specific
+    bool Rewind();
 
-bool FileIsVt100(FILE *fp);
+    const char *GetFileName() const { return filename; }
+    CompressionType GetCompressionType() const { return compression.type; }
+    bool IsValid() const { return filename && !error; }
+    bool IsEOF() const { return eof; }
 
-#ifdef _WIN32
-enum class PipeMode {
-    Byte,
-    Message
-};
+    FILE *GetFile() const;
+    int GetDescriptor() const;
 
-bool CreateOverlappedPipe(bool overlap0, bool overlap1, PipeMode mode, void *out_handles[2]); // HANDLE
-void CloseHandleSafe(void **handle_ptr); // HANDLE
-#else
-void SetSignalHandler(int signal, void (*func)(int), struct sigaction *prev = nullptr);
+    Size Read(Span<uint8_t> out_buf);
+    Size Read(Span<char> out_buf) { return Read(out_buf.As<uint8_t>()); }
+    Size Read(Size max_len, void *out_buf) { return Read(MakeSpan((uint8_t *)out_buf, max_len)); }
 
-bool CreatePipe(int pfd[2]);
-void CloseDescriptorSafe(int *fd_ptr);
-#endif
+    Size ReadAll(Size max_len, HeapArray<uint8_t> *out_buf);
+    Size ReadAll(Size max_len, HeapArray<char> *out_buf)
+        { return ReadAll(max_len, (HeapArray<uint8_t> *)out_buf); }
 
-bool ExecuteCommandLine(const char *cmd_line, FunctionRef<Span<const uint8_t>()> in_func,
-                        FunctionRef<void(Span<uint8_t> buf)> out_func, int *out_code);
-bool ExecuteCommandLine(const char *cmd_line, Span<const uint8_t> in_buf, Size max_len,
-                        HeapArray<uint8_t> *out_buf, int *out_code);
-static inline bool ExecuteCommandLine(const char *cmd_line, int *out_code) {
-    return ExecuteCommandLine(cmd_line, {}, {}, out_code);
-}
-static inline bool ExecuteCommandLine(const char *cmd_line, Span<const uint8_t> in_buf,
-                                      FunctionRef<void(Span<uint8_t> buf)> out_func, int *out_code)
-{
-    const auto read_once = [&]() {
-        Span<const uint8_t> buf = in_buf;
-        in_buf = {};
-        return buf;
-    };
+    int64_t ComputeRawLen();
+    int64_t GetRawRead() const { return raw_read; }
 
-    return ExecuteCommandLine(cmd_line, read_once, out_func, out_code);
-}
-static inline bool ExecuteCommandLine(const char *cmd_line, Span<const char> in_buf,
-                                      FunctionRef<void(Span<char> buf)> out_func, int *out_code)
-{
-    const auto write = [&](Span<uint8_t> buf) { out_func(buf.As<char>()); };
+private:
+    bool Close(bool implicit);
 
-    return ExecuteCommandLine(cmd_line, in_buf.As<const uint8_t>(), write, out_code);
-}
-static inline bool ExecuteCommandLine(const char *cmd_line, Span<const char> in_buf, Size max_len,
-                                      HeapArray<char> *out_buf, int *out_code)
-{
-    return ExecuteCommandLine(cmd_line, in_buf.As<const uint8_t>(), max_len,
-                              (HeapArray<uint8_t> *)out_buf, out_code);
-}
+    bool InitDecompressor(CompressionType type);
 
-void WaitDelay(int64_t delay);
+    Size ReadInflate(Size max_len, void *out_buf);
+    Size ReadBrotli(Size max_len, void *out_buf);
 
-enum class WaitForResult {
-    Interrupt,
-    Message,
-    Timeout
+    Size ReadRaw(Size max_len, void *out_buf);
 };
 
-// After WaitForInterrupt() 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.
-WaitForResult WaitForInterrupt(int64_t timeout = -1);
-void SignalWaitFor();
-
-int GetCoreCount();
-
-#ifndef _WIN32
-bool DropRootIdentity();
-#endif
-#ifdef __linux__
-bool NotifySystemd();
-#endif
-
-#ifndef _WIN32
-    #define RG_POSIX_RESTART_EINTR(CallCode, ErrorCond) \
-        ([&]() { \
-            decltype(CallCode) ret; \
-            while ((ret = (CallCode)) ErrorCond && errno == EINTR); \
-            return ret; \
-        })()
-#endif
-
-// ------------------------------------------------------------------------
-// Standard paths
-// ------------------------------------------------------------------------
+static inline Size ReadFile(const char *filename, CompressionType compression_type, Span<uint8_t> out_buf)
+{
+    StreamReader st(filename, compression_type);
+    return st.Read(out_buf);
+}
+static inline Size ReadFile(const char *filename, Span<uint8_t> out_buf)
+{
+    StreamReader st(filename);
+    return st.Read(out_buf);
+}
+static inline Size ReadFile(const char *filename, CompressionType compression_type, Span<char> out_buf)
+{
+    StreamReader st(filename, compression_type);
+    return st.Read(out_buf);
+}
+static inline Size ReadFile(const char *filename, Span<char> out_buf)
+{
+    StreamReader st(filename);
+    return st.Read(out_buf);
+}
 
-const char *GetUserConfigPath(const char *name, Allocator *alloc);
-const char *GetUserCachePath(const char *name, Allocator *alloc);
-const char *GetTemporaryDirectory();
+static inline Size ReadFile(const char *filename, Size max_len, CompressionType compression_type,
+                            HeapArray<uint8_t> *out_buf)
+{
+    StreamReader st(filename, compression_type);
+    return st.ReadAll(max_len, out_buf);
+}
+static inline Size ReadFile(const char *filename, Size max_len, HeapArray<uint8_t> *out_buf)
+{
+    StreamReader st(filename);
+    return st.ReadAll(max_len, out_buf);
+}
+static inline Size ReadFile(const char *filename, Size max_len, CompressionType compression_type,
+                            HeapArray<char> *out_buf)
+{
+    StreamReader st(filename, compression_type);
+    return st.ReadAll(max_len, out_buf);
+}
+static inline Size ReadFile(const char *filename, Size max_len, HeapArray<char> *out_buf)
+{
+    StreamReader st(filename);
+    return st.ReadAll(max_len, out_buf);
+}
 
-const char *FindConfigFile(const char *name, Allocator *alloc, LocalArray<const char *, 4> *out_possibilities = nullptr);
+class LineReader {
+    RG_DELETE_COPY(LineReader)
 
-const char *CreateTemporaryFile(Span<const char> directory, const char *prefix, const char *extension,
-                                Allocator *alloc, FILE **out_fp = nullptr);
-const char *CreateTemporaryDirectory(Span<const char> directory, const char *prefix, Allocator *alloc);
+    HeapArray<char> buf;
+    Span<char> view = {};
 
-// ------------------------------------------------------------------------
-// Random
-// ------------------------------------------------------------------------
+    StreamReader *st;
+    bool error;
+    bool eof = false;
 
-class FastRandom {
-    uint64_t state[4];
+    Span<char> line = {};
+    int line_number = 0;
 
 public:
-    FastRandom();
-    FastRandom(uint64_t seed);
+    LineReader(StreamReader *st) : st(st), error(!st->IsValid()) {}
 
-    void Fill(void *buf, Size len);
-    void Fill(Span<uint8_t> buf) { Fill(buf.ptr, buf.len); }
+    const char *GetFileName() const { return st->GetFileName(); }
+    int GetLineNumber() const { return line_number; }
+    bool IsValid() const { return !error; }
+    bool IsEOF() const { return eof; }
 
-    int GetInt(int min, int max);
+    bool Next(Span<char> *out_line);
+    bool Next(Span<const char> *out_line) { return Next((Span<char> *)out_line); }
 
-private:
-    uint64_t Next();
+    void PushLogFilter();
 };
 
-void ZeroMemorySafe(void *ptr, Size len);
-void FillRandomSafe(void *buf, Size len);
-static inline void FillRandomSafe(Span<uint8_t> buf) { FillRandomSafe(buf.ptr, buf.len); }
-int GetRandomIntSafe(int min, int max);
+enum class StreamWriterFlag {
+    Exclusive = 1 << 0,
+    Atomic = 1 << 1
+};
 
-// ------------------------------------------------------------------------
-// Sockets
-// ------------------------------------------------------------------------
+class StreamWriter {
+    RG_DELETE_COPY(StreamWriter)
 
-enum class SocketType {
-    Dual,
-    IPv4,
-    IPv6,
-    Unix
-};
-static const char *const SocketTypeNames[] = {
-    "Dual",
-    "IPv4",
-    "IPv6",
-    "Unix"
-};
+    enum class DestinationType {
+        Memory,
+        File,
+        Function
+    };
 
-enum class SocketMode {
-    Stream,
-    Messages
-};
+    const char *filename = nullptr;
+    bool error = true;
 
-int OpenIPSocket(SocketType type, int port, SocketMode mode = SocketMode::Stream);
+    struct {
+        DestinationType type = DestinationType::Memory;
+        union U {
+            struct {
+                HeapArray<uint8_t> *memory;
+                Size start;
+            } mem;
+            struct {
+                FILE *fp;
+                bool owned;
 
-int OpenUnixSocket(const char *path, SocketMode mode = SocketMode::Stream);
-int ConnectToUnixSocket(const char *path, SocketMode mode = SocketMode::Stream);
+                // Atomic write mode
+                const char *tmp_filename;
+                bool tmp_exclusive;
+            } file;
+            std::function<bool(Span<const uint8_t>)> func;
 
-void CloseSocket(int fd);
+            // StreamWriter deals with func destructor
+            U() {}
+            ~U() {}
+        } u;
 
-// ------------------------------------------------------------------------
-// Tasks
-// ------------------------------------------------------------------------
+        bool vt100;
+    } dest;
 
-class Async {
-    RG_DELETE_COPY(Async)
+    struct {
+        CompressionType type = CompressionType::None;
+        CompressionSpeed speed = CompressionSpeed::Default;
+        union {
+            struct MinizDeflateContext *miniz;
+            struct BrotliEncoderStateStruct *brotli;
+        } u;
+    } compression;
 
-    bool stop_after_error;
-    std::atomic_bool success {true};
-    std::atomic_int remaining_tasks {0};
+    int64_t raw_written = 0;
 
-    class AsyncPool *pool;
+    BlockAllocator str_alloc;
 
 public:
-    Async(int threads = -1, bool stop_after_error = true);
-    ~Async();
+    StreamWriter() { Close(true); }
+    StreamWriter(HeapArray<uint8_t> *mem, const char *filename = nullptr,
+                 CompressionType compression_type = CompressionType::None,
+                 CompressionSpeed compression_speed = CompressionSpeed::Default)
+        : StreamWriter() { Open(mem, filename, compression_type, compression_speed); }
+    StreamWriter(FILE *fp, const char *filename,
+                 CompressionType compression_type = CompressionType::None,
+                 CompressionSpeed compression_speed = CompressionSpeed::Default)
+        : StreamWriter() { Open(fp, filename, compression_type, compression_speed); }
+    StreamWriter(const char *filename, unsigned int flags = 0,
+                 CompressionType compression_type = CompressionType::None,
+                 CompressionSpeed compression_speed = CompressionSpeed::Default)
+        : StreamWriter() { Open(filename, flags, compression_type, compression_speed); }
+    StreamWriter(const std::function<bool(Span<const uint8_t>)> &func, const char *filename = nullptr,
+                 CompressionType compression_type = CompressionType::None,
+                 CompressionSpeed compression_speed = CompressionSpeed::Default)
+        : StreamWriter() { Open(func, filename, compression_type, compression_speed); }
+    ~StreamWriter() { Close(true); }
 
-    void Run(const std::function<bool()> &f);
-    bool Sync();
+    bool Open(HeapArray<uint8_t> *mem, const char *filename = nullptr,
+              CompressionType compression_type = CompressionType::None,
+              CompressionSpeed compression_speed = CompressionSpeed::Default);
+    bool Open(FILE *fp, const char *filename,
+              CompressionType compression_type = CompressionType::None,
+              CompressionSpeed compression_speed = CompressionSpeed::Default);
+    bool Open(const char *filename, unsigned int flags = 0,
+              CompressionType compression_type = CompressionType::None,
+              CompressionSpeed compression_speed = CompressionSpeed::Default);
+    bool Open(const std::function<bool(Span<const uint8_t>)> &func, const char *filename = nullptr,
+              CompressionType compression_type = CompressionType::None,
+              CompressionSpeed compression_speed = CompressionSpeed::Default);
+    bool Close() { return Close(false); }
 
-    static bool IsTaskRunning();
-    static int GetWorkerIdx();
+    // For compressed streams, Flush may not be complete and only Close() can finalize the file.
+    bool Flush();
 
-    friend class AsyncPool;
-};
+    const char *GetFileName() const { return filename; }
+    CompressionType GetCompressionType() const { return compression.type; }
+    bool IsVt100() const { return dest.vt100; }
+    bool IsValid() const { return filename && !error; }
 
-// ------------------------------------------------------------------------
-// Fibers
-// ------------------------------------------------------------------------
+    FILE *GetFile() const;
+    int GetDescriptor() const;
 
-class Fiber {
-    RG_DELETE_COPY(Fiber)
+    bool Write(Span<const uint8_t> buf);
+    bool Write(Span<const char> buf) { return Write(buf.As<const uint8_t>()); }
+    bool Write(char buf) { return Write(MakeSpan(&buf, 1)); }
+    bool Write(const void *buf, Size len) { return Write(MakeSpan((const uint8_t *)buf, len)); }
 
-    std::function<bool()> f;
+    int64_t GetRawWritten() const { return raw_written; }
 
-#ifdef _WIN32
-    void *fiber = nullptr;
-#elif defined(RG_FIBER_USE_UCONTEXT)
-    ucontext_t ucp = {};
-#else
-    std::thread thread;
+private:
+    bool Close(bool implicit);
 
-    std::mutex mutex;
-    std::condition_variable cv;
-    std::unique_lock<std::mutex> lock { mutex };
-    int toggle = 1;
-#endif
+    bool InitCompressor(CompressionType type, CompressionSpeed speed);
 
-    bool done = true;
-    bool success = false;
+    bool WriteDeflate(Span<const uint8_t> buf);
+    bool WriteBrotli(Span<const uint8_t> buf);
 
-public:
-    Fiber(const std::function<bool()> &f, Size stack_size = RG_FIBER_DEFAULT_STACK_SIZE);
-    ~Fiber();
+    bool WriteRaw(Span<const uint8_t> buf);
+};
 
-    void SwitchTo();
-    bool Finalize();
+static inline bool WriteFile(Span<const uint8_t> buf, const char *filename, unsigned int flags = 0,
+                             CompressionType compression_type = CompressionType::None)
+{
+    StreamWriter st(filename, flags, compression_type);
+    st.Write(buf);
+    return st.Close();
+}
+static inline bool WriteFile(Span<const char> buf, const char *filename, unsigned int flags = 0,
+                             CompressionType compression_type = CompressionType::None)
+{
+    StreamWriter st(filename, flags, compression_type);
+    st.Write(buf);
+    return st.Close();
+}
 
-    static bool SwitchBack();
+bool SpliceStream(StreamReader *reader, int64_t max_len, StreamWriter *writer);
 
-private:
-#if defined(_WIN64)
-    static void FiberCallback(void *udata);
-#elif defined(_WIN32)
-    static void __stdcall FiberCallback(void *udata);
-#elif defined(RG_FIBER_USE_UCONTEXT)
-    static void FiberCallback(unsigned int high, unsigned int low);
-#else
-    static void ThreadCallback(void *udata);
-    void Toggle(int to, std::unique_lock<std::mutex> *lock);
-#endif
-};
+// For convenience, don't close them
+extern StreamReader stdin_st;
+extern StreamWriter stdout_st;
+extern StreamWriter stderr_st;
 
 // ------------------------------------------------------------------------
 // INI