Starting fresh with the `badlang`

1 files changed, 876 insertions, 0 deletions

diff --git a/src/badlib.h b/src/badlib.h
new file mode 100644
index 0000000..f7a7974
--- /dev/null
+++ b/src/badlib.h
@@ -0,0 +1,876 @@
+#ifndef BADLIB_H
+#define BADLIB_H
+
+// TODO:
+// - Add string operations.
+//     - sub
+// - Add math operations for vectors and matrices.
+// - Can we remove the PlatformAPI function pointers and just use extern
+//   references?
+// - Breakdown this file in the different library parts.
+// - Sort arrays / linked lists with custom functions?
+// - Implement binary search for searching into an array:
+//       SearchResult find_array(Array haystack, Array needle).
+//
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <strings.h>
+#define printstr(s) \
+    if (s) printf("%.*s", (int)(s)->size, (s)->mem);
+#define printstrln(s) \
+    if (s) printf("%.*s\n", (int)(s)->size, (s)->mem);
+
+//
+// This simple header just typedefs the basic C define types to a shorter name,
+// loads the quality of life bool macro for _Bool and defines shorthand macros
+// for byte sizes.  We need that the targeted architecture uses the floating
+// point representation as described on the IEEE-754 standard.
+//
+
+_Static_assert(sizeof(double) == 8, "no support for IEEE-754");
+_Static_assert(sizeof(float) == 4, "no support for IEEE-754");
+
+typedef uint8_t u8;
+typedef uint16_t u16;
+typedef uint32_t u32;
+typedef uint64_t u64;
+typedef int8_t s8;
+typedef int16_t s16;
+typedef int32_t s32;
+typedef int64_t s64;
+typedef float f32;
+typedef double f64;
+typedef ptrdiff_t sz;
+typedef uintptr_t ptrsize;
+typedef size_t usize;
+
+#define KB(N) ((sz)(N)*1024)
+#define MB(N) ((sz)KB(N) * 1024)
+#define GB(N) ((sz)MB(N) * 1024)
+#define TB(N) ((sz)GB(N) * 1024)
+
+// Custom assert macro, better for debugging.
+#ifdef DEBUG
+#define assert(c) \
+    while (!(c))  \
+    __builtin_unreachable()
+#else
+#define assert(c) ;
+#endif
+
+// Abort macro without stdlib.
+#define abort() __builtin_trap()
+
+// Utility macros for numeric comparisons.
+#define MIN(A, B) ((A) <= (B) ? (A) : (B))
+#define MAX(A, B) ((A) >= (B) ? (A) : (B))
+#define ABS(A) \
+    (((A) ^ ((A) >> (sizeof(A) * 8 - 1))) - ((A) >> (sizeof(A) * 8 - 1)))
+#define CLAMP(X, MIN, MAX) ((X) <= (MIN) ? (MIN) : (X) > (MAX) ? (MAX) : (X))
+#define LEN(a) (sz)(sizeof(a) / sizeof(*(a)))
+
+// Handy defer bacro for scoped operations.
+#define MACRO_VAR_CONCAT_HELPER(X, Y) X##Y
+#define MACRO_VAR_CONCAT(X, Y) MACRO_VAR_CONCAT_HELPER(X, Y)
+#define MACRO_VAR(name) MACRO_VAR_CONCAT(name, __LINE__)
+#define defer(begin, end)                                 \
+    for (sz MACRO_VAR(_i_) = (begin, 0); !MACRO_VAR(_i_); \
+         (MACRO_VAR(_i_) += 1), end)
+
+//
+// Allocators and Arenas.
+//
+
+typedef struct Allocator {
+    void *(*malloc)(sz, void *ctx);
+    void *(*calloc)(sz, void *ctx);
+    void (*free)(void *, void *ctx);
+    void *(*realloc)(void *ptr, sz old_size, sz new_size, void *ctx);
+    void *ctx;
+} Allocator;
+
+typedef struct Arena {
+    u8 *beg;
+    sz size;
+    sz cap;
+} Arena;
+
+#define ARENA_ALIGNMENT 8
+
+void *
+arena_malloc(sz size, void *ctx) {
+    assert(size > 0);
+    Arena *a = (Arena *)ctx;
+    sz padding = -size & (ARENA_ALIGNMENT - 1);
+    sz available = a->cap - a->size;
+    if (available < 0 || available < size) {
+        abort();
+    }
+    void *p = a->beg + a->size;
+    a->size += padding + size;
+    return p;
+}
+
+void *
+arena_calloc(sz size, void *ctx) {
+    void *mem = arena_malloc(size, ctx);
+    return memset(mem, 0, size);
+}
+
+void
+arena_free(void *ptr, sz size, void *ctx) {
+    // Undo the latest allocation if possible.
+    Arena *a = (Arena *)ctx;
+    sz padding = -size & (ARENA_ALIGNMENT - 1);
+    size += padding;
+    if (ptr == a->beg + a->size - size) {
+        a->size -= size;
+    }
+}
+
+void *
+arena_realloc(void *ptr, sz old_size, sz new_size, void *ctx) {
+    // This function can avoid copying memory around if we could just extend the
+    // latest allocation, otherwise a new malloc will be performed (keeping the
+    // previous data alive!).
+    Arena *a = (Arena *)ctx;
+    sz old_padding = -old_size & (ARENA_ALIGNMENT - 1);
+    old_size += old_padding;
+    if (ptr == a->beg + a->size - old_size) {
+        sz new_padding = -new_size & (ARENA_ALIGNMENT - 1);
+        new_size += new_padding;
+        a->size += new_size - old_size;
+        return ptr;
+    }
+    u8 *p = (u8 *)arena_malloc(new_size, ctx);
+    memcpy(p, ptr, old_size);
+    return p;
+}
+
+Arena
+arena_create(sz cap, Allocator allocator) {
+    Arena arena = {0};
+    arena.beg = (u8 *)allocator.malloc(cap, allocator.ctx);
+    arena.cap = arena.beg ? cap : 0;
+    return arena;
+}
+
+void
+arena_destroy(Arena *arena, Allocator allocator) {
+    allocator.free(arena->beg, allocator.ctx);
+}
+
+void
+arena_reset(Arena *a) {
+    a->size = 0;
+}
+
+//
+// Arrays, Buffers and Strings.
+//
+
+// A fixed buffer or buffer view, represented as a fat pointer.
+typedef struct Array {
+    u8 *mem;
+    sz size;
+} Array;
+
+typedef struct SearchResult {
+    // Position on the buffer where a result was found.
+    sz pos;
+    // Size of the matched query.
+    sz matched;
+    // Wether the search was successful or not.
+    bool found;
+} SearchResult;
+
+bool
+array_eq(Array a, Array b) {
+    return a.size == b.size && !memcmp(a.mem, b.mem, a.size);
+}
+
+SearchResult
+array_find_next(Array haystack, Array needle) {
+    sz pos = 0;
+    while (haystack.size >= needle.size) {
+        if (*haystack.mem == *needle.mem) {
+            Array candidate = (Array){
+                .mem = haystack.mem,
+                .size = needle.size,
+            };
+            if (array_eq(candidate, needle)) {
+                return (SearchResult){
+                    .pos = pos,
+                    .matched = needle.size,
+                    .found = true,
+                };
+            }
+        }
+        haystack.mem++;
+        haystack.size--;
+        pos++;
+    }
+    return (SearchResult){.found = false};
+}
+
+// A growable arena backed buffer.
+typedef struct Buf {
+    u8 *mem;
+    sz size;
+    sz cap;
+} Buf;
+
+// Reserve a given amount of bytes for a growable buffer.
+void
+buf_reserve(Buf *buf, sz size, Arena *a) {
+    assert(buf);
+    buf->mem = arena_realloc(buf->mem, buf->size, size, a);
+    buf->size = 0;
+    buf->cap = size;
+}
+
+// Zero initialize a growable buffer.
+void
+buf_zero(Buf *buf, sz size, Arena *a) {
+    buf_reserve(buf, size, a);
+    memset(buf->mem, 0, buf->cap);
+}
+
+// Insert a number of bytes into a growable buffer.
+void
+buf_insert(Buf *buf, void *value, sz size, Arena *a) {
+    assert(buf);
+    if (size == 0) {
+        return;
+    }
+    if (!buf->mem) {
+        buf->mem = arena_malloc(size, a);
+        buf->size = size;
+        buf->cap = size;
+        memcpy(buf->mem, value, size);
+        return;
+    }
+    while (buf->cap < buf->size + size) {
+        arena_realloc(buf->mem, buf->cap, buf->cap * 2, a);
+        buf->cap *= 2;
+    }
+    memcpy(buf->mem + buf->size, value, size);
+    buf->size += size;
+}
+
+// Gets a reference to a given position of the buffer. It doesn't copy any
+// information so bear in mind it could become invalidated if the buffer is
+// modified.
+void *
+buf_ref(Buf *buf, sz pos, sz size) {
+    return buf->mem + pos * size;
+}
+
+// Copies a number of bytes from an indexed position from growable buffer into
+// the given destination.
+void
+buf_get(Buf *buf, void *dst, sz pos, sz size) {
+    memcpy(dst, buf->mem + pos * size, size);
+}
+
+// Pops a number of bytes from a growable buffer into the given destination,
+// copying the result and reducing the size of the buffer.
+void
+buf_pop(Buf *buf, void *dst, sz size) {
+    assert(buf->mem + buf->size - size >= buf->mem);
+    memcpy(dst, buf->mem + buf->size - size, size);
+    buf->size -= size;
+}
+
+// A string or string view.
+typedef Array Str;
+
+// Create a string view from a C literal with these.
+#define cstr(s)             \
+    (Str) {                 \
+        (u8 *)s, LEN(s) - 1 \
+    }
+
+bool
+str_eq(Str a, Str b) {
+    return array_eq(a, b);
+}
+
+Str
+str_split(Str *a, Str split) {
+    assert(a != NULL);
+    Str ret = *a;
+    SearchResult res = array_find_next(*a, split);
+    if (res.found) {
+        ret.size = res.pos;
+        a->mem += res.pos + res.matched;
+        a->size -= res.pos + res.matched;
+        return ret;
+    }
+    *a = (Str){0};
+    return ret;
+}
+
+// A customizable splitting function.
+typedef sz(StrSplitFn)(Str s);
+
+Str
+str_split_fn(Str *a, StrSplitFn split_fn) {
+    assert(a != NULL);
+    Str ret = *a;
+    while (a->size > 0) {
+        sz advance = split_fn(*a);
+        if (advance) {
+            ret.size -= a->size;
+            a->size -= advance;
+            a->mem += advance;
+            return ret;
+        }
+        a->size--;
+        a->mem++;
+    }
+    return ret;
+}
+
+// Replaces a single pattern on a string. `from` and `to` have to be of the same
+// size.
+void
+str_replace(Str *a, Str from, Str to) {
+    assert(a != NULL);
+    assert(from.size == to.size);
+    SearchResult res = array_find_next(*a, from);
+    if (res.found) {
+        memcpy(a->mem + res.pos, to.mem, res.matched);
+        return;
+    }
+}
+
+// Same as `str_replace` but applied to all occurences of `from`.
+void
+str_replace_all(Str *a, Str from, Str to) {
+    assert(a != NULL);
+    assert(from.size == to.size);
+    Str data = *a;
+    SearchResult res = array_find_next(data, from);
+    while (res.found) {
+        memcpy(data.mem + res.pos, to.mem, res.matched);
+        data.mem += res.pos;
+        data.size -= res.pos;
+        res = array_find_next(data, from);
+    }
+}
+
+bool
+str_has_prefix(Str str, Str prefix) {
+    if (str.size < prefix.size) {
+        return false;
+    }
+    Str candidate = (Str){
+        .mem = str.mem,
+        .size = prefix.size,
+    };
+    return str_eq(candidate, prefix);
+}
+
+bool
+str_has_suffix(Str str, Str suffix) {
+    if (str.size < suffix.size) {
+        return false;
+    }
+    Str candidate = (Str){
+        .mem = str.mem + str.size - suffix.size,
+        .size = suffix.size,
+    };
+    return str_eq(candidate, suffix);
+}
+
+Str
+str_remove_prefix(Str str, Str prefix) {
+    if (!str_has_prefix(str, prefix)) {
+        return str;
+    }
+    str.mem += prefix.size;
+    str.size -= prefix.size;
+    return str;
+}
+
+Str
+str_remove_suffix(Str str, Str suffix) {
+    if (!str_has_suffix(str, suffix)) {
+        return str;
+    }
+    str.size -= suffix.size;
+    return str;
+}
+
+// Concat.
+Str
+str_concat(Str x, Str y, Arena *a) {
+    Buf buf = {0};
+    buf_insert(&buf, x.mem, x.size, a);
+    buf_insert(&buf, y.mem, y.size, a);
+    return (Str){
+        .mem = buf.mem,
+        .size = buf.size,
+    };
+}
+
+Str
+str_insert(Str orig, Str value, sz position, Arena *a) {
+    Buf buf = {0};
+    buf_insert(&buf, orig.mem, position, a);
+    buf_insert(&buf, value.mem, value.size, a);
+    buf_insert(&buf, orig.mem + position, orig.size - position, a);
+    return (Str){
+        .mem = buf.mem,
+        .size = buf.size,
+    };
+}
+
+// Str
+// str_delete(Str orig, Str value, Arena *a) {
+//     Buf buf = {0};
+//     // TODO: find first location
+//     // TODO: insert orig until that location
+//     // TODO: insert orig after location + value.size
+//     // buf_insert(&buf, orig.mem, position, a);
+//     // buf_insert(&buf, value.mem, value.size, a);
+//     // buf_insert(&buf, orig.mem + position, orig.size - position, a);
+//     return (Str){
+//         .mem = buf.mem,
+//         .size = buf.size,
+//     };
+// }
+
+//
+// Queue.
+//
+
+typedef struct QueueVal {
+    struct QueueVal *next;
+    void *val;
+} QueueVal;
+
+typedef struct Queue {
+    QueueVal *head;
+    QueueVal *tail;
+    sz size;
+} Queue;
+
+void
+queue_push(Queue *l, void *val, Arena *a) {
+    assert(l);
+    QueueVal *next = (QueueVal *)arena_calloc(sizeof(QueueVal), a);
+    next->val = val;
+    if (l->size == 0) {
+        l->head = next;
+        l->tail = next;
+        l->size = 1;
+        return;
+    }
+    QueueVal *cur = l->tail;
+    cur->next = next;
+    l->tail = next;
+    l->size++;
+}
+
+void *
+queue_peek(Queue *l) {
+    assert(l);
+    if (l->size == 0) {
+        return NULL;
+    }
+    QueueVal *cur = l->head;
+    return cur->val;
+}
+
+void *
+queue_pop(Queue *l) {
+    assert(l);
+    if (l->size == 0) {
+        return NULL;
+    }
+    QueueVal *cur = l->head;
+    l->head = cur->next;
+    l->size--;
+    return cur->val;
+}
+
+//
+// Map.
+//
+
+typedef u64(HashFunc)(void *in);
+typedef bool(EqFunc)(void *a, void *b);
+
+typedef struct MapNode {
+    struct MapNode *child[4];
+    void *key;
+    void *val;
+} MapNode;
+
+typedef struct Map {
+    HashFunc *hash_func;
+    EqFunc *eq_func;
+    MapNode *root;
+    Arena *storage;
+} Map;
+
+MapNode *
+map_upsert(Map *m, void *key, Arena *a) {
+    u64 h = m->hash_func(key);
+    MapNode **item = &m->root;
+    while (*item) {
+        if (m->eq_func(key, (*item)->key)) {
+            return *item;
+        }
+        h = (h << 2) | (h >> 62);
+        item = &(*item)->child[h & 0x3];
+    }
+    *item = (MapNode *)arena_calloc(sizeof(MapNode), a);
+    (*item)->key = key;
+    return *item;
+}
+
+void
+map_insert(Map *m, void *key, void *val, Arena *a) {
+    u64 h = m->hash_func(key);
+    MapNode **item = &m->root;
+    while (*item) {
+        if (m->eq_func(key, (*item)->key)) {
+            (*item)->val = val;
+            return;
+        }
+        h = (h << 2) | (h >> 62);
+        item = &(*item)->child[h & 0x3];
+    }
+    *item = (MapNode *)arena_calloc(sizeof(MapNode), a);
+    (*item)->key = key;
+    (*item)->val = val;
+}
+
+MapNode *
+map_lookup(Map *m, void *key) {
+    u64 h = m->hash_func(key);
+    MapNode **item = &m->root;
+    while (*item) {
+        if (m->eq_func(key, (*item)->key)) {
+            return *item;
+        }
+        h = (h << 2) | (h >> 62);
+        item = &(*item)->child[h & 0x3];
+    }
+    return NULL;
+}
+
+typedef struct MapIter {
+    Queue queue;
+} MapIter;
+
+MapIter
+map_iterator(Map map, Arena *a) {
+    MapIter it = {0};
+    queue_push(&it.queue, map.root, a);
+    return it;
+}
+
+MapNode *
+map_next(MapIter *it, Arena *a) {
+    assert(it);
+    assert(a);
+    while (it->queue.head) {
+        MapNode *item = (MapNode *)queue_pop(&it->queue);
+        for (sz i = 0; i < 4; i++) {
+            MapNode *child = item->child[i];
+            if (child) {
+                queue_push(&it->queue, child, a);
+            }
+        }
+        return item;
+    }
+    return NULL;
+}
+
+//
+// Dynamic arrays.
+//
+
+typedef struct ArrayHeader {
+    sz size;
+    sz cap;
+} ArrayHeader;
+
+// Header/Size/capacity accessors.
+#define array_head(ARR) ((ArrayHeader *)((char *)(ARR) - sizeof(ArrayHeader)))
+#define array_size(ARR) ((ARR) ? array_head(ARR)->size : 0)
+#define array_cap(ARR) ((ARR) ? array_head(ARR)->cap : 0)
+
+// Initialize a dynamic array ARR with N elements. The initialization doesn't
+// zero out the data, so thread carefully..
+#define array_init(ARR, N, ARENA) \
+    ((ARR) = _array_reserve(N, sizeof(*(ARR)), (ARENA)))
+
+// Push a given element T to the dynamic array ARR.
+#define array_push(ARR, T, ARENA)                          \
+    ((ARR) = _array_maybe_grow((ARR), sizeof(T), (ARENA)), \
+     (ARR)[array_head(ARR)->size++] = (T))
+
+// Return the last element of the array. Can be used to build stacks.
+#define array_pop(ARR) (ARR)[--array_head(ARR)->size]
+
+// Return the value stored at the OFFSET position from the tail of the array.
+#define array_peek(ARR, OFFSET) (ARR)[array_head(ARR)->size - 1 - (OFFSET)]
+
+// Insert N bytes from the SRC array into the ARR dynamic array.
+#define array_insert(ARR, SRC, N, ARENA) \
+    ((ARR) = _array_insert((ARR), (SRC), (N), sizeof(*(ARR)), (ARENA)))
+
+// Free the memory from the original allocated position.
+#define array_free(ARR) ((ARR) ? free(array_head(ARR)), (ARR) = NULL : 0)
+
+static inline void *
+_array_reserve(sz num_elem, sz type_size, Arena *a) {
+    u8 *p = (u8 *)arena_malloc(num_elem * type_size + sizeof(ArrayHeader), a);
+    p += sizeof(ArrayHeader);
+    array_head(p)->size = 0;
+    array_head(p)->cap = num_elem;
+    return p;
+}
+
+static inline void *
+_array_maybe_grow(void *arr, sz type_size, Arena *a) {
+    ArrayHeader *head = array_head(arr);
+    if (head->cap == head->size) {
+        sz prev_size = head->cap * type_size + sizeof(ArrayHeader);
+        if (head->cap == 0) {
+            head->cap++;
+        } else {
+            head->cap *= 2;
+        }
+        sz new_size = head->cap * type_size + sizeof(ArrayHeader);
+        head = (ArrayHeader *)arena_realloc(head, prev_size, new_size, a);
+    }
+    arr = (char *)head + sizeof(ArrayHeader);
+    return arr;
+}
+
+static inline char *
+_array_insert(char *arr, const char *src, sz n_bytes, sz type_size, Arena *a) {
+    ArrayHeader *head = array_head(arr);
+    sz new_size = n_bytes + head->size;
+    if (new_size > head->cap * type_size) {
+        sz prev_size = head->cap * type_size + sizeof(ArrayHeader);
+        if (head->cap == 0) {
+            head->cap = 1;
+        }
+        while (new_size >= head->cap * type_size) {
+            head->cap *= 2;
+        }
+        sz new_size = head->cap * type_size + sizeof(ArrayHeader);
+        head = (ArrayHeader *)arena_realloc(head, prev_size, new_size, a);
+    }
+    arr = (char *)head + sizeof(ArrayHeader);
+    memcpy((arr + head->size), src, n_bytes);
+    head->size = new_size;
+    return arr;
+}
+
+//
+// Math.
+//
+
+typedef union Vec2f {
+    struct {
+        f32 x, y;
+    };
+    struct {
+        f32 u, v;
+    };
+    struct {
+        f32 left, right;
+    };
+    struct {
+        f32 width, height;
+    };
+    f32 data[2];
+} Vec2f;
+
+typedef union Vec3f {
+    struct {
+        f32 x, y, z;
+    };
+    struct {
+        f32 u, v, w;
+    };
+    struct {
+        f32 r, g, b;
+    };
+    struct {
+        Vec2f xy;
+        f32 _z;
+    };
+    struct {
+        f32 _x;
+        Vec2f yz;
+    };
+    struct {
+        Vec2f uv;
+        f32 _w;
+    };
+    struct {
+        f32 _u;
+        Vec2f vw;
+    };
+    f32 data[2];
+} Vec3f;
+
+typedef union Vec4f {
+    struct {
+        f32 x, y, z, w;
+    };
+    struct {
+        Vec3f xyz;
+        f32 _w;
+    };
+    struct {
+        union {
+            Vec3f rgb;
+            struct {
+                f32 r, g, b;
+            };
+        };
+        f32 a;
+    };
+    struct {
+        Vec2f xy;
+        f32 _y0;
+        f32 _z0;
+    };
+    struct {
+        f32 _x0;
+        Vec2f yz;
+        f32 _z1;
+    };
+    struct {
+        f32 _x1;
+        f32 _y1;
+        Vec2f zw;
+    };
+    f32 data[4];
+} Vec4f;
+
+//
+// OS/Platform stuff.
+//
+
+typedef enum {
+    FILE_ERR_OK = 0,
+    FILE_ERR_CANT_OPEN,
+    FILE_ERR_READ_ERR,
+    FILE_ERR_PATH_TOO_BIG,
+    FILE_ERR_EMPTY,
+    FILE_ERR_NUM,
+} FileErr;
+
+Str file_err_str[FILE_ERR_NUM] = {
+    cstr(""),
+    cstr("couldn't open file"),
+    cstr("couldn't read file"),
+    cstr("file path too big"),
+    cstr("file is empty"),
+};
+
+typedef struct FileContents {
+    Str path;
+    Array data;
+    FileErr err;
+} FileContents;
+
+FileContents
+platform_read_file(Str path, Arena *a) {
+    // Transform Str to cstr.
+    char path_str[KB(1)];
+    if (path.size >= KB(1) - 1) {
+        return (FileContents){
+            .path = path,
+            .err = FILE_ERR_PATH_TOO_BIG,
+        };
+    }
+    memcpy(path_str, path.mem, path.size);
+    path_str[path.size] = 0;
+
+    // Read the entire file into memory.
+    sz file_size = 0;
+    FILE *fp = fopen(path_str, "rb+");
+    if (!fp) {
+        return (FileContents){
+            .path = path,
+            .err = FILE_ERR_CANT_OPEN,
+        };
+    }
+    fseek(fp, 0, SEEK_END);
+    file_size = ftell(fp);
+    rewind(fp);
+    u8 *memory = arena_malloc(file_size, a);
+    sz read = fread(memory, 1, file_size, fp);
+    fclose(fp);
+    if (read == 0) {
+        return (FileContents){
+            .path = path,
+            .err = FILE_ERR_EMPTY,
+        };
+    }
+
+    return (FileContents){
+        .path = path,
+        .data = (Array){.mem = (u8 *)memory, .size = file_size},
+        .err = FILE_ERR_OK,
+    };
+}
+
+void *
+platform_calloc(sz size, void *ctx) {
+    (void)ctx;
+    return calloc(1, size);
+}
+
+void *
+platform_malloc(sz size, void *ctx) {
+    (void)ctx;
+    return malloc(size);
+}
+
+void *
+platform_realloc(void *ptr, sz old_size, sz new_size, void *ctx) {
+    (void)ctx;
+    (void)old_size;
+    (void)new_size;
+    return realloc(ptr, new_size);
+}
+
+void
+platform_free(void *ptr, void *ctx) {
+    (void)ctx;
+    free(ptr);
+}
+
+#include <time.h>
+#include <unistd.h>
+
+void
+platform_sleep(size_t microseconds) {
+    usleep(microseconds);
+}
+
+sz
+platform_time(void) {
+    struct timespec ts;
+    timespec_get(&ts, TIME_UTC);
+    return ts.tv_sec * 1000000000 + ts.tv_nsec;
+}
+
+#endif  // BADLIB_H