727 lines
22 KiB
C
727 lines
22 KiB
C
#ifdef _WIN32
|
|
#ifndef NOMINMAX
|
|
#define NOMINMAX
|
|
#endif
|
|
#ifndef WIN32_LEAN_AND_MEAN
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#endif
|
|
#include <windows.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
OS_API bool OS_EnableTerminalColors(void) {
|
|
// Enable color terminal output
|
|
{
|
|
// Set output mode to handle virtual terminal sequences
|
|
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 {
|
|
IO_Printf("Failed to enable colored terminal output C\n");
|
|
}
|
|
}
|
|
else {
|
|
IO_Printf("Failed to enable colored terminal output B\n");
|
|
}
|
|
}
|
|
else {
|
|
IO_Printf("Failed to enable colored terminal output A\n");
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
OS_API bool OS_IsAbsolute(S8_String path) {
|
|
bool result = path.len > 3 && CHAR_IsAlphabetic(path.str[0]) && path.str[1] == ':' && path.str[2] == '/';
|
|
return result;
|
|
}
|
|
|
|
OS_API S8_String OS_GetExePath(MA_Arena *arena) {
|
|
wchar_t wbuffer[1024];
|
|
DWORD wsize = GetModuleFileNameW(0, wbuffer, MA_LENGTHOF(wbuffer));
|
|
IO_Assert(wsize != 0);
|
|
|
|
S8_String path = UTF_CreateStringFromWidechar(arena, wbuffer, wsize);
|
|
S8_NormalizePathUnsafe(path);
|
|
return path;
|
|
}
|
|
|
|
OS_API S8_String OS_GetExeDir(MA_Arena *arena) {
|
|
S8_String path = OS_GetExePath(arena);
|
|
path = S8_ChopLastSlash(path);
|
|
path.str[path.len] = 0;
|
|
return path;
|
|
}
|
|
|
|
OS_API S8_String OS_GetWorkingDir(MA_Arena *arena) {
|
|
wchar_t wbuffer[1024];
|
|
DWORD wsize = GetCurrentDirectoryW(MA_LENGTHOF(wbuffer), wbuffer);
|
|
IO_Assert(wsize != 0);
|
|
IO_Assert(wsize < 1022);
|
|
wbuffer[wsize++] = '/';
|
|
wbuffer[wsize] = 0;
|
|
|
|
S8_String path = UTF_CreateStringFromWidechar(arena, wbuffer, wsize);
|
|
S8_NormalizePathUnsafe(path);
|
|
return path;
|
|
}
|
|
|
|
OS_API void OS_SetWorkingDir(S8_String path) {
|
|
wchar_t wpath[1024];
|
|
UTF_CreateWidecharFromChar(wpath, MA_LENGTHOF(wpath), path.str, path.len);
|
|
SetCurrentDirectoryW(wpath);
|
|
}
|
|
|
|
OS_API S8_String OS_GetAbsolutePath(MA_Arena *arena, S8_String relative) {
|
|
wchar_t wpath[1024];
|
|
UTF_CreateWidecharFromChar(wpath, MA_LENGTHOF(wpath), relative.str, relative.len);
|
|
wchar_t wpath_abs[1024];
|
|
DWORD written = GetFullPathNameW((wchar_t *)wpath, MA_LENGTHOF(wpath_abs), wpath_abs, 0);
|
|
if (written == 0)
|
|
return S8_MakeEmpty();
|
|
S8_String path = UTF_CreateStringFromWidechar(arena, wpath_abs, written);
|
|
S8_NormalizePathUnsafe(path);
|
|
return path;
|
|
}
|
|
|
|
OS_API bool OS_FileExists(S8_String path) {
|
|
wchar_t wbuff[1024];
|
|
UTF_CreateWidecharFromChar(wbuff, MA_LENGTHOF(wbuff), path.str, path.len);
|
|
DWORD attribs = GetFileAttributesW(wbuff);
|
|
bool result = attribs == INVALID_FILE_ATTRIBUTES ? false : true;
|
|
return result;
|
|
}
|
|
|
|
OS_API bool OS_IsDir(S8_String path) {
|
|
wchar_t wbuff[1024];
|
|
UTF_CreateWidecharFromChar(wbuff, MA_LENGTHOF(wbuff), path.str, path.len);
|
|
DWORD dwAttrib = GetFileAttributesW(wbuff);
|
|
return dwAttrib != INVALID_FILE_ATTRIBUTES && (dwAttrib & FILE_ATTRIBUTE_DIRECTORY);
|
|
}
|
|
|
|
OS_API bool OS_IsFile(S8_String path) {
|
|
wchar_t wbuff[1024];
|
|
UTF_CreateWidecharFromChar(wbuff, MA_LENGTHOF(wbuff), path.str, path.len);
|
|
DWORD dwAttrib = GetFileAttributesW(wbuff);
|
|
bool is_file = (dwAttrib & FILE_ATTRIBUTE_DIRECTORY) == 0;
|
|
return dwAttrib != INVALID_FILE_ATTRIBUTES && is_file;
|
|
}
|
|
|
|
OS_API double OS_GetTime(void) {
|
|
static int64_t counts_per_second;
|
|
if (counts_per_second == 0) {
|
|
LARGE_INTEGER freq;
|
|
QueryPerformanceFrequency(&freq);
|
|
counts_per_second = freq.QuadPart;
|
|
}
|
|
|
|
LARGE_INTEGER time;
|
|
QueryPerformanceCounter(&time);
|
|
double result = (double)time.QuadPart / (double)counts_per_second;
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
User needs to copy particular filename to keep it.
|
|
|
|
for (OS_FileIter it = OS_IterateFiles(it); OS_IsValid(iter); OS_Advance(it)) {
|
|
}
|
|
|
|
*/
|
|
|
|
typedef struct OS_Win32_FileIter {
|
|
HANDLE handle;
|
|
WIN32_FIND_DATAW data;
|
|
} OS_Win32_FileIter;
|
|
|
|
OS_API bool OS_IsValid(OS_FileIter it) {
|
|
return it.is_valid;
|
|
}
|
|
|
|
OS_API void OS_Advance(OS_FileIter *it) {
|
|
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 = UTF_CreateStringFromWidechar(it->arena, data->cFileName, S8_WideLength(data->cFileName));
|
|
const char *is_dir = it->is_directory ? "/" : "";
|
|
const char *separator = it->path.str[it->path.len - 1] == '/' ? "" : "/";
|
|
it->relative_path = S8_Format(it->arena, "%.*s%s%.*s%s", S8_Expand(it->path), separator, S8_Expand(it->filename), is_dir);
|
|
it->absolute_path = OS_GetAbsolutePath(it->arena, it->relative_path);
|
|
it->is_valid = true;
|
|
|
|
if (it->is_directory) {
|
|
IO_Assert(it->relative_path.str[it->relative_path.len - 1] == '/');
|
|
IO_Assert(it->absolute_path.str[it->absolute_path.len - 1] == '/');
|
|
}
|
|
return;
|
|
}
|
|
|
|
it->is_valid = false;
|
|
DWORD error = GetLastError();
|
|
IO_Assert(error == ERROR_NO_MORE_FILES);
|
|
FindClose(it->w32->handle);
|
|
}
|
|
|
|
OS_API OS_FileIter OS_IterateFiles(MA_Arena *scratch_arena, S8_String path) {
|
|
OS_FileIter it = {0};
|
|
it.arena = scratch_arena;
|
|
it.path = path;
|
|
|
|
S8_String modified_path = S8_Format(it.arena, "%.*s\\*", S8_Expand(path));
|
|
wchar_t *wbuff = MA_PushArray(it.arena, wchar_t, modified_path.len + 1);
|
|
int64_t wsize = UTF_CreateWidecharFromChar(wbuff, modified_path.len + 1, modified_path.str, modified_path.len);
|
|
IO_Assert(wsize);
|
|
|
|
it.w32 = MA_PushStruct(it.arena, OS_Win32_FileIter);
|
|
it.w32->handle = FindFirstFileW(wbuff, &it.w32->data);
|
|
if (it.w32->handle == INVALID_HANDLE_VALUE) {
|
|
it.is_valid = false;
|
|
return it;
|
|
}
|
|
|
|
IO_Assert(it.w32->data.cFileName[0] == '.' && it.w32->data.cFileName[1] == 0);
|
|
OS_Advance(&it);
|
|
return it;
|
|
}
|
|
|
|
OS_API OS_Result OS_MakeDir(S8_String path) {
|
|
wchar_t wpath[1024];
|
|
UTF_CreateWidecharFromChar(wpath, MA_LENGTHOF(wpath), path.str, path.len);
|
|
BOOL success = CreateDirectoryW(wpath, NULL);
|
|
OS_Result result = OS_SUCCESS;
|
|
if (success == 0) {
|
|
DWORD error = GetLastError();
|
|
if (error == ERROR_ALREADY_EXISTS) {
|
|
result = OS_ALREADY_EXISTS;
|
|
}
|
|
else if (error == ERROR_PATH_NOT_FOUND) {
|
|
result = OS_PATH_NOT_FOUND;
|
|
}
|
|
else {
|
|
IO_Assert(0);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
OS_API OS_Result OS_CopyFile(S8_String from, S8_String to, bool overwrite) {
|
|
wchar_t wfrom[1024];
|
|
UTF_CreateWidecharFromChar(wfrom, MA_LENGTHOF(wfrom), from.str, from.len);
|
|
|
|
wchar_t wto[1024];
|
|
UTF_CreateWidecharFromChar(wto, MA_LENGTHOF(wto), to.str, to.len);
|
|
|
|
BOOL fail_if_exists = !overwrite;
|
|
BOOL success = CopyFileW(wfrom, wto, fail_if_exists);
|
|
|
|
OS_Result result = OS_SUCCESS;
|
|
if (success == FALSE)
|
|
result = OS_FAILURE;
|
|
return result;
|
|
}
|
|
|
|
OS_API OS_Result OS_DeleteFile(S8_String path) {
|
|
wchar_t wpath[1024];
|
|
UTF_CreateWidecharFromChar(wpath, MA_LENGTHOF(wpath), path.str, path.len);
|
|
BOOL success = DeleteFileW(wpath);
|
|
OS_Result result = OS_SUCCESS;
|
|
if (success == 0)
|
|
result = OS_PATH_NOT_FOUND;
|
|
return result;
|
|
}
|
|
|
|
OS_API OS_Result OS_DeleteDir(S8_String path, unsigned flags) {
|
|
IO_Todo();
|
|
return OS_FAILURE;
|
|
#if 0
|
|
if (flags & OS_RECURSIVE) {
|
|
MA_Checkpoint scratch = MA_GetScratch();
|
|
S8_List list = OS_ListDir(scratch.arena, path, OS_RECURSIVE);
|
|
S8_Node *dirs_to_remove = 0;
|
|
for (S8_Node *it = list.first; it; it = it->next) {
|
|
if (!S8_EndsWith(it->string, S8_Lit("/"), S8_IgnoreCase)) {
|
|
OS_DeleteFile(it->string);
|
|
}
|
|
else {
|
|
S8_Node *node = S8_CreateNode(scratch.arena, it->string);
|
|
SLL_STACK_ADD(dirs_to_remove, node);
|
|
}
|
|
}
|
|
for (S8_Node *it = dirs_to_remove; it; it = it->next) {
|
|
OS_DeleteDir(it->string, OS_NO_FLAGS);
|
|
}
|
|
OS_Result result = OS_DeleteDir(path, OS_NO_FLAGS);
|
|
MA_ReleaseScratch(scratch);
|
|
return result;
|
|
}
|
|
else {
|
|
wchar_t wpath[1024];
|
|
UTF_CreateWidecharFromChar(wpath, MA_LENGTHOF(wpath), path.str, path.len);
|
|
BOOL success = RemoveDirectoryW(wpath);
|
|
OS_Result result = OS_SUCCESS;
|
|
if (success == 0)
|
|
result = OS_PATH_NOT_FOUND;
|
|
return result;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
static OS_Result OS__WriteFile(S8_String path, S8_String data, bool append) {
|
|
wchar_t wpath[1024];
|
|
UTF_CreateWidecharFromChar(wpath, MA_LENGTHOF(wpath), path.str, path.len);
|
|
OS_Result result = OS_FAILURE;
|
|
|
|
DWORD access = GENERIC_WRITE;
|
|
DWORD creation_disposition = CREATE_ALWAYS;
|
|
if (append) {
|
|
access = FILE_APPEND_DATA;
|
|
creation_disposition = OPEN_ALWAYS;
|
|
}
|
|
|
|
HANDLE handle = CreateFileW(wpath, access, 0, NULL, creation_disposition, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
if (handle != INVALID_HANDLE_VALUE) {
|
|
DWORD bytes_written = 0;
|
|
IO_Assert(data.len == (DWORD)data.len); // @Todo: can only read 32 byte size files?
|
|
BOOL error = WriteFile(handle, data.str, (DWORD)data.len, &bytes_written, NULL);
|
|
if (error == TRUE) {
|
|
if (bytes_written == data.len) {
|
|
result = OS_SUCCESS;
|
|
}
|
|
}
|
|
CloseHandle(handle);
|
|
}
|
|
else result = OS_PATH_NOT_FOUND;
|
|
|
|
return result;
|
|
}
|
|
|
|
OS_API OS_Result OS_AppendFile(S8_String path, S8_String string) {
|
|
return OS__WriteFile(path, string, true);
|
|
}
|
|
|
|
OS_API OS_Result OS_WriteFile(S8_String path, S8_String string) {
|
|
return OS__WriteFile(path, string, false);
|
|
}
|
|
|
|
OS_API S8_String OS_ReadFile(MA_Arena *arena, S8_String path) {
|
|
bool success = false;
|
|
S8_String result = S8_MakeEmpty();
|
|
MA_Checkpoint checkpoint = MA_Save(arena);
|
|
|
|
wchar_t wpath[1024];
|
|
UTF_CreateWidecharFromChar(wpath, MA_LENGTHOF(wpath), path.str, 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.str = (char *)MA_PushSizeNonZeroed(arena, result.len + 1);
|
|
DWORD read;
|
|
if (ReadFile(handle, result.str, (DWORD)result.len, &read, NULL)) { // @todo: can only read 32 byte size files?
|
|
if (read == result.len) {
|
|
success = true;
|
|
result.str[result.len] = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
CloseHandle(handle);
|
|
}
|
|
|
|
if (!success) {
|
|
result = S8_MakeEmpty();
|
|
MA_Load(checkpoint);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
OS_API int64_t OS_GetFileModTime(S8_String file) {
|
|
FILETIME time = {0};
|
|
WIN32_FIND_DATAW data;
|
|
|
|
wchar_t wpath[1024];
|
|
UTF_CreateWidecharFromChar(wpath, 1024, file.str, file.len);
|
|
HANDLE handle = FindFirstFileW(wpath, &data);
|
|
if (handle != INVALID_HANDLE_VALUE) {
|
|
FindClose(handle);
|
|
time = data.ftLastWriteTime;
|
|
}
|
|
else {
|
|
return -1;
|
|
}
|
|
int64_t result = (int64_t)time.dwHighDateTime << 32 | time.dwLowDateTime;
|
|
return result;
|
|
}
|
|
|
|
OS_API OS_Date OS_GetDate(void) {
|
|
SYSTEMTIME local;
|
|
GetLocalTime(&local);
|
|
|
|
OS_Date result = {0};
|
|
result.year = local.wYear;
|
|
result.month = local.wMonth;
|
|
result.day = local.wDay;
|
|
result.hour = local.wHour;
|
|
result.second = local.wSecond;
|
|
// result.milliseconds = local.wMilliseconds;
|
|
return result;
|
|
}
|
|
|
|
#else
|
|
#include <unistd.h>
|
|
#include <limits.h>
|
|
#include <sys/stat.h>
|
|
#include <time.h>
|
|
#include <dirent.h>
|
|
|
|
OS_API bool OS_EnableTerminalColors(void) { return true; }
|
|
|
|
OS_API bool OS_IsAbsolute(S8_String path) {
|
|
bool result = path.len >= 1 && path.str[0] == '/';
|
|
return result;
|
|
}
|
|
|
|
OS_API S8_String OS_GetExePath(MA_Arena *arena) {
|
|
char buffer[PATH_MAX] = {};
|
|
if (readlink("/proc/self/exe", buffer, PATH_MAX) == -1) {
|
|
return S8_MakeEmpty();
|
|
}
|
|
S8_String result = S8_Copy(arena, S8_MakeFromChar(buffer));
|
|
return result;
|
|
}
|
|
|
|
OS_API S8_String OS_GetExeDir(MA_Arena *arena) {
|
|
S8_String path = OS_GetExePath(arena);
|
|
S8_String dir = S8_ChopLastSlash(path);
|
|
S8_String copy = S8_Copy(arena, dir);
|
|
return copy;
|
|
}
|
|
|
|
OS_API S8_String OS_GetWorkingDir(MA_Arena *arena) {
|
|
char *buffer = (char *)MA_PushSizeNonZeroed(arena, PATH_MAX);
|
|
char *cwd = getcwd(buffer, PATH_MAX);
|
|
S8_String result = S8_MakeFromChar(cwd);
|
|
return result;
|
|
}
|
|
|
|
OS_API void OS_SetWorkingDir(S8_String path) {
|
|
MA_Checkpoint scratch = MA_GetScratch();
|
|
S8_String copy = S8_Copy(scratch.arena, path);
|
|
chdir(copy.str);
|
|
MA_ReleaseScratch(scratch);
|
|
}
|
|
|
|
OS_API S8_String OS_GetAbsolutePath(MA_Arena *arena, S8_String relative) {
|
|
MA_Checkpoint scratch = MA_GetScratch1(arena);
|
|
S8_String copy = S8_Copy(scratch.arena, relative);
|
|
|
|
char *buffer = (char *)MA_PushSizeNonZeroed(arena, PATH_MAX);
|
|
realpath((char *)copy.str, buffer);
|
|
S8_String result = S8_MakeFromChar(buffer);
|
|
|
|
MA_ReleaseScratch(scratch);
|
|
return result;
|
|
}
|
|
|
|
OS_API bool OS_FileExists(S8_String path) {
|
|
MA_Checkpoint scratch = MA_GetScratch();
|
|
S8_String copy = S8_Copy(scratch.arena, path);
|
|
|
|
bool result = false;
|
|
if (access((char *)copy.str, F_OK) == 0) {
|
|
result = true;
|
|
}
|
|
|
|
MA_ReleaseScratch(scratch);
|
|
return result;
|
|
}
|
|
|
|
OS_API bool OS_IsDir(S8_String path) {
|
|
MA_Checkpoint scratch = MA_GetScratch();
|
|
S8_String copy = S8_Copy(scratch.arena, path);
|
|
|
|
struct stat s;
|
|
if (stat(copy.str, &s) != 0)
|
|
return false;
|
|
|
|
bool result = S_ISDIR(s.st_mode);
|
|
MA_ReleaseScratch(scratch);
|
|
return result;
|
|
}
|
|
|
|
OS_API bool OS_IsFile(S8_String path) {
|
|
MA_Checkpoint scratch = MA_GetScratch();
|
|
S8_String copy = S8_Copy(scratch.arena, path);
|
|
|
|
struct stat s;
|
|
if (stat(copy.str, &s) != 0)
|
|
return false;
|
|
bool result = S_ISREG(s.st_mode);
|
|
MA_ReleaseScratch(scratch);
|
|
return result;
|
|
}
|
|
|
|
OS_API double OS_GetTime(void) {
|
|
struct timespec ts;
|
|
clock_gettime(CLOCK_MONOTONIC, &ts);
|
|
uint64_t timeu64 = (((uint64_t)ts.tv_sec) * 1000000ull) + ((uint64_t)ts.tv_nsec) / 1000ull;
|
|
double timef = (double)timeu64;
|
|
double result = timef / 1000000.0; // Microseconds to seconds
|
|
return result;
|
|
}
|
|
|
|
OS_API bool OS_IsValid(OS_FileIter it) {
|
|
return it.is_valid;
|
|
}
|
|
|
|
OS_API void OS_Advance(OS_FileIter *it) {
|
|
struct dirent *file = 0;
|
|
while ((file = readdir((DIR *)it->dir)) != NULL) {
|
|
if (file->d_name[0] == '.' && file->d_name[1] == '.' && file->d_name[2] == 0) continue;
|
|
if (file->d_name[0] == '.' && file->d_name[1] == 0) continue;
|
|
|
|
it->is_directory = file->d_type == DT_DIR;
|
|
it->filename = S8_CopyChar(it->arena, file->d_name);
|
|
|
|
const char *dir_char_ending = it->is_directory ? "/" : "";
|
|
const char *separator = it->path.str[it->path.len - 1] == '/' ? "" : "/";
|
|
it->relative_path = S8_Format(it->arena, "%.*s%s%s%s", S8_Expand(it->path), separator, file->d_name, dir_char_ending);
|
|
it->absolute_path = OS_GetAbsolutePath(it->arena, it->relative_path);
|
|
if (it->is_directory) it->absolute_path = S8_Format(it->arena, "%.*s/", S8_Expand(it->absolute_path));
|
|
it->is_valid = true;
|
|
return;
|
|
}
|
|
it->is_valid = false;
|
|
closedir((DIR *)it->dir);
|
|
}
|
|
|
|
OS_API OS_FileIter OS_IterateFiles(MA_Arena *arena, S8_String path) {
|
|
OS_FileIter it = {0};
|
|
it.arena = arena;
|
|
it.path = path = S8_Copy(arena, path);
|
|
it.dir = (void *)opendir((char *)path.str);
|
|
if (!it.dir) return it;
|
|
|
|
OS_Advance(&it);
|
|
return it;
|
|
}
|
|
|
|
OS_API OS_Result OS_MakeDir(S8_String path) {
|
|
MA_Checkpoint scratch = MA_GetScratch();
|
|
path = S8_Copy(scratch.arena, path);
|
|
int error = mkdir(path.str, 0755);
|
|
MA_ReleaseScratch(scratch);
|
|
return error == 0 ? OS_SUCCESS : OS_FAILURE;
|
|
}
|
|
|
|
OS_API OS_Result OS_CopyFile(S8_String from, S8_String to, bool overwrite) {
|
|
const char *ow = overwrite ? "-n" : "";
|
|
int result = OS_SystemF("cp %s %.*s %.*s", ow, S8_Expand(from), S8_Expand(to));
|
|
return result == 0 ? OS_SUCCESS : OS_FAILURE;
|
|
}
|
|
|
|
OS_API OS_Result OS_DeleteFile(S8_String path) {
|
|
int result = OS_SystemF("rm %.*s", S8_Expand(path));
|
|
return result == 0 ? OS_SUCCESS : OS_FAILURE;
|
|
}
|
|
|
|
OS_API OS_Result OS_DeleteDir(S8_String path, unsigned flags) {
|
|
IO_Assert(flags & OS_RECURSIVE);
|
|
int result = OS_SystemF("rm -r %.*s", S8_Expand(path));
|
|
return result == 0 ? OS_SUCCESS : OS_FAILURE;
|
|
}
|
|
|
|
OS_API int64_t OS_GetFileModTime(S8_String file) {
|
|
MA_Checkpoint scratch = MA_GetScratch();
|
|
file = S8_Copy(scratch.arena, file);
|
|
|
|
struct stat attrib = {};
|
|
stat(file.str, &attrib);
|
|
struct timespec ts = attrib.IF_LINUX_ELSE(st_mtim, st_mtimespec);
|
|
int64_t result = (((int64_t)ts.tv_sec) * 1000000ll) + ((int64_t)ts.tv_nsec) / 1000ll;
|
|
|
|
MA_ReleaseScratch(scratch);
|
|
return result;
|
|
}
|
|
|
|
OS_API OS_Date OS_GetDate(void) {
|
|
time_t t = time(NULL);
|
|
struct tm date = *localtime(&t);
|
|
|
|
OS_Date s = {0};
|
|
s.second = date.tm_sec;
|
|
s.year = date.tm_year;
|
|
s.month = date.tm_mon;
|
|
s.day = date.tm_mday;
|
|
s.hour = date.tm_hour;
|
|
s.minute = date.tm_min;
|
|
|
|
return s;
|
|
}
|
|
|
|
OS_API OS_Result OS_AppendFile(S8_String path, S8_String string) {
|
|
MA_Checkpoint scratch = MA_GetScratch();
|
|
path = S8_Copy(scratch.arena, path);
|
|
|
|
OS_Result result = OS_FAILURE;
|
|
FILE *f = fopen((const char *)path.str, "a");
|
|
if (f) {
|
|
result = OS_SUCCESS;
|
|
|
|
size_t written = fwrite(string.str, 1, string.len, f);
|
|
if (written < string.len) {
|
|
result = OS_FAILURE;
|
|
}
|
|
|
|
int error = fclose(f);
|
|
if (error != 0) {
|
|
result = OS_FAILURE;
|
|
}
|
|
}
|
|
|
|
MA_ReleaseScratch(scratch);
|
|
return result;
|
|
}
|
|
|
|
OS_API S8_String OS_ReadFile(MA_Arena *arena, S8_String path) {
|
|
MA_Checkpoint scratch = MA_GetScratch1(arena);
|
|
path = S8_Copy(scratch.arena, path);
|
|
|
|
S8_String result = {};
|
|
FILE *f = fopen(path.str, "rb");
|
|
if (f) {
|
|
fseek(f, 0, SEEK_END);
|
|
result.len = ftell(f);
|
|
fseek(f, 0, SEEK_SET);
|
|
|
|
result.str = (char *)MA_PushSizeNonZeroed(arena, result.len + 1);
|
|
fread(result.str, result.len, 1, f);
|
|
result.str[result.len] = 0;
|
|
|
|
fclose(f);
|
|
}
|
|
|
|
MA_ReleaseScratch(scratch);
|
|
return result;
|
|
}
|
|
|
|
#if 0
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
OS_API OS_Result OS_WriteFile(S8_String path, S8_String string) {
|
|
IO_Assert(path.str[path.len] == 0);
|
|
|
|
OS_Result result = OS_FAILURE;
|
|
int fd = open(path.str, O_CREAT | O_WRONLY, 0644);
|
|
if (fd != -1) {
|
|
result = OS_SUCCESS;
|
|
|
|
ssize_t written = write(fd, string.str, string.len);
|
|
if (written != string.len) result = OS_FAILURE;
|
|
|
|
int err = close(fd);
|
|
if (err != 0) result = OS_FAILURE;
|
|
}
|
|
return OS_SUCCESS;
|
|
}
|
|
#else
|
|
OS_API OS_Result OS_WriteFile(S8_String path, S8_String string) {
|
|
MA_Checkpoint scratch = MA_GetScratch();
|
|
path = S8_Copy(scratch.arena, path);
|
|
|
|
OS_Result result = OS_FAILURE;
|
|
FILE *f = fopen((const char *)path.str, "w");
|
|
if (f) {
|
|
result = OS_SUCCESS;
|
|
|
|
size_t written = fwrite(string.str, 1, string.len, f);
|
|
if (written < string.len) {
|
|
result = OS_FAILURE;
|
|
}
|
|
|
|
int error = fclose(f);
|
|
if (error != 0) {
|
|
result = OS_FAILURE;
|
|
}
|
|
}
|
|
|
|
MA_ReleaseScratch(scratch);
|
|
return result;
|
|
}
|
|
#endif
|
|
|
|
#endif
|
|
|
|
OS_API int OS_SystemF(const char *string, ...) {
|
|
MA_Checkpoint scratch = MA_GetScratch();
|
|
S8_FORMAT(scratch.arena, string, result);
|
|
IO_Printf("Executing: %.*s\n", S8_Expand(result));
|
|
fflush(stdout);
|
|
int error_code = system(result.str);
|
|
MA_ReleaseScratch(scratch);
|
|
return error_code;
|
|
}
|
|
|
|
OS_API S8_String UTF_CreateStringFromWidechar(MA_Arena *arena, wchar_t *wstr, int64_t wsize) {
|
|
int64_t buffer_size = (wsize + 1) * 2;
|
|
char *buffer = (char *)MA_PushSizeNonZeroed(arena, buffer_size);
|
|
int64_t size = UTF_CreateCharFromWidechar(buffer, buffer_size, wstr, wsize);
|
|
IO_Assert(size < buffer_size);
|
|
return S8_Make(buffer, size);
|
|
}
|
|
|
|
OS_API bool OS_ExpandIncludesList(MA_Arena *arena, S8_List *out, S8_String filepath) {
|
|
S8_String c = OS_ReadFile(arena, filepath);
|
|
if (c.str == 0) return false;
|
|
S8_String path = S8_ChopLastSlash(filepath);
|
|
S8_String include = S8_Lit("#include \"");
|
|
for (;;) {
|
|
int64_t idx = -1;
|
|
if (S8_Seek(c, include, 0, &idx)) {
|
|
S8_String str_to_add = S8_GetPrefix(c, idx);
|
|
S8_AddNode(arena, out, str_to_add);
|
|
S8_String save = c;
|
|
c = S8_Skip(c, idx + include.len);
|
|
|
|
S8_String filename = c;
|
|
filename.len = 0;
|
|
while (filename.str[filename.len] != '"' && filename.len < c.len) {
|
|
filename.len += 1;
|
|
}
|
|
|
|
c = S8_Skip(c, filename.len + 1);
|
|
S8_String inc_path = S8_Format(arena, "%.*s/%.*s", S8_Expand(path), S8_Expand(filename));
|
|
if (!OS_ExpandIncludesList(arena, out, inc_path)) {
|
|
S8_String s = S8_GetPrefix(save, save.len - c.len);
|
|
S8_AddNode(arena, out, s);
|
|
}
|
|
}
|
|
else {
|
|
S8_AddNode(arena, out, c);
|
|
break;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
OS_API S8_String OS_ExpandIncludes(MA_Arena *arena, S8_String filepath) {
|
|
S8_List out = S8_MakeEmptyList();
|
|
S8_String result = S8_MakeEmpty();
|
|
MA_ScratchScope(s) {
|
|
OS_ExpandIncludesList(s.arena, &out, filepath);
|
|
result = S8_Merge(arena, out);
|
|
}
|
|
return result;
|
|
} |