progress

code/os/core/linux/os_core_linux.h

@@ -0,0 +1,134 @@
+#ifdef MD_INTELLISENSE_DIRECTIVES
+#pragma once
+#include 
+#endif
+
+// Copyright (c) 2024 Epic Games Tools
+// Licensed under the MIT license (https://opensource.org/license/mit/)
+
+////////////////////////////////
+//~ rjf: Includes
+
+#define _GNU_SOURCE
+#include <features.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <linux/limits.h>
+#include <time.h>
+#include <dirent.h>
+#include <pthread.h>
+#include <sys/syscall.h>
+#include <signal.h>
+#include <errno.h>
+#include <dlfcn.h>
+#include <sys/sysinfo.h>
+#include <sys/random.h>
+
+int pthread_setname_np(pthread_t thread, const char *name);
+int pthread_getname_np(pthread_t thread, char *name, size_t size);
+
+typedef struct tm tm;
+typedef struct timespec timespec;
+
+////////////////////////////////
+//~ rjf: File Iterator
+
+typedef struct OS_LNX_FileIter OS_LNX_FileIter;
+struct OS_LNX_FileIter
+{
+  DIR *dir;
+  struct dirent *dp;
+  String8 path;
+};
+StaticAssert(sizeof(Member(OS_FileIter, memory)) >= sizeof(OS_LNX_FileIter), os_lnx_file_iter_size_check);
+
+////////////////////////////////
+//~ rjf: Safe Call Handler Chain
+
+typedef struct OS_LNX_SafeCallChain OS_LNX_SafeCallChain;
+struct OS_LNX_SafeCallChain
+{
+  OS_LNX_SafeCallChain *next;
+  OS_ThreadFunctionType *fail_handler;
+  void *ptr;
+};
+
+////////////////////////////////
+//~ rjf: Entities
+
+typedef enum OS_LNX_EntityKind
+{
+  OS_LNX_EntityKind_Thread,
+  OS_LNX_EntityKind_Mutex,
+  OS_LNX_EntityKind_RWMutex,
+  OS_LNX_EntityKind_ConditionVariable,
+}
+OS_LNX_EntityKind;
+
+typedef struct OS_LNX_Entity OS_LNX_Entity;
+struct OS_LNX_Entity
+{
+  OS_LNX_Entity *next;
+  OS_LNX_EntityKind kind;
+  union
+  {
+    struct
+    {
+      pthread_t handle;
+      OS_ThreadFunctionType *func;
+      void *ptr;
+    } thread;
+    pthread_mutex_t mutex_handle;
+    pthread_rwlock_t rwmutex_handle;
+    struct
+    {
+      pthread_cond_t cond_handle;
+      pthread_mutex_t rwlock_mutex_handle;
+    } cv;
+  };
+};
+
+////////////////////////////////
+//~ rjf: State
+
+typedef struct OS_LNX_State OS_LNX_State;
+struct OS_LNX_State
+{
+  Arena *arena;
+  OS_SystemInfo system_info;
+  OS_ProcessInfo process_info;
+  pthread_mutex_t entity_mutex;
+  Arena *entity_arena;
+  OS_LNX_Entity *entity_free;
+};
+
+////////////////////////////////
+//~ rjf: Globals
+
+global OS_LNX_State os_lnx_state = {0};
+thread_static OS_LNX_SafeCallChain *os_lnx_safe_call_chain = 0;
+
+////////////////////////////////
+//~ rjf: Helpers
+
+internal DateTime os_lnx_date_time_from_tm(tm in, U32 msec);
+internal tm os_lnx_tm_from_date_time(DateTime dt);
+internal timespec os_lnx_timespec_from_date_time(DateTime dt);
+internal DenseTime os_lnx_dense_time_from_timespec(timespec in);
+internal FileProperties os_lnx_file_properties_from_stat(struct stat *s);
+internal void os_lnx_safe_call_sig_handler(int x);
+
+////////////////////////////////
+//~ rjf: Entities
+
+internal OS_LNX_Entity *os_lnx_entity_alloc(OS_LNX_EntityKind kind);
+internal void os_lnx_entity_release(OS_LNX_Entity *entity);
+
+////////////////////////////////
+//~ rjf: Thread Entry Point
+
+internal void *os_lnx_thread_entry_point(void *ptr);

