fix int parsing

.clangd

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

app.c

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

app.cpp

@@ -1,12 +0,0 @@
-#include "core.c"
-
-int main(int argc, char **argv) {
-    initialiseDjStdCore();
-    Arena *arena = arenaAlloc(Megabytes(64));
-    StringList args = getArgs(arena, argc, argv);
-
-    printStrList(args);
-    printStrList(strSplit(arena, s("-"), s("the-quick-brown-fox-jumps-over-the-lazy-dog")));
-
-    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.c"
 #include "math.h"
-#include "string.h" // memmove
+#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,9 +71,6 @@ 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);
 }
@@ -165,8 +162,6 @@ string strPrintf(Arena *arena, const char *fmt, ...) {
     return result;
 }
 
-#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) {
         stop = str.length;
@@ -181,6 +176,19 @@ string strSlice(string str, size_t start, size_t stop) {
     };
 }
 
+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,
@@ -188,7 +196,7 @@ string strSliceCStr(char *data, size_t start, size_t stop) {
     };
 }
 
-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;
@@ -197,9 +205,24 @@ bool stringContains(string str, char c) {
     return false;
 }
 
+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;
+}
+
 string NUMERIC_CHARS = s("0123456789");
-inline bool isNumeric(char c) {
-    return stringContains(NUMERIC_CHARS, c);
+inline function bool isNumeric(char c) {
+    return strContainsChar(NUMERIC_CHARS, c);
 }
 
 StringList strSplit(Arena *arena, string splitStr, string inputStr) {
@@ -208,15 +231,15 @@ StringList strSplit(Arena *arena, string splitStr, string inputStr) {
         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) {
+        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++;
         }
@@ -228,33 +251,51 @@ StringList strSplit(Arena *arena, string splitStr, string inputStr) {
 
         result.data = (string *)beginning;
         result.length = splitCount;
-        result.head = 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 (ParsePositiveIntResult){ result, true };
+        return (Int32Result){ .result=result, .valid=true };
     } else {
-        return (ParsePositiveIntResult){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};
+    }
+}
+
+Real32Result parsePositiveReal32(string str) {
+    Real32Result result = { .result=NAN, .valid=false};
 
     string wholePartStr = (string){0};
     string fractionalPartStr = (string){0};
@@ -273,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);
@@ -283,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;
@@ -295,7 +335,7 @@ ParsePositiveReal32Result parsePositiveReal32(string str, size_t *lengthPointer)
 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;
 }
