path: root/jrk.h

/*
 * NOTES:
 *   - i think i've finally landed on dynamic array api
 *     that i like.
 *
 * TODO:
 *   - remove strnlen/strncmp from hm impl. should probably be using
 *     jrk_StringView's
 *
 *   - add a log interface to give user control of logging.
 *     disable completely, log to file, log format, etc.
 *
 *   - look at at the jrk_sv_chop_delim_loop stuff. there must
 *     must be a better way of handling things.
 */

#include <stdbool.h>
#include <stdint.h>

typedef int8_t i8;
typedef int16_t i16;
typedef int32_t i32;
typedef int64_t i64;

typedef uint8_t u8;
typedef uint16_t u16;
typedef uint32_t u32;
typedef uint64_t u64;

typedef float f32;
typedef double f64;

#define JRK_UNUSED(x) (void)x
#define JRK_ARRLENGTH(arr) (sizeof(arr) / sizeof(arr[0]))
#define JRK_MIN(a, b) ((a) < (b) ? (a) : (b))
#define JRK_MAX(a, b) ((a) > (b) ? (a) : (b))

#define jrk_return_defer(value) \
    do { result = value; goto defer; } while(0)

#define JRK_KILOBYTES(x) ((u64)x*1024)
#define JRK_MEGABYTES(x) ((u64)JRK_KILOBYTES((u64)x*1024))
#define JRK_GIGABYTES(x) ((u64)JRK_MEGABYTES((u64)x*1024))
#define JRK_TERABYTES(x) ((u64)JRK_GIGABYTES((u64)x*1024))

#define JRK_TMPSTRINGS_ARR_CAPACITY 4
#define JRK_TMPSTRINGS_STR_CAPACITY JRK_KILOBYTES(1)

typedef struct {
    u8 *data;
    u64 offset;
    u64 prev_offset;
    u64 capacity;
} jrk_Arena;

typedef struct {
    char *data;
    u64 size;
} jrk_StringView;

void *jrk_ecalloc(u64, u64);
void *jrk_erealloc(void*, u64);

void *jrk_array_alloc_function_arena(u64, u64, void*);
void *jrk_array_realloc_function_arena(void*, u64, u64, void*);

jrk_Arena jrk_arena_create(u8*, u64);
void *jrk_arena_push(jrk_Arena*, u64);
char *jrk_arena_push_strf(jrk_Arena*, char*, ...);
void jrk_arena_reset(jrk_Arena*);
void *jrk_arena_resize(jrk_Arena*, void*, u64, u64);

i32 jrk_rand_num(i32);
i32 jrk_rand_num_range(i32, i32);

i32 jrk_fd_open_read(char*);
i32 jrk_fd_open_write(char*);
i32 jrk_fd_open_write_append(char*);
bool jrk_fd_size(i32, u64*);
void jrk_fd_close(i32);

jrk_StringView jrk_sv_from_parts(char*, u64);
jrk_StringView jrk_sv_trim_right(jrk_StringView);
jrk_StringView jrk_sv_trim_left(jrk_StringView);
jrk_StringView jrk_sv_trim(jrk_StringView);
jrk_StringView jrk_sv_from_cstr(char*);
jrk_StringView jrk_sv_chop_delim(jrk_StringView*, char delim);
bool jrk_sv_equals(jrk_StringView*, jrk_StringView*);       // takes the lowest size and matches up to that size
bool jrk_sv_equals_exact(jrk_StringView*, jrk_StringView*); // must be same size to be equals

char *jrk_tmpstrings_push(char*);
char *jrk_tmpstrings_pushf(char*, ...);

/* XXX: im not thrilled with this api, the memory can get messy real fast */
#define jrk_sv_chop_delim_loop(sv, it, delim) \
    for (jrk_StringView it = jrk_sv_chop_delim(sv, delim); it.size != 0; it = jrk_sv_chop_delim(sv, delim))

#ifndef jrk_die
  #define jrk_die(x)                                                   \
      do {                                                             \
          fprintf(stderr, "%s:%d: error: "x" \n", __FILE__, __LINE__); \
          exit(69);                                                    \
      } while (0)
#endif