code/os/core/os_core.c

@@ -0,0 +1,173 @@
+// Copyright (c) 2024 Epic Games Tools
+// Licensed under the MIT license (https://opensource.org/license/mit/)
+
+////////////////////////////////
+//~ rjf: Handle Type Functions (Helpers, Implemented Once)
+
+internal OS_Handle
+os_handle_zero(void)
+{
+  OS_Handle handle = {0};
+  return handle;
+}
+
+internal B32
+os_handle_match(OS_Handle a, OS_Handle b)
+{
+  return a.u64[0] == b.u64[0];
+}
+
+internal void
+os_handle_list_push(Arena *arena, OS_HandleList *handles, OS_Handle handle)
+{
+  OS_HandleNode *n = push_array(arena, OS_HandleNode, 1);
+  n->v = handle;
+  SLLQueuePush(handles->first, handles->last, n);
+  handles->count += 1;
+}
+
+internal OS_HandleArray
+os_handle_array_from_list(Arena *arena, OS_HandleList *list)
+{
+  OS_HandleArray result = {0};
+  result.count = list->count;
+  result.v = push_array_no_zero(arena, OS_Handle, result.count);
+  U64 idx = 0;
+  for(OS_HandleNode *n = list->first; n != 0; n = n->next, idx += 1)
+  {
+    result.v[idx] = n->v;
+  }
+  return result;
+}
+
+////////////////////////////////
+//~ rjf: Command Line Argc/Argv Helper (Helper, Implemented Once)
+
+internal String8List
+os_string_list_from_argcv(Arena *arena, int argc, char **argv)
+{
+  String8List result = {0};
+  for(int i = 0; i < argc; i += 1)
+  {
+    String8 str = str8_cstring(argv[i]);
+    str8_list_push(arena, &result, str);
+  }
+  return result;
+}
+
+////////////////////////////////
+//~ rjf: Filesystem Helpers (Helpers, Implemented Once)
+
+internal String8
+os_data_from_file_path(Arena *arena, String8 path)
+{
+  OS_Handle file = os_file_open(OS_AccessFlag_Read|OS_AccessFlag_ShareRead, path);
+  FileProperties props = os_properties_from_file(file);
+  String8 data = os_string_from_file_range(arena, file, r1u64(0, props.size));
+  os_file_close(file);
+  return data;
+}
+
+internal B32
+os_write_data_to_file_path(String8 path, String8 data)
+{
+  B32 good = 0;
+  OS_Handle file = os_file_open(OS_AccessFlag_Write, path);
+  if(!os_handle_match(file, os_handle_zero()))
+  {
+    good = 1;
+    os_file_write(file, r1u64(0, data.size), data.str);
+    os_file_close(file);
+  }
+  return good;
+}
+
+internal B32
+os_write_data_list_to_file_path(String8 path, String8List list)
+{
+  B32 good = 0;
+  OS_Handle file = os_file_open(OS_AccessFlag_Write, path);
+  if(!os_handle_match(file, os_handle_zero()))
+  {
+    good = 1;
+    U64 off = 0;
+    for(String8Node *n = list.first; n != 0; n = n->next)
+    {
+      os_file_write(file, r1u64(off, off+n->string.size), n->string.str);
+      off += n->string.size;
+    }
+    os_file_close(file);
+  }
+  return good;
+}
+
+internal B32
+os_append_data_to_file_path(String8 path, String8 data)
+{
+  B32 good = 0;
+  if(data.size != 0)
+  {
+    OS_Handle file = os_file_open(OS_AccessFlag_Write|OS_AccessFlag_Append, path);
+    if(!os_handle_match(file, os_handle_zero()))
+    {
+      good = 1;
+      U64 pos = os_properties_from_file(file).size;
+      os_file_write(file, r1u64(pos, pos+data.size), data.str);
+      os_file_close(file);
+    }
+  }
+  return good;
+}
+
+internal OS_FileID
+os_id_from_file_path(String8 path)
+{
+  OS_Handle file = os_file_open(OS_AccessFlag_Read|OS_AccessFlag_ShareRead, path);
+  OS_FileID id = os_id_from_file(file);
+  os_file_close(file);
+  return id;
+}
+
+internal S64
+os_file_id_compare(OS_FileID a, OS_FileID b)
+{
+  S64 cmp = MemoryCompare((void*)&a.v[0], (void*)&b.v[0], sizeof(a.v));
+  return cmp;
+}
+
+internal String8
+os_string_from_file_range(Arena *arena, OS_Handle file, Rng1U64 range)
+{
+  U64 pre_pos = arena_pos(arena);
+  String8 result;
+  result.size = dim_1u64(range);
+  result.str = push_array_no_zero(arena, U8, result.size);
+  U64 actual_read_size = os_file_read(file, range, result.str);
+  if(actual_read_size < result.size)
+  {
+    arena_pop_to(arena, pre_pos + actual_read_size);
+    result.size = actual_read_size;
+  }
+  return result;
+}
+
+////////////////////////////////
+//~ rjf: GUID Helpers (Helpers, Implemented Once)
+
+internal String8
+os_string_from_guid(Arena *arena, OS_Guid guid)
+{
+  String8 result = push_str8f(arena, "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
+                              guid.data1,
+                              guid.data2,
+                              guid.data3,
+                              guid.data4[0],
+                              guid.data4[1],
+                              guid.data4[2],
+                              guid.data4[3],
+                              guid.data4[4],
+                              guid.data4[5],
+                              guid.data4[6],
+                              guid.data4[7]);
+  return result;
+}

