djstdlib/core.c

#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;
        arena->head += bytes;
        memset(ptr, fill, bytes);
        return ptr;
    }
    return 0;
}

void *pushSize(Arena *arena, size_t bytes) {
    if (arena->capacity - arena->head >= bytes) {
        void *ptr = (char *)arena->memory + arena->head;
        arena->head += bytes;
        return ptr;
    }
    return 0;
}

Arena *arenaAlloc(size_t capacity) {
    Arena *result = (Arena *)os_alloc(sizeof(Arena) + capacity);
    result->memory = result + sizeof(Arena);
    result->capacity = capacity;
    result->head = 0;
    return result;
}

void arenaFree(Arena *arena) {
    os_free(arena, arena->capacity);
}

void arenaFreeFrom(Arena *arena, size_t position) {
    arena->head = position;
}

void arenaPopTo(Arena *arena, void *position) {
    arena->head = (byte *)position - (byte *)arena->memory;
}

Arena *scratchArenas[2];

void initialiseDjStdCore() {
    for (EachInArray(scratchArenas, i)) {
        scratchArenas[i] = arenaAlloc(Megabytes(64));
    }
}

Scratch scratchStart(Arena **conflicts, size_t conflictCount) {
    Scratch scratch = {0};
    for (size_t i = 0; i < ArrayCount(scratchArenas); i += 1) {
        bool conflicted = false;
        for (Arena **conflict = conflicts; conflict < conflicts + conflictCount; conflict += 1) {
            if (*conflict == scratchArenas[i]) {
                conflicted = true;
                break;
            }
        }
        if (conflicted == false) {
            scratch.arena = scratchArenas[i];
            scratch.start = scratch.arena->head;
            break;
        }
    }
    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);
}

const char *cstring(Arena *arena, string str) {
    char *arr = PushArray(arena, char, str.length + 1);
    memmove(arr, str.str, str.length);
    arr[str.length] = '\0';
    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;
    }
    for (size_t i = 0; i < testStr.length; i++) {
        if (str.str[i] != testStr.str[i]) {
            return false;
        }
    }
    return true;
}

bool strEql(string s1, string s2) {
    if (s1.length != s2.length) {
        return false;
    }
    for (size_t i = 0; i < s1.length; i++) {
        if (s1.str[i] != s2.str[i]) {
            return false;
        }
    }
    return true;
}

size_t calcStringLen(const char *str) {
    size_t size = 0;
    if (str == NULL) {
        return size;
    }
    while (str[size] != '\0') {
        size++;
    }
    return size;
}

string strFromCString(Arena *arena, const char *str) {
    string result = PushString(arena, calcStringLen(str));
    memcpy(result.str, str, result.length);
    return result;
}

string strReverse(Arena *arena, string str) {
    string reversed = PushString(arena, str.length);
    for (
        size_t mainIndex = str.length - 1, reversedIndex = 0; 
        mainIndex < str.length; 
        mainIndex--, reversedIndex++
    ) {
        reversed.str[reversedIndex] = str.str[mainIndex];
    }
    return reversed;
}

string strPrintfv(Arena *arena, const char *fmt, va_list args) {
    string result = {0};
    va_list argsCopy;
    va_copy(argsCopy, args);
    uint64 bufSize = stb_vsnprintf(0, 0, fmt, args) + 1;
    result.str = PushArray(arena, char, bufSize);
    result.length = bufSize - 1;
    stb_vsnprintf((char *)result.str, (int)bufSize, fmt, argsCopy);
    return result;
}

string strPrintf(Arena *arena, const char *fmt, ...) {
    string result = {0};
    va_list args;
    va_start(args, fmt);
    result = strPrintfv(arena, fmt, args);
    va_end(args);
    return result;
}

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 (string){0};
    }
    return (string){
        str.str + start,
        stop - start,
    };
}

string strSliceCStr(char *data, size_t start, size_t stop) {
    return (string){
        data + start,
        stop - start,
    };
}

bool stringContains(string str, char c) {
    for (size_t i = 0; i < str.length; i++) {
        if (str.str[i] == c) {
            return true;
        }
    }
    return false;
}

string NUMERIC_CHARS = s("0123456789");
inline bool isNumeric(char c) {
    return stringContains(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) {
            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;
            }
            c++;
        }

        string *splitString = PushStruct(arena, string);
        splitString->str = inputStr.str + start;
        splitString->length = inputStr.length - start;
        splitCount++;

        result.data = (string *)beginning;
        result.length = splitCount;
        result.capacity = splitCount;
    }
    return result;
}

ParsePositiveIntResult parsePositiveInt(string str, size_t *lengthPointer) {
    size_t numEnd = 0;
    char currChar = str.str[numEnd];
    while (numEnd < str.length && isNumeric(currChar)) {
        currChar = str.str[++numEnd];
        *lengthPointer += 1;
    }
    *lengthPointer -= 1;
    if (numEnd > 0) {
        uint8 result = 0;
        for (size_t i = 0; i < numEnd; i++) {
            result *= 10;
            result += str.str[i] - '0';
        }
        return (ParsePositiveIntResult){ .result=result, .valid=true };
    } else {
        return (ParsePositiveIntResult){ .result=0, .valid=false};
    }
}

