koffi 2.1.0 → 2.1.2

package/vendor/libcc/libcc.cc

@@ -87,19 +87,11 @@
 #ifdef __APPLE__
     #include <sys/random.h>
     #include <mach-o/dyld.h>
-
-    #define off64_t off_t
-    #define fseeko64 fseeko
-    #define ftello64 ftello
 #endif
 #if defined(__OpenBSD__) || defined(__FreeBSD__)
     #include <pthread_np.h>
     #include <sys/param.h>
     #include <sys/sysctl.h>
-
-    #define off64_t off_t
-    #define fseeko64 fseeko
-    #define ftello64 ftello
 #endif
 #include <chrono>
 #include <random>
@@ -141,42 +133,44 @@ protected:
         void *ptr = malloc((size_t)size);
         RG_CRITICAL(ptr, "Failed to allocate %1 of memory", FmtMemSize(size));
 
-        if (flags & (int)Allocator::Flag::Zero) {
+        if (flags & (int)AllocFlag::Zero) {
             memset_safe(ptr, 0, (size_t)size);
         }
 
         return ptr;
     }
 
-    void Resize(void **ptr, Size old_size, Size new_size, unsigned int flags) override
+    void *Resize(void *ptr, Size old_size, Size new_size, unsigned int flags) override
     {
         if (!new_size) {
-            Release(*ptr, old_size);
-            *ptr = nullptr;
+            Release(ptr, old_size);
+            ptr = nullptr;
         } else {
-            void *new_ptr = realloc(*ptr, (size_t)new_size);
+            void *new_ptr = realloc(ptr, (size_t)new_size);
             RG_CRITICAL(new_ptr || !new_size, "Failed to resize %1 memory block to %2",
                                               FmtMemSize(old_size), FmtMemSize(new_size));
 
-            if ((flags & (int)Allocator::Flag::Zero) && new_size > old_size) {
+            if ((flags & (int)AllocFlag::Zero) && new_size > old_size) {
                 memset_safe((uint8_t *)new_ptr + old_size, 0, (size_t)(new_size - old_size));
             }
 
-            *ptr = new_ptr;
+            ptr = new_ptr;
         }
+
+        return ptr;
     }
 
-    void Release(void *ptr, Size) override
+    void Release(const void *ptr, Size) override
     {
-        free(ptr);
+        free((void *)ptr);
     }
 };
 
 class NullAllocator: public Allocator {
 protected:
     void *Allocate(Size, unsigned int) override { RG_UNREACHABLE(); }
-    void Resize(void **, Size, Size, unsigned int) override { RG_UNREACHABLE(); }
-    void Release(void *, Size) override {}
+    void *Resize(void *, Size, Size, unsigned int) override { RG_UNREACHABLE(); }
+    void Release(const void *, Size) override {}
 };
 
 Allocator *GetDefaultAllocator()
@@ -205,7 +199,7 @@ void LinkedAllocator::ReleaseAll()
     Node *head = list.next;
     while (head) {
         Node *next = head->next;
-        ReleaseMemory(allocator, head, -1);
+        ReleaseRaw(allocator, head, -1);
         head = next;
     }
     list = {};
@@ -213,7 +207,7 @@ void LinkedAllocator::ReleaseAll()
 
 void *LinkedAllocator::Allocate(Size size, unsigned int flags)
 {
-    Bucket *bucket = AllocateMemory<Bucket>(allocator, RG_SIZE(*bucket) + size, flags).ptr;
+    Bucket *bucket = (Bucket *)AllocateRaw(allocator, RG_SIZE(Node) + size, flags);
 
     if (list.prev) {
         list.prev->next = &bucket->head;
@@ -227,26 +221,21 @@ void *LinkedAllocator::Allocate(Size size, unsigned int flags)
         bucket->head.next = nullptr;
     }
 
-    uint8_t *data = bucket->data;
-    uint8_t *aligned = AlignUp(data, 16);
-
-    RG_ASSERT(aligned - data <= 8);
-
-    return (void *)aligned;
+    return (void *)bucket->data;
 }
 
