95 lines
2.3 KiB
C
95 lines
2.3 KiB
C
#include "arena.h"
|
|
#include "str.h"
|
|
|
|
#include <sys/mman.h>
|
|
|
|
Arena *make_arena(ptrdiff_t size);
|
|
str read_file(Arena *arena, const char *filename);
|
|
|
|
typedef struct {
|
|
isize len;
|
|
str *tokens;
|
|
} Tokens;
|
|
|
|
Tokens str_tokenize(Arena *arena, str s, str delim);
|
|
Tokens read_lines(Arena *arena, const char *path);
|
|
|
|
char *str_to_cstr(str s, Arena *a);
|
|
i64 parse_i64(str s, Arena temp);
|
|
|
|
typedef struct Grid {
|
|
u8 *grid;
|
|
i32 width, height;
|
|
} Grid;
|
|
|
|
Grid parse_grid(str input, Arena *arena);
|
|
static inline u8
|
|
grid_at(Grid *grid, i32 x, i32 y) {
|
|
return grid->grid[y * grid->width + x];
|
|
}
|
|
|
|
static inline bool
|
|
grid_contains(Grid *grid, i32 x, i32 y) {
|
|
return x >= 0 && y >= 0 && x < grid->width && y < grid->height;
|
|
}
|
|
|
|
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
|
|
#include <stdio.h>
|
|
#define ASSERT(cond) if (!(cond)) { fprintf(stderr, "%s:%d (%s): Assertion failed: %s\n", __FILE__, __LINE__, __func__, #cond); __builtin_trap(); }
|
|
|
|
typedef uint64_t u64;
|
|
typedef uint32_t u32;
|
|
typedef uint16_t u16;
|
|
typedef uint8_t u8;
|
|
|
|
typedef int64_t i64;
|
|
typedef int32_t i32;
|
|
typedef int16_t i16;
|
|
typedef int8_t i8;
|
|
|
|
typedef size_t usize;
|
|
typedef ptrdiff_t isize;
|
|
|
|
typedef float f32;
|
|
typedef double f64;
|
|
|
|
#define MAX(a, b) ((a) > (b) ? (a) : (b))
|
|
#define MIN(a, b) ((a) < (b) ? (a) : (b))
|
|
#define CLAMP(x, lo, hi) ((x) < (lo) ? (lo) : (x) > (hi) ? (hi) : (x))
|
|
|
|
#define MIN3(a, b, c) MIN(MIN(a, b), c)
|
|
#define MAX3(a, b, c) MAX(MAX(a, b), c)
|
|
|
|
#define MIN4(a, b, c, d) MIN(MIN(a, b), MIN(c, d))
|
|
#define MAX4(a, b, c, d) MAX(MAX(a, b), MAX(c, d))
|
|
|
|
#define Kilobytes(x) ((u64) (x) << 10)
|
|
#define Megabytes(x) ((u64) (x) << 20)
|
|
#define Gigabytes(x) ((u64) (x) << 30)
|
|
|
|
#define DYNAMIC_ARRAY(type) \
|
|
struct { \
|
|
type *data; \
|
|
isize len, cap; \
|
|
}
|
|
|
|
#define push(slice, arena) \
|
|
((slice)->len >= ((slice)->cap) \
|
|
? grow(slice, sizeof(*(slice)->data), arena), \
|
|
(slice)->data + (slice)->len++ \
|
|
: (slice)->data + (slice)->len++)
|
|
|
|
static inline void
|
|
grow(void *slice, isize elem_size, Arena *arena) {
|
|
struct {
|
|
void *data;
|
|
isize len;
|
|
isize cap;
|
|
} repl;
|
|
memcpy(&repl, slice, sizeof(repl));
|
|
isize new_cap = MAX(16, 2 * repl.cap);
|
|
repl.data = arena_realloc_aligned(arena, repl.data, repl.cap * elem_size, new_cap * elem_size, elem_size);
|
|
repl.cap = new_cap;
|
|
memcpy(slice, &repl, sizeof(repl));
|
|
}
|