#pragma once #include "dqn.h" /* //////////////////////////////////////////////////////////////////////////////////////////////////// // // $$$$$$\ $$$$$$\ // $$ __$$\ $$ __$$\ // $$ / $$ |$$ / \__| // $$ | $$ |\$$$$$$\ // $$ | $$ | \____$$\ // $$ | $$ |$$\ $$ | // $$$$$$ |\$$$$$$ | // \______/ \______/ // // dqn_os.h -- Common APIs/services provided by the operating system/platform layer // //////////////////////////////////////////////////////////////////////////////////////////////////// // // [$OMEM] DN_OSMem -- -- Memory allocation (typically virtual memory if supported) // [$DATE] DN_OSDate -- -- Date time APIs // [$FILE] DN_OSPathInfo/File -- -- File path info/reading/writing // [$PATH] DN_OSPath -- -- Construct native OS paths helpers // [$EXEC] DN_OSExec -- -- Execute programs programatically // [$SEMA] DN_OSSemaphore -- DN_SEMAPHORE -- // [$MUTX] DN_OSMutex -- -- // [$THRD] DN_OSThread -- DN_THREAD -- // [$HTTP] DN_OSHttp -- -- // //////////////////////////////////////////////////////////////////////////////////////////////////// */ // NOTE: [$OMEM] DN_OSMem ////////////////////////////////////////////////////////////////////////// enum DN_OSMemCommit { DN_OSMemCommit_No, DN_OSMemCommit_Yes, }; enum DN_OSMemPage { // Exception on read/write with a page. This flag overrides the read/write // access. DN_OSMemPage_NoAccess = 1 << 0, DN_OSMemPage_Read = 1 << 1, // Only read permitted on the page. // Only write permitted on the page. On Windows this is not supported and // will be promoted to read+write permissions. DN_OSMemPage_Write = 1 << 2, DN_OSMemPage_ReadWrite = DN_OSMemPage_Read | DN_OSMemPage_Write, // Modifier used in conjunction with previous flags. Raises exception on // first access to the page, then, the underlying protection flags are // active. This is supported on Windows, on other OS's using this flag will // set the OS equivalent of DN_OSMemPage_NoAccess. // This flag must only be used in DN_OSMem_Protect DN_OSMemPage_Guard = 1 << 3, // If leak tracing is enabled, this flag will allow the allocation recorded // from the reserve call to be leaked, e.g. not printed when leaks are // dumped to the console. DN_OSMemPage_AllocRecordLeakPermitted = 1 << 4, // If leak tracing is enabled this flag will prevent any allocation record // from being created in the allocation table at all. If this flag is // enabled, 'OSMemPage_AllocRecordLeakPermitted' has no effect since the // record will never be created. DN_OSMemPage_NoAllocRecordEntry = 1 << 5, // [INTERNAL] Do not use. All flags together do not constitute a correct // configuration of pages. DN_OSMemPage_All = DN_OSMemPage_NoAccess | DN_OSMemPage_ReadWrite | DN_OSMemPage_Guard | DN_OSMemPage_AllocRecordLeakPermitted | DN_OSMemPage_NoAllocRecordEntry, }; // NOTE: [$DATE] DN_OSDate //////////////////////////////////////////////////////////////////////// struct DN_OSDateTimeStr8 { char date[DN_ARRAY_UCOUNT("YYYY-MM-SS")]; uint8_t date_size; char hms[DN_ARRAY_UCOUNT("HH:MM:SS")]; uint8_t hms_size; }; struct DN_OSDateTime { uint8_t day; uint8_t month; uint16_t year; uint8_t hour; uint8_t minutes; uint8_t seconds; }; struct DN_OSTimer /// Record time between two time-points using the OS's performance counter. { uint64_t start; uint64_t end; }; #if !defined(DN_NO_OS_FILE_API) // NOTE: [$FSYS] DN_OSFile //////////////////////////////////////////////////////////////////////// enum DN_OSPathInfoType { DN_OSPathInfoType_Unknown, DN_OSPathInfoType_Directory, DN_OSPathInfoType_File, }; struct DN_OSPathInfo { bool exists; DN_OSPathInfoType type; uint64_t create_time_in_s; uint64_t last_write_time_in_s; uint64_t last_access_time_in_s; uint64_t size; }; struct DN_OSDirIterator { void *handle; DN_Str8 file_name; char buffer[512]; }; // NOTE: R/W Stream API //////////////////////////////////////////////////////////////////////////// struct DN_OSFile { bool error; void *handle; }; enum DN_OSFileOpen { DN_OSFileOpen_CreateAlways, // Create file if it does not exist, otherwise, zero out the file and open DN_OSFileOpen_OpenIfExist, // Open file at path only if it exists DN_OSFileOpen_OpenAlways, // Open file at path, create file if it does not exist }; typedef uint32_t DN_OSFileAccess; enum DN_OSFileAccess_ { DN_OSFileAccess_Read = 1 << 0, DN_OSFileAccess_Write = 1 << 1, DN_OSFileAccess_Execute = 1 << 2, DN_OSFileAccess_AppendOnly = 1 << 3, // This flag cannot be combined with any other access mode DN_OSFileAccess_ReadWrite = DN_OSFileAccess_Read | DN_OSFileAccess_Write, DN_OSFileAccess_All = DN_OSFileAccess_ReadWrite | DN_OSFileAccess_Execute | DN_OSFileAccess_AppendOnly, }; #endif // DN_NO_OS_FILE_API // NOTE: DN_OSPath //////////////////////////////////////////////////////////////////////////////// #if !defined(DN_OSPathSeperator) #if defined(DN_OS_WIN32) #define DN_OSPathSeperator "\\" #else #define DN_OSPathSeperator "/" #endif #define DN_OSPathSeperatorString DN_STR8(DN_OSPathSeperator) #endif struct DN_OSPathLink { DN_Str8 string; DN_OSPathLink *next; DN_OSPathLink *prev; }; struct DN_OSPath { bool has_prefix_path_separator; DN_OSPathLink *head; DN_OSPathLink *tail; DN_USize string_size; uint16_t links_size; }; // NOTE: [$EXEC] DN_OSExec //////////////////////////////////////////////////////////////////////// typedef uint32_t DN_OSExecFlags; enum DN_OSExecFlags_ { DN_OSExecFlags_Nil = 0, DN_OSExecFlags_SaveStdout = 1 << 0, DN_OSExecFlags_SaveStderr = 1 << 1, DN_OSExecFlags_SaveOutput = DN_OSExecFlags_SaveStdout | DN_OSExecFlags_SaveStderr, DN_OSExecFlags_MergeStderrToStdout = 1 << 2 | DN_OSExecFlags_SaveOutput, }; struct DN_OSExecAsyncHandle { DN_OSExecFlags exec_flags; uint32_t os_error_code; uint32_t exit_code; void *process; void *stdout_read; void *stdout_write; void *stderr_read; void *stderr_write; }; struct DN_OSExecResult { bool finished; DN_Str8 stdout_text; DN_Str8 stderr_text; uint32_t os_error_code; uint32_t exit_code; }; struct DN_OSExecArgs { DN_OSExecFlags flags; DN_Str8 working_dir; DN_Slice environment; }; #if !defined(DN_NO_SEMAPHORE) // NOTE: [$SEMA] DN_OSSemaphore /////////////////////////////////////////////////////////////////// uint32_t const DN_OS_SEMAPHORE_INFINITE_TIMEOUT = UINT32_MAX; struct DN_OSSemaphore { #if defined(DN_OS_WIN32) && !defined(DN_OS_WIN32_USE_PTHREADS) void *win32_handle; #else sem_t posix_handle; bool posix_init; #endif }; enum DN_OSSemaphoreWaitResult { DN_OSSemaphoreWaitResult_Failed, DN_OSSemaphoreWaitResult_Success, DN_OSSemaphoreWaitResult_Timeout, }; #endif // !defined(DN_NO_SEMAPHORE) // NOTE: [$THRD] DN_OSThread ///////////////////////////////////////////////////////////////////// #if !defined(DN_NO_THREAD) && !defined(DN_NO_SEMAPHORE) typedef int32_t (DN_OSThreadFunc)(struct DN_OSThread*); struct DN_OSThread { DN_FStr8<64> name; DN_TLS tls; void *handle; uint64_t thread_id; void *user_context; DN_OSThreadFunc *func; DN_OSSemaphore init_semaphore; }; #endif // !defined(DN_NO_THREAD) // NOTE: [$HTTP] DN_OSHttp //////////////////////////////////////////////////////////////////////// enum DN_OSHttpRequestSecure { DN_OSHttpRequestSecure_No, DN_OSHttpRequestSecure_Yes, }; struct DN_OSHttpResponse { // NOTE: Response data uint32_t error_code; DN_Str8 error_msg; uint16_t http_status; DN_Str8 body; DN_B32 done; // NOTE: Book-keeping DN_Arena *arena; // Allocates memory for the response // NOTE: Async book-keeping // Synchronous HTTP response uses the TLS scratch arena whereas async // calls use their own dedicated arena. DN_Arena tmp_arena; DN_Arena *tmem_arena; DN_Str8Builder builder; DN_OSSemaphore on_complete_semaphore; #if defined(DN_PLATFORM_EMSCRIPTEN) emscripten_fetch_t *em_handle; #elif defined(DN_OS_WIN32) HINTERNET win32_request_session; HINTERNET win32_request_connection; HINTERNET win32_request_handle; #endif }; DN_API void DN_OS_Init(); // NOTE: [$OMEM] Memory ////////////////////////////////////////////////////////////////////////// DN_API void * DN_OS_MemReserve (DN_USize size, DN_OSMemCommit commit, uint32_t page_flags); DN_API bool DN_OS_MemCommit (void *ptr, DN_USize size, uint32_t page_flags); DN_API void DN_OS_MemDecommit(void *ptr, DN_USize size); DN_API void DN_OS_MemRelease (void *ptr, DN_USize size); DN_API int DN_OS_MemProtect (void *ptr, DN_USize size, uint32_t page_flags); // NOTE: Heap DN_API void *DN_OS_MemAlloc (DN_USize size, DN_ZeroMem zero_mem); DN_API void DN_OS_MemDealloc (void *ptr); // NOTE: [$DATE] Date ////////////////////////////////////////////////////////////////////////////// DN_API DN_OSDateTime DN_OS_DateLocalTimeNow (); DN_API DN_OSDateTimeStr8 DN_OS_DateLocalTimeStr8Now(char date_separator = '-', char hms_separator = ':'); DN_API DN_OSDateTimeStr8 DN_OS_DateLocalTimeStr8 (DN_OSDateTime time, char date_separator = '-', char hms_separator = ':'); DN_API uint64_t DN_OS_DateUnixTimeNs (); DN_API uint64_t DN_OS_DateUnixTimeS (); DN_API DN_OSDateTime DN_OS_DateUnixTimeSToDate (uint64_t time); DN_API uint64_t DN_OS_DateLocalToUnixTimeS(DN_OSDateTime date); DN_API uint64_t DN_OS_DateToUnixTimeS (DN_OSDateTime date); DN_API bool DN_OS_DateIsValid (DN_OSDateTime date); // NOTE: Other ///////////////////////////////////////////////////////////////////////////////////// DN_API bool DN_OS_SecureRNGBytes (void *buffer, uint32_t size); DN_API bool DN_OS_SetEnvVar (DN_Str8 name, DN_Str8 value); DN_API DN_Str8 DN_OS_EXEPath (DN_Arena *arena); DN_API DN_Str8 DN_OS_EXEDir (DN_Arena *arena); #define DN_OS_EXEDir_TLS() DN_OS_EXEDir(DN_TLS_TopArena()) DN_API void DN_OS_SleepMs (DN_UInt milliseconds); // NOTE: Counters ////////////////////////////////////////////////////////////////////////////////// DN_API uint64_t DN_OS_PerfCounterNow (); DN_API uint64_t DN_OS_PerfCounterFrequency(); DN_API DN_F64 DN_OS_PerfCounterS (uint64_t begin, uint64_t end); DN_API DN_F64 DN_OS_PerfCounterMs (uint64_t begin, uint64_t end); DN_API DN_F64 DN_OS_PerfCounterUs (uint64_t begin, uint64_t end); DN_API DN_F64 DN_OS_PerfCounterNs (uint64_t begin, uint64_t end); DN_API DN_OSTimer DN_OS_TimerBegin (); DN_API void DN_OS_TimerEnd (DN_OSTimer *timer); DN_API DN_F64 DN_OS_TimerS (DN_OSTimer timer); DN_API DN_F64 DN_OS_TimerMs (DN_OSTimer timer); DN_API DN_F64 DN_OS_TimerUs (DN_OSTimer timer); DN_API DN_F64 DN_OS_TimerNs (DN_OSTimer timer); DN_API uint64_t DN_OS_EstimateTSCPerSecond(uint64_t duration_ms_to_gauge_tsc_frequency); #if !defined(DN_NO_OS_FILE_API) // NOTE: File system paths ///////////////////////////////////////////////////////////////////////// DN_API DN_OSPathInfo DN_OS_PathInfo (DN_Str8 path); DN_API bool DN_OS_FileIsOlderThan(DN_Str8 file, DN_Str8 check_against); DN_API bool DN_OS_PathDelete (DN_Str8 path); DN_API bool DN_OS_FileExists (DN_Str8 path); DN_API bool DN_OS_CopyFile (DN_Str8 src, DN_Str8 dest, bool overwrite, DN_ErrSink *err); DN_API bool DN_OS_MoveFile (DN_Str8 src, DN_Str8 dest, bool overwrite, DN_ErrSink *err); DN_API bool DN_OS_MakeDir (DN_Str8 path); DN_API bool DN_OS_DirExists (DN_Str8 path); DN_API bool DN_OS_DirIterate (DN_Str8 path, DN_OSDirIterator *it); // NOTE: R/W Stream API //////////////////////////////////////////////////////////////////////////// DN_API DN_OSFile DN_OS_FileOpen (DN_Str8 path, DN_OSFileOpen open_mode, DN_OSFileAccess access, DN_ErrSink *err); DN_API bool DN_OS_FileRead (DN_OSFile *file, void *buffer, DN_USize size, DN_ErrSink *err); DN_API bool DN_OS_FileWritePtr(DN_OSFile *file, void const *data, DN_USize size, DN_ErrSink *err); DN_API bool DN_OS_FileWrite (DN_OSFile *file, DN_Str8 buffer, DN_ErrSink *err); DN_API bool DN_OS_FileWriteFV (DN_OSFile *file, DN_ErrSink *err, DN_FMT_ATTRIB char const *fmt, va_list args); DN_API bool DN_OS_FileWriteF (DN_OSFile *file, DN_ErrSink *err, DN_FMT_ATTRIB char const *fmt, ...); DN_API bool DN_OS_FileFlush (DN_OSFile *file, DN_ErrSink *err); DN_API void DN_OS_FileClose (DN_OSFile *file); // NOTE: R/W Entire File /////////////////////////////////////////////////////////////////////////// DN_API DN_Str8 DN_OS_ReadAll (DN_Arena *arena, DN_Str8 path, DN_ErrSink *err); #define DN_OS_ReadAll_TLS(...) DN_OS_ReadAll(DN_TLS_TopArena(), ##__VA_ARGS__) DN_API bool DN_OS_WriteAll (DN_Str8 path, DN_Str8 buffer, DN_ErrSink *err); DN_API bool DN_OS_WriteAllFV (DN_Str8 path, DN_ErrSink *err, DN_FMT_ATTRIB char const *fmt, va_list args); DN_API bool DN_OS_WriteAllF (DN_Str8 path, DN_ErrSink *err, DN_FMT_ATTRIB char const *fmt, ...); DN_API bool DN_OS_WriteAllSafe (DN_Str8 path, DN_Str8 buffer, DN_ErrSink *err); DN_API bool DN_OS_WriteAllSafeFV (DN_Str8 path, DN_ErrSink *err, DN_FMT_ATTRIB char const *fmt, va_list args); DN_API bool DN_OS_WriteAllSafeF (DN_Str8 path, DN_ErrSink *err, DN_FMT_ATTRIB char const *fmt, ...); #endif // !defined(DN_NO_OS_FILE_API) // NOTE: File system paths ///////////////////////////////////////////////////////////////////////// DN_API bool DN_OS_PathAddRef (DN_Arena *arena, DN_OSPath *fs_path, DN_Str8 path); #define DN_OS_PathAddRef_TLS(...) DN_OS_PathAddRef(DN_TLS_TopArena(), ##__VA_ARGS__) #define DN_OS_PathAddRef_Frame(...) DN_OS_PathAddRef(DN_TLS_FrameArena(), ##__VA_ARGS__) DN_API bool DN_OS_PathAdd (DN_Arena *arena, DN_OSPath *fs_path, DN_Str8 path); #define DN_OS_PathAdd_TLS(...) DN_OS_PathAdd(DN_TLS_TopArena(), ##__VA_ARGS__) #define DN_OS_PathAdd_Frame(...) DN_OS_PathAdd(DN_TLS_FrameArena(), ##__VA_ARGS__) DN_API bool DN_OS_PathAddF (DN_Arena *arena, DN_OSPath *fs_path, DN_FMT_ATTRIB char const *fmt, ...); #define DN_OS_PathAddF_TLS(...) DN_OS_PathAddF(DN_TLS_TopArena(), ##__VA_ARGS__) #define DN_OS_PathAddF_Frame(...) DN_OS_PathAddF(DN_TLS_FrameArena(), ##__VA_ARGS__) DN_API bool DN_OS_PathPop (DN_OSPath *fs_path); DN_API DN_Str8 DN_OS_PathBuildWithSeparator (DN_Arena *arena, DN_OSPath const *fs_path, DN_Str8 path_separator); #define DN_OS_PathBuildWithSeperator_TLS(...) DN_OS_PathBuildWithSeperator(DN_TLS_TopArena(), ##__VA_ARGS__) #define DN_OS_PathBuildWithSeperator_Frame(...) DN_OS_PathBuildWithSeperator(DN_TLS_FrameArena(), ##__VA_ARGS__) DN_API DN_Str8 DN_OS_PathTo (DN_Arena *arena, DN_Str8 path, DN_Str8 path_separtor); #define DN_OS_PathTo_TLS(...) DN_OS_PathTo(DN_TLS_TopArena(), ##__VA_ARGS__) #define DN_OS_PathTo_Frame(...) DN_OS_PathTo(DN_TLS_FrameArena(), ##__VA_ARGS__) DN_API DN_Str8 DN_OS_PathToF (DN_Arena *arena, DN_Str8 path_separator, DN_FMT_ATTRIB char const *fmt, ...); #define DN_OS_PathToF_TLS(...) DN_OS_PathToF(DN_TLS_TopArena(), ##__VA_ARGS__) #define DN_OS_PathToF_Frame(...) DN_OS_PathToF(DN_TLS_FrameArena(), ##__VA_ARGS__) DN_API DN_Str8 DN_OS_Path (DN_Arena *arena, DN_Str8 path); #define DN_OS_Path_TLS(...) DN_OS_Path(DN_TLS_TopArena(), ##__VA_ARGS__) #define DN_OS_Path_Frame(...) DN_OS_Path(DN_TLS_FrameArena(), ##__VA_ARGS__) DN_API DN_Str8 DN_OS_PathF (DN_Arena *arena, DN_FMT_ATTRIB char const *fmt, ...); #define DN_OS_PathF_TLS(...) DN_OS_PathF(DN_TLS_TopArena(), ##__VA_ARGS__) #define DN_OS_PathF_Frame(...) DN_OS_PathF(DN_TLS_FrameArena(), ##__VA_ARGS__) #define DN_OS_PathBuildFwdSlash(allocator, fs_path) DN_OS_PathBuildWithSeparator(allocator, fs_path, DN_STR8("/")) #define DN_OS_PathBuildBackSlash(allocator, fs_path) DN_OS_PathBuildWithSeparator(allocator, fs_path, DN_STR8("\\")) #define DN_OS_PathBuild(allocator, fs_path) DN_OS_PathBuildWithSeparator(allocator, fs_path, DN_OSPathSeparatorString) // NOTE: [$EXEC] DN_OSExec //////////////////////////////////////////////////////////////////////// DN_API void DN_OS_Exit (int32_t exit_code); DN_API DN_OSExecResult DN_OS_ExecPump (DN_OSExecAsyncHandle handle, char *stdout_buffer, size_t *stdout_size, char *stderr_buffer, size_t *stderr_size, uint32_t timeout_ms, DN_ErrSink *err); DN_API DN_OSExecResult DN_OS_ExecWait (DN_OSExecAsyncHandle handle, DN_Arena *arena, DN_ErrSink *err); DN_API DN_OSExecAsyncHandle DN_OS_ExecAsync (DN_Slice cmd_line, DN_OSExecArgs *args, DN_ErrSink *err); DN_API DN_OSExecResult DN_OS_Exec (DN_Slice cmd_line, DN_OSExecArgs *args, DN_Arena *arena, DN_ErrSink *err); DN_API DN_OSExecResult DN_OS_ExecOrAbort (DN_Slice cmd_line, DN_OSExecArgs *args, DN_Arena *arena); #define DN_OS_ExecOrAbort_TLS(...) DN_OS_ExecOrAbort(__VA_ARGS__, DN_TLS_TopArena()) // NOTE: [$SEMA] DN_OSSemaphore /////////////////////////////////////////////////////////////////// #if !defined(DN_NO_SEMAPHORE) DN_API DN_OSSemaphore DN_OS_SemaphoreInit (uint32_t initial_count); DN_API bool DN_OS_SemaphoreIsValid (DN_OSSemaphore *semaphore); DN_API void DN_OS_SemaphoreDeinit (DN_OSSemaphore *semaphore); DN_API void DN_OS_SemaphoreIncrement(DN_OSSemaphore *semaphore, uint32_t amount); DN_API DN_OSSemaphoreWaitResult DN_OS_SemaphoreWait (DN_OSSemaphore *semaphore, uint32_t timeout_ms); #endif // !defined(DN_NO_SEMAPHORE) // NOTE: [$MUTX] DN_OSMutex /////////////////////////////////////////////////////////////////////// DN_API DN_OSMutex DN_OS_MutexInit (); DN_API void DN_OS_MutexDeinit(DN_OSMutex *mutex); DN_API void DN_OS_MutexLock (DN_OSMutex *mutex); DN_API void DN_OS_MutexUnlock(DN_OSMutex *mutex); #define DN_OS_Mutex(mutex) DN_DEFER_LOOP(DN_OS_MutexLock(mutex), DN_OS_MutexUnlock(mutex)) // NOTE: [$THRD] DN_OSThread ///////////////////////////////////////////////////////////////////// #if !defined(DN_NO_THREAD) && !defined(DN_NO_SEMAPHORE) DN_API bool DN_OS_ThreadInit (DN_OSThread *thread, DN_OSThreadFunc *func, void *user_context); DN_API void DN_OS_ThreadDeinit(DN_OSThread *thread); DN_API uint32_t DN_OS_ThreadID (); DN_API void DN_OS_ThreadSetTLS(DN_TLS *tls); DN_API void DN_OS_ThreadSetName(DN_Str8 name); #endif // !defined(DN_NO_THREAD) // NOTE: [$HTTP] DN_OSHttp //////////////////////////////////////////////////////////////////////// DN_API void DN_OS_HttpRequestAsync(DN_OSHttpResponse *response, DN_Arena *arena, DN_Str8 host, DN_Str8 path, DN_OSHttpRequestSecure secure, DN_Str8 method, DN_Str8 body, DN_Str8 headers); DN_API void DN_OS_HttpRequestWait (DN_OSHttpResponse *response); DN_API void DN_OS_HttpRequestFree (DN_OSHttpResponse *response); DN_API DN_OSHttpResponse DN_OS_HttpRequest (DN_Arena *arena, DN_Str8 host, DN_Str8 path, DN_OSHttpRequestSecure secure, DN_Str8 method, DN_Str8 body, DN_Str8 headers);