#ifndef jrk_diev
  #define jrk_diev(x, ...)                                                         \
      do {                                                                         \
          fprintf(stderr, "%s:%d: error: "x"\n", __FILE__, __LINE__, __VA_ARGS__); \
          exit(69);                                                                \
      } while (0)
#endif

#define jrk_edie(x) jrk_diev(x": %s", strerror(errno))
#define jrk_ediev(x, ...) jrk_diev(x": %s", __VA_ARGS__, strerror(errno))

#ifndef jrk_log
  #define jrk_log(x)                    \
    do {                                \
        fprintf(stderr, "info: "x"\n"); \
    } while (0)
#endif

#ifndef jrk_logv
  #define jrk_logv(x, ...)                            \
    do {                                              \
        fprintf(stderr, "info: "x"\n",  __VA_ARGS__); \
    } while (0)
#endif

#ifndef jrk_elog
  #define jrk_elog(x) jrk_log(x": %s", strerror(errno))
#endif

#ifndef jrk_elogv
  #define jrk_elogv(x, ...) jrk_logv(x": %s", __VA_ARGS__, strerror(errno))
#endif

#ifndef jrk_error
  #define jrk_error(x)                   \
    do {                                 \
        fprintf(stderr, "error: "x"\n"); \
    } while (0)
#endif

#ifndef jrk_errorv
  #define jrk_errorv(x, ...)                           \
    do {                                               \
        fprintf(stderr, "error: "x"\n",  __VA_ARGS__); \
    } while (0)
#endif

#ifndef jrk_eerror
  #define jrk_eerror(x) jrk_errorv(x": %s", strerror(errno))
#endif

#ifndef jrk_eerrorv
  #define jrk_eerrorv(x, ...) jrk_errorv(x": %s", __VA_ARGS__, strerror(errno))
#endif

#define jrk_assert(c, msg) do { if (!(c)) jrk_die("jrk_assert: "msg); } while(0)
#define jrk_assertv(c, msg, ...) do { if (!(c)) jrk_diev("jrk_assert: "msg, __VA_ARGS__); } while(0)

#define jrk_shift(x, n) ((n)--, *(x)++)
#define jrk_shift_loop(x, n, it) for (char *it = jrk_shift(x, n); n >= 0; it = jrk_shift(x, n))

#define jrk_emalloc(n) jrk_ecalloc(1, n)

#define JRK_ARRAY_DEFAULT_INIT_CAPACITY 16

#ifndef JRK_ARRAY_DEFAULT_ALLOC_FN
    #define JRK_ARRAY_DEFAULT_ALLOC_FN jrk_ecalloc
#endif

#ifndef JRK_ARRAY_DEFAULT_REALLOC_FN
    #define JRK_ARRAY_DEFAULT_REALLOC_FN jrk_erealloc
#endif

#ifndef JRK_ARRAY_DEFAULT_FREE_FN
    #define JRK_ARRAY_DEFAULT_FREE_FN free
#endif

typedef void *(*jrk_array_alloc_function_t) (u64, u64, void*);
typedef void *(*jrk_array_realloc_function_t) (void*, u64, u64, void*);

#define __jrk_array_alloc(arr, count, size) (arr)->allocfn ? (arr)->allocfn((count), (size), (arr)->allocfn_user) : JRK_ARRAY_DEFAULT_ALLOC_FN((count), (size))
#define __jrk_array_realloc(arr, _size) (arr)->reallocfn ? (arr)->reallocfn((arr)->items, (arr)->size * sizeof((arr)->items[0]), (_size), (arr)->allocfn_user) : JRK_ARRAY_DEFAULT_REALLOC_FN((arr)->items, (_size))

#define jrk_array_prototype(type)                                                                                             \
    typedef struct {                                                                                                          \
        type *items;                                                                                                          \
        u64 size;                                                                                                             \
        u64 capacity;                                                                                                         \
        jrk_array_alloc_function_t allocfn;                                                                                   \
        jrk_array_realloc_function_t reallocfn;                                                                               \
        void *allocfn_user;                                                                                                   \
    } jrk_Array_##type;                                                                                                       \
                                                                                                                              \
    bool jrk_array_##type##_init_ex(jrk_Array_##type*, u64, jrk_array_alloc_function_t, jrk_array_realloc_function_t, void*); \
    bool jrk_array_##type##_init(jrk_Array_##type*, u64);                                                                     \
    void jrk_array_##type##_deinit(jrk_Array_##type*);                                                                        \
    bool jrk_array_##type##_setcap(jrk_Array_##type*, u64);                                                                   \
    bool jrk_array_##type##_push(jrk_Array_##type*, type);                                                                    \
    bool jrk_array_##type##_pushn(jrk_Array_##type*, type*, u64)

