Init repo

src/transcript_browser/filesystem.h

@@ -0,0 +1,34 @@
+#pragma once
+#include "../pdf_browser/basic.h"
+
+struct FileIter {
+    bool   is_valid;
+    bool   is_directory;
+    String absolute_path;
+    String relative_path;
+    String filename;
+
+    String    path;
+    Allocator allocator;
+    Arena    *arena;
+    TempArena temp;
+    union {
+        struct Win32_FileIter *w32;
+        void                  *dir;
+    };
+};
+
+String   ReadFile(Allocator arena, String path);
+String   GetAbsolutePath(Allocator arena, String relative);
+bool     IsValid(const FileIter &it);
+void     Advance(FileIter *it);
+FileIter IterateFiles(Allocator allocator, String path);
+bool     InitOS();
+
+struct Process {
+    bool is_valid;
+    char platform[32];
+};
+
+Process RunEx(String cmd);
+int     Wait(Process *process);

src/transcript_browser/main.cpp

@@ -0,0 +1,377 @@
+#define BASIC_IMPL
+#include "../pdf_browser/basic.h"
+#include "filesystem.h"
+#include "tests.h"
+#include "raylib.h"
+
+#include <thread>
+#include <semaphore>
+#include <mutex>
+
+struct XToTimeString {
+    String   string; // String inside transcript arena
+    uint16_t hour;
+    uint16_t minute;
+    uint16_t second;
+    String   filepath;
+};
+
+struct TimeString {
+    uint16_t hour;
+    uint16_t minute;
+    uint16_t second;
+    String   string;
+};
+
+struct TimeFile {
+    Array<TimeString> time_strings;
+    String            file;
+};
+
+bool  AppInitializedWithFolder;
+Arena XArena;
+Arena Perm;
+
+Array<TimeString> ParseSrtFile(Arena *arena, String filename) {
+    String        content = ReadFile(*arena, filename);
+    Array<String> lines   = Split(*arena, content, "\n");
+
+    IterRemove(lines) {
+        IterRemovePrepare(lines);
+        it = Trim(it);
+        if (it.len == 0) remove_item = true;
+    }
+
+    long              section_number = 1;
+    Array<TimeString> time_strings   = {*arena};
+    for (int i = 0; i < lines.len;) {
+        String it0 = lines[i++];
+        long   num = strtol(it0.data, NULL, 10);
+        Assert(section_number == num);
+        section_number += 1;
+
+        TimeString item = {};
+        String     it1  = lines[i++];
+        item.hour       = (uint16_t)strtol(it1.data, NULL, 10);
+        item.minute     = (uint16_t)strtol(it1.data + 3, NULL, 10);
+        item.second     = (uint16_t)strtol(it1.data + 6, NULL, 10);
+
+        String next_section_number = Format(*arena, "%d", section_number);
+        while (i < lines.len && lines[i] != next_section_number) {
+            String it   = lines[i];
+            item.string = lines[i];
+            time_strings.add(item);
+            i += 1;
+        }
+    }
+
+    IterRemove(time_strings) {
+        IterRemovePrepare(time_strings);
+        if (i > 0 && AreEqual(time_strings[i - 1].string, time_strings[i].string, true)) {
+            remove_item = true;
+        }
+    }
+
+    return time_strings;
+}
+
+Array<Arena *>  ArenasToFree;
+Array<TimeFile> TimeFiles;
+std::mutex      ParseThreadMutex;
+void            ParseThreadEntry(Array<String> files) {
+    Arena *arena = AllocArena();
+    ParseThreadMutex.lock();
+    ArenasToFree.add(arena);
+    ParseThreadMutex.unlock();
+    For(files) {
+        Array<TimeString> time_strings = ParseSrtFile(arena, it);
+        ParseThreadMutex.lock();
+        TimeFiles.add({time_strings, it});
+        ParseThreadMutex.unlock();
+    }
+}
+
+Array<XToTimeString> XToTimeStringArray = {Perm};
+Array<String>        InitForFolder(String folder) {
+    Scratch scratch;
+    ArenasToFree.allocator = scratch;
+    TimeFiles.allocator    = scratch;
+
+    int           thread_count = 16;
+    Array<String> filenames    = {Perm};
+    Array<String> srt_files    = {scratch};
+    for (FileIter iter = IterateFiles(scratch, folder); IsValid(iter); Advance(&iter)) {
+        filenames.add(Copy(Perm, iter.absolute_path));
+        if (EndsWith(iter.filename, ".srt")) {
+            srt_files.add(Copy(scratch, iter.absolute_path));
+        }
+    }
+
+    Array<std::thread *> threads          = {scratch};
+    int                  files_per_thread = srt_files.len / thread_count;
+    int                  remainder        = srt_files.len % thread_count;
+    int                  fi               = 0;
+    for (int ti = 0; ti < thread_count; ti += 1) {
+        Array<String> files = {scratch};
+        for (int i = 0; fi < srt_files.len && i < files_per_thread + remainder; fi += 1, i += 1) {
+            files.add(srt_files[fi]);
+        }
+        if (remainder) remainder = 0;
+        threads.add(new std::thread(ParseThreadEntry, files));
+    }
+
+    For(threads) {
+        it->join();
+        delete it;
+    }
+
+    ForItem(file, TimeFiles) {
+        For(file.time_strings) {
+            String s      = Copy(XArena, it.string);
+            s.data[s.len] = ' ';
+            XToTimeStringArray.add({s, it.hour, it.minute, it.second, file.file});
+        }
+    }
+    For(ArenasToFree) Release(it);
+
+    AppInitializedWithFolder = true;
+    return filenames;
+}
+
+//
+// Searching thread
+//
+
+Arena          MatchesArena;
+Array<String>  Matches = {MatchesArena};
+XToTimeString *ItemFound;
+Array<char>    Prompt; // system allocated
+
+std::mutex            SearchThreadArrayMutex;
+std::binary_semaphore SearchThreadSemaphore{0};
+bool                  SearchThreadStopSearching = false;
+bool                  SearchThreadRunning       = true;
+void                  SearchThreadEntry() {
+    InitArena(&MatchesArena);
+    for (;;) {
+        SearchThreadSemaphore.acquire();
+        if (!SearchThreadRunning) break;
+        SearchThreadStopSearching = false;
+
+        if (Prompt.len) {
+            SearchThreadArrayMutex.lock();
+            {
+                Matches.clear();
+            }
+            SearchThreadArrayMutex.unlock();
+
+            String  buffer = {(char *)XArena.data, (int64_t)XArena.len};
+            String  find   = {Prompt.data, Prompt.len};
+            int64_t index  = 0;
+            while (Seek(buffer, find, &index, SeekFlag_IgnoreCase)) {
+                String found = {buffer.data + index, find.len};
+                SearchThreadArrayMutex.lock();
+                {
+                    Matches.add(found);
+                }
+                SearchThreadArrayMutex.unlock();
+
+                if (SearchThreadStopSearching) break;
+                buffer = buffer.skip(index + find.len);
+            }
+        }
+    }
+}
+
+void SearchThreadClose(std::thread &thread) {
+    SearchThreadRunning = false;
+    SearchThreadSemaphore.release();
+    thread.join();
+}
+
+int main() {
+    InitOS();
+    InitScratch();
+    InitArena(&Perm);
+    InitArena(&XArena);
+    Arena *frame_arena = AllocArena();
+    XArena.align       = 0;
+
+    String start_string = "C:/video";
+    For(start_string) Prompt.add(it);
+
+    std::thread   search_thread(SearchThreadEntry);
+    int64_t       chosen_text         = 0;
+    int64_t       match_search_offset = 0;
+    Array<String> filenames           = {};
+
+    InitWindow(1920, 1080, "Transcript Browser");
+    SetWindowState(FLAG_WINDOW_RESIZABLE);
+    SetTargetFPS(60);
+    Font font = LoadFontEx("C:/Windows/Fonts/consola.ttf", 20, 0, 250);
+    while (!WindowShouldClose()) {
+        Clear(frame_arena);
+
+        for (int key = GetCharPressed(); key; key = GetCharPressed()) {
+            UTF8Result utf8 = UTF32ToUTF8(key);
+            if (utf8.error) {
+                Prompt.add('?');
+                continue;
+            }
+
+            for (int i = 0; i < utf8.len; i += 1) {
+                Prompt.add(utf8.out_str[i]);
+                match_search_offset       = 0;
+                SearchThreadStopSearching = true;
+                SearchThreadSemaphore.release();
+            }
+        }
+
+        if (IsKeyPressed(KEY_BACKSPACE) || IsKeyPressedRepeat(KEY_BACKSPACE)) {
+            if (ItemFound) {
+                ItemFound = NULL;
+            } else if (Prompt.len > 0) {
+                Prompt.pop();
+                match_search_offset       = 0;
+                SearchThreadStopSearching = true;
+                SearchThreadSemaphore.release();
+            }
+        }
+
+        int64_t offset_size = 1;
+        if (IsKeyDown(KEY_LEFT_CONTROL)) {
+            offset_size = 10;
+        }
+        if (IsKeyPressed(KEY_DOWN) || IsKeyPressedRepeat(KEY_DOWN)) {
+            chosen_text += offset_size;
+            if (chosen_text > 10) match_search_offset += offset_size;
+        }
+        if (IsKeyPressed(KEY_UP) || IsKeyPressedRepeat(KEY_UP)) {
+            chosen_text -= offset_size;
+            match_search_offset -= offset_size;
+        }
+        chosen_text         = Clamp(chosen_text, (int64_t)0, Max(Matches.len - 1, (int64_t)0));
+        match_search_offset = Clamp(match_search_offset, (int64_t)0, Max(Matches.len - 1 - 10, (int64_t)0));
+
+        if (IsKeyPressed(KEY_ENTER)) {
+            if (!AppInitializedWithFolder) {
+                Prompt.add('\0');
+                filenames = InitForFolder(Prompt.data);
+                Prompt.clear();
+            } else if (ItemFound) {
+                String base = ChopLastPeriod(ItemFound->filepath); // .srt
+                base        = ChopLastPeriod(base);                // .en
+
+                For(filenames) {
+                    if (StartsWith(it, base)) {
+                        if (EndsWith(it, ".mkv") || EndsWith(it, ".webm") || EndsWith(it, ".mp4")) {
+                            int    seconds = ItemFound->hour * 60 * 60 + ItemFound->minute * 60 + ItemFound->second;
+                            String copy    = Copy(*frame_arena, it);
+                            for (int i = 0; i < copy.len; i += 1)
+                                if (copy.data[i] == '/') copy.data[i] = '\\';
+                            String args = Format(*frame_arena, "C:\\Program Files\\VideoLAN\\VLC\\vlc.exe --start-time %d \"%.*s\"", seconds, FmtString(copy));
+                            printf("%.*s\n", FmtString(args));
+                            RunEx(args);
+                        }
+                    }
+                }
+            } else if (Matches.len) {
+                String string = Matches[chosen_text];
+                For(XToTimeStringArray) {
+                    uintptr_t begin  = (uintptr_t)(it.string.data);
+                    uintptr_t end    = (uintptr_t)(it.string.data + it.string.len);
+                    uintptr_t needle = (uintptr_t)string.data;
+
+                    if (needle >= begin && needle < end) {
+                        ItemFound = &it;
+                        break;
+                    }
+                }
+            }
+        }
+        BeginDrawing();
+        ClearBackground(RAYWHITE);
+
+        float font_size = 20;
+        float y         = 0;
+        int   xwidth    = MeasureTextEx(font, "_", font_size, 1).x;
+
+        if (!AppInitializedWithFolder) {
+            Prompt.add('\0');
+            DrawTextEx(font, "> ", {0, y}, font_size, 1, BLACK);
+            DrawTextEx(font, Prompt.data, {(float)xwidth * 3, y}, font_size, 1, BLACK);
+            Prompt.len -= 1;
+        } else if (ItemFound) {
+            uintptr_t begin_region = (uintptr_t)XArena.data;
+            uintptr_t end_region   = (uintptr_t)XArena.data + XArena.len;
+
+            uintptr_t begin = (uintptr_t)(ItemFound->string.data - 1000);
+            uintptr_t end   = (uintptr_t)(ItemFound->string.data + 1000);
+
+            begin         = Clamp(begin, begin_region, end_region);
+            end           = Clamp(end, begin_region, end_region);
+            String string = {(char *)begin, (int64_t)(end - begin)};
+
+            String filename = SkipToLastSlash(ItemFound->filepath);
+            DrawTextEx(font, filename.data, {0, y}, font_size, 1, BLACK);
+            y += font_size;
+
+            int per_line = (GetRenderWidth() / xwidth) - 20;
+
+            for (String it = string; it.len;) {
+                String line = it.get_prefix(per_line);
+
+                if (ItemFound->string.data >= line.data && ItemFound->string.data < line.data + line.len) {
+                    DrawRectangleLines(0, y + font_size, GetRenderWidth(), 2, SKYBLUE);
+                }
+
+                String line_terminated = Copy(*frame_arena, line);
+                DrawTextEx(font, line_terminated.data, {0, y}, font_size, 1, DARKGRAY);
+
+                y += font_size;
+                it = it.skip(per_line);
+            }
+        } else {
+            Prompt.add('\0');
+            DrawTextEx(font, "> ", {0, y}, font_size, 1, BLACK);
+            DrawTextEx(font, Prompt.data, {(float)xwidth * 3, y}, font_size, 1, BLACK);
+            Prompt.pop();
+            y += font_size;
+
+            int64_t chars_per_line = GetRenderWidth() / xwidth - Prompt.len;
+
+            SearchThreadArrayMutex.lock();
+            for (int64_t i = match_search_offset; i < Matches.len; i += 1) {
+                String    it           = Matches[i];
+                uintptr_t begin_region = (uintptr_t)XArena.data;
+                uintptr_t end_region   = (uintptr_t)XArena.data + XArena.len;
+
+                uintptr_t begin = (uintptr_t)(it.data - chars_per_line / 2);
+                uintptr_t end   = (uintptr_t)(it.data + chars_per_line / 2);
+
+                begin         = Clamp(begin, begin_region, end_region);
+                end           = Clamp(end, begin_region, end_region);
+                String string = Copy(*frame_arena, {(char *)begin, (int64_t)(end - begin)});
+
+                String string_first  = Copy(*frame_arena, {(char *)begin, (int64_t)(it.data - begin)});
+                String string_middle = Copy(*frame_arena, it);
+                int    width         = MeasureTextEx(font, string_first.data, font_size, 1).x;
+                if (chosen_text == i) DrawRectangleLines(0, y + font_size, GetRenderWidth(), 2, SKYBLUE);
+
+                String num = Format(*frame_arena, "%d", i);
+                DrawTextEx(font, num.data, {0, y}, font_size, 1, DARKGRAY);
+                DrawTextEx(font, string.data, {(float)xwidth * 4, y}, font_size, 1, DARKGRAY);
+                DrawTextEx(font, string_middle.data, {(float)xwidth * 4 + (float)width, y}, font_size, 1, SKYBLUE);
+
+                y += font_size;
+                if (y > GetRenderHeight()) break;
+            }
+            SearchThreadArrayMutex.unlock();
+        }
+
+        if (IsKeyDown(KEY_F1)) DrawFPS(0, 0);
+        EndDrawing();
+    }
+    CloseWindow();
+    SearchThreadClose(search_thread);
+}

