fixes

.clangd

@@ -1,3 +1,4 @@
 CompileFlags:
-  Add: 
+  Add:
+    - [-std=c99, -xc]
     - -DOS_LINUX

app.cpp

@@ -1,13 +1,12 @@
-#include <stdio.h>
-#include "core.cpp"
-#include "core.h"
+#include "core.c"
 
 int main(int argc, char **argv) {
     initialiseDjStdCore();
     Arena *arena = arenaAlloc(Megabytes(64));
-    list<string> args = getArgs(arena, argc, argv);
+    StringList args = getArgs(arena, argc, argv);
 
-    print("%S", strSplit(arena, "-"_s, "hallo-world"_s));
+    printStrList(args);
+    printStrList(strSplit(arena, s("-"), s("the-quick-brown-fox-jumps-over-the-lazy-dog")));
 
     return 0;
 }

core.c

@@ -1,6 +1,6 @@
-#include "os.cpp"
-#include <math.h>
-#include <string.h>
+#include "os.c"
+#include "math.h"
+#include "string.h" // memmove
 #include "core.h"
 #define STB_SPRINTF_IMPLEMENTATION
 #include "vendor/stb_sprintf.h"
@@ -78,42 +78,6 @@ void scratchEnd(Scratch scratch) {
     arenaFreeFrom(scratch.arena, scratch.start);
 }
 