@@ -307,9 +347,8 @@ UnixTimestamp getSystemUnixTime() {
 }
 
 Timestamp timestampFromUnixTime(UnixTimestamp *unixTimestamp) {
-    struct tm timestamp = {0};
-    gmtime_r((time_t *)unixTimestamp, &timestamp);
-    return timestamp;
+    struct tm *timestamp = gmtime((time_t *)unixTimestamp);
+    return *timestamp;
 }
 
 string formatTimeHmsUnix(Arena *arena, UnixTimestamp time) {
@@ -342,13 +381,20 @@ string formatTimeYmd(Arena *arena, Timestamp *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);
@@ -356,8 +402,31 @@ function void printStdout(const char *fmt, ...) {
     va_end(argList);
 }
 
+function void printlnStdout(const char *fmt, ...) {
+    va_list argList;
+    va_start(argList, fmt);
+    os_println(StdStream_stdout, fmt, argList);
+    va_end(argList);
+}
+
 void (*print)(const char *fmt, ...) = &printStdout;
-#define SetStdErr() DeferLoop(print = &printStderr, print = &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
 /*
@@ -406,7 +475,7 @@ void printIntList(IntList l) {
         }
         print("%i", l.data[i]);
     }
-    print(" } length: %zu, head: %zu\n", l.length, l.head);
+    print(" } length: %zu, capacity: %zu\n", l.length, l.capacity);
 }
 
 void printStrList(StringList l) {
@@ -417,7 +486,7 @@ void printStrList(StringList l) {
         }
         print("\"%S\"", l.data[i]);
     }
-    print(" } 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) {
@@ -426,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,14 +2,13 @@
 #define CORE_H
 
 // cstdlib includes
-#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
+#include <string.h>
 
 // ### Misc macros ###
-#if ENABLE_ASSERT
+#if DJSTDLIB_DEBUG
 #define Assert(expression) if (!(expression)) {*(volatile int *)0 = 0;}
 #else
 #define Assert(expression)
@@ -18,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;
@@ -28,7 +30,7 @@ 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;
@@ -46,21 +48,21 @@ typedef struct string string;
 
 #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 ###
-typedef struct {
+typedef struct Arena Arena;
+struct Arena {
     void *memory;
     size_t capacity;
     size_t head;
-} Arena;
+};
 
-typedef struct {
+typedef struct Scratch Scratch;
+struct Scratch {
     Arena *arena;
     size_t start;
-} Scratch;
+};
 
 void *pushSize(Arena *arena, size_t bytes);
 void *pushSizeFill(Arena *arena, size_t bytes, byte fill);
@@ -78,15 +80,17 @@ 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 ###
-typedef union {
+typedef union Vec2 Vec2;
+union Vec2 {
     struct {
         real32 x;
         real32 y;
     };
     real32 vec[2];
-} Vec2;
+};
 inline function Vec2 vec2(real32 x, real32 y) {
     Vec2 result = {0};
     result.x = x;
@@ -94,14 +98,15 @@ inline function Vec2 vec2(real32 x, real32 y) {
     return result;
 }
 
-typedef union {
+typedef union Vec3 Vec3;
+union Vec3 {
     struct {
         real32 x;
         real32 y;
         real32 z;
     };
     real32 vec[3];
-} Vec3;
+};
 inline function Vec3 vec3(real32 x, real32 y, real32 z) {
     Vec3 result = {0};
     result.x = x;
@@ -110,7 +115,8 @@ inline function Vec3 vec3(real32 x, real32 y, real32 z) {
     return result;
 }
 
-typedef union {
+typedef union Vec4 Vec4;
+union Vec4 {
     struct {
         real32 r;
         real32 g;
@@ -124,7 +130,7 @@ typedef union {
         real32 w;
     };
     real32 vec[4];
-} Vec4;
+};
 inline function Vec4 vec4(real32 x, real32 y, real32 z, real32 w) {
     Vec4 result = {0};
     result.x = x;
@@ -136,28 +142,65 @@ inline function Vec4 vec4(real32 x, real32 y, real32 z, real32 w) {
 
 // ### Lists ###
 #define DefineList(type, prefix) \
-    typedef struct {\
-        type* data;\
+    typedef struct prefix ## List prefix ## List;\
+    struct prefix ## List {\
+        type *data;\
         size_t length;\
-        size_t head;\
-    } prefix ## List
+        size_t capacity;\
+    };\
+    typedef type prefix ## List ## _underlying
+#define ListElementSize(list) MemberSizeUnderlying(list, data)
 
 DefineList(string, String);
+DefineList(void, Void);
 
-#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 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 AppendList(list, element) \
-    if ((list)->head < (list)->length) { \
-        (list)->data[(list)->head++] = (element); \
+#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;\
     }
-#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 {
@@ -170,6 +213,7 @@ struct string {
 #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
 DefineList(char, Char);
@@ -180,21 +224,33 @@ 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);
+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, ...);
 
-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);
+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 ###
 StringList getArgs(Arena *arena, int argc, char **argv);
@@ -220,9 +276,10 @@ typedef enum {
     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
@@ -267,13 +324,19 @@ typedef enum {
 #define COLOR_TEXT_RGB(text, red, green, blue) ANSI_INSTRUCTION_STR("38;2;" #red ";" #green ";" #blue) text ANSI_RESET
 
 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.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

@@ -5,9 +5,19 @@
 
 #include "sys/mman.h"
 #include "sys/stat.h"
-#include "unistd.h"
+#include "string.h" // memcpy TODO(dledda): replace memcpy with custom impl?
+#include "unistd.h" // POSIX Standard, read, write, close, open, etc.
 
-void *os_alloc(size_t capacity) {
+#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);
 }
 
@@ -17,7 +27,7 @@ void os_commit(void *ptr) {
 void os_decommit(void *ptr) {
 }
 
-void os_free(void *ptr, size_t size) {
+void os_free(void *ptr, uint64 size) {
     int err = munmap(ptr, size);
     Assert(err != -1);
 }
@@ -25,53 +35,89 @@ void os_free(void *ptr, size_t size) {
 string os_readEntireFile(Arena *arena, string filename) {
     Scratch temp = scratchStart(&arena, 1);
 
-    FILE *input = fopen(cstring(temp.arena, filename), "r");
+    int input = open(cstring(temp.arena, filename), O_RDONLY);
     string readBuffer;
     if (input) {
         struct stat st;
         stat((char *)filename.str, &st);
-        size_t fsize = st.st_size;
+        uint64 fsize = st.st_size;
         readBuffer = PushString(arena, fsize);
-        fread(readBuffer.str, sizeof(byte), readBuffer.length, input);
-        fclose(input);
+        int64 bytesRead = read(input, readBuffer.str, readBuffer.length);
+        close(input);
+        if (bytesRead == -1) {
+            arenaPopTo(arena, readBuffer.str);
+            return s("");
+        }
     } else {
-        readBuffer = PushString(arena, 0);
+        readBuffer = s("");
     }
 
     scratchEnd(temp);
     return readBuffer;
 }
 
-bool os_writeEntireFile(Arena *arena, string filename, const byte *contents, size_t contentsLength) {
+bool os_writeEntireFile(Arena *arena, string filename, const byte *contents, uint64 contentsLength) {
     Scratch temp = scratchStart(&arena, 1);
 
     bool result = false;
-    FILE *output = fopen(cstring(temp.arena, filename), "w");
+    int output = open(cstring(temp.arena, filename), O_WRONLY);
     if (output) {
-        fwrite(contents, sizeof(byte), contentsLength, output);
-        fclose(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, size_t contentsLength) {
+bool os_fileAppend(Arena *arena, string filename, const byte *contents, uint64 contentsLength) {
     Scratch temp = scratchStart(&arena, 1);
 
     bool result = false;
-    FILE *output = fopen(cstring(temp.arena, filename), "a");
+    int output = open(cstring(temp.arena, filename), O_APPEND);
     if (output) {
-        fwrite(contents, sizeof(byte), contentsLength, output);
-        fclose(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);
 
@@ -82,12 +128,10 @@ void os_print(StdStream target, const char *fmt, va_list argList) {
             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;
     }
@@ -95,4 +139,240 @@ void os_print(StdStream target, const char *fmt, va_list argList) {
     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