src/transcript_browser/tests.h

@@ -0,0 +1,80 @@
+
+void TestArena() {
+    Arena arena = {};
+
+    {
+        void *value = PushSize(&arena, sizeof(int));
+        Assert(value == 0);
+    }
+
+    InitArena(&arena, MiB(256) + PAGE_SIZE);
+    Assert(arena.data && arena.reserve);
+
+    {
+        uint8_t *data       = (uint8_t *)PushSize(&arena, sizeof(uint8_t));
+        *data               = 10;
+        data[PAGE_SIZE - 1] = 0;
+        // data[PAGE_SIZE] = 0;
+
+        Assert(*data == 10);
+        Assert(arena.len == 1);
+        Assert(arena.commit == PAGE_SIZE);
+
+        uint8_t *d2 = (uint8_t *)PushSize(&arena, sizeof(uint8_t));
+        *d2         = 20;
+        Assert(arena.len == 9);
+    }
+
+    {
+        int *alot_of_data = (int *)PushSize(&arena, MiB(256));
+
+        for (int i = 0; i < 1024 * 1024 * 1; i += 1) {
+            alot_of_data[i] = i;
+        }
+        for (int i = 0; i < 1024 * 1024 * 1; i += 1) {
+            Assert(alot_of_data[i] == i);
+        }
+        Assert(arena.len == 16 + MiB(256));
+        Assert(arena.commit == AlignUp(16 + MiB(256), PAGE_SIZE));
+    }
+
+    {
+        void *result = PushSize(&arena, PAGE_SIZE - 16);
+        Assert(result);
+        Assert(arena.commit == arena.reserve);
+        Assert(arena.commit == arena.len);
+
+        void *v = PushSize(&arena, 2423);
+        Assert(v == NULL);
+    }
+
+    Release(&arena);
+
+    {
+        Arena *arena = AllocArena();
+        int   *a     = (int *)PushSize(arena, 1024);
+        for (int i = 0; i < 64; i += 1) a[i] = 0;
+        Clear(arena);
+        a = (int *)PushSize(arena, 1024);
+        for (int i = 0; i < 64; i += 1) a[i] = 0;
+        Release(arena);
+    }
+}
+
+void TestArray() {
+    Array<int> arr = {};
+    defer { arr.dealloc(); };
+
+    for (int i = 0; i < 32; i += 1) arr.add(i);
+
+    int i = 31;
+    For(arr.reverse_iter()) {
+        defer { arr.unordered_remove(it); };
+        Assert(i-- == it);
+    }
+}
+
+void RunTests() {
+    TestArena();
+    TestArray();
+}