ParsePositiveReal32Result parsePositiveReal32(string str, size_t *lengthPointer) {
    ParsePositiveReal32Result result = { .result=NAN, .valid=false};

    string wholePartStr = (string){0};
    string fractionalPartStr = (string){0};

    bool split = false;
    size_t c = 0;
    while (c < str.length) {
        if (str.str[c] == '.') {
            wholePartStr.str = str.str;
            wholePartStr.length = c;
            fractionalPartStr.str = str.str + c + 1;
            fractionalPartStr.length = str.length - c - 1;
            split = true;
            break;
        }
        c++;
    }
    if (split) {
        ParsePositiveIntResult wholePartParsed = parsePositiveInt(wholePartStr, lengthPointer);
        *lengthPointer += 1;
        ParsePositiveIntResult fractionalPartParsed = parsePositiveInt(fractionalPartStr, lengthPointer);
        if (wholePartParsed.valid && fractionalPartParsed.valid) {
            // TODO(dledda): implement powf with intrinsics? or just custom
            real32 fractionalPartMultiplier = 1.0f / powf(10.0f, (real32)fractionalPartStr.length);
            result.result = (real32)wholePartParsed.result + (real32)fractionalPartParsed.result * (real32)fractionalPartMultiplier;
            result.valid = true;
        }
    } else if (c > 0) {
        ParsePositiveIntResult intPartParsed = parsePositiveInt(str, lengthPointer);
        if (intPartParsed.valid) {
            result.result = (real32)intPartParsed.result;
            result.valid = true;
        }
    }
    return result;
}

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]));
    }
    return args;
}

UnixTimestamp getSystemUnixTime() {
    time_t now;
    time(&now);
    return (UnixTimestamp)now;
}

Timestamp timestampFromUnixTime(UnixTimestamp *unixTimestamp) {
    struct tm *timestamp = gmtime((time_t *)unixTimestamp);
    return *timestamp;
}

string formatTimeHmsUnix(Arena *arena, UnixTimestamp time) {
    local_persist const string format = s("HH-MM-SS");
    string buf = PushString(arena, format.length);
    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 = s("HH-MM-SS");
    string buf = PushString(arena, format.length);
    strftime(buf.str, buf.length + 1, "%T", (struct tm *)time);
    return buf;
}

string formatTimeYmdUnix(Arena *arena, UnixTimestamp time) {
    local_persist const string format = s("YYYY-mm-dd");
    string buf = PushString(arena, format.length);
    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 = s("YYYY-mm-dd");
    string buf = PushString(arena, format.length);
    strftime(buf.str, buf.length + 1, "%Y-%m-%d", (struct tm *)time);
    return buf;
}

void printStderr(const char *fmt, ...) {
    va_list argList;
    va_start(argList, fmt);
    os_print(StdStream_stdout, fmt, argList);
    va_end(argList);
}

function void printStdout(const char *fmt, ...) {
    va_list argList;
    va_start(argList, fmt);
    os_print(StdStream_stdout, fmt, argList);
    va_end(argList);
}

void (*print)(const char *fmt, ...) = &printStdout;
#define SetStdErr() DeferLoop(print = &printStderr, print = &printStdout)

// TODO(dledda): mat print functions
/*
void print(list<Vector4<real32>> l, StdStream target) {
    void (*logFn)(const char *fmt, ...) = target == StdStream_stdout ? &printStdout : &printStderr;
    logFn("{ ");
    for (size_t i = 0; i < l.length; i++) {
        if (i != 0) {
            logFn(", ");
        }
        logFn("{ %.2f, %.2f, %.2f, %.2f }", l.data[i].x, l.data[i].y, l.data[i].z, l.data[i].w);
    }
    logFn(" } length: %zu, head: %zu\n", l.length, l.head);
}

void print(list<Vector3<real32>> l, StdStream target) {
    void (*logFn)(const char *fmt, ...) = target == StdStream_stdout ? &printStdout : &printStderr;
    logFn("{ ");
    for (size_t i = 0; i < l.length; i++) {
        if (i != 0) {
            logFn(", ");
        }
        logFn("{ %.2f, %.2f, %.2f }", l.data[i].x, l.data[i].y, l.data[i].z);
    }
    logFn(" } length: %zu, head: %zu\n", l.length, l.head);
}

void print(list<Vector2<real32>> l, StdStream target) {
    void (*logFn)(const char *fmt, ...) = target == StdStream_stdout ? &printStdout : &printStderr;
    logFn("{ ");
    for (size_t i = 0; i < l.length; i++) {
        if (i != 0) {
            logFn(", ");
        }
        logFn("{ %.2f, %.2f }", l.data[i].x, l.data[i].y);
    }
    logFn(" } length: %zu, head: %zu\n", l.length, l.head);
}
*/

void printIntList(IntList l) {
    print("{ ");
    for (size_t i = 0; i < l.length; i++) {
        if (i != 0) {
            print(", ");
        }
        print("%i", l.data[i]);
    }
    print(" } length: %zu, capacity: %zu\n", l.length, l.capacity);
}

void printStrList(StringList l) {
    print("{ ");
    for (size_t i = 0; i < l.length; i++) {
        if (i != 0) {
            print(", ");
        }
        print("\"%S\"", l.data[i]);
    }
    print(" } length: %zu, capacity: %zu\n", l.length, l.capacity);
}

int intCompare(const void *a, const void *b) {
    int *x = (int *)a;
    int *y = (int *)b;
    return (*x > *y) - (*x < *y);
}