Success running on linux

src/basic/unix.cpp

@@ -0,0 +1,239 @@
+#include "filesystem.h"
+#include <dirent.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/syscall.h>
+#include <sys/mman.h>
+#include <linux/limits.h>
+#include <unistd.h>
+#include <time.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+void (*Error)(const char *, ...);
+
+void *VReserve(size_t size) {
+    void *result = mmap(0, size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, (off_t)0);
+    return result == (void *)-1 ? 0 : result;
+}
+
+bool VCommit(void *p, size_t size) {
+    int result = mprotect(p, size, PROT_READ | PROT_WRITE);
+    return result == 0;
+}
+
+bool VRelease(void *p, size_t size) {
+    int result = munmap(p, size);
+    return result == 0;
+}
+
+bool VDecommit(void *p, size_t size) {
+    mprotect(p, size, PROT_NONE);
+    madvise(p, size, MADV_DONTNEED);
+    return true;
+}
+
+void InitOS(void (*error_proc)(const char *, ...)) {
+    Error = error_proc;
+}
+
+String ReadFile(Allocator al, String path) {
+    Scratch scratch(al);
+    String null_term = Copy(scratch, path);
+    String result = {};
+    FILE *f = fopen(null_term.data, "rb");
+    if (f) {
+        fseek(f, 0, SEEK_END);
+        result.len = ftell(f);
+        fseek(f, 0, SEEK_SET);
+
+        result.data = (char *)AllocSize(al, result.len + 1);
+        fread(result.data, result.len, 1, f);
+        result.data[result.len] = 0;
+
+        fclose(f);
+    }
+    return result;
+}
+
+bool WriteFile(String path, String data) {
+    Scratch scratch;
+    String null_term = Copy(scratch, path);
+    bool result = false;
+    FILE *f = fopen((const char *)null_term.data, "w");
+    if (f) {
+        size_t written = fwrite(data.data, 1, data.len, f);
+        if (written == data.len) {
+            result = true;
+        }
+        fclose(f);
+    }
+    return result;
+}
+
+bool DeleteFile(String path) {
+    Scratch scratch;
+    String null_term = Copy(scratch, path);
+    int result = unlink(null_term.data);
+    return result == 0;
+}
+
+MakeDirResult MakeDir(String path) {
+    Scratch scratch;
+    String null_term = Copy(scratch, path);
+    int error = mkdir(null_term.data, 0755);
+    MakeDirResult result = MakeDirResult_Success;
+    if (error != 0) {
+        result = MakeDirResult_ErrorOther;
+        if (errno == EEXIST) result = MakeDirResult_Exists;
+    }
+    return result;
+}
+
+int64_t GetFileModTime(String path) {
+    Scratch scratch;
+    String null_term = Copy(scratch, path);
+    struct stat attrib = {};
+    stat(null_term.data, &attrib);
+    struct timespec ts = attrib.st_mtim;
+    int64_t result = (((int64_t)ts.tv_sec) * 1000000ll) + ((int64_t)ts.tv_nsec) / 1000ll;
+    return result;
+}
+
+String GetAbsolutePath(Allocator al, String path) {
+    Scratch scratch(al);
+    String null_term = Copy(scratch, path);
+    char *buffer = AllocArray(al, char, PATH_MAX);
+    realpath(null_term.data, buffer);
+    String result = buffer;
+    return buffer;
+}
+
+bool FileExists(String path) {
+    Scratch scratch;
+    String null_term = Copy(scratch, path);
+    bool result = false;
+    if (access((char *)null_term.data, F_OK) == 0) {
+        result = true;
+    }
+    return result;
+}
+
+bool IsDir(String path) {
+    Scratch scratch;
+    String null_term = Copy(scratch, path);
+    struct stat s;
+    if (stat(null_term.data, &s) != 0)
+        return false;
+    return S_ISDIR(s.st_mode);
+}
+
+bool IsFile(String path) {
+    Scratch scratch;
+    String null_term = Copy(scratch, path);
+    struct stat s;
+    if (stat(null_term.data, &s) != 0)
+        return false;
+    return S_ISREG(s.st_mode);
+}
+
+bool IsAbsolute(String path) {
+    bool result = path.len && path.data[0] == '/';
+    return result;
+}
+
+String GetWorkingDir(Allocator al) {
+    char *buffer = AllocArray(al, char, PATH_MAX);
+    char *cwd = getcwd(buffer, PATH_MAX);
+    return cwd;
+}
+
+String GetExePath(Allocator al) {
+    char *buffer = AllocArray(al, char, PATH_MAX);
+    readlink("/proc/self/exe", buffer, PATH_MAX);
+    return buffer;
+}
+
+String GetExeDir(Allocator al) {
+    Scratch scratch(al);
+    String exe_path = GetExePath(scratch);
+    String dir = ChopLastSlash(exe_path);
+    String result = Copy(al, dir);
+    return result;
+}
+
+double get_time_in_micros(void) {
+    struct timespec spec;
+    clock_gettime(CLOCK_MONOTONIC, &spec);
+    return (((double)spec.tv_sec) * 1000000) + (((double)spec.tv_nsec) / 1000);
+}
+
+bool IsValid(const FileIter &it) {
+    return it.is_valid;
+}
+
+void Advance(FileIter *it) {
+    struct dirent *file = NULL;
+    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 = Copy(it->allocator, file->d_name);
+
+        const char *dir_char_ending = it->is_directory ? "/" : "";
+        const char *separator = it->path.data[it->path.len - 1] == '/' ? "" : "/";
+        it->relative_path = Format(it->allocator, "%.*s%s%s%s", FmtString(it->path), separator, file->d_name, dir_char_ending);
+        it->absolute_path = GetAbsolutePath(it->allocator, it->relative_path);
+        if (it->is_directory) it->absolute_path = Format(it->allocator, "%.*s/", FmtString(it->absolute_path));
+        it->is_valid = true;
+        return;
+    }
+    it->is_valid = false;
+    closedir((DIR *)it->dir);
+}
+
+FileIter IterateFiles(Allocator alo, String path) {
+    FileIter it = {};
+    it.allocator = alo;
+    it.path = path;
+    Scratch scratch(alo);
+    String null_term = Copy(scratch, path);
+    it.dir = (void *)opendir((char *)null_term.data);
+    if (it.dir) {
+        Advance(&it);
+    }
+    return it;
+}
+
+struct UnixProcess {
+    pid_t pid;
+};
+
+Process SpawnProcess(String command_line, String working_dir, String write_stdin, Array<String> enviroment) {
+    return {};
+}
+
+bool IsValid(Process *process) {
+    return false;
+}
+
+void KillProcess(Process *process) {
+
+}
+
+String PollStdout(Allocator allocator, Process *process) {
+    return "";
+}
+
+void WriteStdin(Process *process, String string) {
+}
+
+void CloseStdin(Process *process) {
+}