#define jrk_array_impl(type)                                                                                                                                             \
    bool jrk_array_##type##_init_ex(jrk_Array_##type *arr, u64 capacity, jrk_array_alloc_function_t allocfn, jrk_array_realloc_function_t reallocfn, void *allocfn_user) \
    {                                                                                                                                                                    \
        (arr)->allocfn = (allocfn) ? (allocfn) : NULL;                                                                                                                   \
        (arr)->reallocfn = (reallocfn) ? (reallocfn) : NULL;                                                                                                             \
        (arr)->allocfn_user = (allocfn_user) ? (allocfn_user) : NULL;                                                                                                    \
        (arr)->size = 0;                                                                                                                                                 \
        (arr)->capacity = (capacity);                                                                                                                                    \
        (arr)->items = __jrk_array_alloc((arr), (arr)->capacity, sizeof(type));                                                                                          \
        if (!(arr)->items) return false;                                                                                                                                 \
        memset((arr)->items, 0, (arr)->capacity * sizeof(type));                                                                                                         \
        return true;                                                                                                                                                     \
    }                                                                                                                                                                    \
                                                                                                                                                                         \
    bool jrk_array_##type##_init(jrk_Array_##type *arr, u64 capacity)                                                                                                    \
    {                                                                                                                                                                    \
        return jrk_array_##type##_init_ex(arr, capacity, NULL, NULL, NULL);                                                                                              \
    }                                                                                                                                                                    \
                                                                                                                                                                         \
    void jrk_array_##type##_deinit(jrk_Array_##type *arr)                                                                                                                \
    {                                                                                                                                                                    \
        if ((arr)->items && !(arr)->allocfn)                                                                                                                             \
            JRK_ARRAY_DEFAULT_FREE_FN((arr)->items);                                                                                                                     \
    }                                                                                                                                                                    \
                                                                                                                                                                         \
    bool jrk_array_##type##_setcap(jrk_Array_##type *arr, u64 new_capacity)                                                                                              \
    {                                                                                                                                                                    \
        if (new_capacity < (arr)->capacity) return false;                                                                                                                \
        (arr)->items = __jrk_array_realloc((arr), new_capacity * sizeof(type));                                                                                          \
        if (!(arr)->items) return false;                                                                                                                                 \
        memset((arr)->items + (arr)->size, 0, (new_capacity * sizeof(type)) - ((arr)->capacity * sizeof(type)));                                                         \
        (arr)->capacity = new_capacity;                                                                                                                                  \
        return true;                                                                                                                                                     \
    }                                                                                                                                                                    \
                                                                                                                                                                         \
    bool jrk_array_##type##_push(jrk_Array_##type *arr, type val)                                                                                                        \
    {                                                                                                                                                                    \
        if ((arr)->size + 1 > (arr)->capacity) {                                                                                                                         \
            while ((arr)->size + 1 > ((arr)->capacity))                                                                                                                  \
                (arr)->capacity = (arr->capacity) ? (arr)->capacity * 2 : JRK_ARRAY_DEFAULT_INIT_CAPACITY;                                                               \
            (arr)->items = __jrk_array_realloc((arr), (arr)->capacity * sizeof(type));                                                                                   \
            if (!(arr)->items) return false;                                                                                                                             \
        }                                                                                                                                                                \
        (arr)->items[(arr)->size++] = (val);                                                                                                                             \
        return true;                                                                                                                                                     \
    }                                                                                                                                                                    \
                                                                                                                                                                         \
    bool jrk_array_##type##_pushn(jrk_Array_##type *arr, type *vals, u64 count)                                                                                          \
    {                                                                                                                                                                    \
        if ((arr)->size + count > (arr)->capacity) {                                                                                                                     \
            while ((arr)->size + count > ((arr)->capacity))                                                                                                              \
                (arr)->capacity = (arr->capacity) ? (arr)->capacity * 2 : JRK_ARRAY_DEFAULT_INIT_CAPACITY;                                                               \
            (arr)->items = __jrk_array_realloc((arr), (arr)->capacity * sizeof(type));                                                                                   \
            if (!(arr)->items) return false;                                                                                                                             \
            memset((arr)->items + (arr)->size, 0, count * sizeof(type));                                                                                                 \
        }                                                                                                                                                                \
        memcpy(&(arr)->items[(arr)->size], (vals), sizeof(type) * (count));                                                                                              \
        (arr)->size += count;                                                                                                                                            \
        return true;                                                                                                                                                     \
    }

