migration
This commit is contained in:
Daniel Ledda
431
core.c
Normal file
431
core.c
Normal file
@@ -0,0 +1,431 @@
|
||||
#include "os.c"
|
||||
#include "math.h"
|
||||
#include "string.h" // 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;
|
||||
}
|
||||
|
||||
#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;
|
||||
}
|
||||
// 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) {
|
||||
if (strEql(strSlice(inputStr, c, c + splitStr.length), 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.head = splitCount,
|
||||
result.length = 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, true };
|
||||
} else {
|
||||
return (ParsePositiveIntResult){0, false};
|
||||
}
|
||||
}
|
||||
|
||||
ParsePositiveReal32Result parsePositiveReal32(string str, size_t *lengthPointer) {
|
||||
ParsePositiveReal32Result result = {NAN, 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(string, &args, strFromCString(arena, argv[i]));
|
||||
}
|
||||
return args;
|
||||
}
|
||||
|
||||
UnixTimestamp getSystemUnixTime() {
|
||||
time_t now;
|
||||
time(&now);
|
||||
return (UnixTimestamp)now;
|
||||
}
|
||||
|
||||
Timestamp timestampFromUnixTime(UnixTimestamp *unixTimestamp) {
|
||||
struct tm timestamp = {0};
|
||||
gmtime_r((time_t *)unixTimestamp, ×tamp);
|
||||
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, ...) {
|
||||
va_list argList;
|
||||
va_start(argList, fmt);
|
||||
os_print(StdStream_stdout, fmt, argList);
|
||||
va_end(argList);
|
||||
}
|
||||
|
||||
// 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 (*__djstdlib_logFn)(const char *fmt, ...) = &printStdout;
|
||||
void printIntList(IntList l) {
|
||||
__djstdlib_logFn("{ ");
|
||||
for (size_t i = 0; i < l.length; i++) {
|
||||
if (i != 0) {
|
||||
__djstdlib_logFn(", ");
|
||||
}
|
||||
__djstdlib_logFn("%i", l.data[i]);
|
||||
}
|
||||
__djstdlib_logFn(" } length: %zu, head: %zu\n", l.length, l.head);
|
||||
}
|
||||
|
||||
void printStringList(StringList l) {
|
||||
__djstdlib_logFn("{ ");
|
||||
for (size_t i = 0; i < l.length; i++) {
|
||||
if (i != 0) {
|
||||
__djstdlib_logFn(", ");
|
||||
}
|
||||
__djstdlib_logFn("\"%S\"", l.data[i]);
|
||||
}
|
||||
__djstdlib_logFn(" } length: %zu, head: %zu\n", l.length, l.head);
|
||||
}
|
||||
|
||||
int intCompare(const void *a, const void *b) {
|
||||
int *x = (int *)a;
|
||||
int *y = (int *)b;
|
||||
return (*x > *y) - (*x < *y);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user