code/os/core/os_core.h

@@ -0,0 +1,336 @@
+// Copyright (c) 2024 Epic Games Tools
+// Licensed under the MIT license (https://opensource.org/license/mit/)
+
+#ifndef OS_CORE_H
+#define OS_CORE_H
+
+////////////////////////////////
+//~ rjf: System Info
+
+typedef struct OS_SystemInfo OS_SystemInfo;
+struct OS_SystemInfo
+{
+  U32 logical_processor_count;
+  U64 page_size;
+  U64 large_page_size;
+  U64 allocation_granularity;
+  String8 machine_name;
+};
+
+////////////////////////////////
+//~ rjf: Process Info
+
+typedef struct OS_ProcessInfo OS_ProcessInfo;
+struct OS_ProcessInfo
+{
+  U32 pid;
+  String8 binary_path;
+  String8 initial_path;
+  String8 user_program_data_path;
+  String8List module_load_paths;
+  String8List environment;
+};
+
+////////////////////////////////
+//~ rjf: Access Flags
+
+typedef U32 OS_AccessFlags;
+enum
+{
+  OS_AccessFlag_Read       = (1<<0),
+  OS_AccessFlag_Write      = (1<<1),
+  OS_AccessFlag_Execute    = (1<<2),
+  OS_AccessFlag_Append     = (1<<3),
+  OS_AccessFlag_ShareRead  = (1<<4),
+  OS_AccessFlag_ShareWrite = (1<<5),
+};
+
+////////////////////////////////
+//~ rjf: Files
+
+typedef U32 OS_FileIterFlags;
+enum
+{
+  OS_FileIterFlag_SkipFolders     = (1 << 0),
+  OS_FileIterFlag_SkipFiles       = (1 << 1),
+  OS_FileIterFlag_SkipHiddenFiles = (1 << 2),
+  OS_FileIterFlag_Done            = (1 << 31),
+};
+
+typedef struct OS_FileIter OS_FileIter;
+struct OS_FileIter
+{
+  OS_FileIterFlags flags;
+  U8 memory[800];
+};
+
+typedef struct OS_FileInfo OS_FileInfo;
+struct OS_FileInfo
+{
+  String8 name;
+  FileProperties props;
+};
+
+// nick: on-disk file identifier
+typedef struct OS_FileID OS_FileID;
+struct OS_FileID
+{
+  U64 v[3];
+};
+
+////////////////////////////////
+//~ rjf: Process Launch Parameters
+
+typedef struct OS_ProcessLaunchParams OS_ProcessLaunchParams;
+struct OS_ProcessLaunchParams
+{
+  String8List cmd_line;
+  String8 path;
+  String8List env;
+  B32 inherit_env;
+  B32 consoleless;
+};
+
+////////////////////////////////
+//~ rjf: Handle Type
+
+typedef struct OS_Handle OS_Handle;
+struct OS_Handle
+{
+  U64 u64[1];
+};
+
+typedef struct OS_HandleNode OS_HandleNode;
+struct OS_HandleNode
+{
+  OS_HandleNode *next;
+  OS_Handle v;
+};
+
+typedef struct OS_HandleList OS_HandleList;
+struct OS_HandleList
+{
+  OS_HandleNode *first;
+  OS_HandleNode *last;
+  U64 count;
+};
+
+typedef struct OS_HandleArray OS_HandleArray;
+struct OS_HandleArray
+{
+  OS_Handle *v;
+  U64 count;
+};
+
+////////////////////////////////
+//~ rjf: Globally Unique IDs
+
+typedef struct OS_Guid OS_Guid;
+struct OS_Guid
+{
+  U32 data1;
+  U16 data2;
+  U16 data3;
+  U8  data4[8];
+};
+StaticAssert(sizeof(OS_Guid) == 16, os_guid_check);
+
+////////////////////////////////
+//~ rjf: Thread Types
+
+typedef void OS_ThreadFunctionType(void *ptr);
+
+////////////////////////////////
+//~ rjf: Handle Type Functions (Helpers, Implemented Once)
+
+internal OS_Handle os_handle_zero(void);
+internal B32 os_handle_match(OS_Handle a, OS_Handle b);
+internal void os_handle_list_push(Arena *arena, OS_HandleList *handles, OS_Handle handle);
+internal OS_HandleArray os_handle_array_from_list(Arena *arena, OS_HandleList *list);
+
+////////////////////////////////
+//~ rjf: Command Line Argc/Argv Helper (Helper, Implemented Once)
+
+internal String8List os_string_list_from_argcv(Arena *arena, int argc, char **argv);
+
+////////////////////////////////
+//~ rjf: Filesystem Helpers (Helpers, Implemented Once)
+
+internal String8        os_data_from_file_path(Arena *arena, String8 path);
+internal B32            os_write_data_to_file_path(String8 path, String8 data);
+internal B32            os_write_data_list_to_file_path(String8 path, String8List list);
+internal B32            os_append_data_to_file_path(String8 path, String8 data);
+internal OS_FileID      os_id_from_file_path(String8 path);
+internal S64            os_file_id_compare(OS_FileID a, OS_FileID b);
+internal String8        os_string_from_file_range(Arena *arena, OS_Handle file, Rng1U64 range);
+
+////////////////////////////////
+//~ rjf: GUID Helpers (Helpers, Implemented Once)
+
+internal String8 os_string_from_guid(Arena *arena, OS_Guid guid);
+
+////////////////////////////////
+//~ rjf: @os_hooks System/Process Info (Implemented Per-OS)
+
+internal OS_SystemInfo *os_get_system_info(void);
+internal OS_ProcessInfo *os_get_process_info(void);
+internal String8 os_get_current_path(Arena *arena);
+
+////////////////////////////////
+//~ rjf: @os_hooks Memory Allocation (Implemented Per-OS)
+
+//- rjf: basic
+internal void *os_reserve(U64 size);
+internal B32   os_commit(void *ptr, U64 size);
+internal void  os_decommit(void *ptr, U64 size);
+internal void  os_release(void *ptr, U64 size);
+
+//- rjf: large pages
+internal void *os_reserve_large(U64 size);
+internal B32 os_commit_large(void *ptr, U64 size);
+
+////////////////////////////////
+//~ rjf: @os_hooks Thread Info (Implemented Per-OS)
+
+internal U32 os_tid(void);
+internal void os_set_thread_name(String8 string);
+
+////////////////////////////////
+//~ rjf: @os_hooks Aborting (Implemented Per-OS)
+
+internal void os_abort(S32 exit_code);
+
+////////////////////////////////
+//~ rjf: @os_hooks File System (Implemented Per-OS)
+
+//- rjf: files
+internal OS_Handle      os_file_open(OS_AccessFlags flags, String8 path);
+internal void           os_file_close(OS_Handle file);
+internal U64            os_file_read(OS_Handle file, Rng1U64 rng, void *out_data);
+internal U64            os_file_write(OS_Handle file, Rng1U64 rng, void *data);
+internal B32            os_file_set_times(OS_Handle file, DateTime time);
+internal FileProperties os_properties_from_file(OS_Handle file);
+internal OS_FileID      os_id_from_file(OS_Handle file);
+internal B32            os_delete_file_at_path(String8 path);
+internal B32            os_copy_file_path(String8 dst, String8 src);
+internal String8        os_full_path_from_path(Arena *arena, String8 path);
+internal B32            os_file_path_exists(String8 path);
+internal FileProperties os_properties_from_file_path(String8 path);
+
+//- rjf: file maps
+internal OS_Handle os_file_map_open(OS_AccessFlags flags, OS_Handle file);
+internal void      os_file_map_close(OS_Handle map);
+internal void *    os_file_map_view_open(OS_Handle map, OS_AccessFlags flags, Rng1U64 range);
+internal void      os_file_map_view_close(OS_Handle map, void *ptr, Rng1U64 range);
+
+//- rjf: directory iteration
+internal OS_FileIter *os_file_iter_begin(Arena *arena, String8 path, OS_FileIterFlags flags);
+internal B32          os_file_iter_next(Arena *arena, OS_FileIter *iter, OS_FileInfo *info_out);
+internal void         os_file_iter_end(OS_FileIter *iter);
+
+//- rjf: directory creation
+internal B32 os_make_directory(String8 path);
+
+////////////////////////////////
+//~ rjf: @os_hooks Shared Memory (Implemented Per-OS)
+
+internal OS_Handle os_shared_memory_alloc(U64 size, String8 name);
+internal OS_Handle os_shared_memory_open(String8 name);
+internal void      os_shared_memory_close(OS_Handle handle);
+internal void *    os_shared_memory_view_open(OS_Handle handle, Rng1U64 range);
+internal void      os_shared_memory_view_close(OS_Handle handle, void *ptr, Rng1U64 range);
+
+////////////////////////////////
+//~ rjf: @os_hooks Time (Implemented Per-OS)
+
+internal U64         os_now_microseconds(void);
+internal U32         os_now_unix(void);
+internal DateTime    os_now_universal_time(void);
+internal DateTime    os_universal_time_from_local(DateTime *local_time);
+internal DateTime    os_local_time_from_universal(DateTime *universal_time);
+internal void        os_sleep_milliseconds(U32 msec);
+
+////////////////////////////////
+//~ rjf: @os_hooks Child Processes (Implemented Per-OS)
+
+internal OS_Handle os_process_launch(OS_ProcessLaunchParams *params);
+internal B32       os_process_join(OS_Handle handle, U64 endt_us);
+internal void      os_process_detach(OS_Handle handle);
+
+////////////////////////////////
+//~ rjf: @os_hooks Threads (Implemented Per-OS)
+
+internal OS_Handle os_thread_launch(OS_ThreadFunctionType *func, void *ptr, void *params);
+internal B32       os_thread_join(OS_Handle handle, U64 endt_us);
+internal void      os_thread_detach(OS_Handle handle);
+
+////////////////////////////////
+//~ rjf: @os_hooks Synchronization Primitives (Implemented Per-OS)
+
+//- rjf: recursive mutexes
+internal OS_Handle os_mutex_alloc(void);
+internal void      os_mutex_release(OS_Handle mutex);
+internal void      os_mutex_take(OS_Handle mutex);
+internal void      os_mutex_drop(OS_Handle mutex);
+
+//- rjf: reader/writer mutexes
+internal OS_Handle os_rw_mutex_alloc(void);
+internal void      os_rw_mutex_release(OS_Handle rw_mutex);
+internal void      os_rw_mutex_take_r(OS_Handle mutex);
+internal void      os_rw_mutex_drop_r(OS_Handle mutex);
+internal void      os_rw_mutex_take_w(OS_Handle mutex);
+internal void      os_rw_mutex_drop_w(OS_Handle mutex);
+
+//- rjf: condition variables
+internal OS_Handle os_condition_variable_alloc(void);
+internal void      os_condition_variable_release(OS_Handle cv);
+// returns false on timeout, true on signal, (max_wait_ms = max_U64) -> no timeout
+internal B32       os_condition_variable_wait(OS_Handle cv, OS_Handle mutex, U64 endt_us);
+internal B32       os_condition_variable_wait_rw_r(OS_Handle cv, OS_Handle mutex_rw, U64 endt_us);
+internal B32       os_condition_variable_wait_rw_w(OS_Handle cv, OS_Handle mutex_rw, U64 endt_us);
+internal void      os_condition_variable_signal(OS_Handle cv);
+internal void      os_condition_variable_broadcast(OS_Handle cv);
+
+//- rjf: cross-process semaphores
+internal OS_Handle os_semaphore_alloc(U32 initial_count, U32 max_count, String8 name);
+internal void      os_semaphore_release(OS_Handle semaphore);
+internal OS_Handle os_semaphore_open(String8 name);
+internal void      os_semaphore_close(OS_Handle semaphore);
+internal B32       os_semaphore_take(OS_Handle semaphore, U64 endt_us);
+internal void      os_semaphore_drop(OS_Handle semaphore);
+
+//- rjf: scope macros
+#define OS_MutexScope(mutex) DeferLoop(os_mutex_take(mutex), os_mutex_drop(mutex))
+#define OS_MutexScopeR(mutex) DeferLoop(os_rw_mutex_take_r(mutex), os_rw_mutex_drop_r(mutex))
+#define OS_MutexScopeW(mutex) DeferLoop(os_rw_mutex_take_w(mutex), os_rw_mutex_drop_w(mutex))
+#define OS_MutexScopeRWPromote(mutex) DeferLoop((os_rw_mutex_drop_r(mutex), os_rw_mutex_take_w(mutex)), (os_rw_mutex_drop_w(mutex), os_rw_mutex_take_r(mutex)))
+
+////////////////////////////////
+//~ rjf: @os_hooks Dynamically-Loaded Libraries (Implemented Per-OS)
+
+internal OS_Handle os_library_open(String8 path);
+internal void      os_library_close(OS_Handle lib);
+internal VoidProc *os_library_load_proc(OS_Handle lib, String8 name);
+
+////////////////////////////////
+//~ rjf: @os_hooks Safe Calls (Implemented Per-OS)
+
+internal void os_safe_call(OS_ThreadFunctionType *func, OS_ThreadFunctionType *fail_handler, void *ptr);
+
+////////////////////////////////
+//~ rjf: @os_hooks GUIDs (Implemented Per-OS)
+
+internal OS_Guid os_make_guid(void);
+
+////////////////////////////////
+//~ rjf: @os_hooks Entry Points (Implemented Per-OS)
+
+// NOTE(rjf): The implementation of `os_core` will define low-level entry
+// points if BUILD_ENTRY_DEFINING_UNIT is defined to 1. These will call
+// into the standard codebase program entry points, named "entry_point".
+
+#if BUILD_ENTRY_DEFINING_UNIT
+internal void entry_point(CmdLine *cmdline);
+#endif
+
+#endif // OS_CORE_H