#define jrk_array_foreach(type, it, arr) for (type *it = (arr)->items; it < (arr)->items + (arr)->size; ++it)

jrk_array_prototype(char);
#define jrk_StringBuilder jrk_Array_char

#define jrk_sb_append_null(sb) jrk_array_char_push((sb), 0)
#define jrk_sb_append_cstr(sb, str) jrk_sb_appendf((sb), (str))
#define jrk_sb_append_buf(sb, buf, bufsz) jrk_array_char_pushn((sb), (buf), (bufsz))
#define jrk_sb_init_ex(sb, size, allocfn, reallocfn, userarg) jrk_array_char_init_ex((sb), (size), (allocfn), (reallocfn), (userarg))
#define jrk_sb_init_arena(sb, size, arena) jrk_sb_init_ex((sb), (size), jrk_array_alloc_function_arena, jrk_array_realloc_function_arena, (void *)(arena))
#define jrk_sb_deinit(sb) jrk_array_char_deinit((sb))
#define jrk_sb_to_sv(sb) jrk_sv_from_parts((sb).items, (sb).size)

bool jrk_sb_appendf(jrk_StringBuilder*, char*, ...);
bool jrk_sb_append_buf_at(jrk_StringBuilder*, char*, u64, u64);
bool jrk_sb_fd_write(jrk_StringBuilder*, i32);
bool jrk_sb_write_entire_file(jrk_StringBuilder *, char *);
bool jrk_sb_fd_read_all(jrk_StringBuilder*, i32);
bool jrk_sb_read_entire_file(jrk_StringBuilder*, char*);


// http://www.isthe.com/chongo/tech/comp/fnv/index.html#FNV-param
// for 64 bit hash
#define FNV1A_64_OFFSET_BASIS 0xCBF29CE484222325
#define FNV1A_64_PRIME        0x100000001B3
uint64_t jrk_fnv1a_64(uint8_t *data, uint64_t size);

#define JRK_HM_MAX_KEY_SIZE 16
#define jrk_hm_prototype(type)                                                                               \
    typedef struct {                                                                                         \
        char key[JRK_HM_MAX_KEY_SIZE];                                                                       \
        type val;                                                                                            \
    } jrk_HashMapItem_##type;                                                                                \
                                                                                                             \
    typedef struct {                                                                                         \
        jrk_HashMapItem_##type *items;                                                                       \
        uint64_t capacity;                                                                                   \
    } jrk_HashMap_##type;                                                                                    \
                                                                                                             \
    bool jrk_hm_##type##_init(jrk_HashMap_##type *map, jrk_HashMapItem_##type *items, uint64_t items_sz);    \
    bool jrk_hm_##type##_push(jrk_HashMap_##type *map, char *key, type val);                                 \
    bool jrk_hm_##type##_get(jrk_HashMap_##type *map, char *key, type *outval);

