Ledda/djstdlib
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Compare commits

base: Ledda:e9290ba9f25419c39b345753e62dddfda4589d0f
Branches Tags
Ledda:master Ledda:c-only
...
compare: Ledda:db92620d65125a21827711a7f15fca669f5a71ae
Branches Tags
Ledda:master Ledda:c-only

3 Commits
e9290ba9f2 ... db92620d65

Author SHA1 Message Date
Daniel Ledda
db92620d65 fixes 2025-11-09 05:36:10 +01:00
Daniel Ledda
52f9a2fe33 migration 2025-11-09 04:18:08 +01:00
Daniel Ledda
768424e199 update 2025-11-09 13:30:05 +11:00
8 changed files with 181 additions and 223 deletions
Expand all files Collapse all files

3
.clangd
View File

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

9
app.cpp
View File

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

160
core.cpp → core.c
View File

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

202
core.h
View File

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

8
os.cpp → os.c
View File

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

6
os.h
View File

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

10
os_linux.cpp → os_linux.c
View File

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

6
os_win32.cpp → os_win32.c
View File

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