src/transcript_browser/win32.cpp

@@ -0,0 +1,206 @@
+#include "filesystem.h"
+
+#ifndef NOMINMAX
+    #define NOMINMAX
+#endif
+#ifndef WIN32_LEAN_AND_MEAN
+    #define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <stdio.h>
+
+// Basic begin
+void *VReserve(size_t size) {
+    void *result = (uint8_t *)VirtualAlloc(0, size, MEM_RESERVE, PAGE_READWRITE);
+    return result;
+}
+
+bool VCommit(void *p, size_t size) {
+    void *result = VirtualAlloc(p, size, MEM_COMMIT, PAGE_READWRITE);
+    return result ? true : false;
+}
+
+bool VRelease(void *p) {
+    BOOL result = VirtualFree(p, 0, MEM_RELEASE);
+    return result ? true : false;
+}
+
+bool VDecommit(void *p, size_t size) {
+    BOOL result = VirtualFree(p, size, MEM_DECOMMIT);
+    return result ? true : false;
+}
+// Basic end
+
+Process RunEx(String args) {
+    Scratch      scratch;
+    wchar_t     *application_name = NULL;
+    wchar_t     *cmd              = ToWidechar(scratch, args);
+    BOOL         inherit_handles  = FALSE;
+    DWORD        creation_flags   = 0;
+    void        *enviroment       = NULL;
+    wchar_t     *working_dir      = NULL;
+    STARTUPINFOW startup_info     = {};
+    startup_info.cb               = sizeof(STARTUPINFOW);
+    Process result                = {};
+    Assert(sizeof(result.platform) >= sizeof(PROCESS_INFORMATION));
+    PROCESS_INFORMATION *process_info = (PROCESS_INFORMATION *)result.platform;
+    BOOL                 success      = CreateProcessW(application_name, cmd, NULL, NULL, inherit_handles, creation_flags, enviroment, working_dir, &startup_info, process_info);
+    result.is_valid                   = true;
+    if (!success) {
+        result.is_valid = false;
+
+        LPVOID lpMsgBuf;
+        DWORD  dw = GetLastError();
+        FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+                      NULL, dw, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpMsgBuf, 0, NULL);
+        LocalFree(lpMsgBuf);
+
+        printf("Failed to create process \ncmd: %.*s\nwindows_message: %s", FmtString(args), (char *)lpMsgBuf);
+        Assert(!"Failed to create process");
+    }
+    return result;
+}
+
+int Wait(Process *process) {
+    Assert(process->is_valid);
+    PROCESS_INFORMATION *pi = (PROCESS_INFORMATION *)process->platform;
+    WaitForSingleObject(pi->hProcess, INFINITE);
+
+    DWORD exit_code;
+    BOOL  err = GetExitCodeProcess(pi->hProcess, &exit_code);
+    Assert(err != 0);
+
+    CloseHandle(pi->hProcess);
+    CloseHandle(pi->hThread);
+    process[0] = {};
+    return (int)exit_code;
+}
+
+bool InitOS() {
+    SetConsoleOutputCP(CP_UTF8);
+
+    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
+    if (hOut != INVALID_HANDLE_VALUE) {
+        DWORD dwMode = 0;
+        if (GetConsoleMode(hOut, &dwMode)) {
+            dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+            if (SetConsoleMode(hOut, dwMode)) {
+                return true;
+            } else {
+                printf("Failed to enable colored terminal output C\n");
+            }
+        } else {
+            printf("Failed to enable colored terminal output B\n");
+        }
+    } else {
+        printf("Failed to enable colored terminal output A\n");
+    }
+    return false;
+}
+
+String ReadFile(Allocator arena, String path) {
+    bool   success = false;
+    String result  = {};
+
+    wchar_t wpath[1024];
+    CreateWidecharFromChar(wpath, Lengthof(wpath), path.data, path.len);
+    HANDLE handle = CreateFileW(wpath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+    if (handle != INVALID_HANDLE_VALUE) {
+        LARGE_INTEGER file_size;
+        if (GetFileSizeEx(handle, &file_size)) {
+            if (file_size.QuadPart != 0) {
+                result.len  = (int64_t)file_size.QuadPart;
+                result.data = (char *)AllocSize(arena, result.len + 1);
+                DWORD read;
+                if (ReadFile(handle, result.data, (DWORD)result.len, &read, NULL)) { // @todo: can only read 32 byte size files?
+                    if (read == result.len) {
+                        success                 = true;
+                        result.data[result.len] = 0;
+                    }
+                }
+            }
+        }
+        CloseHandle(handle);
+    }
+
+    if (!success) {
+        Dealloc(arena, &result.data);
+        result = {};
+    }
+
+    return result;
+}
+
+typedef struct Win32_FileIter {
+    HANDLE           handle;
+    WIN32_FIND_DATAW data;
+} Win32_FileIter;
+
+String GetAbsolutePath(Allocator arena, String relative) {
+    wchar_t wpath[1024];
+    CreateWidecharFromChar(wpath, Lengthof(wpath), relative.data, relative.len);
+    wchar_t wpath_abs[1024];
+    DWORD   written = GetFullPathNameW((wchar_t *)wpath, Lengthof(wpath_abs), wpath_abs, 0);
+    if (written == 0)
+        return {};
+    String path = ToString(arena, {(wchar_t *)wpath_abs, written});
+    NormalizePathInPlace(path);
+    return path;
+}
+
+bool IsValid(const FileIter &it) {
+    return it.is_valid;
+}
+
+void Advance(FileIter *it) {
+    if (it->temp.arena) EndTemp(it->temp);
+    it->temp = BeginTemp(it->arena);
+    while (FindNextFileW(it->w32->handle, &it->w32->data) != 0) {
+        WIN32_FIND_DATAW *data = &it->w32->data;
+
+        // Skip '.' and '..'
+        if (data->cFileName[0] == '.' && data->cFileName[1] == '.' && data->cFileName[2] == 0) continue;
+        if (data->cFileName[0] == '.' && data->cFileName[1] == 0) continue;
+
+        it->is_directory      = data->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
+        it->filename          = ToString(*it->arena, (wchar_t *)data->cFileName, WideLength(data->cFileName));
+        const char *is_dir    = it->is_directory ? "/" : "";
+        const char *separator = it->path.data[it->path.len - 1] == '/' ? "" : "/";
+        it->relative_path     = Format(*it->arena, "%.*s%s%.*s%s", FmtString(it->path), separator, FmtString(it->filename), is_dir);
+        it->absolute_path     = GetAbsolutePath(*it->arena, it->relative_path);
+        it->is_valid          = true;
+
+        if (it->is_directory) {
+            Assert(it->relative_path.data[it->relative_path.len - 1] == '/');
+            Assert(it->absolute_path.data[it->absolute_path.len - 1] == '/');
+        }
+        return;
+    }
+
+    it->is_valid = false;
+    DWORD error  = GetLastError();
+    Assert(error == ERROR_NO_MORE_FILES);
+    FindClose(it->w32->handle);
+    Dealloc(it->allocator, &it->arena);
+}
+
+FileIter IterateFiles(Allocator alo, String path) {
+    FileIter it  = {0};
+    it.allocator = alo;
+    it.arena     = AllocArena(alo, MiB(2));
+    it.path      = path;
+
+    String   modified_path   = Format(*it.arena, "%.*s\\*", FmtString(path));
+    String16 modified_path16 = ToString16(*it.arena, modified_path);
+
+    it.w32         = AllocType(*it.arena, Win32_FileIter);
+    it.w32->handle = FindFirstFileW(modified_path16.data, &it.w32->data);
+    if (it.w32->handle == INVALID_HANDLE_VALUE) {
+        it.is_valid = false;
+        return it;
+    }
+
+    Assert(it.w32->data.cFileName[0] == '.' && it.w32->data.cFileName[1] == 0);
+    Advance(&it);
+    return it;
+}