#define jrk_hm_impl(type)                                                                                                                          \
    bool                                                                                                                                           \
    jrk_hm_##type##_init(jrk_HashMap_##type *map, jrk_HashMapItem_##type *items, uint64_t items_cap)                                               \
    {                                                                                                                                              \
        if (!map) {                                                                                                                                \
            fprintf(stderr, "error: failed to init hashmap: map pointer is NULL\n");                                                               \
            return false;                                                                                                                          \
        }                                                                                                                                          \
        if (!items) {                                                                                                                              \
            fprintf(stderr, "error: failed to init hashmap: buf pointer is NULL\n");                                                               \
            return false;                                                                                                                          \
        }                                                                                                                                          \
        map->items = items;                                                                                                                        \
        map->capacity = items_cap;                                                                                                                 \
        return true;                                                                                                                               \
    }                                                                                                                                              \
                                                                                                                                                   \
    bool                                                                                                                                           \
    jrk_hm_##type##_push(jrk_HashMap_##type *map, char *key, type val)                                                                             \
    {                                                                                                                                              \
        if (!key) {                                                                                                                                \
            fprintf(stderr, "error: failed to push key into hashmap: key pointer is NULL\n");                                                      \
            return false;                                                                                                                          \
        }                                                                                                                                          \
        if (!map) {                                                                                                                                \
            fprintf(stderr, "error: failed to push key '%s' into hashmap: map pointer is NULL\n", key);                                            \
            return false;                                                                                                                          \
        }                                                                                                                                          \
        uint64_t idx = jrk_fnv1a_64((uint8_t *) key, strnlen(key, JRK_HM_MAX_KEY_SIZE)) % map->capacity;                                           \
        jrk_HashMapItem_##type *item = &map->items[idx];                                                                                           \
        if (item->key[0] != 0 && 0 != strncmp(item->key, key, JRK_HM_MAX_KEY_SIZE))                                                                \
            printf("%s collision with %s\n", key, item->key);                                                                                      \
        for (; item < &map->items[map->capacity] && item->key[0] != 0 && 0 != strncmp(item->key, key, JRK_HM_MAX_KEY_SIZE); ++item);               \
        if (item == &map->items[map->capacity]) {                                                                                                  \
            for (item = &map->items[0]; item < &map->items[idx] && item->key[0] != 0; ++item);                                                     \
            if (item == &map->items[idx]) {                                                                                                        \
                fprintf(stderr, "error: no space found for key '%s': hashmap is full\n", key);                                                     \
                return false;                                                                                                                      \
            }                                                                                                                                      \
        }                                                                                                                                          \
        memcpy(item->key, key, strlen(key));                                                                                                       \
        item->val = val;                                                                                                                           \
        return true;                                                                                                                               \
    }                                                                                                                                              \
                                                                                                                                                   \
    bool                                                                                                                                           \
    jrk_hm_##type##_get(jrk_HashMap_##type *map, char *key, type *outval)                                                                          \
    {                                                                                                                                              \
        if (!key) {                                                                                                                                \
            fprintf(stderr, "error: failed to get key from hashmap: key pointer is NULL\n");                                                       \
            return false;                                                                                                                          \
        }                                                                                                                                          \
        if (!map) {                                                                                                                                \
            fprintf(stderr, "error: failed to get key '%s' from hashmap: map pointer is NULL\n", key);                                             \
            return false;                                                                                                                          \
        }                                                                                                                                          \
        if (!outval) {                                                                                                                             \
            fprintf(stderr, "error: failed to get key '%s' from hashmap: outval pointer is NULL\n", key);                                          \
            return false;                                                                                                                          \
        }                                                                                                                                          \
        uint64_t idx = jrk_fnv1a_64((uint8_t *) key, strnlen(key, JRK_HM_MAX_KEY_SIZE)) % map->capacity;                                           \
        jrk_HashMapItem_##type *item = &map->items[idx];                                                                                           \
        if (0 == strncmp(item->key, key, JRK_HM_MAX_KEY_SIZE)) {                                                                                   \
            *outval = item->val;                                                                                                                   \
            return true;                                                                                                                           \
        }                                                                                                                                          \
        for (; item < &map->items[map->capacity] && 0 != strncmp(item->key, key, JRK_HM_MAX_KEY_SIZE); ++item)                                     \
            if (item->key[0] == 0)                                                                                                                 \
                return false;                                                                                                                      \
        if (item == &map->items[map->capacity]) {                                                                                                  \
            for (item = &map->items[0]; item < &map->items[idx] && 0 != strncmp(item->key, key, JRK_HM_MAX_KEY_SIZE); ++item);                     \
            if (item == &map->items[idx])                                                                                                          \
                return false;                                                                                                                      \
        }                                                                                                                                          \
        *outval = item->val;                                                                                                                       \
        return true;                                                                                                                               \
    }

#ifdef JRK_IMPLEMENTATION
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>

jrk_array_impl(char)