-void LinkedAllocator::Resize(void **ptr, Size old_size, Size new_size, unsigned int flags)
+void *LinkedAllocator::Resize(void *ptr, Size old_size, Size new_size, unsigned int flags)
 {
-    if (!*ptr) {
-        *ptr = Allocate(new_size, flags);
+    if (!ptr) {
+        ptr = Allocate(new_size, flags);
     } else if (!new_size) {
-        Release(*ptr, old_size);
-        *ptr = nullptr;
+        Release(ptr, old_size);
+        ptr = nullptr;
     } else {
-        Bucket *bucket = PointerToBucket(*ptr);
+        Bucket *bucket = PointerToBucket(ptr);
 
-        bucket = ResizeMemory(allocator, bucket, RG_SIZE(*bucket) + old_size,
-                                                 RG_SIZE(*bucket) + new_size, flags).ptr;
+        bucket = (Bucket *)ResizeRaw(allocator, bucket, RG_SIZE(Node) + old_size,
+                                                        RG_SIZE(Node) + new_size, flags);
 
         if (bucket->head.next) {
             bucket->head.next->prev = &bucket->head;
@@ -259,19 +248,16 @@ void LinkedAllocator::Resize(void **ptr, Size old_size, Size new_size, unsigned
             list.next = &bucket->head;
         }
 
-        uint8_t *data = bucket->data;
-        uint8_t *aligned = AlignUp(data, 16);
-
-        RG_ASSERT(aligned - data <= 8);
-
-        *ptr = (void *)aligned;
+        ptr = (void *)bucket->data;
     }
+
+    return ptr;
 }
 
-void LinkedAllocator::Release(void *ptr, Size size)
+void LinkedAllocator::Release(const void *ptr, Size size)
 {
     if (ptr) {
-        Bucket *bucket = PointerToBucket(ptr);
+        Bucket *bucket = PointerToBucket((void *)ptr);
 
         if (bucket->head.next) {
             bucket->head.next->prev = bucket->head.prev;
@@ -284,10 +270,16 @@ void LinkedAllocator::Release(void *ptr, Size size)
             list.next = bucket->head.next;
         }
 
-        ReleaseMemory(allocator, bucket, size);
+        ReleaseRaw(allocator, bucket, RG_SIZE(Bucket) + size);
     }
 }
 
+LinkedAllocator::Bucket *LinkedAllocator::PointerToBucket(void *ptr)
+{
+    uint8_t *data = (uint8_t *)ptr;
+    return (Bucket *)(data - RG_OFFSET_OF(Bucket, data));
+}
+
 void *BlockAllocatorBase::Allocate(Size size, unsigned int flags)
 {
     RG_ASSERT(size >= 0);
@@ -298,21 +290,19 @@ void *BlockAllocatorBase::Allocate(Size size, unsigned int flags)
     Size aligned_size = AlignLen(size, 8);
 
     if (AllocateSeparately(aligned_size)) {
-        uint8_t *ptr = AllocateMemory<uint8_t>(alloc, size, flags).ptr;
+        uint8_t *ptr = (uint8_t *)AllocateRaw(alloc, size, flags);
         return ptr;
     } else {
         if (!current_bucket || (current_bucket->used + aligned_size) > block_size) {
-            current_bucket = AllocateMemory<Bucket>(alloc, RG_SIZE(Bucket) + block_size,
-                                                           flags & ~(int)Allocator::Flag::Zero).ptr;
-            current_bucket->used = AlignUp(current_bucket->data, 16) - current_bucket->data;
-
-            RG_ASSERT(current_bucket->used <= 8);
+            current_bucket = (Bucket *)AllocateRaw(alloc, RG_SIZE(Bucket) + block_size,
+                                                   flags & ~(int)AllocFlag::Zero);
+            current_bucket->used = 0;
         }
 
         uint8_t *ptr = current_bucket->data + current_bucket->used;
         current_bucket->used += aligned_size;
 
-        if (flags & (int)Allocator::Flag::Zero) {
+        if (flags & (int)AllocFlag::Zero) {
             memset_safe(ptr, 0, size);
         }
 
@@ -321,15 +311,16 @@ void *BlockAllocatorBase::Allocate(Size size, unsigned int flags)
     }
 }
 
-void BlockAllocatorBase::Resize(void **ptr, Size old_size, Size new_size, unsigned int flags)
+void *BlockAllocatorBase::Resize(void *ptr, Size old_size, Size new_size, unsigned int flags)
 {
     RG_ASSERT(old_size >= 0);
     RG_ASSERT(new_size >= 0);
 
     if (!new_size) {
-        Release(*ptr, old_size);
+        Release(ptr, old_size);
+        ptr = nullptr;
     } else {
-        if (!*ptr) {
+        if (!ptr) {
             old_size = 0;
         }
 
@@ -338,35 +329,37 @@ void BlockAllocatorBase::Resize(void **ptr, Size old_size, Size new_size, unsign
         Size aligned_delta = aligned_new_size - aligned_old_size;
 
         // Try fast path
-        if (*ptr && *ptr == last_alloc &&
+        if (ptr && ptr == last_alloc &&
                 (current_bucket->used + aligned_delta) <= block_size &&
                 !AllocateSeparately(aligned_new_size)) {
             current_bucket->used += aligned_delta;
 
-            if ((flags & (int)Allocator::Flag::Zero) && new_size > old_size) {
-                memset_safe(ptr + old_size, 0, new_size - old_size);
+            if ((flags & (int)AllocFlag::Zero) && new_size > old_size) {
+                memset_safe((uint8_t *)ptr + old_size, 0, new_size - old_size);
             }
         } else if (AllocateSeparately(aligned_old_size)) {
             LinkedAllocator *alloc = GetAllocator();
-            ptr = ResizeMemory(alloc, ptr, old_size, new_size, flags).ptr;
+            ptr = ResizeRaw(alloc, ptr, old_size, new_size, flags);
         } else {
-            void *new_ptr = Allocate(new_size, flags & ~(int)Allocator::Flag::Zero);
+            void *new_ptr = Allocate(new_size, flags & ~(int)AllocFlag::Zero);
             if (new_size > old_size) {
-                memcpy_safe(new_ptr, *ptr, old_size);
+                memcpy_safe(new_ptr, ptr, old_size);
 
-                if (flags & (int)Allocator::Flag::Zero) {
-                    memset_safe(ptr + old_size, 0, new_size - old_size);
+                if (flags & (int)AllocFlag::Zero) {
+                    memset_safe((uint8_t *)ptr + old_size, 0, new_size - old_size);
                 }
             } else {
-                memcpy_safe(new_ptr, *ptr, new_size);
+                memcpy_safe(new_ptr, ptr, new_size);
             }
 
-            *ptr = new_ptr;
+            ptr = new_ptr;
         }
     }
+
+    return ptr;
 }
 
-void BlockAllocatorBase::Release(void *ptr, Size size)
+void BlockAllocatorBase::Release(const void *ptr, Size size)
 {
     RG_ASSERT(size >= 0);
 
@@ -377,13 +370,15 @@ void BlockAllocatorBase::Release(void *ptr, Size size)
 
         if (ptr == last_alloc) {
             current_bucket->used -= aligned_size;
+
             if (!current_bucket->used) {
-                ReleaseMemory(alloc, current_bucket, RG_SIZE(Bucket) + block_size);
+                ReleaseRaw(alloc, current_bucket, RG_SIZE(Bucket) + block_size);
                 current_bucket = nullptr;
             }
+
             last_alloc = nullptr;
         } else if (AllocateSeparately(aligned_size)) {
-            ReleaseMemory(alloc, ptr, size);
+            ReleaseRaw(alloc, ptr, size);
         }
     }
 }
@@ -425,6 +420,7 @@ IndirectBlockAllocator& IndirectBlockAllocator::operator=(IndirectBlockAllocator
 
 void IndirectBlockAllocator::ReleaseAll()
 {
+    ForgetCurrentBlock();
     allocator->ReleaseAll();
 }
 
@@ -692,7 +688,7 @@ TimeSpec DecomposeTime(int64_t time, TimeMode mode)
     switch (mode) {
         case TimeMode::Local: {
             localtime_r(&time64, &ti);
-            offset = ti.tm_gmtoff + ti.tm_isdst * 3600;
+            offset = ti.tm_gmtoff;
         } break;
 
         case TimeMode::UTC: {
@@ -762,7 +758,7 @@ bool CopyString(Span<const char> str, Span<char> buf)
 
 Span<char> DuplicateString(Span<const char> str, Allocator *alloc)
 {
-    char *new_str = AllocateMemory<char>(alloc, str.len + 1).ptr;
+    char *new_str = (char *)AllocateRaw(alloc, str.len + 1);
     memcpy_safe(new_str, str.ptr, (size_t)str.len);
     new_str[str.len] = 0;
     return MakeSpan(new_str, str.len);
@@ -830,7 +826,7 @@ static Span<char> FormatUnsignedToDecimal(uint64_t value, char out_buf[32])
     return MakeSpan(out_buf + offset, 32 - offset);
 }
 
-static Span<char> FormatUnsignedToHex(uint64_t value, char out_buf[32])
+static Span<char> FormatUnsignedToBigHex(uint64_t value, char out_buf[32])
 {
     static const char literals[] = "0123456789ABCDEF";
 
@@ -844,6 +840,20 @@ static Span<char> FormatUnsignedToHex(uint64_t value, char out_buf[32])
     return MakeSpan(out_buf + offset, 32 - offset);
 }
 
+static Span<char> FormatUnsignedToSmallHex(uint64_t value, char out_buf[32])
+{
+    static const char literals[] = "0123456789abcdef";
+
+    Size offset = 32;
+    do {
+        uint64_t digit = value & 0xF;
+        value >>= 4;
+        out_buf[--offset] = literals[digit];
+    } while (value);
+
+    return MakeSpan(out_buf + offset, 32 - offset);
+}
+
 static Span<char> FormatUnsignedToBinary(uint64_t value, char out_buf[64])
 {
     Size msb = 64 - (Size)CountLeadingZeros(value);
@@ -1135,8 +1145,11 @@ static inline void ProcessArg(const FmtArg &arg, AppendFunc append)
             case FmtType::Binary: {
                 out = FormatUnsignedToBinary(arg.u.u, num_buf);
             } break;
-            case FmtType::Hexadecimal: {
-                out = FormatUnsignedToHex(arg.u.u, num_buf);
+            case FmtType::BigHex: {
+                out = FormatUnsignedToBigHex(arg.u.u, num_buf);
+            } break;
+            case FmtType::SmallHex: {
+                out = FormatUnsignedToSmallHex(arg.u.u, num_buf);
             } break;
 
             case FmtType::MemorySize: {
@@ -1246,42 +1259,69 @@ static inline void ProcessArg(const FmtArg &arg, AppendFunc append)
             } break;
 
             case FmtType::TimeISO: {
-                if (arg.u.time.offset) {
-                    int offset_h = arg.u.time.offset / 60;
-                    int offset_m = arg.u.time.offset % 60;
+                const TimeSpec &spec = arg.u.time.spec;
+
+                if (spec.offset && arg.u.time.ms) {
+                    int offset_h = spec.offset / 60;
+                    int offset_m = spec.offset % 60;
 
                     out_buf.len = Fmt(out_buf.data, "%1%2%3T%4%5%6.%7%8%9%10",
-                                      FmtArg(arg.u.time.year).Pad0(-2), FmtArg(arg.u.time.month).Pad0(-2),
-                                      FmtArg(arg.u.time.day).Pad0(-2), FmtArg(arg.u.time.hour).Pad0(-2),
-                                      FmtArg(arg.u.time.min).Pad0(-2), FmtArg(arg.u.time.sec).Pad0(-2), FmtArg(arg.u.time.msec).Pad0(-3),
+                                      FmtArg(spec.year).Pad0(-2), FmtArg(spec.month).Pad0(-2),
+                                      FmtArg(spec.day).Pad0(-2), FmtArg(spec.hour).Pad0(-2),
+                                      FmtArg(spec.min).Pad0(-2), FmtArg(spec.sec).Pad0(-2), FmtArg(spec.msec).Pad0(-3),
                                       offset_h >= 0 ? "+" : "", FmtArg(offset_h).Pad0(-2), FmtArg(offset_m).Pad0(-2)).len;
-                } else {
+                } else if (spec.offset) {
+                    int offset_h = spec.offset / 60;
+                    int offset_m = spec.offset % 60;
+
+                    out_buf.len = Fmt(out_buf.data, "%1%2%3T%4%5%6%7%8%9",
+                                      FmtArg(spec.year).Pad0(-2), FmtArg(spec.month).Pad0(-2),
+                                      FmtArg(spec.day).Pad0(-2), FmtArg(spec.hour).Pad0(-2),
+                                      FmtArg(spec.min).Pad0(-2), FmtArg(spec.sec).Pad0(-2),
+                                      offset_h >= 0 ? "+" : "", FmtArg(offset_h).Pad0(-2), FmtArg(offset_m).Pad0(-2)).len;
+                } else if (arg.u.time.ms) {
                     out_buf.len = Fmt(out_buf.data, "%1%2%3T%4%5%6.%7Z",
-                                      FmtArg(arg.u.time.year).Pad0(-2), FmtArg(arg.u.time.month).Pad0(-2),
-                                      FmtArg(arg.u.time.day).Pad0(-2), FmtArg(arg.u.time.hour).Pad0(-2),
-                                      FmtArg(arg.u.time.min).Pad0(-2), FmtArg(arg.u.time.sec).Pad0(-2), FmtArg(arg.u.time.msec).Pad0(-3)).len;
+                                      FmtArg(spec.year).Pad0(-2), FmtArg(spec.month).Pad0(-2),
+                                      FmtArg(spec.day).Pad0(-2), FmtArg(spec.hour).Pad0(-2),
+                                      FmtArg(spec.min).Pad0(-2), FmtArg(spec.sec).Pad0(-2), FmtArg(spec.msec).Pad0(-3)).len;
+                } else {
+                    out_buf.len = Fmt(out_buf.data, "%1%2%3T%4%5%6Z",
+                                      FmtArg(spec.year).Pad0(-2), FmtArg(spec.month).Pad0(-2),
+                                      FmtArg(spec.day).Pad0(-2), FmtArg(spec.hour).Pad0(-2),
+                                      FmtArg(spec.min).Pad0(-2), FmtArg(spec.sec).Pad0(-2)).len;
                 }
                 out = out_buf;
             } break;
             case FmtType::TimeNice: {
-                int offset_h = arg.u.time.offset / 60;
-                int offset_m = arg.u.time.offset % 60;
-
-                out_buf.len = Fmt(out_buf.data, "%1-%2-%3 %4:%5:%6.%7 %8%9%10",
-                                  FmtArg(arg.u.time.year).Pad0(-2), FmtArg(arg.u.time.month).Pad0(-2),
-                                  FmtArg(arg.u.time.day).Pad0(-2), FmtArg(arg.u.time.hour).Pad0(-2),
-                                  FmtArg(arg.u.time.min).Pad0(-2), FmtArg(arg.u.time.sec).Pad0(-2), FmtArg(arg.u.time.msec).Pad0(-3),
-                                  offset_h >= 0 ? "+" : "", FmtArg(offset_h).Pad0(-2), FmtArg(offset_m).Pad0(-2)).len;
+                const TimeSpec &spec = arg.u.time.spec;
+
+                int offset_h = spec.offset / 60;
+                int offset_m = spec.offset % 60;
+
+                if (arg.u.time.ms) {
+                    out_buf.len = Fmt(out_buf.data, "%1-%2-%3 %4:%5:%6.%7 %8%9%10",
+                                      FmtArg(spec.year).Pad0(-2), FmtArg(spec.month).Pad0(-2),
+                                      FmtArg(spec.day).Pad0(-2), FmtArg(spec.hour).Pad0(-2),
+                                      FmtArg(spec.min).Pad0(-2), FmtArg(spec.sec).Pad0(-2), FmtArg(spec.msec).Pad0(-3),
+                                      offset_h >= 0 ? "+" : "", FmtArg(offset_h).Pad0(-2), FmtArg(offset_m).Pad0(-2)).len;
+                } else {
+                    out_buf.len = Fmt(out_buf.data, "%1-%2-%3 %4:%5:%6 %7%8%9",
+                                      FmtArg(spec.year).Pad0(-2), FmtArg(spec.month).Pad0(-2),
+                                      FmtArg(spec.day).Pad0(-2), FmtArg(spec.hour).Pad0(-2),
+                                      FmtArg(spec.min).Pad0(-2), FmtArg(spec.sec).Pad0(-2),
+                                      offset_h >= 0 ? "+" : "", FmtArg(offset_h).Pad0(-2), FmtArg(offset_m).Pad0(-2)).len;
+                }
                 out = out_buf;
             } break;
 
             case FmtType::Random: {
-                RG_ASSERT(arg.u.random_len <= RG_SIZE(out_buf.data));
+                static const char *const DefaultChars = "abcdefghijklmnopqrstuvwxyz0123456789";
+                Span<const char> chars = arg.u.random.chars ? arg.u.random.chars : DefaultChars;
 
-                for (Size j = 0; j < arg.u.random_len; j++) {
-                    static const char *chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+                RG_ASSERT(arg.u.random.len <= RG_SIZE(out_buf.data));
 
-                    int rnd = GetRandomIntSafe(0, (int)strlen(chars));
+                for (Size j = 0; j < arg.u.random.len; j++) {
+                    int rnd = GetRandomIntSafe(0, (int)chars.len);
                     out_buf.Append(chars[rnd]);
                 }
 
@@ -1335,7 +1375,8 @@ static inline void ProcessArg(const FmtArg &arg, AppendFunc append)
                         case FmtType::Integer:
                         case FmtType::Unsigned:
                         case FmtType::Binary:
-                        case FmtType::Hexadecimal: {
+                        case FmtType::BigHex:
+                        case FmtType::SmallHex: {
                             switch (arg.u.span.type_len) {
                                 case 8: { arg2.u.u = *(const uint64_t *)ptr; } break;
                                 case 4: { arg2.u.u = *(const uint32_t *)ptr; } break;
@@ -1358,7 +1399,7 @@ static inline void ProcessArg(const FmtArg &arg, AppendFunc append)
                         case FmtType::DiskSize: { arg2.u.i = *(const int64_t *)ptr; } break;
                         case FmtType::Date: { arg2.u.date = *(const LocalDate *)ptr; } break;
                         case FmtType::TimeISO:
-                        case FmtType::TimeNice: { arg2.u.time = *(const TimeSpec *)ptr; } break;
+                        case FmtType::TimeNice: { arg2.u.time = *(decltype(FmtArg::u.time) *)ptr; } break;
                         case FmtType::Random: { RG_UNREACHABLE(); } break;
                         case FmtType::FlagNames: { RG_UNREACHABLE(); } break;
                         case FmtType::FlagOptions: { RG_UNREACHABLE(); } break;
@@ -1677,6 +1718,20 @@ void PrintLnFmt(const char *fmt, Span<const FmtArg> args, FILE *fp)
     fputc('\n', fp);
 }
 
+// PrintLn variants without format strings
+void PrintLn(StreamWriter *out_st)
+{
+    out_st->Write('\n');
+}
+void PrintLn(FILE *out_fp)
+{
+    fputc('\n', out_fp);
+}
+void PrintLn()
+{
+    putchar('\n');
+}
+
 // ------------------------------------------------------------------------
 // Debug and errors
 // ------------------------------------------------------------------------
@@ -2027,7 +2082,7 @@ static FileType FileAttributesToType(uint32_t attr)
     }
 }
 
-bool StatFile(const char *filename, unsigned int flags, FileInfo *out_info)
+StatResult StatFile(const char *filename, unsigned int flags, FileInfo *out_info)
 {
     // We don't detect symbolic links, but since they are much less of a hazard
     // than on POSIX systems we care a lot less about them.
@@ -2039,40 +2094,54 @@ bool StatFile(const char *filename, unsigned int flags, FileInfo *out_info)
     } else {
         wchar_t filename_w[4096];
         if (ConvertUtf8ToWin32Wide(filename, filename_w) < 0)
-            return false;
+            return StatResult::OtherError;
 
         h = CreateFileW(filename_w, 0, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                         nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr);
     }
     if (h == INVALID_HANDLE_VALUE) {
         DWORD err = GetLastError();
-        if (!(flags & (int)StatFlag::IgnoreMissing) ||
-                (err != ERROR_FILE_NOT_FOUND && err != ERROR_PATH_NOT_FOUND)) {
-            LogError("Cannot stat file '%1': %2", filename, GetWin32ErrorString(err));
+
+        switch (err) {
+            case ERROR_FILE_NOT_FOUND:
+            case ERROR_PATH_NOT_FOUND: {
+                if (!(flags & (int)StatFlag::IgnoreMissing)) {
+                    LogError("Cannot stat file '%1': %2", filename, GetWin32ErrorString(err));
+                }
+                return StatResult::MissingPath;
+            } break;
+            case ERROR_ACCESS_DENIED: {
+                LogError("Cannot stat file '%1': %2", filename, GetWin32ErrorString(err));
+                return StatResult::AccessDenied;
+            }
+            default: {
+                LogError("Cannot stat file '%1': %2", filename, GetWin32ErrorString(err));
+                return StatResult::OtherError;
+            } break;
         }
-        return false;
     }
     RG_DEFER { CloseHandle(h); };
 
     BY_HANDLE_FILE_INFORMATION attr;
     if (!GetFileInformationByHandle(h, &attr)) {
         LogError("Cannot stat file '%1': %2", filename, GetWin32ErrorString());
-        return false;
+        return StatResult::OtherError;
     }
 
     out_info->type = FileAttributesToType(attr.dwFileAttributes);
     out_info->size = ((uint64_t)attr.nFileSizeHigh << 32) | attr.nFileSizeLow;
     out_info->mtime = FileTimeToUnixTime(attr.ftLastWriteTime);
+    out_info->mode = (out_info->type == FileType::Directory) ? 0755 : 0644;
 
-    return true;
+    return StatResult::Success;
 }
 
-bool RenameFile(const char *src_filename, const char *dest_filename, bool overwrite, bool)
+bool RenameFile(const char *src_filename, const char *dest_filename, unsigned int flags)
 {
-    DWORD flags = overwrite ? MOVEFILE_REPLACE_EXISTING : 0;
+    DWORD move_flags = (flags & (int)RenameFlag::Overwrite) ? MOVEFILE_REPLACE_EXISTING : 0;
 
     if (win32_utf8) {
-        if (!MoveFileExA(src_filename, dest_filename, flags))
+        if (!MoveFileExA(src_filename, dest_filename, move_flags))
             goto error;
     } else {
         wchar_t src_filename_w[4096];
@@ -2082,7 +2151,7 @@ bool RenameFile(const char *src_filename, const char *dest_filename, bool overwr
         if (ConvertUtf8ToWin32Wide(dest_filename, dest_filename_w) < 0)
             return false;
 
-        if (!MoveFileExW(src_filename_w, dest_filename_w, flags))
+        if (!MoveFileExW(src_filename_w, dest_filename_w, move_flags))
             goto error;
     }
 
@@ -2093,7 +2162,7 @@ error:
     return false;
 }
 
-EnumStatus EnumerateDirectory(const char *dirname, const char *filter, Size max_files,
+EnumResult EnumerateDirectory(const char *dirname, const char *filter, Size max_files,
                               FunctionRef<bool(const char *, FileType)> func)
 {
     if (filter) {
@@ -2107,18 +2176,20 @@ EnumStatus EnumerateDirectory(const char *dirname, const char *filter, Size max_
         char find_filter[4096];
         if (snprintf(find_filter, RG_SIZE(find_filter), "%s\\%s", dirname, filter) >= RG_SIZE(find_filter)) {
             LogError("Cannot enumerate directory '%1': Path too long", dirname);
-            return EnumStatus::Error;
+            return EnumResult::OtherError;
         }
 
         if (ConvertUtf8ToWin32Wide(find_filter, find_filter_w) < 0)
-            return EnumStatus::Error;
+            return EnumResult::OtherError;
     }
 
     WIN32_FIND_DATAW find_data;
     HANDLE handle = FindFirstFileExW(find_filter_w, FindExInfoBasic, &find_data,
                                      FindExSearchNameMatch, nullptr, FIND_FIRST_EX_LARGE_FETCH);
     if (handle == INVALID_HANDLE_VALUE) {
-        if (GetLastError() == ERROR_FILE_NOT_FOUND) {
+        DWORD err = GetLastError();
+
+        if (err == ERROR_FILE_NOT_FOUND) {
             // Erase the filter part from the buffer, we are about to exit anyway.
             // And no, I don't want to include wchar.h
             Size len = 0;
@@ -2128,12 +2199,17 @@ EnumStatus EnumerateDirectory(const char *dirname, const char *filter, Size max_
 
             DWORD attrib = GetFileAttributesW(find_filter_w);
             if (attrib != INVALID_FILE_ATTRIBUTES && (attrib & FILE_ATTRIBUTE_DIRECTORY))
-                return EnumStatus::Complete;
+                return EnumResult::Success;
         }
 
-        LogError("Cannot enumerate directory '%1': %2", dirname,
-                 GetWin32ErrorString());
-        return EnumStatus::Error;
+        LogError("Cannot enumerate directory '%1': %2", dirname, GetWin32ErrorString());
+
+        switch (err) {
+            case ERROR_FILE_NOT_FOUND:
+            case ERROR_PATH_NOT_FOUND: return EnumResult::MissingPath;
+            case ERROR_ACCESS_DENIED: return EnumResult::AccessDenied;
+            default: return EnumResult::OtherError;
+        }
     }
     RG_DEFER { FindClose(handle); };
 
@@ -2145,26 +2221,26 @@ EnumStatus EnumerateDirectory(const char *dirname, const char *filter, Size max_
 
         if (RG_UNLIKELY(count++ >= max_files && max_files >= 0)) {
             LogError("Partial enumation of directory '%1'", dirname);
-            return EnumStatus::Partial;
+            return EnumResult::PartialEnum;
         }
 
         char filename[512];
         if (ConvertWin32WideToUtf8(find_data.cFileName, filename) < 0)
-            return EnumStatus::Error;
+            return EnumResult::OtherError;
 
         FileType file_type = FileAttributesToType(find_data.dwFileAttributes);
 
         if (!func(filename, file_type))
-            return EnumStatus::Stopped;
+            return EnumResult::CallbackFail;
     } while (FindNextFileW(handle, &find_data));
 
     if (GetLastError() != ERROR_NO_MORE_FILES) {
         LogError("Error while enumerating directory '%1': %2", dirname,
                  GetWin32ErrorString());
-        return EnumStatus::Error;
+        return EnumResult::OtherError;
     }
 
-    return EnumStatus::Complete;
+    return EnumResult::Success;
 }
 
 #else
@@ -2203,16 +2279,28 @@ static FileType FileModeToType(mode_t mode)
     }
 }
 
-bool StatFile(const char *filename, unsigned int flags, FileInfo *out_info)
+StatResult StatFile(const char *filename, unsigned int flags, FileInfo *out_info)
 {
     int stat_flags = (flags & (int)StatFlag::FollowSymlink) ? 0 : AT_SYMLINK_NOFOLLOW;
 
     struct stat sb;
     if (fstatat(AT_FDCWD, filename, &sb, stat_flags) < 0) {
-        if (!(flags & (int)StatFlag::IgnoreMissing) || errno != ENOENT) {
-            LogError("Cannot stat '%1': %2", filename, strerror(errno));
+        switch (errno) {
+            case ENOENT: {
+                if (!(flags & (int)StatFlag::IgnoreMissing)) {
+                    LogError("Cannot stat '%1': %2", filename, strerror(errno));
+                }
+                return StatResult::MissingPath;
+            } break;
+            case EACCES: {
+                LogError("Cannot stat '%1': %2", filename, strerror(errno));
+                return StatResult::AccessDenied;
+            } break;
+            default: {
+                LogError("Cannot stat '%1': %2", filename, strerror(errno));
+                return StatResult::OtherError;
+            } break;
         }
-        return false;
     }
 
     out_info->type = FileModeToType(sb.st_mode);
@@ -2226,8 +2314,9 @@ bool StatFile(const char *filename, unsigned int flags, FileInfo *out_info)
 #else
     out_info->mtime = (int64_t)sb.st_mtime * 1000;
 #endif
+    out_info->mode = (unsigned int)sb.st_mode;
 
-    return true;
+    return StatResult::Success;
 }
 
 static bool SyncFileDirectory(const char *filename)
@@ -2257,10 +2346,10 @@ static bool SyncFileDirectory(const char *filename)
     return true;
 }
 
-bool RenameFile(const char *src_filename, const char *dest_filename, bool overwrite, bool sync)
+bool RenameFile(const char *src_filename, const char *dest_filename, unsigned int flags)
 {
     int fd = -1;
-    if (!overwrite) {
+    if (!(flags & (int)RenameFlag::Overwrite)) {
         fd = open(dest_filename, O_CREAT | O_EXCL, 0644);
         if (fd < 0) {
             if (errno == EEXIST) {
@@ -2281,7 +2370,7 @@ bool RenameFile(const char *src_filename, const char *dest_filename, bool overwr
 
     // Not much we can do if fsync fails (I think), so ignore errors.
     // Hope for the best: that's the spirit behind the POSIX filesystem API (...).
-    if (sync) {
+    if (flags & (int)RenameFlag::Sync) {
         SyncFileDirectory(src_filename);
         SyncFileDirectory(dest_filename);
     }
@@ -2289,13 +2378,18 @@ bool RenameFile(const char *src_filename, const char *dest_filename, bool overwr
     return true;
 }
 
-EnumStatus EnumerateDirectory(const char *dirname, const char *filter, Size max_files,
+EnumResult EnumerateDirectory(const char *dirname, const char *filter, Size max_files,
                               FunctionRef<bool(const char *, FileType)> func)
 {
     DIR *dirp = RG_POSIX_RESTART_EINTR(opendir(dirname), == nullptr);
     if (!dirp) {
         LogError("Cannot enumerate directory '%1': %2", dirname, strerror(errno));
-        return EnumStatus::Error;
+
+        switch (errno) {
+            case ENOENT: return EnumResult::MissingPath;
+            case EACCES: return EnumResult::AccessDenied;
+            default: return EnumResult::OtherError;
+        }
     }
     RG_DEFER { closedir(dirp); };
 
@@ -2312,7 +2406,7 @@ EnumStatus EnumerateDirectory(const char *dirname, const char *filter, Size max_
         if (!filter || !fnmatch(filter, dent->d_name, FNM_PERIOD)) {
             if (RG_UNLIKELY(count++ >= max_files && max_files >= 0)) {
                 LogError("Partial enumation of directory '%1'", dirname);
-                return EnumStatus::Partial;
+                return EnumResult::PartialEnum;
             }
 
             FileType file_type;
@@ -2345,7 +2439,7 @@ EnumStatus EnumerateDirectory(const char *dirname, const char *filter, Size max_
             }
 
             if (!func(dent->d_name, file_type))
-                return EnumStatus::Stopped;
+                return EnumResult::CallbackFail;
         }
 
         errno = 0;
@@ -2353,10 +2447,10 @@ EnumStatus EnumerateDirectory(const char *dirname, const char *filter, Size max_
 
     if (errno) {
         LogError("Error while enumerating directory '%1': %2", dirname, strerror(errno));
-        return EnumStatus::Error;
+        return EnumResult::OtherError;
     }
 
-    return EnumStatus::Complete;
+    return EnumResult::Success;
 }
 
 #endif
@@ -2366,8 +2460,8 @@ bool EnumerateFiles(const char *dirname, const char *filter, Size max_depth, Siz
 {
     RG_DEFER_NC(out_guard, len = out_files->len) { out_files->RemoveFrom(len); };
 
-    EnumStatus status = EnumerateDirectory(dirname, nullptr, max_files,
-                                           [&](const char *basename, FileType file_type) {
+    EnumResult ret = EnumerateDirectory(dirname, nullptr, max_files,
+                                        [&](const char *basename, FileType file_type) {
         switch (file_type) {
             case FileType::Directory: {
                 if (max_depth) {
@@ -2392,7 +2486,7 @@ bool EnumerateFiles(const char *dirname, const char *filter, Size max_depth, Siz
 
         return true;
     });
-    if (status == EnumStatus::Error)
+    if (ret != EnumResult::Success && ret != EnumResult::PartialEnum)
         return false;
 
     out_guard.Disable();
@@ -2401,14 +2495,19 @@ bool EnumerateFiles(const char *dirname, const char *filter, Size max_depth, Siz
 
 bool IsDirectoryEmpty(const char *dirname)
 {
-    EnumStatus status = EnumerateDirectory(dirname, nullptr, -1, [](const char *, FileType) { return false; });
-    return status == EnumStatus::Complete;
+    EnumResult ret = EnumerateDirectory(dirname, nullptr, -1, [](const char *, FileType) { return false; });
+
+    bool empty = (ret == EnumResult::Success);
+    return empty;
 }
 
 bool TestFile(const char *filename)
 {
     FileInfo file_info;
-    return StatFile(filename, (int)StatFlag::IgnoreMissing, &file_info);
+    StatResult ret = StatFile(filename, (int)StatFlag::IgnoreMissing, &file_info);
+
+    bool exists = (ret == StatResult::Success);
+    return exists;
 }
 
 bool TestFile(const char *filename, FileType type)
@@ -2416,7 +2515,7 @@ bool TestFile(const char *filename, FileType type)
     RG_ASSERT(type != FileType::Link);
 
     FileInfo file_info;
-    if (!StatFile(filename, (int)StatFlag::IgnoreMissing, &file_info))
+    if (StatFile(filename, (int)StatFlag::IgnoreMissing, &file_info) != StatResult::Success)
         return false;
 
     // Don't follow, but don't warn if we just wanted a file
@@ -2771,7 +2870,7 @@ const char *GetApplicationExecutable()
             RG_ASSERT(strlen(path) < RG_SIZE(executable_path));
 
             CopyString(path, executable_path);
-            ReleaseMemory(nullptr, (void *)path, -1);
+            ReleaseRaw(nullptr, (void *)path, -1);
         }
     }
 
@@ -2963,47 +3062,49 @@ static bool CheckForDumbTerm()
 
 #ifdef _WIN32
 
-int OpenDescriptor(const char *filename, unsigned int flags)
+OpenResult OpenDescriptor(const char *filename, unsigned int flags, unsigned int silent, int *out_fd)
 {
+    RG_ASSERT(!(silent & ((int)OpenResult::Success | (int)OpenResult::OtherError)));
+
     DWORD access = 0;
     DWORD share = 0;
     DWORD creation = 0;
     int oflags = -1;
-    switch (flags & ((int)OpenFileFlag::Read |
-                     (int)OpenFileFlag::Write |
-                     (int)OpenFileFlag::Append)) {
-        case (int)OpenFileFlag::Read: {
+    switch (flags & ((int)OpenFlag::Read |
+                     (int)OpenFlag::Write |
+                     (int)OpenFlag::Append)) {
+        case (int)OpenFlag::Read: {
             access = GENERIC_READ;
             share = FILE_SHARE_READ | FILE_SHARE_WRITE;
             creation = OPEN_EXISTING;
 
             oflags = _O_RDONLY | _O_BINARY | _O_NOINHERIT;
         } break;
-        case (int)OpenFileFlag::Write: {
+        case (int)OpenFlag::Write: {
             access = GENERIC_WRITE;
             share = FILE_SHARE_READ | FILE_SHARE_WRITE;
-            creation = (flags & (int)OpenFileFlag::Exclusive) ? CREATE_NEW : CREATE_ALWAYS;
+            creation = (flags & (int)OpenFlag::Exclusive) ? CREATE_NEW : CREATE_ALWAYS;
 
             oflags = _O_WRONLY | _O_CREAT | _O_TRUNC | _O_BINARY | _O_NOINHERIT;
         } break;
-        case (int)OpenFileFlag::Read | (int)OpenFileFlag::Write: {
+        case (int)OpenFlag::Read | (int)OpenFlag::Write: {
             access = GENERIC_READ | GENERIC_WRITE;
             share = FILE_SHARE_READ | FILE_SHARE_WRITE;
-            creation = (flags & (int)OpenFileFlag::Exclusive) ? CREATE_NEW : CREATE_ALWAYS;
+            creation = (flags & (int)OpenFlag::Exclusive) ? CREATE_NEW : CREATE_ALWAYS;
 
             oflags = _O_RDWR | _O_CREAT | _O_TRUNC | _O_BINARY | _O_NOINHERIT;
         } break;
-        case (int)OpenFileFlag::Append: {
+        case (int)OpenFlag::Append: {
             access = GENERIC_WRITE;
             share = FILE_SHARE_READ | FILE_SHARE_WRITE;
-            creation = (flags & (int)OpenFileFlag::Exclusive) ? CREATE_NEW : CREATE_ALWAYS;
+            creation = (flags & (int)OpenFlag::Exclusive) ? CREATE_NEW : CREATE_ALWAYS;
 
             oflags = _O_WRONLY | _O_CREAT | _O_APPEND | _O_BINARY | _O_NOINHERIT;
         } break;
     }
     RG_ASSERT(oflags >= 0);
 
-    if (flags & (int)OpenFileFlag::Exclusive) {
+    if (flags & (int)OpenFlag::Exclusive) {
         oflags |= (int)_O_EXCL;
     }
     share |= FILE_SHARE_DELETE;
@@ -3014,20 +3115,26 @@ int OpenDescriptor(const char *filename, unsigned int flags)
     } else {
         wchar_t filename_w[4096];
         if (ConvertUtf8ToWin32Wide(filename, filename_w) < 0)
-            return -1;
+            return OpenResult::OtherError;
 
         h = CreateFileW(filename_w, access, share, nullptr, creation, FILE_ATTRIBUTE_NORMAL, nullptr);
     }
     if (h == INVALID_HANDLE_VALUE) {
         DWORD err = GetLastError();
 
-        if (err == ERROR_FILE_EXISTS) {
-            LogError("File '%1' already exists", filename);
-        } else {
-            LogError("Cannot open '%1': %2", filename, GetWin32ErrorString(err));
+        OpenResult ret;
+        switch (err) {
+            case ERROR_FILE_NOT_FOUND:
+            case ERROR_PATH_NOT_FOUND: { ret = OpenResult::MissingPath; } break;
+            case ERROR_FILE_EXISTS: { ret = OpenResult::FileExists; } break;
+            case ERROR_ACCESS_DENIED: { ret = OpenResult::AccessDenied; } break;
+            default: { ret = OpenResult::OtherError; } break;
         }
 
-        return -1;
+        if (!(silent & (int)ret)) {
+            LogError("Cannot open '%1': %2", filename, GetWin32ErrorString(err));
+        }
+        return ret;
     }
 
     int fd = _open_osfhandle((intptr_t)h, oflags);
@@ -3035,22 +3142,23 @@ int OpenDescriptor(const char *filename, unsigned int flags)
         LogError("Cannot open '%1': %2", filename, strerror(errno));
         CloseHandle(h);
 
-        return -1;
+        return OpenResult::OtherError;
     }
 
-    return fd;
+    *out_fd = fd;
+    return OpenResult::Success;
 }
 
-FILE *OpenFile(const char *filename, unsigned int flags)
+OpenResult OpenFile(const char *filename, unsigned int flags, unsigned int silent, FILE **out_fp)
 {
     char mode[16] = {};
-    switch (flags & ((int)OpenFileFlag::Read |
-                     (int)OpenFileFlag::Write |
-                     (int)OpenFileFlag::Append)) {
-        case (int)OpenFileFlag::Read: { CopyString("rbc", mode); } break;
-        case (int)OpenFileFlag::Write: { CopyString("wbc", mode); } break;
-        case (int)OpenFileFlag::Read | (int)OpenFileFlag::Write: { CopyString("w+bc", mode); } break;
-        case (int)OpenFileFlag::Append: { CopyString("abc", mode); } break;
+    switch (flags & ((int)OpenFlag::Read |
+                     (int)OpenFlag::Write |
+                     (int)OpenFlag::Append)) {
+        case (int)OpenFlag::Read: { CopyString("rbc", mode); } break;
+        case (int)OpenFlag::Write: { CopyString("wbc", mode); } break;
+        case (int)OpenFlag::Read | (int)OpenFlag::Write: { CopyString("w+bc", mode); } break;
+        case (int)OpenFlag::Append: { CopyString("abc", mode); } break;
     }
     RG_ASSERT(mode[0]);
 
@@ -3059,17 +3167,35 @@ FILE *OpenFile(const char *filename, unsigned int flags)
     strcat(mode, "N");
 #endif
 
-    int fd = OpenDescriptor(filename, flags);
-    if (fd < 0)
-        return nullptr;
+    int fd = -1;
+    OpenResult ret = OpenDescriptor(filename, flags, silent, &fd);
+    if (ret != OpenResult::Success)
+        return ret;
 
     FILE *fp = _fdopen(fd, mode);
     if (!fp) {
         LogError("Cannot open '%1': %2", filename, strerror(errno));
         _close(fd);
+
+        return OpenResult::OtherError;
+    }
+
+    *out_fp = fp;
+    return OpenResult::Success;
+}
+
+bool FlushFile(int fd, const char *filename)
+{
+    RG_ASSERT(filename);
+
+    HANDLE h = (HANDLE)_get_osfhandle(fd);
+
+    if (!FlushFileBuffers(h)) {
+        LogError("Failed to sync '%1': %2", filename, GetWin32ErrorString());
+        return false;
     }
 
-    return fp;
+    return true;
 }
 
 bool FlushFile(FILE *fp, const char *filename)
@@ -3269,60 +3395,89 @@ error:
 
 #else
 
-int OpenDescriptor(const char *filename, unsigned int flags)
+OpenResult OpenDescriptor(const char *filename, unsigned int flags, unsigned int silent, int *out_fd)
 {
+    RG_ASSERT(!(silent & ((int)OpenResult::Success | (int)OpenResult::OtherError)));
+
     int oflags = -1;
-    switch (flags & ((int)OpenFileFlag::Read |
-                     (int)OpenFileFlag::Write |
-                     (int)OpenFileFlag::Append)) {
-        case (int)OpenFileFlag::Read: { oflags = O_RDONLY | O_CLOEXEC; } break;
-        case (int)OpenFileFlag::Write: { oflags = O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC; } break;
-        case (int)OpenFileFlag::Read | (int)OpenFileFlag::Write: { oflags = O_RDWR | O_CREAT | O_TRUNC | O_CLOEXEC; } break;
-        case (int)OpenFileFlag::Append: { oflags = O_WRONLY | O_CREAT | O_APPEND | O_CLOEXEC; } break;
+    switch (flags & ((int)OpenFlag::Read |
+                     (int)OpenFlag::Write |
+                     (int)OpenFlag::Append)) {
+        case (int)OpenFlag::Read: { oflags = O_RDONLY | O_CLOEXEC; } break;
+        case (int)OpenFlag::Write: { oflags = O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC; } break;
+        case (int)OpenFlag::Read | (int)OpenFlag::Write: { oflags = O_RDWR | O_CREAT | O_TRUNC | O_CLOEXEC; } break;
+        case (int)OpenFlag::Append: { oflags = O_WRONLY | O_CREAT | O_APPEND | O_CLOEXEC; } break;
     }
     RG_ASSERT(oflags >= 0);
 
-    if (flags & (int)OpenFileFlag::Exclusive) {
+    if (flags & (int)OpenFlag::Exclusive) {
         oflags |= O_EXCL;
     }
 
     int fd = RG_POSIX_RESTART_EINTR(open(filename, oflags, 0644), < 0);
     if (fd < 0) {
-        if (errno == EEXIST) {
-            LogError("File '%1' already exists", filename);
-        } else {
+        OpenResult ret;
+        switch (errno) {
+            case ENOENT: { ret = OpenResult::MissingPath; } break;
+            case EEXIST: { ret = OpenResult::FileExists; } break;
+            case EACCES: { ret = OpenResult::AccessDenied; } break;
+            default: { ret = OpenResult::OtherError; } break;
+        }
+
+        if (!(silent & (int)ret)) {
             LogError("Cannot open '%1': %2", filename, strerror(errno));
         }
-        return -1;
+        return ret;
     }
 
-    return fd;
+    *out_fd = fd;
+    return OpenResult::Success;
 }
 
-FILE *OpenFile(const char *filename, unsigned int flags)
+OpenResult OpenFile(const char *filename, unsigned int flags, unsigned int silent, FILE **out_fp)
 {
     const char *mode = nullptr;
-    switch (flags & ((int)OpenFileFlag::Read |
-                     (int)OpenFileFlag::Write |
-                     (int)OpenFileFlag::Append)) {
-        case (int)OpenFileFlag::Read: { mode = "rbe"; } break;
-        case (int)OpenFileFlag::Write: { mode = "wbe"; } break;
-        case (int)OpenFileFlag::Read | (int)OpenFileFlag::Write: { mode = "w+be"; } break;
-        case (int)OpenFileFlag::Append: { mode = "abe"; } break;
+    switch (flags & ((int)OpenFlag::Read |
+                     (int)OpenFlag::Write |
+                     (int)OpenFlag::Append)) {
+        case (int)OpenFlag::Read: { mode = "rbe"; } break;
+        case (int)OpenFlag::Write: { mode = "wbe"; } break;
+        case (int)OpenFlag::Read | (int)OpenFlag::Write: { mode = "w+be"; } break;
+        case (int)OpenFlag::Append: { mode = "abe"; } break;
     }
     RG_ASSERT(mode);
 
-    int fd = OpenDescriptor(filename, flags);
-    if (fd < 0)
-        return nullptr;
+    int fd = -1;
+    OpenResult ret = OpenDescriptor(filename, flags, silent, &fd);
+    if (ret != OpenResult::Success)
+        return ret;
 
     FILE *fp = fdopen(fd, mode);
     if (!fp) {
         LogError("Cannot open '%1': %2", filename, strerror(errno));
         close(fd);
+
+        return OpenResult::OtherError;
     }
 
-    return fp;
+    *out_fp = fp;
+    return OpenResult::Success;
+}
+
+bool FlushFile(int fd, const char *filename)
+{
+    RG_ASSERT(filename);
+
+#ifdef __APPLE__
+    if (fsync(fd) < 0 && errno != EINVAL && errno != ENOTSUP) {
+#else
+    if (fsync(fd) < 0 && errno != EINVAL) {
+#endif
+        LogError("Failed to sync '%1': %2", filename, strerror(errno));
+        return false;
+    }
+
+    return true;
 }
 
 bool FlushFile(FILE *fp, const char *filename)
@@ -3560,8 +3715,8 @@ bool ExecuteCommandLine(const char *cmd_line, FunctionRef<Span<const uint8_t>()>
     STARTUPINFOW si = {};
 
     // Convert command line
-    Span<wchar_t> cmd_line_w = AllocateMemory<wchar_t>(nullptr, 4 * strlen(cmd_line) + 2);
-    RG_DEFER { ReleaseMemory(nullptr, cmd_line_w.ptr, cmd_line_w.len); };
+    Span<wchar_t> cmd_line_w = AllocateSpan<wchar_t>(nullptr, 2 * strlen(cmd_line) + 1);
+    RG_DEFER { ReleaseSpan(nullptr, cmd_line_w); };
     if (ConvertUtf8ToWin32Wide(cmd_line, cmd_line_w) < 0)
         return false;
 
@@ -4008,7 +4163,7 @@ bool ExecuteCommandLine(const char *cmd_line, FunctionRef<Span<const uint8_t>()>
         }
 
         // Try to read
-        if (out_revents & (POLLHUP | POLLERR)) {
+        if (out_revents & POLLERR) {
             break;
         } else if (out_revents & POLLIN) {
             RG_ASSERT(out_func.IsValid());
@@ -4025,6 +4180,9 @@ bool ExecuteCommandLine(const char *cmd_line, FunctionRef<Span<const uint8_t>()>
                 LogError("Failed to read process output: %1", strerror(errno));
                 break;
             }
+        } else if (out_revents & POLLHUP) {
+            // Only deal with this once POLLIN goes down to avoid truncated output
+            break;
         }
 
         if (term_revents) {
@@ -4245,10 +4403,12 @@ int GetCoreCount()
         if (env) {
             char *end_ptr;
             long value = strtol(env, &end_ptr, 10);
+
             if (end_ptr > env && !end_ptr[0] && value > 0) {
                 cores = (int)value;
             } else {
                 LogError("OVERRIDE_CORES must be positive number (ignored)");
+                cores = (int)std::thread::hardware_concurrency();
             }
         } else {
             cores = (int)std::thread::hardware_concurrency();
@@ -4539,8 +4699,8 @@ const char *FindConfigFile(const char *name, Allocator *alloc, LocalArray<const
     return filename;
 }
 
-static const char *CreateTemporaryPath(Span<const char> directory, const char *prefix, const char *extension,
-                                       Allocator *alloc, FunctionRef<bool(const char *path)> create)
+static const char *CreateUniquePath(Span<const char> directory, const char *prefix, const char *extension,
+                                    Allocator *alloc, FunctionRef<bool(const char *path)> create)
 {
     RG_ASSERT(alloc);
 
@@ -4573,12 +4733,12 @@ static const char *CreateTemporaryPath(Span<const char> directory, const char *p
     return nullptr;
 }
 
-const char *CreateTemporaryFile(Span<const char> directory, const char *prefix, const char *extension,
-                                Allocator *alloc, FILE **out_fp)
+const char *CreateUniqueFile(Span<const char> directory, const char *prefix, const char *extension,
+                             Allocator *alloc, FILE **out_fp)
 {
-    return CreateTemporaryPath(directory, prefix, extension, alloc, [&](const char *path) {
-        int flags = (int)OpenFileFlag::Read | (int)OpenFileFlag::Write |
-                    (int)OpenFileFlag::Exclusive;
+    return CreateUniquePath(directory, prefix, extension, alloc, [&](const char *path) {
+        int flags = (int)OpenFlag::Read | (int)OpenFlag::Write |
+                    (int)OpenFlag::Exclusive;
 
         FILE *fp = OpenFile(path, flags);
 
@@ -4596,9 +4756,9 @@ const char *CreateTemporaryFile(Span<const char> directory, const char *prefix,
     });
 }
 
-const char *CreateTemporaryDirectory(Span<const char> directory, const char *prefix, Allocator *alloc)
+const char *CreateUniqueDirectory(Span<const char> directory, const char *prefix, Allocator *alloc)
 {
-    return CreateTemporaryPath(directory, prefix, "", alloc, [&](const char *path) {
+    return CreateUniquePath(directory, prefix, "", alloc, [&](const char *path) {
         return MakeDirectory(path);
     });
 }
@@ -5080,6 +5240,9 @@ class AsyncPool {
 public:
     AsyncPool(int threads, bool leak);
 
+    int GetWorkerCount() const { return (int)queues.len; }
+    int CountPendingTasks() const { return pending_tasks; }
+
     void RegisterAsync();
     void UnregisterAsync();
 
@@ -5124,9 +5287,18 @@ Async::Async(int threads, bool stop_after_error)
     pool->RegisterAsync();
 }
 
+Async::Async(Async *parent, bool stop_after_error)
+    : stop_after_error(stop_after_error)
+{
+    RG_ASSERT(parent);
+
+    pool = parent->pool;
+    pool->RegisterAsync();
+}
+
 Async::~Async()
 {
-    RG_ASSERT(!remaining_tasks);
+    Sync();
     pool->UnregisterAsync();
 }
 
@@ -5141,6 +5313,11 @@ bool Async::Sync()
     return success;
 }
 
+int Async::CountPendingTasks()
+{
+    return pool->CountPendingTasks();
+}
+
 bool Async::IsTaskRunning()
 {
     return async_running_task;
@@ -5151,6 +5328,11 @@ int Async::GetWorkerIdx()
     return async_running_worker_idx;
 }
 
+int Async::GetWorkerCount()
+{
+    return async_running_pool->GetWorkerCount();
+}
+
 AsyncPool::AsyncPool(int threads, bool leak)
 {
     if (threads > RG_ASYNC_MAX_THREADS) {
@@ -5444,7 +5626,7 @@ Fiber::~Fiber()
         fib_run = nullptr;
     }
 
-    ReleaseMemory(nullptr, ucp.uc_stack.ss_sp, (Size)ucp.uc_stack.ss_size);
+    ReleaseRaw(nullptr, ucp.uc_stack.ss_sp, (Size)ucp.uc_stack.ss_size);
 }
 
 void Fiber::SwitchTo()
@@ -5637,6 +5819,7 @@ bool StreamReader::Open(Span<const uint8_t> buf, const char *filename,
 
     RG_DEFER_N(err_guard) { error = true; };
     error = false;
+    raw_read = 0;
 
     this->filename = filename ? DuplicateString(filename, &str_alloc).ptr : "<memory>";
 
@@ -5657,6 +5840,7 @@ bool StreamReader::Open(FILE *fp, const char *filename, CompressionType compress
 
     RG_DEFER_N(err_guard) { error = true; };
     error = false;
+    raw_read = 0;
 
     RG_ASSERT(fp);
     RG_ASSERT(filename);
@@ -5673,27 +5857,30 @@ bool StreamReader::Open(FILE *fp, const char *filename, CompressionType compress
     return true;
 }
 
-bool StreamReader::Open(const char *filename, CompressionType compression_type)
+OpenResult StreamReader::Open(const char *filename, CompressionType compression_type)
 {
     Close(true);
 
     RG_DEFER_N(err_guard) { error = true; };
     error = false;
+    raw_read = 0;
 
     RG_ASSERT(filename);
     this->filename = DuplicateString(filename, &str_alloc).ptr;
 
     source.type = SourceType::File;
-    source.u.file.fp = OpenFile(filename, (int)OpenFileFlag::Read);
-    if (!source.u.file.fp)
-        return false;
+    {
+        OpenResult ret = OpenFile(filename, (int)OpenFlag::Read, &source.u.file.fp);
+        if (ret != OpenResult::Success)
+            return ret;
+    }
     source.u.file.owned = true;
 
     if (!InitDecompressor(compression_type))
-        return false;
+        return OpenResult::OtherError;
 
     err_guard.Disable();
-    return true;
+    return OpenResult::Success;
 }
 
 bool StreamReader::Open(const std::function<Size(Span<uint8_t>)> &func, const char *filename,
@@ -5703,6 +5890,7 @@ bool StreamReader::Open(const std::function<Size(Span<uint8_t>)> &func, const ch
 
     RG_DEFER_N(err_guard) { error = true; };
     error = false;
+    raw_read = 0;
 
     this->filename = filename ? DuplicateString(filename, &str_alloc).ptr : "<closure>";
 
@@ -5726,7 +5914,7 @@ bool StreamReader::Close(bool implicit)
         case CompressionType::Gzip:
         case CompressionType::Zlib: {
 #ifdef MZ_VERSION
-            ReleaseMemory(nullptr, compression.u.miniz, RG_SIZE(*compression.u.miniz));
+            ReleaseOne(nullptr, compression.u.miniz);
             compression.u.miniz = nullptr;
 #else
             RG_UNREACHABLE();
@@ -5742,7 +5930,7 @@ bool StreamReader::Close(bool implicit)
                     BrotliDecoderDestroyInstance(ctx->state);
                 }
 
-                ReleaseMemory(nullptr, ctx, RG_SIZE(*ctx));
+                ReleaseOne(nullptr, ctx);
                 compression.u.brotli = nullptr;
             }
 #else
@@ -5773,7 +5961,6 @@ bool StreamReader::Close(bool implicit)
     source.eof = false;
     eof = false;
     raw_len = -1;
-    raw_read = 0;
     str_alloc.ReleaseAll();
 
     return ret;
@@ -5833,6 +6020,23 @@ bool StreamReader::Rewind()
     return true;
 }
 
+FILE *StreamReader::GetFile() const
+{
+    RG_ASSERT(source.type == SourceType::File);
+    return source.u.file.fp;
+}
+
+int StreamReader::GetDescriptor() const
+{
+    RG_ASSERT(source.type == SourceType::File);
+
+#ifdef _WIN32
+    return _fileno(source.u.file.fp);
+#else
+    return fileno(source.u.file.fp);
+#endif
+}
+
 Size StreamReader::Read(Span<uint8_t> out_buf)
 {
     if (RG_UNLIKELY(error))
@@ -5975,8 +6179,7 @@ bool StreamReader::InitDecompressor(CompressionType type)
         case CompressionType::Gzip:
         case CompressionType::Zlib: {
 #ifdef MZ_VERSION
-            compression.u.miniz =
-                AllocateMemory<MinizInflateContext>(nullptr, RG_SIZE(MinizInflateContext), (int)Allocator::Flag::Zero).ptr;
+            compression.u.miniz = AllocateOne<MinizInflateContext>(nullptr, (int)AllocFlag::Zero);
             tinfl_init(&compression.u.miniz->inflator);
             compression.u.miniz->crc32 = MZ_CRC32_INIT;
 #else
@@ -5988,8 +6191,7 @@ bool StreamReader::InitDecompressor(CompressionType type)
 
         case CompressionType::Brotli: {
 #ifdef BROTLI_DEFAULT_MODE
-            compression.u.brotli =
-                AllocateMemory<BrotliDecompressContext>(nullptr, RG_SIZE(BrotliDecompressContext), (int)Allocator::Flag::Zero).ptr;
+            compression.u.brotli = AllocateOne<BrotliDecompressContext>(nullptr, (int)AllocFlag::Zero);
             compression.u.brotli->state = BrotliDecoderCreateInstance(nullptr, nullptr, nullptr);
 #else
             LogError("Brotli decompression not available for '%1'", filename);
@@ -6338,6 +6540,7 @@ bool StreamWriter::Open(HeapArray<uint8_t> *mem, const char *filename,
 
     RG_DEFER_N(err_guard) { error = true; };
     error = false;
+    raw_written = 0;
 
     this->filename = filename ? DuplicateString(filename, &str_alloc).ptr : "<memory>";
 
@@ -6360,6 +6563,7 @@ bool StreamWriter::Open(FILE *fp, const char *filename,
 
     RG_DEFER_N(err_guard) { error = true; };
     error = false;
+    raw_written = 0;
 
     RG_ASSERT(fp);
     RG_ASSERT(filename);
@@ -6384,6 +6588,7 @@ bool StreamWriter::Open(const char *filename, unsigned int flags,
 
     RG_DEFER_N(err_guard) { error = true; };
     error = false;
+    raw_written = 0;
 
     RG_ASSERT(filename);
     this->filename = DuplicateString(filename, &str_alloc).ptr;
@@ -6395,8 +6600,8 @@ bool StreamWriter::Open(const char *filename, unsigned int flags,
         Span<const char> directory = GetPathDirectory(filename);
 
         if (flags & (int)StreamWriterFlag::Exclusive) {
-            FILE *fp = OpenFile(filename, (int)OpenFileFlag::Write |
-                                          (int)OpenFileFlag::Exclusive);
+            FILE *fp = OpenFile(filename, (int)OpenFlag::Write |
+                                          (int)OpenFlag::Exclusive);
             if (!fp)
                 return false;
             fclose(fp);
@@ -6404,13 +6609,13 @@ bool StreamWriter::Open(const char *filename, unsigned int flags,
             dest.u.file.tmp_exclusive = true;
         }
 
-        dest.u.file.tmp_filename = CreateTemporaryFile(directory, "", ".tmp", &str_alloc, &dest.u.file.fp);
+        dest.u.file.tmp_filename = CreateUniqueFile(directory, "", ".tmp", &str_alloc, &dest.u.file.fp);
         if (!dest.u.file.tmp_filename)
             return false;
         dest.u.file.owned = true;
     } else {
-        unsigned int open_flags = (int)OpenFileFlag::Write;
-        open_flags |= (flags & (int)StreamWriterFlag::Exclusive) ? (int)OpenFileFlag::Exclusive : 0;
+        unsigned int open_flags = (int)OpenFlag::Write;
+        open_flags |= (flags & (int)StreamWriterFlag::Exclusive) ? (int)OpenFlag::Exclusive : 0;
 
         dest.u.file.fp = OpenFile(filename, open_flags);
         if (!dest.u.file.fp)
@@ -6433,6 +6638,7 @@ bool StreamWriter::Open(const std::function<bool(Span<const uint8_t>)> &func, co
 
     RG_DEFER_N(err_guard) { error = true; };
     error = false;
+    raw_written = 0;
 
     this->filename = filename ? DuplicateString(filename, &str_alloc).ptr : "<closure>";
 
@@ -6454,13 +6660,37 @@ bool StreamWriter::Flush()
 
     switch (dest.type) {
         case DestinationType::Memory: return true;
-        case DestinationType::File: return FlushFile(dest.u.file.fp, filename);
+        case DestinationType::File: {
+            if (!FlushFile(dest.u.file.fp, filename)) {
+                error = true;
+                return false;
+            }
+
+            return true;
+        } break;
         case DestinationType::Function: return true;
     }
 
     RG_UNREACHABLE();
 }
 
+FILE *StreamWriter::GetFile() const
+{
+    RG_ASSERT(dest.type == DestinationType::File);
+    return dest.u.file.fp;
+}
+
+int StreamWriter::GetDescriptor() const
+{
+    RG_ASSERT(dest.type == DestinationType::File);
+
+#ifdef _WIN32
+    return _fileno(dest.u.file.fp);
+#else
+    return fileno(dest.u.file.fp);
+#endif
+}
+
 bool StreamWriter::Write(Span<const uint8_t> buf)
 {
     if (RG_UNLIKELY(error))
@@ -6527,7 +6757,7 @@ bool StreamWriter::Close(bool implicit)
             MinizDeflateContext *ctx = compression.u.miniz;
 
             RG_DEFER { 
-                ReleaseMemory(nullptr, ctx, RG_SIZE(*ctx));
+                ReleaseOne(nullptr, ctx);
                 compression.u.miniz = nullptr;
             };
 
@@ -6600,21 +6830,23 @@ bool StreamWriter::Close(bool implicit)
         case DestinationType::Memory: { dest.u.mem = {}; } break;
 
         case DestinationType::File: {
-            if (IsValid() && !FlushFile(dest.u.file.fp, filename)) {
-                error = true;
-            }
-
             if (dest.u.file.tmp_filename) {
-                if (IsValid() && implicit) {
-                    LogDebug("Deleting implicitly closed file '%1'", filename);
-                    error = true;
+                if (IsValid()) {
+                    if (implicit) {
+                        LogDebug("Deleting implicitly closed file '%1'", filename);
+                        error = true;
+                    } else if (!FlushFile(dest.u.file.fp, filename)) {
+                        error = true;
+                    }
                 }
 
                 if (IsValid()) {
                     fclose(dest.u.file.fp);
                     dest.u.file.owned = false;
 
-                    if (RenameFile(dest.u.file.tmp_filename, filename, true)) {
+                    unsigned int flags = (int)RenameFlag::Overwrite | (int)RenameFlag::Sync;
+
+                    if (RenameFile(dest.u.file.tmp_filename, filename, flags)) {
                         dest.u.file.tmp_filename = nullptr;
                         dest.u.file.tmp_exclusive = false;
                     } else {
@@ -6665,8 +6897,7 @@ bool StreamWriter::InitCompressor(CompressionType type, CompressionSpeed speed)
         case CompressionType::Gzip:
         case CompressionType::Zlib: {
 #ifdef MZ_VERSION
-            compression.u.miniz =
-                AllocateMemory<MinizDeflateContext>(nullptr, RG_SIZE(MinizDeflateContext), (int)Allocator::Flag::Zero).ptr;
+            compression.u.miniz = AllocateOne<MinizDeflateContext>(nullptr, (int)AllocFlag::Zero);
             compression.u.miniz->crc32 = MZ_CRC32_INIT;
 
             int flags = 0;
@@ -6797,7 +7028,7 @@ bool StreamWriter::WriteRaw(Span<const uint8_t> buf)
             memcpy_safe(dest.u.mem.memory->ptr + dest.u.mem.memory->len, buf.ptr, (size_t)buf.len);
             dest.u.mem.memory->len += buf.len;
 
-            return true;
+            raw_written += buf.len;
         } break;
 
         case DestinationType::File: {
@@ -6816,9 +7047,9 @@ bool StreamWriter::WriteRaw(Span<const uint8_t> buf)
 
                 buf.ptr += write_len;
                 buf.len -= write_len;
-            }
 
-            return true;
+                raw_written += write_len;
+            }
         } break;
 
         case DestinationType::Function: {
@@ -6826,13 +7057,16 @@ bool StreamWriter::WriteRaw(Span<const uint8_t> buf)
             if (!buf.len)
                 return true;
 
-            bool ret = dest.u.func(buf);
-            error |= !ret;
-            return ret;
+            if (!dest.u.func(buf)) {
+                error = true;
+                return false;
+            }
+
+            raw_written += buf.len;
         } break;
     }
 
-    RG_UNREACHABLE();
+    return true;
 }
 
 bool SpliceStream(StreamReader *reader, int64_t max_len, StreamWriter *writer)
@@ -6983,7 +7217,7 @@ bool ReloadAssets()
     // Check library time
     {
         FileInfo file_info;
-        if (!StatFile(assets_filename, &file_info))
+        if (StatFile(assets_filename, &file_info) != StatResult::Success)
             return false;
 
         if (assets_last_check == file_info.mtime)
@@ -7033,7 +7267,7 @@ bool ReloadAssets()
         AssetInfo asset_copy;
 
         asset_copy.name = DuplicateString(asset.name, &assets_alloc).ptr;
-        asset_copy.data = AllocateMemory<uint8_t>(&assets_alloc, asset.data.len);
+        asset_copy.data = AllocateSpan<uint8_t>(&assets_alloc, asset.data.len);
         memcpy_safe((void *)asset_copy.data.ptr, asset.data.ptr, (size_t)asset.data.len);
         asset_copy.compression_type = asset.compression_type;
         asset_copy.source_map = DuplicateString(asset.source_map, &assets_alloc).ptr;