fix int parsing

.clangd

@@ -1,3 +1,5 @@
 CompileFlags:
   Add:
+    - -std=c99
+    - -xc
     - -DOS_LINUX

app.c

@@ -0,0 +1,2 @@
+//#include "./examples/server-chat.c"
+#include "./examples/http1-1.c"

app.cpp

@@ -1,13 +0,0 @@
-#include <stdio.h>
-#include "core.cpp"
-#include "core.h"
-
-int main(int argc, char **argv) {
-    initialiseDjStdCore();
-    Arena *arena = arenaAlloc(Megabytes(64));
-    list<string> args = getArgs(arena, argc, argv);
-
-    print("%S", strSplit(arena, "-"_s, "hallo-world"_s));
-
-    return 0;
-}

build

@@ -1,3 +1,7 @@
 #!/bin/bash
 
-g++ -g -g3 -lm -DOS_LINUX=1 -DENABLE_ASSERT=1 ./app.cpp -o ./target/app
+clang -g -g3 -lm -DOS_LINUX=1 -DENABLE_ASSERT=1 ./app.c -o ./target/app
+
+if [[ $1 == "run" ]] then
+    ./target/app
+fi

core.c

@@ -1,13 +1,13 @@
-#include "os.cpp"
-#include <math.h>
-#include <string.h>
+#include "os.c"
+#include "math.h"
+#include "string.h" // for memmove
 #include "core.h"
 #define STB_SPRINTF_IMPLEMENTATION
 #include "vendor/stb_sprintf.h"
 
 void *pushSizeFill(Arena *arena, size_t bytes, byte fill) {
     if (arena->capacity - arena->head >= bytes) {
-        void *ptr = (char *)arena->memory + arena->head;
+        void *ptr = (byte *)arena->memory + arena->head;
         arena->head += bytes;
         memset(ptr, fill, bytes);
         return ptr;
@@ -17,7 +17,7 @@ void *pushSizeFill(Arena *arena, size_t bytes, byte fill) {
 
 void *pushSize(Arena *arena, size_t bytes) {
     if (arena->capacity - arena->head >= bytes) {
-        void *ptr = (char *)arena->memory + arena->head;
+        void *ptr = (byte *)arena->memory + arena->head;
         arena->head += bytes;
         return ptr;
     }
@@ -26,7 +26,7 @@ void *pushSize(Arena *arena, size_t bytes) {
 
 Arena *arenaAlloc(size_t capacity) {
     Arena *result = (Arena *)os_alloc(sizeof(Arena) + capacity);
-    result->memory = result + sizeof(Arena);
+    result->memory = (byte *)result + sizeof(Arena);
     result->capacity = capacity;
     result->head = 0;
     return result;
@@ -71,49 +71,10 @@ Scratch scratchStart(Arena **conflicts, size_t conflictCount) {
     return scratch;
 }
 
-#define DeferLoop(begin_stmnt, end_stmnt) for(int __defer_i = ((begin_stmnt), 0); __defer_i < 1; (++__defer_i, (end_stmnt)))
-#define WithScratch(scratchName) Scratch scratchName; DeferLoop(scratchName = scratchStart(0, 0), scratchEnd(scratchName))
-
 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 +82,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,44 +162,41 @@ 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,
-    };
-}
-
 string strSlice(string str, size_t start, size_t stop) {
     if (stop == 0) {
         stop = str.length;
     }
     // 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 {
+inline string strChopStart(string str, size_t start) {
+    return strSlice(str, start, str.length);
+}
+
+string strListJoin(Arena *arena, StringList list) {
+    string result = PushString(arena, 0);
+    for (EachEl(list, string, item)) {
+        PushString(arena, item->length);
+        memcpy(result.str + result.length, item->str, item->length);
+    }
+    return result;
+}
+
+string strSliceCStr(char *data, size_t start, size_t stop) {
+    return (string){
         data + start,
         stop - start,
     };
 }
 
-bool stringContains(string str, char c) {
+bool strContainsChar(string str, char c) {
     for (size_t i = 0; i < str.length; i++) {
         if (str.str[i] == c) {
             return true;
@@ -240,25 +205,41 @@ bool stringContains(string str, char c) {
     return false;
 }
 
-string NUMERIC_CHARS = "0123456789"_s;
-inline bool isNumeric(char c) {
-    return stringContains(NUMERIC_CHARS, c);
+bool strContains(string str, string search) {
+    if (search.length == 0) return true;
+    if (search.length <= str.length) {
+        for (size_t i = 0; i <= str.length - search.length; i++) {
+            for (size_t j = 0; j < search.length; j++) {
+                if (str.str[i + j] != search.str[j]) {
+                    break;
+                }
+                if (j == search.length - 1) return true;
+            }
+        }
+    }
+    return false;
 }
 
-list<string> strSplit(Arena *arena, string splitStr, string inputStr) {
-    list<string> result = {0};
+string NUMERIC_CHARS = s("0123456789");
+inline function bool isNumeric(char c) {
+    return strContainsChar(NUMERIC_CHARS, c);
+}
+
+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)) {
+        void *beginning = arena->memory + arena->head;
+        while (c < inputStr.length) {
+            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;
                 splitCount++;
-                start = c + 1;
+                start = c + splitStr.length;
             }
             c++;
         }
@@ -267,38 +248,57 @@ 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.capacity = splitCount;
     }
     return result;
 }
 
-ParsePositiveIntResult parsePositiveInt(string str, size_t *lengthPointer) {
+Int32Result parsePositiveInt32(string str) {
     size_t numEnd = 0;
     char currChar = str.str[numEnd];
     while (numEnd < str.length && isNumeric(currChar)) {
-        currChar = str.str[++numEnd];
-        *lengthPointer += 1;
+        numEnd++;
+        currChar = str.str[numEnd];
     }
-    *lengthPointer -= 1;
     if (numEnd > 0) {
-        uint8 result = 0;
+        uint32 result = 0;
         for (size_t i = 0; i < numEnd; i++) {
             result *= 10;
             result += str.str[i] - '0';
         }
-        return {result, true};
+        return (Int32Result){ .result=result, .valid=true };
     } else {
-        return {0, false};
+        return (Int32Result){ .result=0, .valid=false};
     }
 }
 
-ParsePositiveReal32Result parsePositiveReal32(string str, size_t *lengthPointer) {
-    ParsePositiveReal32Result result = {NAN, false};
+Int64Result parsePositiveInt64(string str) {
+    size_t numEnd = 0;
+    char currChar = str.str[numEnd];
+    while (numEnd < str.length && isNumeric(currChar)) {
+        numEnd++;
+        currChar = str.str[numEnd];
+    }
+    if (numEnd > 0) {
+        uint64 result = 0;
+        for (size_t i = 0; i < numEnd; i++) {
+            result *= 10;
+            result += str.str[i] - '0';
+        }
+        return (Int64Result){ .result=result, .valid=true };
+    } else {
+        return (Int64Result){ .result=0, .valid=false};
+    }
+}
 
-    string wholePartStr = string{0};
-    string fractionalPartStr = string{0};
+Real32Result parsePositiveReal32(string str) {
+    Real32Result result = { .result=NAN, .valid=false};
+
+    string wholePartStr = (string){0};
+    string fractionalPartStr = (string){0};
 
     bool split = false;
     size_t c = 0;
@@ -314,9 +314,8 @@ ParsePositiveReal32Result parsePositiveReal32(string str, size_t *lengthPointer)
         c++;
     }
     if (split) {
-        ParsePositiveIntResult wholePartParsed = parsePositiveInt(wholePartStr, lengthPointer);
-        *lengthPointer += 1;
-        ParsePositiveIntResult fractionalPartParsed = parsePositiveInt(fractionalPartStr, lengthPointer);
+        Int32Result wholePartParsed = parsePositiveInt32(wholePartStr);
+        Int32Result fractionalPartParsed = parsePositiveInt32(fractionalPartStr);
         if (wholePartParsed.valid && fractionalPartParsed.valid) {
             // TODO(dledda): implement powf with intrinsics? or just custom
             real32 fractionalPartMultiplier = 1.0f / powf(10.0f, (real32)fractionalPartStr.length);
@@ -324,7 +323,7 @@ ParsePositiveReal32Result parsePositiveReal32(string str, size_t *lengthPointer)
             result.valid = true;
         }
     } else if (c > 0) {
-        ParsePositiveIntResult intPartParsed = parsePositiveInt(str, lengthPointer);
+        Int32Result intPartParsed = parsePositiveInt32(str);
         if (intPartParsed.valid) {
             result.result = (real32)intPartParsed.result;
             result.valid = true;
@@ -333,10 +332,10 @@ 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]));
+        ListAppend(args, strFromCString(arena, argv[i]));
     }
     return args;
 }
@@ -348,48 +347,54 @@ UnixTimestamp getSystemUnixTime() {
 }
 
 Timestamp timestampFromUnixTime(UnixTimestamp *unixTimestamp) {
-    tm timestamp = {0};
-    gmtime_r((time_t *)unixTimestamp, &timestamp);
-    return timestamp;
+    struct tm *timestamp = gmtime((time_t *)unixTimestamp);
+    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;
 }
 
-void printStderr(const char *fmt, ...) {
+function void printStderr(const char *fmt, ...) {
     va_list argList;
     va_start(argList, fmt);
     os_print(StdStream_stdout, fmt, argList);
     va_end(argList);
 }
 
+function void printlnStderr(const char *fmt, ...) {
+    va_list argList;
+    va_start(argList, fmt);
+    os_println(StdStream_stdout, fmt, argList);
+    va_end(argList);
+}
+
 function void printStdout(const char *fmt, ...) {
     va_list argList;
     va_start(argList, fmt);
@@ -397,13 +402,34 @@ function void printStdout(const char *fmt, ...) {
     va_end(argList);
 }
 
-void print(const char *fmt, ...) {
+function void printlnStdout(const char *fmt, ...) {
     va_list argList;
     va_start(argList, fmt);
-    os_print(StdStream_stdout, fmt, argList);
+    os_println(StdStream_stdout, fmt, argList);
     va_end(argList);
 }
 
+void (*print)(const char *fmt, ...) = &printStdout;
+void (*println)(const char *fmt, ...) = &printlnStdout;
+
+void printStr(string str) {
+    print("%S\n", str);
+}
+
+void setStdout() {
+    print = &printStdout;
+    println = &printlnStdout;
+}
+
+void setStderr() {
+    print = &printStderr;
+    println = &printlnStderr;
+}
+
+#define UseStderr() DeferLoop(setStderr(), setStdout())
+
+// 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 +465,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, capacity: %zu\n", l.length, l.capacity);
 }
 
-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(", ");
+            print(", ");
         }
-        logFn("\"%S\"", l.data[i]);
+        print("\"%S\"", l.data[i]);
     }
-    logFn(" } length: %zu, head: %zu\n", l.length, l.head);
+    print(" } length: %zu, capacity: %zu\n", l.length, l.capacity);
 }
 
 int intCompare(const void *a, const void *b) {
@@ -470,3 +495,18 @@ int intCompare(const void *a, const void *b) {
     return (*x > *y) - (*x < *y);
 }
 
+
+#ifdef DJSTD_BASIC_ENTRY
+int djstd_entry(Arena* arena, StringList args);
+
+#ifndef DJSTD_BASIC_ENTRY_ARENA_ALLOC
+#define DJSTD_BASIC_ENTRY_ARENA_ALLOC Megabytes(64)
+#endif
+
+int main(int argc, char **argv) {
+    initialiseDjStdCore();
+    Arena *arena = arenaAlloc(DJSTD_BASIC_ENTRY_ARENA_ALLOC);
+    StringList args = getArgs(arena, argc, argv);
+    return djstd_entry(arena, args);
+}
+#endif

core.h

@@ -2,13 +2,13 @@
 #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 "stdbool.h"
+#include "stdint.h" // necessary for int type sizes
+#include "time.h" // TODO(djledda): try not to depend on this one
+#include <string.h>
 
 // ### Misc macros ###
-#if ENABLE_ASSERT
+#if DJSTDLIB_DEBUG
 #define Assert(expression) if (!(expression)) {*(volatile int *)0 = 0;}
 #else
 #define Assert(expression)
@@ -17,6 +17,9 @@
 #define function static
 #define global static
 #define local_persist static
+#define Forever for (;;)
+
+#define DeferLoop(begin_stmnt, end_stmnt) for(int __defer_i = ((begin_stmnt), 0); __defer_i < 1; (++__defer_i, (end_stmnt)))
 
 // ### Types ###
 typedef int8_t int8;
@@ -27,9 +30,10 @@ typedef uint8_t uint8;
 typedef uint16_t uint16;
 typedef uint32_t uint32;
 typedef uint64_t uint64;
-typedef uint8_t byte;
+typedef char byte;
 typedef float real32;
 typedef double real64;
+typedef struct string string;
 
 // ### Sizes and Numbers ###
 #define Bytes(n) (n)
@@ -43,14 +47,18 @@ 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 MemberSizeUnderlying(type, memberName) sizeof(*((type *)0)->memberName)
 
 // ### Arenas ###
+typedef struct Arena Arena;
 struct Arena {
     void *memory;
     size_t capacity;
     size_t head;
 };
 
+typedef struct Scratch Scratch;
 struct Scratch {
     Arena *arena;
     size_t start;
@@ -72,61 +80,59 @@ void scratchEnd(Scratch scratch);
 #define PushArrayZero(arena, type, size) (type *)pushSizeFill(arena, sizeof(type) * (size), 0)
 #define PushStruct(arena, type) (type *)pushSize(arena, sizeof(type))
 #define PushStructZero(arena, type) (type *)pushSizeFill(arena, sizeof(type), 0)
+#define WithScratch(scratchName) Scratch scratchName; DeferLoop(scratchName = scratchStart(0, 0), scratchEnd(scratchName))
 
 // ### Vectors ###
-template <typename T>
-union Vector2 {
+typedef union Vec2 Vec2;
+union Vec2 {
     struct {
-        T x;
-        T y;
+        real32 x;
+        real32 y;
     };
-    T vec[2];
+    real32 vec[2];
 };
-template <typename T>
-inline function Vector2<T> vec2(T x, T y) {
-    Vector2<T> result = {0};
+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 Vec3 Vec3;
+union Vec3 {
     struct {
-        T x;
-        T y;
-        T z;
+        real32 x;
+        real32 y;
+        real32 z;
     };
-    T vec[3];
+    real32 vec[3];
 };
-template <typename T>
-inline function Vector3<T> vec3(T x, T y, T z) {
-    Vector3<T> result = {0};
+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 Vec4 Vec4;
+union Vec4 {
     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];
+    real32 vec[4];
 };
-template <typename T>
-inline function Vector4<T> vec4(T x, T y, T z, T w) {
-    Vector4<T> result = {0};
+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 +141,66 @@ 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 prefix ## List prefix ## List;\
+    struct prefix ## List {\
+        type *data;\
+        size_t length;\
+        size_t capacity;\
+    };\
+    typedef type prefix ## List ## _underlying
+#define ListElementSize(list) MemberSizeUnderlying(list, data)
 
-#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);
+DefineList(void, Void);
 
-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){ .data=pushSize(arena, ListElementSize(type)*(size)), .length=0, .capacity=(size) }
+#define PushListZero(arena, type, size) (type){ .data=pushSizeFill(arena, ListElementSize(type)*(size), 0), .length=0, .capacity=(size) }
+#define PushFullList(arena, type, size) (type){ .data=pushSize(arena, ListElementSize(type)*size), .length=(size), .capacity=(size) }
+#define PushFullListZero(arena, type, size) (type){ .data=pushSizeFill(arena, ListElementSize(type)*(size), 0), .length=(size), .capacity=(size) }
+
+#define EmptyList() { NULL, 0, 0 }
+#define __ArrayAsList(array) { .data=(array), .length=ArrayCount(array), .capacity=ArrayCount(array) }
+#define AsList(listtype, ...) (listtype)__ArrayAsList(((listtype##_underlying[])__VA_ARGS__))
+
+#define ListAppend(list, element) \
+    if ((list).length < (list).capacity) { \
+        (list).data[(list).length++] = (element); \
+    }
+#define ZeroListFull(list) memset((list)->data, 0, (list)->length * sizeof((list)->data[0]))
+#define ZeroList(list) (list)->length = 0; \
+    memset((list)->data, 0, (list)->length * sizeof((list)->data[0]))
+/** 1 indicates last element, 2 second last, etc. */
+#define ListGetFromEnd(list, count) ((list).data[(list).length - (count)])
+#define ListLast(list) ListGetFromEnd(list, 1)
+
+inline VoidList __cloneList(Arena *arena, VoidList list, size_t underlyingSize) {
+    byte *newData = PushArrayZero(arena, void, list.capacity*underlyingSize);
+    memcpy(newData, list.data, list.capacity*underlyingSize);
+    return (VoidList){
+        .data=newData,
+        .capacity=list.capacity,
+        .length=list.length,
+    };
+}
+#define CloneList(arena, type, list) (type)cloneList((arena), (VoidList)(list), (MemberSizeUnderlying(list)))
+#define ListAppendList(appendee, list)\
+    if ((appendee).capacity - (appendee).length >= list.length) {\
+        memcpy((appendee).data + (appendee).length, (list).data, MemberSizeUnderlying(list)*(list).length);\
+        (appendee).length += (list).length;\
+    }
+    
+
+// Following two macros do not use pointers due to copying
+#define ListSlice(list, start, stop) {\
+    .data= (stop > (list).length || start > stop) ? 0 : (list).data + start,\}
+#define ListTail(list, start) ListSlice(list, start, (list).length)
+
+#define ListRemove(list, index)\
+    if ((index) >= 0 && (index) < (list)->length) {\
+        memcpy((list)->data + (index), (list)->data + (index) + 1, ((list)->length - (i + 1))*sizeof(*((list)->data)));\
+        (list)->length -= 1;\
+    }
 
 // ### Strings ###
 struct string {
@@ -162,62 +210,76 @@ 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) })
+#define StrFromList(list) ((string){.str=(list).data,.length=(list).length})
 
 // C Strings
-const char *cstring(Arena *arena, list<char> buf); 
+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 strStartsWith(string str, string testStr);
-bool stringContains(string str, char c); 
+bool strContainChar(string str, char c);
+bool strContains(string a, string b);
 
 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 strSlice(string str, size_t start, size_t stop);
+string strChopStart(string str, size_t start);
+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); 
+string strListJoin(Arena *arena, StringList list);
 
-inline function bool isNumeric(char c); 
+#define DefineResult(type, prefix) \
+    typedef struct prefix ## Result prefix ## Result;\
+    struct prefix ## Result {\
+        type result;\
+        bool valid;\
+    };\
+    typedef type prefix ## Result ## _underlying
+
+DefineResult(int32, Int32);
+Int32Result parsePositiveInt32(string str);
+DefineResult(int64, Int64);
+Int64Result parsePositiveInt64(string str);
+DefineResult(real32, Real32);
+Real32Result parsePositiveReal32(string str);
 
 // ### 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 formatTimeHmsUnix(Arena *arena, UnixTimestamp time);
 string formatTimeHms(Arena *arena, Timestamp *time);
-string formatTimeYmd(Arena *arena, UnixTimestamp 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"
-#define ANSI_INSTRUCTION_STR(ansiCodeStr) "\u001b[" ansiCodeStr "m"
+#define ANSI_INSTRUCTION(ansiCode) "\x1b[" #ansiCode
+#define ANSI_INSTRUCTION_STR(ansiCodeStr) "\x1b[" ansiCodeStr
+#define ANSI_GRAPHIC_INSTRUCTION(ansiCode) "\x1b[" #ansiCode "m"
+#define ANSI_GRAPHIC_INSTRUCTION_STR(ansiCodeStr) "\x1b[" ansiCodeStr "m"
 #define ANSI_RESET ANSI_INSTRUCTION(0)
 
 #define ANSI_fg_black 30
@@ -261,17 +323,20 @@ 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);
+void printStr(string str);
+void setStdout();
+void setStderr();
+extern void (*print)(const char *fmt, ...);
+extern void (*println)(const char *fmt, ...);
 
 // ### Loops ###
-#define EachIn(list, it) size_t it = 0; it < (list).head; it++
-#define EachInReversed(list, it) size_t it = (list).head - 1; it >= 0 && it < (list).head; it--
+#define EachIn(list, it) size_t it = 0; it < (list).length; it++
+#define EachEl(list, type, element) type *element = (list).data; element < (list).data + (list).length; element += 1
+#define EachInReversed(list, it) size_t it = (list).length - 1; it >= 0 && it < (list).length; it--
 #define EachInArray(arr, it)  size_t it = 0; it < ArrayCount(arr); ++it
 
 // ### Misc ###

examples/http1-1.c

@@ -0,0 +1,62 @@
+#define DJSTD_BASIC_ENTRY
+#include "../core.c"
+
+int djstd_entry(Arena *arena, StringList args) {
+    Socket sock = socketConnect(arena, (SocketConnectInfo){ 
+        .address="dlh.mediasuite.zii.aero", 
+        .port=443, 
+        .blocking=true 
+    });
+
+    println("%d", sock.closed);
+    string newLine = s("\r\n");
+    string lines[] = {
+        s("GET / HTTP/1.1"),
+        s("Host: localhost"),
+    };
+
+    for (EachInArray(lines, i)) {
+        socketWriteStr(&sock, lines[i]);
+        socketWriteStr(&sock, newLine);
+    }
+    socketWriteStr(&sock, newLine);
+
+    StringList body = EmptyList();
+    bool streamingBody = false;
+
+    Forever {
+        StringResult response = socketReadStr(arena, &sock);
+        if (response.valid) {
+            if (streamingBody) {
+                if (body.capacity - body.length >= response.result.length) {
+                    ListAppend(body, response.result);
+                }
+            } else {
+                StringList lines = strSplit(arena, s("\r\n"), response.result);
+                for (EachEl(lines, string, line)) {
+                    if (body.capacity > 0 && strEql(*line, s(""))) {
+                        streamingBody = true;
+                    } else if (streamingBody && (body.capacity - body.length) >= line->length) {
+                        ListAppend(body, *line);
+                    } else {
+                        StringList split = strSplit(arena, s("Content-Length: "), *line);
+                        if (split.length > 1) {
+                            Int32Result lengthResult = parsePositiveInt(split.data[1]);
+                            if (lengthResult.valid) {
+                                body = PushList(arena, StringList, lengthResult.result);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if (streamingBody == true && body.length == body.capacity) {
+            break;
+        }
+    }
+
+    printStr(strListJoin(arena, body));
+
+    return 0;
+}

examples/server-chat.c

@@ -0,0 +1,204 @@
+#define DJSTD_BASIC_ENTRY
+
+#include "../core.c"
+#include "signal.h"
+
+Server *openServer = NULL;
+SocketList *openSockets = NULL;
+
+void handleSigint(int dummy) {
+    if (openServer) {
+        println("");
+        println("Closing server socket.");
+        serverClose(openServer);
+        println("Success.");
+    }
+    if (openSockets && openSockets->length) {
+        println("");
+        println("Closing open sockets.");
+        for (EachEl(*openSockets, Socket, socket)) {
+            socketClose(socket);
+        }
+        println("Success.");
+    }
+    signal(SIGINT, SIG_DFL);
+    raise(SIGINT);
+}
+
+typedef struct ChatClient ChatClient;
+struct ChatClient {
+    Socket *socket;
+    string nickname;
+};
+DefineList(ChatClient, ChatClient);
+
+void startServer(Arena *arena, int32 port) {
+    println("Starting server...");
+    Server server = serverInit((ServerInitInfo){
+        .concurrentClients=2,
+        .port=port,
+        .memory=Megabytes(64),
+        .maxEvents=64,
+    });
+    openServer = &server;
+
+    serverListen(&server);
+    if (server.listening) {
+        println("Listening on port %d", port);
+    }
+
+    Arena *serverLoopArena = arenaAlloc(Megabytes(64));
+    ChatClientList chatClients = PushListZero(arena, ChatClientList, 256);
+
+    ServerEvent *nextEvent;
+
+    Forever {
+        nextEvent = serverGetNextEvent(&server);
+        switch (nextEvent->type) {
+            case ServerEventType_AcceptClient: {
+                Socket *client = serverAccept(&server);
+                if (client != NULL) {
+                    println("New client connected from %d", client->address);
+                }
+                break;
+            };
+            case ServerEventType_ClientMessage: {
+                StringResult clientMsg = socketReadStr(serverLoopArena, nextEvent->tClientMessage.client);
+                ChatClient *chatClient = NULL;
+                if (clientMsg.valid) {
+                    if (strStartsWith(clientMsg.result, s("hello-"))) {
+                        StringList nickSplit = strSplit(serverLoopArena, s("-"), clientMsg.result);
+                        if (nickSplit.length == 2 && nickSplit.data[1].length > 0) {
+                            string newNick = PushString(arena, nickSplit.data[1].length);
+                            newNick.length = nickSplit.data[1].length;
+                            memcpy(newNick.str, nickSplit.data[1].str, nickSplit.data[1].length);
+                            ChatClient newChatClient = (ChatClient){
+                                .socket=nextEvent->tClientMessage.client,
+                                .nickname=newNick,
+                            };
+                            AppendList(&chatClients, newChatClient);
+                            println("Client from %d calls themselves \"%S\"", newChatClient.socket->address, newChatClient.nickname);
+                        }
+                    } else {
+                        for (EachEl(chatClients, ChatClient, maybeChatClient)) {
+                            if (maybeChatClient->socket->handle == nextEvent->tClientMessage.client->handle) {
+                                chatClient = maybeChatClient;
+                            }
+                        }
+                        if (chatClient != NULL) {
+                            if (strStartsWith(clientMsg.result, s("say-"))) {
+                                StringList saySplit = strSplit(arena, s("-"), clientMsg.result);
+                                if (saySplit.length == 2 && saySplit.data[1].length > 0) {
+                                    string broadcast = strPrintf(serverLoopArena, "%S says:\n%S", chatClient->nickname, saySplit.data[1]);
+                                    for (EachEl(server.clients, Socket, client)) {
+                                        socketWriteStr(client, broadcast);
+                                    }
+                                }
+                            } else {
+                                // Invalid client message
+                            }
+                        }
+                    }
+                }
+                break;
+            };
+            case ServerEventType_None:
+            default:
+                break;
+        }
+
+        arenaFreeFrom(serverLoopArena, 0);
+    }
+
+    println("Shutting down chat.");
+    serverClose(&server);
+}
+
+void clearStdInLn() {
+    print("\r");
+    print(ANSI_INSTRUCTION(J));
+}
+
+void clearStdInLnAfterInput() {
+    print("\r");
+    print(ANSI_INSTRUCTION(A));
+    print(ANSI_INSTRUCTION(J));
+}
+
+void startClient(Arena *arena, string addr, int32 port, string nickname) {
+    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
+
+    println("Connecting to server at [%S]:%d with nickname \"%S\"", addr, port, nickname);
+    Socket server = socketConnect(arena, (SocketConnectInfo){ .address=addr, .port=port });
+    if (server.closed) {
+        println("Connection error. Closing.");
+    } else {
+        println("Connected successfully");
+        string message = strPrintf(arena, "hello-%S", nickname);
+        CharList inputBuf = PushList(arena, CharList, 512);
+        socketWriteStr(&server, message);
+
+        print("(you)> ");
+        Forever {
+            Scratch scratch = scratchStart(&arena, 1);
+
+            int32 numRead = read(0, inputBuf.data + inputBuf.length, inputBuf.capacity - inputBuf.length);
+            if (numRead >= 0) {
+                inputBuf.length += numRead;
+                if (inputBuf.data[inputBuf.length - 1] == '\n') {
+                    clearStdInLnAfterInput();
+                    socketWriteStr(&server, strPrintf(scratch.arena, "say-%S", (string){.str=inputBuf.data,.length=inputBuf.length}));
+                    inputBuf.length = 0;
+                }
+            }
+
+            StringResult serverMsg = socketReadStr(scratch.arena, &server);
+            if (serverMsg.valid && serverMsg.result.length > 0) {
+                clearStdInLn();
+                println("%S", serverMsg.result);
+                print("(you)> %S", (string){.str=inputBuf.data, inputBuf.length});
+            }
+
+            scratchEnd(scratch);
+        }
+    }
+    socketClose(&server);
+}
+
+int djstd_entry(Arena *arena, StringList args) {
+    signal(SIGINT, &handleSigint);
+
+    bool argumentErr = true;
+    bool isServer = strEql(args.data[0], s("server"));
+    bool isClient = strEql(args.data[0], s("client"));
+
+    if (isServer) {
+        Int32Result portParsed = parsePositiveInt(args.data[1]);
+        if (portParsed.valid) {
+            startServer(arena, portParsed.result);
+            argumentErr = false;
+        }
+    } else if (isClient) {
+        if (args.length == 3) {
+            StringList split = strSplit(arena, s("]:"), args.data[1]);
+            if (split.length == 2) {
+                Int32Result portParsed = parsePositiveInt(split.data[1]);
+                string addr = strSlice(split.data[0], 1, split.data[0].length);
+                string nickname = args.data[2];
+                if (portParsed.valid && addr.length > 0 && nickname.length > 0) {
+                    startClient(arena, addr, portParsed.result, nickname);
+                    argumentErr = false;
+                }
+            }
+        }
+    }
+
+    if (argumentErr) {
+        println("Usage:");
+        println("server [PORT]");
+        println("OR");
+        println("client [REMOTE_ADDRESS:PORT] [NICKNAME]");
+    }
+
+    return 0;
+}

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

@@ -4,17 +4,115 @@
 #include "core.h"
 
 // ### Memory ###
-void *os_alloc(size_t capacity);
+void *os_alloc(uint64 capacity);
 void os_reserve(void *ptr);
 void os_decommit(void *ptr);
-void os_free(void *ptr, size_t freeSize);
+void os_free(void *ptr, uint64 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); 
+bool os_writeEntireFile(Arena *arena, string filename, const byte *contents, uint64 contentsLength);
+bool os_fileAppend(Arena *arena, string filename, const byte *contents, uint64 contentsLength);
 
 // ### Standard IO ###
 void os_print(StdStream target, const char *fmt, va_list argList);
+void os_println(StdStream target, const char *fmt, va_list argList);
+
+// ### Multithreading ###
+typedef struct OS_Thread OS_Thread;
+struct OS_Thread {
+    uint64 id;
+};
+
+OS_Thread os_createThread(void *(*entry)(void *ctx), void *ctx);
+
+// ### Network I/O ###
+typedef struct Address Address;
+struct Address;
+
+typedef struct SocketHandle SocketHandle;
+struct SocketHandle;
+
+typedef struct ServerEvents ServerEvents;
+struct ServerEvents;
+
+typedef struct Socket Socket;
+struct Socket {
+    const Address *address;
+    SocketHandle *handle;
+    bool closed;
+};
+DefineList(Socket, Socket);
+
+typedef struct Server Server;
+struct Server {
+    Arena *arena;
+    Address *address;
+    uint32 port;
+    SocketHandle *handle;
+    SocketList clients;
+    bool listening;
+    ServerEvents *events;
+};
+
+typedef struct ServerInitInfo ServerInitInfo;
+struct ServerInitInfo {
+    int16 port;
+    int32 concurrentClients;
+    int64 memory;
+    int32 maxEvents;
+};
+
+typedef struct SocketConnectInfo SocketConnectInfo;
+struct SocketConnectInfo {
+    string address;
+    uint16 port;
+    bool blocking;
+};
+
+
+// Server/Client interface
+Server serverInit(ServerInitInfo info);
+
+void serverListen(Server *s);
+
+Socket *serverAccept(Server *s);
+
+void serverClose(Server *s);
+
+enum ServerEventType {
+    ServerEventType_AcceptClient,
+    ServerEventType_ClientMessage,
+    ServerEventType_None,
+    ServerEventType_COUNT,
+};
+
+typedef struct ServerEvent ServerEvent;
+struct ServerEvent {
+    enum ServerEventType type;
+    union {
+        struct {} tAcceptClient;
+        struct {
+            int32 clientId;
+            Socket *client;
+        } tClientMessage;
+    };
+};
+
+ServerEvent *serverGetNextEvent(Server *s);
+
+// Generic socket interface
+Socket socketConnect(Arena *arena, SocketConnectInfo info);
+
+int64 socketRead(Socket *s, byte *dest, uint64 numBytes);
+
+DefineResult(string, String);
+StringResult socketReadStr(Arena *arena, Socket *s);
+
+int64 socketWrite(Socket *s, byte *source, uint64 numBytes);
+
+int64 socketWriteStr(Socket *socket, string data);
+
+void socketClose(Socket *s);
 
 #endif

os_linux.c

@@ -0,0 +1,378 @@
+#ifndef OS_IMPL_LINUX_C
+#define OS_IMPL_LINUX_C
+
+#include "os.h"
+
+#include "sys/mman.h"
+#include "sys/stat.h"
+#include "string.h" // memcpy TODO(dledda): replace memcpy with custom impl?
+#include "unistd.h" // POSIX Standard, read, write, close, open, etc.
+
+#include "pthread.h"
+
+#include "fcntl.h"
+#include "sys/epoll.h"
+#include "sys/socket.h"
+#include "arpa/inet.h"
+#include <stdio.h>
+
+
+void *os_alloc(uint64 capacity) {
+    return mmap(0, capacity, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+}
+
+void os_commit(void *ptr) {
+}
+
+void os_decommit(void *ptr) {
+}
+
+void os_free(void *ptr, uint64 size) {
+    int err = munmap(ptr, size);
+    Assert(err != -1);
+}
+
+string os_readEntireFile(Arena *arena, string filename) {
+    Scratch temp = scratchStart(&arena, 1);
+
+    int input = open(cstring(temp.arena, filename), O_RDONLY);
+    string readBuffer;
+    if (input) {
+        struct stat st;
+        stat((char *)filename.str, &st);
+        uint64 fsize = st.st_size;
+        readBuffer = PushString(arena, fsize);
+        int64 bytesRead = read(input, readBuffer.str, readBuffer.length);
+        close(input);
+        if (bytesRead == -1) {
+            arenaPopTo(arena, readBuffer.str);
+            return s("");
+        }
+    } else {
+        readBuffer = s("");
+    }
+
+    scratchEnd(temp);
+    return readBuffer;
+}
+
+bool os_writeEntireFile(Arena *arena, string filename, const byte *contents, uint64 contentsLength) {
+    Scratch temp = scratchStart(&arena, 1);
+
+    bool result = false;
+    int output = open(cstring(temp.arena, filename), O_WRONLY);
+    if (output) {
+        int64 bytesWritten = write(output, contents, contentsLength);
+        if (bytesWritten != -1) {
+            result = true;
+        }
+        close(output);
+    }
+
+    scratchEnd(temp);
+    return result;
+}
+
+bool os_fileAppend(Arena *arena, string filename, const byte *contents, uint64 contentsLength) {
+    Scratch temp = scratchStart(&arena, 1);
+
+    bool result = false;
+    int output = open(cstring(temp.arena, filename), O_APPEND);
+    if (output) {
+        int bytesWritten = write(output, contents, contentsLength);
+        if (bytesWritten != -1) {
+            result = true;
+        }
+        close(output);
+    }
+
+    scratchEnd(temp);
+    return result;
+}
+
+void os_println(StdStream target, const char *fmt, va_list argList) {
+    Scratch temp = scratchStart(0, 0);
+
+    uint64 origLen = calcStringLen(fmt);
+    string fmtLn = PushString(temp.arena, origLen + 2);
+    memcpy(fmtLn.str, fmt, origLen);
+
+    fmtLn.str[fmtLn.length - 2] = '\n';
+    fmtLn.str[fmtLn.length - 1] = '\0';
+
+    string result = strPrintfv(temp.arena, fmtLn.str, argList);
+    // TODO(djledda): finish implementation without cstdlib
+    switch (target) {
+        case StdStream_stdin:
+            write(0, (const void *)result.str, result.length);
+            break;
+        case StdStream_stderr:
+            write(2, (const void *)result.str, result.length);
+            break;
+        case StdStream_stdout:
+        default:
+            write(1, (const void *)result.str, result.length);
+            break;
+    }
+
+    scratchEnd(temp);
+}
+
+void os_print(StdStream target, const char *fmt, va_list argList) {
+    Scratch temp = scratchStart(0, 0);
+
+    string result = strPrintfv(temp.arena, fmt, argList);
+    // TODO(djledda): finish implementation without cstdlib
+    switch (target) {
+        case StdStream_stdin:
+            write(0, (const void *)result.str, result.length);
+            break;
+        case StdStream_stderr:
+            write(2, (const void *)result.str, result.length);
+            break;
+        case StdStream_stdout:
+        default:
+            write(1, (const void *)result.str, result.length);
+            break;
+    }
+
+    scratchEnd(temp);
+}
+
+OS_Thread os_createThread(void *(*entry)(void *), void *ctx) {
+    pthread_t handle;
+    pthread_attr_t attr;
+    pthread_attr_init(&attr);
+    pthread_create(&handle, &attr, entry, ctx);
+    pthread_attr_destroy(&attr);
+    return (OS_Thread){ .id=handle };
+}
+
+DefineList(ServerEvent, ServerEvent);
+typedef struct EPollServerEvents EPollServerEvents;
+struct EPollServerEvents {
+    int epollFd;
+    int32 maxEvents;
+    int32 numEvents;
+    struct epoll_event *events;
+    bool err;
+    ServerEventList userEvents;
+};
+
+Server serverInit(ServerInitInfo info) {
+    Arena *arena = arenaAlloc(info.memory);
+
+    EPollServerEvents *events = PushStructZero(arena, EPollServerEvents);
+    events->epollFd = epoll_create1(0);
+    events->events = PushArrayZero(arena, struct epoll_event, info.maxEvents);
+    events->maxEvents = info.maxEvents;
+    events->numEvents = 0;
+    events->userEvents = PushListZero(arena, ServerEventList, info.maxEvents);
+
+    struct sockaddr_in6 *serverAddr = PushStructZero(arena, struct sockaddr_in6);
+    serverAddr->sin6_family = AF_INET6;
+    serverAddr->sin6_port = htons(info.port);
+    serverAddr->sin6_addr = in6addr_any;
+
+    Server server = {
+        .arena=arena,
+        .address=(Address *)serverAddr,
+        .clients=PushListZero(arena, SocketList, info.concurrentClients),
+        .listening=false,
+        .port=info.port,
+        .handle=(SocketHandle *)(uint64)socket(AF_INET6, SOCK_STREAM, 0 /* IPPROTO_TCP */),
+        .events=(ServerEvents *)events,
+    };
+
+    fcntl((uint64)server.handle, F_SETFL, fcntl((uint64)server.handle, F_GETFL, 0) | O_NONBLOCK);
+
+    struct epoll_event event = {
+        .data.fd=(uint64)server.handle,
+        .events=EPOLLIN | EPOLLET,
+    };
+    epoll_ctl(events->epollFd, EPOLL_CTL_ADD, (int64)server.handle, &event);
+
+    int bindErr = bind((uint64)server.handle, (struct sockaddr *)serverAddr, sizeof(*serverAddr));
+    if (bindErr == -1) {
+        // TODO(dledda): handle err
+    }
+
+    return server;
+}
+
+void serverListen(Server *s) {
+    int listenErr = listen((uint64)s->handle, s->clients.capacity);
+    if (listenErr == -1) {
+        s->listening = false;
+    } else {
+        s->listening = true;
+    }
+}
+
+Socket *serverAccept(Server *s) {
+    struct sockaddr_in6 *clientAddr = PushStructZero(s->arena, struct sockaddr_in6);
+    socklen_t clientAddrLen = sizeof(*clientAddr);
+
+    uint64 clientSockHandle = accept((int)(uint64)s->handle, (struct sockaddr *)clientAddr, &clientAddrLen);
+    if (clientSockHandle == -1) {
+        clientSockHandle = (uint64)NULL;
+    } else {
+        fcntl((uint64)clientSockHandle, F_SETFL, fcntl((uint64)clientSockHandle, F_GETFL, 0) | O_NONBLOCK);
+    }
+
+    struct epoll_event event = {
+        .data.fd=clientSockHandle,
+        .events=EPOLLIN | EPOLLET,
+    };
+    epoll_ctl(((EPollServerEvents *)s->events)->epollFd, EPOLL_CTL_ADD, clientSockHandle, &event);
+
+    if (s->clients.length < s->clients.capacity) {
+        ListAppend(s->clients, ((Socket){
+            .handle=(SocketHandle *)(uint64)clientSockHandle,
+            .address=(Address *)clientAddr,
+        }));
+        return &s->clients.data[s->clients.length - 1];
+    } else {
+        return PushStructZero(s->arena, Socket);
+    }
+}
+
+ServerEvent *serverGetNextEvent(Server *s) {
+    EPollServerEvents *serverEvents = ((EPollServerEvents *)s->events);
+
+    if (serverEvents->userEvents.length == 0) {
+        serverEvents->numEvents = epoll_wait(serverEvents->epollFd, serverEvents->events, serverEvents->maxEvents, -1);
+        if (serverEvents->numEvents == -1) {
+            serverEvents->err = true;
+            serverEvents->numEvents = 0;
+        } else {
+            serverEvents->userEvents.length = serverEvents->numEvents;
+            for (int32 i = 0; i < serverEvents->numEvents; i++) {
+                struct epoll_event *ev = &serverEvents->events[i];
+                if ((ev->events & EPOLLIN) && ev->data.fd == (int)(int64)s->handle) {
+                    serverEvents->userEvents.data[i] = (ServerEvent){
+                        .type=ServerEventType_AcceptClient,
+                        .tAcceptClient={},
+                    };
+                } else if (ev->events & EPOLLIN) {
+                    int64 fd = serverEvents->events[i].data.fd;
+                    Socket *client = NULL;
+                    ServerEvent serverEv = {
+                        .type=ServerEventType_ClientMessage,
+                    };
+
+                    for (EachIn(s->clients, j)) {
+                        if ((int64)s->clients.data[j].handle == fd) {
+                            client = &s->clients.data[j];
+                            serverEv.tClientMessage.client = client;
+                            serverEv.tClientMessage.clientId = j;
+                        }
+                    }
+
+                    if (client == NULL) {
+                        serverEv.type = ServerEventType_None;
+                    } else {
+                        serverEvents->userEvents.data[i] = serverEv;
+                    }
+                }
+            }
+        }
+
+    }
+
+    if (serverEvents->userEvents.length == 0) {
+        ListAppend(serverEvents->userEvents, (ServerEvent){ .type=ServerEventType_None });
+    }
+
+    // Pop next event
+    serverEvents->userEvents.length--;
+    return &serverEvents->userEvents.data[serverEvents->userEvents.length];
+}
+
+int64 socketRead(Socket *socket, byte *dest, uint64 numBytes) {
+    int64 bytesRead = read((uint64)socket->handle, dest, numBytes);
+    if (bytesRead == -1) {
+        // TODO(dledda): handle err
+    }
+    return bytesRead;
+}
+
+StringResult socketReadStr(Arena *arena, Socket *socket) {
+    byte *dest = PushArray(arena, byte, Kilobytes(256));
+    int64 bytesRead = read((uint64)socket->handle, dest, Kilobytes(1024));
+    bool err = bytesRead == -1 || bytesRead == 0;
+    if (err) {
+        arenaPopTo(arena, dest);
+    } else {
+        arenaPopTo(arena, dest + bytesRead);
+    }
+    return (StringResult){
+        .valid=!err,
+        .result=(string){
+            .str=dest,
+            .length=err ? 0 : bytesRead,
+        },
+    };
+}
+
+void serverClose(Server *s) {
+    close((int)(uint64)s->handle);
+}
+
+bool serverHangupClient(Server *s, Socket *client) {
+    struct epoll_event eventUnsubscribe = {
+        .data.fd=(int)(int64)client->handle,
+        .events=EPOLLIN | EPOLLET,
+    };
+    int err = epoll_ctl(((EPollServerEvents *)s->events)->epollFd, EPOLL_CTL_DEL, (int)(int64)client->handle, &eventUnsubscribe);
+    if (err == 0) {
+        for (EachIn(s->clients, i)) {
+            if (s->clients.data[i].handle == client->handle) {
+                ListRemove(&s->clients, i);
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+void socketClose(Socket *s) {
+    close((int)(uint64)s->handle);
+}
+
+Socket socketConnect(Arena *arena, SocketConnectInfo info) {
+    int socketFd = socket(AF_INET6, SOCK_STREAM, 0 /* IPPROTO_TCP */);
+    if (!info.blocking) {
+        fcntl(socketFd, F_SETFL, fcntl(socketFd, F_GETFL, 0) | O_NONBLOCK);
+    }
+
+    struct sockaddr_in6 *remoteAddr = PushStructZero(arena, struct sockaddr_in6);
+    remoteAddr->sin6_family = AF_INET6;
+    inet_pton(AF_INET6, cstring(arena, info.address), &remoteAddr->sin6_addr);
+    remoteAddr->sin6_port = htons(info.port);
+    int connectErr = connect(socketFd, (struct sockaddr *)remoteAddr, sizeof(*remoteAddr));
+
+    Socket result = {
+        .handle=(SocketHandle *)(uint64)socketFd,
+        .address=(Address *)remoteAddr,
+        .closed=connectErr == -1,
+        // TODO(dledda): investigate error behaviour
+    };
+    perror("errconn");
+
+    return result;
+}
+
+int64 socketWrite(Socket *socket, byte *source, uint64 numBytes) {
+    int64 written = send((uint64)socket->handle, source, numBytes, MSG_NOSIGNAL);
+    if (written == -1) socket->closed = true;
+    return written;
+}
+
+int64 socketWriteStr(Socket *socket, string data) {
+    int64 written = send((uint64)socket->handle, data.str, data.length, MSG_NOSIGNAL);
+    if (written == -1) socket->closed = true;
+    return written;
+}
+
+#endif

os_linux.cpp

@@ -1,98 +0,0 @@
-#ifndef OS_IMPL_LINUX_CPP
-#define OS_IMPL_LINUX_CPP
-
-#include "os.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);
-}
-
-void os_commit(void *ptr) {
-}
-
-void os_decommit(void *ptr) {
-}
-
-void os_free(void *ptr, size_t size) {
-    int err = munmap(ptr, size);
-    Assert(err != -1);
-}
-
-string os_readEntireFile(Arena *arena, string filename) {
-    Scratch temp = scratchStart(&arena, 1);
-
-    FILE *input = fopen(cstring(temp.arena, filename), "r");
-    string readBuffer;
-    if (input) {
-        struct stat st;
-        stat((char *)filename.str, &st);
-        size_t fsize = st.st_size;
-        readBuffer = PushString(arena, fsize);
-        fread(readBuffer.str, sizeof(byte), readBuffer.length, input);
-        fclose(input);
-    } else {
-        readBuffer = PushString(arena, 0);
-    }
-
-    scratchEnd(temp);
-    return readBuffer;
-}
-
-bool os_writeEntireFile(Arena *arena, string filename, const byte *contents, size_t contentsLength) {
-    Scratch temp = scratchStart(&arena, 1);
-
-    bool result = false;
-    FILE *output = fopen(cstring(temp.arena, filename), "w");
-    if (output) {
-        fwrite(contents, sizeof(byte), contentsLength, output);
-        fclose(output);
-        result = true;
-    }
-
-    scratchEnd(temp);
-    return result;
-}
-
-bool os_fileAppend(Arena *arena, string filename, const byte *contents, size_t contentsLength) {
-    Scratch temp = scratchStart(&arena, 1);
-
-    bool result = false;
-    FILE *output = fopen(cstring(temp.arena, filename), "a");
-    if (output) {
-        fwrite(contents, sizeof(byte), contentsLength, output);
-        fclose(output);
-        result = true;
-    }
-
-    scratchEnd(temp);
-    return result;
-}
-
-void os_print(StdStream target, const char *fmt, va_list argList) {
-    Scratch temp = scratchStart(0, 0);
-
-    string result = strPrintfv(temp.arena, fmt, argList);
-    // TODO(djledda): finish implementation without cstdlib
-    switch (target) {
-        case StdStream_stdin: 
-            write(0, (const void *)result.str, result.length);
-            break;
-        case StdStream_stderr: 
-            fflush(stderr);
-            write(2, (const void *)result.str, result.length);
-            break;
-        case StdStream_stdout: 
-        default:
-            fflush(stdout);
-            write(1, (const void *)result.str, result.length);
-            break;
-    }
-
-    scratchEnd(temp);
-}
-
-#endif

os_win32.c

@@ -1,5 +1,5 @@
-#ifndef OS_IMPL_WIN32_CPP
-#define OS_IMPL_WIN32_CPP
+#ifndef OS_IMPL_WIN32_C
+#define OS_IMPL_WIN32_C
 
 #include "Windows.h"
 #include "os.h"