void *
jrk_array_alloc_function_arena(u64 size, u64 count, void *user)
{
    void *result = NULL;
    jrk_Arena *arena = (jrk_Arena *) user;
    result = jrk_arena_push(arena, size * count);
    return result;
}

void *
jrk_array_realloc_function_arena(void *ptr, u64 old_size, u64 new_size, void *user)
{
    void *result = NULL;
    jrk_Arena *arena = (jrk_Arena *) user;
    result = jrk_arena_resize(arena, ptr, old_size, new_size);
    return result;
}

bool
jrk_sb_appendf(jrk_StringBuilder *sb, char *fmt, ...)
{
    char buf[JRK_KILOBYTES(1)];
    va_list args;
    va_start(args, fmt);

    i32 buf_sz = vsnprintf(buf, sizeof(buf), fmt, args);
    if (buf_sz < 0) {
        jrk_eerrorv("jrk_sb_appendf(%p, %s): failed to create full string from '%s'", (void *) sb, fmt, fmt);
        return false;
    }
    va_end(args);

    i32 actual_sz = 0;
    if ((u32) buf_sz > JRK_ARRLENGTH(buf)) {
        actual_sz = JRK_ARRLENGTH(buf);
        jrk_errorv("jrk_sb_appendf(%p, %s): pushing '%s' into sb caused truncation of %ld bytes",
                   (void *) sb, fmt, fmt, buf_sz - JRK_ARRLENGTH(buf));
        return false;
    } else {
        actual_sz = buf_sz;
    }

    if (!jrk_array_char_pushn(sb, buf, actual_sz)) {
        jrk_errorv("jrk_sb_appendf(%p, %s): failed to push '%s' into sb", (void *) sb, fmt, fmt);
        return false;
    }

    return true;
}

bool
jrk_sb_append_buf_at(jrk_StringBuilder *sb, char *buf, u64 buf_sz, u64 idx)
{
    if (idx > sb->size) {
        jrk_errorv("jrk_sb_append_buf_at(%p, %s, %ld, %ld): idx is greater than sb.size",
                   (void *)sb, buf, buf_sz, idx);
        return false;
    }

    if (sb->size + (buf_sz) > sb->capacity) {
        while (sb->size + (buf_sz) > sb->capacity) {
            sb->capacity *= 2;
        }
        sb->items = __jrk_array_realloc(sb, sb->capacity);
        if (!sb->items) return false;
        memset(sb->items + sb->size, 0, sb->capacity - sb->size);
    }

    memmove(sb->items + idx + buf_sz, sb->items + idx, sb->size - idx);
    memcpy(sb->items + idx, buf, buf_sz);

    sb->size += buf_sz;
    return true;
}

bool
jrk_sb_fd_read_all(jrk_StringBuilder *sb, i32 fd)
{
    bool result = true;
    u64 filesize = 0;
    if (!jrk_fd_size(fd, &filesize)) jrk_return_defer(false);
    char *buf = jrk_emalloc(filesize);
    if (read(fd, buf, filesize) < 0) {
        jrk_eerrorv("jrk_sb_fd_read_all(%p, %d)", (void *)sb, fd);
        jrk_return_defer(false);
    }

    if (!jrk_sb_append_buf(sb, buf, filesize)) jrk_return_defer(false);
defer:
    free(buf);
    return result;
}

bool
jrk_sb_fd_write(jrk_StringBuilder *sb, i32 fd)
{
    i64 result;
    result = write(fd, (void *) sb->items, sb->size);
    if (result < 0) {
        jrk_eerrorv("jrk_sb_fd_write_all(%p, %d)", (void *)sb, fd);
        return -1;
    }

    return result;
}

bool
jrk_sb_read_entire_file(jrk_StringBuilder *sb, char *filename)
{
    bool result = true;
    i32 fd = jrk_fd_open_read(filename);
    if (fd < 0) return false;
    if (!jrk_sb_fd_read_all(sb, fd)) jrk_return_defer(false);

defer:
    jrk_fd_close(fd);
    return result;
}

bool
jrk_sb_write_entire_file(jrk_StringBuilder *sb, char *filename)
{
    bool result = true;
    i32 fd = jrk_fd_open_write(filename);
    if (fd < 0) return false;
    if(!jrk_sb_fd_write(sb, fd)) jrk_return_defer(false);

defer:
    jrk_fd_close(fd);
    return result;
}