code/os/core/win32/os_core_win32.h

@@ -0,0 +1,122 @@
+// Copyright (c) 2024 Epic Games Tools
+// Licensed under the MIT license (https://opensource.org/license/mit/)
+
+#ifndef OS_CORE_WIN32_H
+#define OS_CORE_WIN32_H
+
+////////////////////////////////
+//~ rjf: Includes / Libraries
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#include <windowsx.h>
+#include <timeapi.h>
+#include <tlhelp32.h>
+#include <Shlobj.h>
+#include <processthreadsapi.h>
+#pragma comment(lib, "user32")
+#pragma comment(lib, "winmm")
+#pragma comment(lib, "shell32")
+#pragma comment(lib, "advapi32")
+#pragma comment(lib, "rpcrt4")
+#pragma comment(lib, "shlwapi")
+#pragma comment(lib, "comctl32")
+#pragma comment(linker,"\"/manifestdependency:type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"") // this is required for loading correct comctl32 dll file
+
+////////////////////////////////
+//~ rjf: File Iterator Types
+
+typedef struct OS_W32_FileIter OS_W32_FileIter;
+struct OS_W32_FileIter
+{
+  HANDLE handle;
+  WIN32_FIND_DATAW find_data;
+  B32 is_volume_iter;
+  String8Array drive_strings;
+  U64 drive_strings_iter_idx;
+};
+StaticAssert(sizeof(Member(OS_FileIter, memory)) >= sizeof(OS_W32_FileIter), file_iter_memory_size);
+
+////////////////////////////////
+//~ rjf: Entity Types
+
+typedef enum OS_W32_EntityKind
+{
+  OS_W32_EntityKind_Null,
+  OS_W32_EntityKind_Thread,
+  OS_W32_EntityKind_Mutex,
+  OS_W32_EntityKind_RWMutex,
+  OS_W32_EntityKind_ConditionVariable,
+}
+OS_W32_EntityKind;
+
+typedef struct OS_W32_Entity OS_W32_Entity;
+struct OS_W32_Entity
+{
+  OS_W32_Entity *next;
+  OS_W32_EntityKind kind;
+  union
+  {
+    struct
+    {
+      OS_ThreadFunctionType *func;
+      void *ptr;
+      HANDLE handle;
+      DWORD tid;
+    } thread;
+    CRITICAL_SECTION mutex;
+    SRWLOCK rw_mutex;
+    CONDITION_VARIABLE cv;
+  };
+};
+
+////////////////////////////////
+//~ rjf: State
+
+typedef struct OS_W32_State OS_W32_State;
+struct OS_W32_State
+{
+  Arena *arena;
+  
+  // rjf: info
+  OS_SystemInfo system_info;
+  OS_ProcessInfo process_info;
+  U64 microsecond_resolution;
+  
+  // rjf: entity storage
+  CRITICAL_SECTION entity_mutex;
+  Arena *entity_arena;
+  OS_W32_Entity *entity_free;
+};
+
+////////////////////////////////
+//~ rjf: Globals
+
+global OS_W32_State os_w32_state = {0};
+
+////////////////////////////////
+//~ rjf: File Info Conversion Helpers
+
+internal FilePropertyFlags os_w32_file_property_flags_from_dwFileAttributes(DWORD dwFileAttributes);
+internal void os_w32_file_properties_from_attribute_data(FileProperties *properties, WIN32_FILE_ATTRIBUTE_DATA *attributes);
+
+////////////////////////////////
+//~ rjf: Time Conversion Helpers
+
+internal void os_w32_date_time_from_system_time(DateTime *out, SYSTEMTIME *in);
+internal void os_w32_system_time_from_date_time(SYSTEMTIME *out, DateTime *in);
+internal void os_w32_dense_time_from_file_time(DenseTime *out, FILETIME *in);
+internal U32 os_w32_sleep_ms_from_endt_us(U64 endt_us);
+
+////////////////////////////////
+//~ rjf: Entity Functions
+
+internal OS_W32_Entity *os_w32_entity_alloc(OS_W32_EntityKind kind);
+internal void os_w32_entity_release(OS_W32_Entity *entity);
+
+////////////////////////////////
+//~ rjf: Thread Entry Point
+
+internal DWORD os_w32_thread_entry_point(void *ptr);
+
+#endif // OS_CORE_WIN32_H