-template <typename T>
-T *appendList(list<T> *list, T element) {
-    if (list->head < list->length) {
-        list->data[list->head] = element;
-        list->head++;
-        return &(list->data[list->head - 1]);
-    } else {
-        return 0;
-    }
-}
-
-template <typename T>
-void zeroListFull(list<T> *list) {
-    memset(list->data, 0, list->head * sizeof(T));
-}
-
-template <typename T>
-void zeroList(list<T> *list) {
-    list->head = 0;
-    memset(list->data, 0, list->head * sizeof(T));
-}
-
-inline string operator""_s(const char *cstrLiteral, size_t length) {
-    return {
-        (char *)cstrLiteral,
-        length,
-    };
-}
-
-const char *cstring(Arena *arena, list<char> buf) {
-    char *arr = PushArray(arena, char, buf.length + 1);
-    memmove(arr, buf.data, buf.length);
-    arr[buf.length] = '\0';
-    return arr;
-}
-
 const char *cstring(Arena *arena, string str) {
     char *arr = PushArray(arena, char, str.length + 1);
     memmove(arr, str.str, str.length);
@@ -121,6 +85,13 @@ const char *cstring(Arena *arena, string str) {
     return arr;
 }
 
+const char *cstringFromCharList(Arena *arena, CharList buf) {
+    char *arr = PushArray(arena, char, buf.length + 1);
+    memmove(arr, buf.data, buf.length);
+    arr[buf.length] = '\0';
+    return arr;
+}
+
 bool strStartsWith(string str, string testStr) {
     if (str.length < testStr.length) {
         return false;
@@ -194,21 +165,7 @@ string strPrintf(Arena *arena, const char *fmt, ...) {
     return result;
 }
 
-template <typename T>
-list<T> listSlice(list<T> l, size_t start, size_t stop) {
-    if (stop == 0) {
-        stop = l.head;
-    }
-    // TODO(djledda): maybe assert instead
-    if (stop > l.head || start > stop) {
-        return {0};
-    }
-    return {
-        l.data + start,
-        stop - start,
-        stop - start,
-    };
-}
+#define ListSlice(__ls_list__, __ls_start__, __ls_stop__) (__ls_stop__ > l.head || __ls_start__ > __ls_stop__ ? {0} : { l.data + start, stop - start, stop - start, })
 
 string strSlice(string str, size_t start, size_t stop) {
     if (stop == 0) {
@@ -216,16 +173,16 @@ string strSlice(string str, size_t start, size_t stop) {
     }
     // TODO(djledda): maybe assert instead
     if (stop > str.length || start > stop) {
-        return {0};
+        return (string){0};
     }
-    return {
+    return (string){
         str.str + start,
         stop - start,
     };
 }
 
-string strSlice(char *data, size_t start, size_t stop) {
-    return {
+string strSliceCStr(char *data, size_t start, size_t stop) {
+    return (string){
         data + start,
         stop - start,
     };
@@ -240,20 +197,21 @@ bool stringContains(string str, char c) {
     return false;
 }
 
-string NUMERIC_CHARS = "0123456789"_s;
+string NUMERIC_CHARS = s("0123456789");
 inline bool isNumeric(char c) {
     return stringContains(NUMERIC_CHARS, c);
 }
 
-list<string> strSplit(Arena *arena, string splitStr, string inputStr) {
-    list<string> result = {0};
+StringList strSplit(Arena *arena, string splitStr, string inputStr) {
+    StringList result = {0};
     if (inputStr.length > 0) {
         size_t splitCount = 0;
         size_t c = 0;
         size_t start = 0;
         void *beginning = (char *)arena->memory + arena->head;
         while (c < inputStr.length - splitStr.length) {
-            if (strEql(strSlice(inputStr, c, c + splitStr.length), splitStr)) {
+            string mystr = strSlice(inputStr, c, c + splitStr.length);
+            if (strEql(mystr, splitStr)) {
                 string *splitString = PushStruct(arena, string);
                 splitString->str = inputStr.str + start;
                 splitString->length = c - start;
@@ -267,9 +225,10 @@ list<string> strSplit(Arena *arena, string splitStr, string inputStr) {
         splitString->str = inputStr.str + start;
         splitString->length = inputStr.length - start;
         splitCount++;
-        result.data = (string *)beginning,
-        result.head = splitCount,
+
+        result.data = (string *)beginning;
         result.length = splitCount;
+        result.head = splitCount;
     }
     return result;
 }
@@ -288,17 +247,17 @@ ParsePositiveIntResult parsePositiveInt(string str, size_t *lengthPointer) {
             result *= 10;
             result += str.str[i] - '0';
         }
-        return {result, true};
+        return (ParsePositiveIntResult){ result, true };
     } else {
-        return {0, false};
+        return (ParsePositiveIntResult){0, false};
     }
 }
 
 ParsePositiveReal32Result parsePositiveReal32(string str, size_t *lengthPointer) {
     ParsePositiveReal32Result result = {NAN, false};
 
-    string wholePartStr = string{0};
-    string fractionalPartStr = string{0};
+    string wholePartStr = (string){0};
+    string fractionalPartStr = (string){0};
 
     bool split = false;
     size_t c = 0;
@@ -333,14 +292,14 @@ ParsePositiveReal32Result parsePositiveReal32(string str, size_t *lengthPointer)
     return result;
 }
 
-list<string> getArgs(Arena *arena, int argc, char **argv) {
-    list<string> args = PushList(arena, string, (size_t)argc - 1);
+StringList getArgs(Arena *arena, int argc, char **argv) {
+    StringList args = PushList(arena, StringList, (size_t)argc - 1);
     for (int i = 1; i < argc; i++) {
-        appendList(&args, strFromCString(arena, argv[i]));
+        AppendList(&args, strFromCString(arena, argv[i]));
     }
     return args;
 }
- 
+
 UnixTimestamp getSystemUnixTime() {
     time_t now;
     time(&now);
@@ -348,38 +307,38 @@ UnixTimestamp getSystemUnixTime() {
 }
 
 Timestamp timestampFromUnixTime(UnixTimestamp *unixTimestamp) {
-    tm timestamp = {0};
+    struct tm timestamp = {0};
     gmtime_r((time_t *)unixTimestamp, &timestamp);
     return timestamp;
 }
 
-string formatTimeHms(Arena *arena, UnixTimestamp time) {
-    local_persist const string format = "HH-MM-SS"_s;
+string formatTimeHmsUnix(Arena *arena, UnixTimestamp time) {
+    local_persist const string format = s("HH-MM-SS");
     string buf = PushString(arena, format.length);
-    tm *timestamp = gmtime((time_t *)&time);
+    struct tm *timestamp = gmtime((time_t *)&time);
     strftime(buf.str, buf.length + 1, "%T", timestamp);
     return buf;
 }
 
 string formatTimeHms(Arena *arena, Timestamp *time) {
-    local_persist const string format = "HH-MM-SS"_s;
+    local_persist const string format = s("HH-MM-SS");
     string buf = PushString(arena, format.length);
-    strftime(buf.str, buf.length + 1, "%T", (tm *)time);
+    strftime(buf.str, buf.length + 1, "%T", (struct tm *)time);
     return buf;
 }
 
-string formatTimeYmd(Arena *arena, UnixTimestamp time) {
-    local_persist const string format = "YYYY-mm-dd"_s;
+string formatTimeYmdUnix(Arena *arena, UnixTimestamp time) {
+    local_persist const string format = s("YYYY-mm-dd");
     string buf = PushString(arena, format.length);
-    tm *timestamp = gmtime((time_t *)&time);
+    struct tm *timestamp = gmtime((time_t *)&time);
     strftime(buf.str, buf.length + 1, "%Y-%m-%d", timestamp);
     return buf;
 }
 
 string formatTimeYmd(Arena *arena, Timestamp *time) {
-    local_persist const string format = "YYYY-mm-dd"_s;
+    local_persist const string format = s("YYYY-mm-dd");
     string buf = PushString(arena, format.length);
-    strftime(buf.str, buf.length + 1, "%Y-%m-%d", (tm *)time);
+    strftime(buf.str, buf.length + 1, "%Y-%m-%d", (struct tm *)time);
     return buf;
 }
 
@@ -397,13 +356,11 @@ function void printStdout(const char *fmt, ...) {
     va_end(argList);
 }
 
-void print(const char *fmt, ...) {
-    va_list argList;
-    va_start(argList, fmt);
-    os_print(StdStream_stdout, fmt, argList);
-    va_end(argList);
-}
+void (*print)(const char *fmt, ...) = &printStdout;
+#define SetStdErr() DeferLoop(print = &printStderr, print = &printStdout)
 
+// TODO(dledda): mat print functions
+/*
 void print(list<Vector4<real32>> l, StdStream target) {
     void (*logFn)(const char *fmt, ...) = target == StdStream_stdout ? &printStdout : &printStderr;
     logFn("{ ");
@@ -439,29 +396,28 @@ void print(list<Vector2<real32>> l, StdStream target) {
     }
     logFn(" } length: %zu, head: %zu\n", l.length, l.head);
 }
+*/
 
-void print(list<int> l, StdStream target) {
-    void (*logFn)(const char *fmt, ...) = target == StdStream_stdout ? &printStdout : &printStderr;
-    logFn("{ ");
+void printIntList(IntList l) {
+    print("{ ");
     for (size_t i = 0; i < l.length; i++) {
         if (i != 0) {
-            logFn(", ");
+            print(", ");
         }
-        logFn("%i", l.data[i]);
+        print("%i", l.data[i]);
     }
-    logFn(" } length: %zu, head: %zu\n", l.length, l.head);
+    print(" } length: %zu, head: %zu\n", l.length, l.head);
 }
 
-void print(list<string> l, StdStream target) {
-    void (*logFn)(const char *fmt, ...) = target == StdStream_stdout ? &printStdout : &printStderr;
-    logFn("{ ");
+void printStrList(StringList l) {
+    print("{ ");
     for (size_t i = 0; i < l.length; i++) {
         if (i != 0) {
-            logFn(", ");
-        } 
-        logFn("\"%S\"", l.data[i]);
+            print(", ");
+        }
+        print("\"%S\"", l.data[i]);
     }
-    logFn(" } length: %zu, head: %zu\n", l.length, l.head);
+    print(" } length: %zu, head: %zu\n", l.length, l.head);
 }
 
 int intCompare(const void *a, const void *b) {

core.h

@@ -2,20 +2,21 @@
 #define CORE_H
 
 // cstdlib includes
-#include <math.h>
-#include <stdint.h> // necessary for int type sizes
-#include <stdio.h>
-#include <time.h> // TODO(djledda): try not to depend on this one
+#include "math.h"
+#include "stdbool.h"
+#include "stdint.h" // necessary for int type sizes
+#include "stdio.h"
+#include "time.h" // TODO(djledda): try not to depend on this one
 
-// ### Misc macros ### 
+// ### Misc macros ###
 #if ENABLE_ASSERT
 #define Assert(expression) if (!(expression)) {*(volatile int *)0 = 0;}
 #else
-#define Assert(expression) 
+#define Assert(expression)
 #endif
 
 #define function static
-#define global static 
+#define global static
 #define local_persist static
 
 // ### Types ###
@@ -30,6 +31,7 @@ typedef uint64_t uint64;
 typedef uint8_t byte;
 typedef float real32;
 typedef double real64;
+typedef struct string string;
 
 // ### Sizes and Numbers ###
 #define Bytes(n) (n)
@@ -43,18 +45,22 @@ typedef double real64;
 #define Billion(n)  ((n)*1000000000LL)
 
 #define ArrayCount(arr) (sizeof(arr) / sizeof((arr)[0]))
+#define MemberSize(type, memberName) sizeof(((type *)0)->memberName)
+#define MemberType(type, memberName) typeof(((type *)0)->memberName)
+#define MemberSizeUnderlying(type, memberName) sizeof(*((type *)0)->memberName)
+#define MemberTypeUnderlying(type, memberName) typeof(*((type *)0)->memberName)
 
 // ### Arenas ###
-struct Arena {
+typedef struct {
     void *memory;
     size_t capacity;
     size_t head;
-};
+} Arena;
 
-struct Scratch {
+typedef struct {
     Arena *arena;
     size_t start;
-};
+} Scratch;
 
 void *pushSize(Arena *arena, size_t bytes);
 void *pushSizeFill(Arena *arena, size_t bytes, byte fill);
@@ -65,8 +71,8 @@ void arenaPopTo(Arena *arena, void *pos);
 
 void initialiseDjStdCore();
 
-Scratch scratchStart(Arena **conflicts, size_t conflictCount); 
-void scratchEnd(Scratch scratch); 
+Scratch scratchStart(Arena **conflicts, size_t conflictCount);
+void scratchEnd(Scratch scratch);
 
 #define PushArray(arena, type, size) (type *)pushSize(arena, sizeof(type) * (size))
 #define PushArrayZero(arena, type, size) (type *)pushSizeFill(arena, sizeof(type) * (size), 0)
@@ -74,59 +80,53 @@ void scratchEnd(Scratch scratch);
 #define PushStructZero(arena, type) (type *)pushSizeFill(arena, sizeof(type), 0)
 
 // ### Vectors ###
-template <typename T>
-union Vector2 {
+typedef union {
     struct {
-        T x;
-        T y;
+        real32 x;
+        real32 y;
     };
-    T vec[2];
-};
-template <typename T>
-inline function Vector2<T> vec2(T x, T y) {
-    Vector2<T> result = {0};
+    real32 vec[2];
+} Vec2;
+inline function Vec2 vec2(real32 x, real32 y) {
+    Vec2 result = {0};
     result.x = x;
     result.y = y;
     return result;
 }
 
-template <typename T>
-union Vector3 {
+typedef union {
     struct {
-        T x;
-        T y;
-        T z;
+        real32 x;
+        real32 y;
+        real32 z;
     };
-    T vec[3];
-};
-template <typename T>
-inline function Vector3<T> vec3(T x, T y, T z) {
-    Vector3<T> result = {0};
+    real32 vec[3];
+} Vec3;
+inline function Vec3 vec3(real32 x, real32 y, real32 z) {
+    Vec3 result = {0};
     result.x = x;
     result.y = y;
     result.z = z;
     return result;
 }
 
-template <typename T>
-union Vector4 {
+typedef union {
     struct {
-        T r;
-        T g;
-        T b;
-        T a;
+        real32 r;
+        real32 g;
+        real32 b;
+        real32 a;
     };
     struct {
-        T x;
-        T y;
-        T z;
-        T w;
+        real32 x;
+        real32 y;
+        real32 z;
+        real32 w;
     };
-    T vec[4];
-};
-template <typename T>
-inline function Vector4<T> vec4(T x, T y, T z, T w) {
-    Vector4<T> result = {0};
+    real32 vec[4];
+} Vec4;
+inline function Vec4 vec4(real32 x, real32 y, real32 z, real32 w) {
+    Vec4 result = {0};
     result.x = x;
     result.y = y;
     result.z = z;
@@ -135,24 +135,29 @@ inline function Vector4<T> vec4(T x, T y, T z, T w) {
 }
 
 // ### Lists ###
-template <typename T>
-struct list {
-    T* data;
-    size_t length;
-    size_t head;
-};
+#define DefineList(type, prefix) \
+    typedef struct {\
+        type* data;\
+        size_t length;\
+        size_t head;\
+    } prefix ## List
 
-#define PushList(arena, type, size) (list<type>{ PushArray(arena, type, size), size, 0 })
-#define EmptyList(type) (list<type>{ NULL, 0, 0 })
-#define PushListZero(arena, type, size) (list<type>{ PushArrayZero(arena, type, size), size, 0 })
-#define PushFullList(arena, type, size) (list<type>{ PushArray(arena, type, size), size, size })
-#define PushFullListZero(arena, type, size) (list<type>{ PushArrayZero(arena, type, size), size, size })
-#define ArrayAsList(type, array) (list<type>{ array, ArrayCount(array), ArrayCount(array) })
+DefineList(string, String);
 
-template <typename T> T *appendList(list<T> *list, T element); 
-template <typename T> void zeroList(list<T> *list); 
-template <typename T> void zeroListFull(list<T> *list); 
-template <typename T> list<T> listSlice(list<T> l, size_t start, size_t stop = 0); 
+#define PushList(arena, type, size) (type){ (MemberTypeUnderlying(type, data) *)pushSize(arena, MemberSizeUnderlying(type, data)*size), size, 0 }
+#define EmptyList(type) (type){ NULL, 0, 0 }
+#define PushListZero(arena, type, size) (type){ (MemberTypeUnderlying(type, data) *)pushSizeFill(arena, MemberSizeUnderlying(type, data)*size, 0), size, 0 }
+#define PushFullList(arena, type, size) (type){ (MemberTypeUnderlying(type, data) *)pushSize(arena, MemberSizeUnderlying(type, data))*size, size, size }
+#define PushFullListZero(arena, type, size) (type){ (MemberTypeUnderlying(type, data) *)pushSizeFill(arena, MemberSizeUnderlying(type, data)*size, 0), size, size }
+#define ArrayAsList(type, array) (type){ array, ArrayCount(array), ArrayCount(array) }
+
+#define AppendList(list, element) \
+    if ((list)->head < (list)->length) { \
+        (list)->data[(list)->head++] = (element); \
+    }
+#define ZeroListFull(list) memset((list)->data, 0, (list)->head * sizeof(T))
+#define ZeroList(list) (list)->head = 0; \
+    memset((list)->data, 0, (list)->head * sizeof(T));
 
 // ### Strings ###
 struct string {
@@ -162,58 +167,58 @@ struct string {
 #define STB_SPRINTF_DECORATE(name) stb_##name // define this before including if you want to change the names
 #include "vendor/stb_sprintf.h"
 
-#define strlit(lit) (string{(char *)(lit), sizeof(lit) - 1})
-#define PushString(arena, length) (string{ (char *)pushSize(arena, length), (length) })
-#define PushStringFill(arena, length, characterByte) (string{ (char *)pushSizeFill(arena, length, characterByte), (length) })
-string operator""_s(const char *cstrLiteral, size_t length);
+#define s(lit) ((string){(char *)(lit), sizeof(lit) - 1})
+#define PushString(arena, length) ((string){ (char *)pushSize(arena, length), (length) })
+#define PushStringFill(arena, length, characterByte) ((string){ (char *)pushSizeFill(arena, length, characterByte), (length) })
 
 // C Strings
-const char *cstring(Arena *arena, list<char> buf); 
-const char *cstring(Arena *arena, string str); 
-size_t calcStringLen(const char *str); 
-string strFromCString(Arena *arena, const char *str); 
+DefineList(char, Char);
+const char *cstringFromCharList(Arena *arena, CharList buf);
+const char *cstring(Arena *arena, string str);
+size_t calcStringLen(const char *str);
+string strFromCString(Arena *arena, const char *str);
 
-bool strEql(string s1, string s2); 
+bool strEql(string s1, string s2);
 bool strStartsWith(string str, string testStr);
-bool stringContains(string str, char c); 
+bool stringContains(string str, char c);
 
-string strReverse(Arena *arena, string str); 
-string strSlice(string str, size_t start, size_t stop = 0); 
-string strSlice(char *data, size_t start, size_t stop = 0); 
-list<string> strSplit(Arena *arena, string splitStr, string inputStr); 
+string strReverse(Arena *arena, string str);
+string strSlice(string str, size_t start, size_t stop);
+string strSliceCStr(char *data, size_t start, size_t stop);
+StringList strSplit(Arena *arena, string splitStr, string inputStr);
 string strPrintfv(Arena *arena, const char *fmt, va_list args);
 string strPrintf(Arena *arena, const char *fmt, ...);
 
-struct ParsePositiveIntResult { uint8 result; bool valid; };
-ParsePositiveIntResult parsePositiveInt(string str, size_t *lengthPointer); 
-struct ParsePositiveReal32Result { real32 result; bool valid; };
-ParsePositiveReal32Result parsePositiveReal32(Arena *arena, string str, size_t *lengthPointer); 
+typedef struct { uint8 result; bool valid; } ParsePositiveIntResult;
+ParsePositiveIntResult parsePositiveInt(string str, size_t *lengthPointer);
+typedef struct { real32 result; bool valid; } ParsePositiveReal32Result;
+ParsePositiveReal32Result parsePositiveReal32(string str, size_t *lengthPointer);
 
-inline function bool isNumeric(char c); 
+inline function bool isNumeric(char c);
 
 // ### Cmdline ###
-list<string> getArgs(Arena *arena, int argc, char **argv); 
+StringList getArgs(Arena *arena, int argc, char **argv);
 
 // ### Time ###
 typedef uint64 UnixTimestamp;
-typedef tm Timestamp;
+typedef struct tm Timestamp;
 
-UnixTimestamp getSystemUnixTime(); 
-Timestamp timestampFromUnixTime(UnixTimestamp *unixTimestamp); 
-string formatTimeHms(Arena *arena, UnixTimestamp time); 
-string formatTimeHms(Arena *arena, Timestamp *time); 
-string formatTimeYmd(Arena *arena, UnixTimestamp time); 
-string formatTimeYmd(Arena *arena, Timestamp *time); 
+UnixTimestamp getSystemUnixTime();
+Timestamp timestampFromUnixTime(UnixTimestamp *unixTimestamp);
+string formatTimeHmsUnix(Arena *arena, UnixTimestamp time);
+string formatTimeHms(Arena *arena, Timestamp *time);
+string formatTimeYmdUnix(Arena *arena, UnixTimestamp time);
+string formatTimeYmd(Arena *arena, Timestamp *time);
 
 // ### Linked Lists ###
 // TODO(djledda): implement basic linked lists (based on arenas?)
 
 // ### Logging ###
-enum StdStream {
+typedef enum {
     StdStream_stdout,
     StdStream_stdin,
     StdStream_stderr,
-};
+} StdStream;
 
 #define ANSI_INSTRUCTION_FROM_ENUM(ansiCodeEnum) ANSI_INSTRUCTION(ansiCodeEnum)
 #define ANSI_INSTRUCTION(ansiCode) "\u001b[" #ansiCode "m"
@@ -261,13 +266,10 @@ enum StdStream {
 #define COLOR_TEXT_FG_BG(text, foregroundcolor, backgroundcolor) ANSI_INSTRUCTION_FROM_ENUM(foregroundcolor) ANSI_INSTRUCTION_FROM_ENUM(backgroundcolor) text  ANSI_RESET
 #define COLOR_TEXT_RGB(text, red, green, blue) ANSI_INSTRUCTION_STR("38;2;" #red ";" #green ";" #blue) text ANSI_RESET
 
-void print(list<int> l, StdStream target = StdStream_stdout);
-void print(list<string> l, StdStream target = StdStream_stdout);
-void print(list<Vector2<real32>> l, StdStream target = StdStream_stdout);
-void print(list<Vector3<real32>> l, StdStream target = StdStream_stdout);
-void print(list<Vector4<real32>> l, StdStream target = StdStream_stdout);
-void print(const char *fmt, ...);
-void printErr(const char *fmt, ...);
+DefineList(int, Int);
+void printIntList(IntList l);
+void printStrList(StringList l);
+extern void (*print)(const char *fmt, ...);
 
 // ### Loops ###
 #define EachIn(list, it) size_t it = 0; it < (list).head; it++
@@ -275,6 +277,6 @@ void printErr(const char *fmt, ...);
 #define EachInArray(arr, it)  size_t it = 0; it < ArrayCount(arr); ++it
 
 // ### Misc ###
-int intCompare(const void *a, const void *b); 
+int intCompare(const void *a, const void *b);
 
 #endif

os.c

@@ -1,10 +1,10 @@
-#ifndef OS_CPP
-#define OS_CPP
+#ifndef OS_C
+#define OS_C
 
 #if OS_WINDOWS
-#include "os_win32.cpp"
+#include "os_win32.c"
 #elif OS_LINUX
-#include "os_linux.cpp"
+#include "os_linux.c"
 #else
     #error Development environment not supported.
 #endif

os.h

@@ -10,9 +10,9 @@ void os_decommit(void *ptr);
 void os_free(void *ptr, size_t freeSize);
 
 // ### File IO ###
-string os_readEntireFile(Arena *arena, string filename); 
-bool os_writeEntireFile(Arena *arena, string filename, const byte *contents, size_t contentsLength); 
-bool os_fileAppend(Arena *arena, string filename, const byte *contents, size_t contentsLength); 
+string os_readEntireFile(Arena *arena, string filename);
+bool os_writeEntireFile(Arena *arena, string filename, const byte *contents, size_t contentsLength);
+bool os_fileAppend(Arena *arena, string filename, const byte *contents, size_t contentsLength);
 
 // ### Standard IO ###
 void os_print(StdStream target, const char *fmt, va_list argList);

os_linux.c

@@ -1,11 +1,11 @@
-#ifndef OS_IMPL_LINUX_CPP
-#define OS_IMPL_LINUX_CPP
+#ifndef OS_IMPL_LINUX_C
+#define OS_IMPL_LINUX_C
 
 #include "os.h"
 
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <unistd.h>
+#include "sys/mman.h"
+#include "sys/stat.h"
+#include "unistd.h"
 
 void *os_alloc(size_t capacity) {
     return mmap(0, capacity, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

os_win32.c

@@ -1,7 +1,7 @@
-#ifndef OS_IMPL_WIN32_CPP
-#define OS_IMPL_WIN32_CPP
+#ifndef OS_IMPL_WIN32_C
+#define OS_IMPL_WIN32_C
 
-#include "Windows.h" 
+#include "Windows.h"
 #include "os.h"
 
 void *os_alloc(size_t commitSize) {