void *
jrk_ecalloc(u64 nmemb, u64 size)
{
    void *p;

    if (!(p = calloc(nmemb, size)))
        jrk_ediev("jrk_ecalloc(%ld, %ld): buy more ram lol", nmemb, size);
    return p;
}

void *
jrk_erealloc(void *ptr, u64 size)
{
    void *p;

    if (!(p = realloc(ptr, size)))
        jrk_ediev("jrk_erealloc(%p, %ld): buy more ram lol", ptr, size);
    return p;
}

// NOTE: only allocate space for translation units with JRK_IMPLEMENTATION
static char jrk__tmpstrings[JRK_TMPSTRINGS_ARR_CAPACITY][JRK_TMPSTRINGS_STR_CAPACITY];
static u32 jrk__tmpstrings_idx = 0;

char *
jrk_tmpstrings_push(char *str)
{
    char *result;
    result = jrk_tmpstrings_pushf(str);
    return result;
}

char *
jrk_tmpstrings_pushf(char *fmt, ...)
{
    char *result = jrk__tmpstrings[jrk__tmpstrings_idx];

    va_list args;
    va_start(args, fmt);
    vsnprintf(result, JRK_TMPSTRINGS_STR_CAPACITY, fmt, args);
    va_end(args);

    if (++jrk__tmpstrings_idx >= JRK_TMPSTRINGS_ARR_CAPACITY)
        jrk__tmpstrings_idx = 0;

    return result;
}

jrk_Arena
jrk_arena_create(u8 *buffer, u64 buffer_count)
{
    jrk_Arena result = {0};
    result.data = buffer;
    result.capacity = buffer_count;
    result.offset = 0;
    result.prev_offset = 0;
    return result;
}

void *
jrk_arena_push(jrk_Arena *arena, u64 n)
{
    if (arena->offset + n > arena->capacity) {
        jrk_errorv("jrk_arena_push(%p, %ld): arena push requires %ld bytes but has a capacity of %ld bytes",
                 (void *) arena, n, arena->offset + n, arena->capacity);
        return NULL;
    }

    void *result = &arena->data[arena->offset];
    arena->prev_offset = arena->offset;
    arena->offset += n;
    memset(result, 0, n);

    return result;
}

char *
jrk_arena_push_strf(jrk_Arena *arena, char *fmt, ...)
{
    char *result = NULL;

    va_list args;
    va_start(args, fmt);
    i32 n = vsnprintf(NULL, 0, fmt, args);
    va_end(args);

    result = jrk_arena_push(arena, (u64) n + 1);
    if (!result) return NULL;

    va_start(args, fmt);
    vsnprintf(result, n + 1, fmt, args);
    va_end(args);

    return result;
}

void *
jrk_arena_resize(jrk_Arena *arena, void *old, u64 old_size, u64 new_size)
{
    u8 *result = NULL;

    if (new_size < old_size) {
        jrk_errorv("jrk_arena_resize(%p, %p, %ld, %ld): new_size is smaller than the old_size",
                 (void *) arena, old, old_size, new_size);
        return result;
    }

    if (arena->offset + (new_size - old_size) > arena->capacity) {
        jrk_errorv("jrk_arena_resize(%p, %p, %ld, %ld): arena resize requires %ld bytes but has a capacity of %ld bytes",
                 (void *) arena, old, old_size, new_size, arena->offset + (new_size - old_size), arena->capacity);
        return result;
    }

    if (old == &arena->data[arena->prev_offset]) {
        result = old;
        arena->prev_offset = arena->offset;
        arena->offset += new_size;
        memset(&arena->data[arena->prev_offset], 0, new_size - old_size);
    } else {
        result = &arena->data[arena->offset];
        arena->prev_offset = arena->offset;
        arena->offset += new_size;
        if (arena->offset > arena->capacity) {
            jrk_errorv("jrk_arena_resize(%p, %p, %ld, %ld): arena resize requires %ld bytes but has a capacity of %ld bytes",
                       (void *) arena, old, old_size, new_size, arena->offset, arena->capacity);
            return NULL;
        }
        memmove(result, old, old_size);
        memset(result + old_size, 0, new_size - old_size);
    }

    return (void *) result;
}