code/os/metagen_os_inc.c

@@ -0,0 +1,12 @@
+// Copyright (c) 2024 Epic Games Tools
+// Licensed under the MIT license (https://opensource.org/license/mit/)
+
+#include "metagen/metagen_os/core/metagen_os_core.c"
+
+#if OS_WINDOWS
+# include "metagen/metagen_os/core/win32/metagen_os_core_win32.c"
+#elif OS_LINUX
+# include "metagen/metagen_os/core/linux/metagen_os_core_linux.c"
+#else
+# error OS core layer not implemented for this operating system.
+#endif

code/os/metagen_os_inc.h

@@ -0,0 +1,25 @@
+// Copyright (c) 2024 Epic Games Tools
+// Licensed under the MIT license (https://opensource.org/license/mit/)
+
+#ifndef OS_INC_H
+#define OS_INC_H
+
+#if !defined(OS_FEATURE_GRAPHICAL)
+# define OS_FEATURE_GRAPHICAL 0
+#endif
+
+#if !defined(OS_GFX_STUB)
+# define OS_GFX_STUB 0
+#endif
+
+#include "metagen/metagen_os/core/metagen_os_core.h"
+
+#if OS_WINDOWS
+# include "metagen/metagen_os/core/win32/metagen_os_core_win32.h"
+#elif OS_LINUX
+# include "metagen/metagen_os/core/linux/metagen_os_core_linux.h"
+#else
+# error OS core layer not implemented for this operating system.
+#endif
+
+#endif // OS_INC_H