void
jrk_arena_reset(jrk_Arena *arena)
{
    arena->offset = 0;
    arena->prev_offset = 0;
    memset(arena->data, 0, arena->capacity);
}

bool
jrk_fd_size(i32 fd, u64 *size)
{
    if (!size) {
        jrk_errorv("jrk_fd_size(%d, %p): size ptr is NULL", fd, (void *) size);
        return false;
    }

    struct stat statbuf = {0};
    if (fstat(fd, &statbuf) < 0) {
        jrk_eerrorv("jrk_fd_size(%d, %p)", fd, (void *) size);
        return false;
    }

    *size = statbuf.st_size;
    return true;
}

void
jrk_fd_close(i32 fd)
{
    close(fd);
}

i32
jrk_fd_open_read(char *path)
{
    i32 result = open(path, O_RDONLY);

    if (result < 0) {
        jrk_eerrorv("jrk_fd_open_read(%s)", path);
        return -1;
    }

    return result;
}

i32
jrk_fd_open_write(char *path)
{
    i32 result = open(path,
                     O_WRONLY | O_CREAT | O_TRUNC,
                     S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);

    if (result < 0) {
        jrk_eerrorv("jrk_fd_open_write(%s)", path);
        return -1;
    }

    return result;
}

i32
jrk_fd_open_write_append(char *path)
{
    i32 result = open(path,
                     O_WRONLY | O_CREAT | O_APPEND,
                     S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);

    if (result < 0) {
        jrk_eerrorv("jrk_fd_open_write_append(%s)", path);
        return -1;
    }

    return result;
}

jrk_StringView
jrk_sv_from_parts(char *data, u64 size)
{
    jrk_StringView result = {0};
    result.data = data;
    result.size = size;
    return result;
}

jrk_StringView
jrk_sv_from_cstr(char *data)
{
    jrk_StringView result = {0};
    result.data = data;
    result.size = strlen(data);
    return result;
}

jrk_StringView
jrk_sv_trim_right(jrk_StringView sv)
{
    u64 i = 0;
    for (; i < sv.size && isspace(sv.data[sv.size - 1 - i]); ++i);
    return jrk_sv_from_parts(sv.data, sv.size - i);
}

jrk_StringView
jrk_sv_trim_left(jrk_StringView sv)
{
    u64 i = 0;
    for (; i < sv.size && isspace(sv.data[i]); ++i);
    return jrk_sv_from_parts(sv.data + i, sv.size - i);
}

jrk_StringView
jrk_sv_trim(jrk_StringView sv)
{
    return jrk_sv_trim_right(jrk_sv_trim_left(sv));
}

jrk_StringView
jrk_sv_chop_delim(jrk_StringView *sv, char delim)
{
    u64 i = 0;
    while (i < sv->size && sv->data[i] != delim)
        ++i;

    jrk_StringView result = jrk_sv_from_parts(sv->data, i);

    if (i < sv->size) {
        sv->data += i + 1;
        sv->size -= i + 1;
    } else {
        sv->data += i;
        sv->size -= i;
    }

    return result;
}

bool
jrk_sv_equals(jrk_StringView *a, jrk_StringView *b)
{
    for (u64 i = 0; i < JRK_MIN(a->size, b->size); ++i)
        if (a->data[i] != b->data[i]) return false;

    return true;
}

bool
jrk_sv_equals_exact(jrk_StringView *a, jrk_StringView *b)
{
    if (a->size != b->size) return false;

    for (u64 i = 0; i < a->size; ++i)
        if (a->data[i] != b->data[i]) return false;

    return true;
}

uint64_t jrk_fnv1a_64(uint8_t *data, uint64_t size)
{
    uint64_t result = FNV1A_64_OFFSET_BASIS;
    for (u64 i = 0; i < size; ++i) {
        result ^= data[i];
        result *= FNV1A_64_PRIME;
    }
    return result;
}

i32
jrk_rand_num(i32 upbound)
{
    return rand() % upbound + 1;
}

i32
jrk_rand_num_range(i32 min, i32 max)
{
    return rand() % (max - min + 1) + min;
}

#endif // JRK_IMPLEMENTATION