1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
|
#include <stdint.h>
#ifdef JRK_IMPLEMENTATION_WITH_SHORTNAMES
#define JRK_IMPLEMENTATION
#define JRK_SHORTNAMES
#endif // JRK_IMPLEMENTATION_WITH_SHORTNAMES
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;
typedef struct {
u8 *data;
u64 length;
u64 capacity;
} jrk_Arena;
typedef struct {
char *items;
u64 count;
u64 capacity;
} jrk_StringBuilder;
void *jrk_ecalloc(u64, u64);
void *jrk_erealloc(void*, u64);
jrk_Arena jrk_arena_create(u64);
void *jrk__arena_push(jrk_Arena*, u64);
void jrk_arena_expand(jrk_Arena*, u64);
i32 jrk_rand_num(i32);
i32 jrk_rand_num_range(i32, i32);
/* NOTE(jake): no shortname as 'assert' is just too generic */
#define jrk_assert(c, msg) do { if (!(c)) jrk_die("jrk_assert: "msg); } while(0)
#define jrk_emalloc(n) jrk_ecalloc(1, n)
#define jrk_arena_destroy(arena) ((arena.data) ? free(arena.data) : (void) 0)
#define jrk_arena_push_array(arena, type, n) (type *) jrk__arena_push(arena, sizeof(type) * n)
#define jrk_arena_push_struct(arena, type) (type *) jrk__arena_push(arena, sizeof(type))
#define jrk_da_reserve(da, expected_capacity) \
do { \
if ((expected_capacity) > (da)->capacity) { \
if ((da)->capacity == 0) { \
(da)->capacity = 4; \
} \
while ((expected_capacity) > (da)->capacity) { \
(da)->capacity *= 2; \
} \
(da)->items = jrk_erealloc((da)->items, (da)->capacity * sizeof(*(da)->items)); \
jrk_assert((da)->items, "buy more ram lol"); \
} \
} while (0)
#define jrk_da_append(da, item) \
do { \
jrk_da_reserve((da), (da)->count + 1); \
(da)->items[(da)->count++] = (item); \
} while (0);
#define jrk_da_append_many(da, new_items, new_items_count) \
do { \
jrk_da_reserve((da), (da)->count + (new_items_count)); \
memcpy((da)->items + (da)->count, (new_items), (new_items_count)*sizeof(*(da)->items)); \
(da)->count += (new_items_count); \
} while (0)
#define jrk_da_create(name, type) \
struct name { \
type *items; \
u64 count; \
u64 capacity; \
}; \
typedef struct name name
#define jrk_da_free(da) \
do { \
jrk_assert((da).items, "bad free: jrk_da_free da.items is NULL"); \
free((da).items); \
} while (0)
#define jrk_da_foreach(type,it,da) for (type *it = (da)->items; it < (da)->items + (da)->count; ++it)
#define jrk_sb_append_null(sb) jrk_da_append_many(sb, "\0", 1)
#define jrk_sb_free(sb) jrk_da_free(sb)
#define jrk_sb_append_cstr(sb, cstr) \
do { \
const char *s = (cstr); \
i64 n = strlen(cstr); \
jrk_da_append_many(sb, s, n); \
} while (0)
#define jrk_sb_append_buf(sb, buf, size) jrk_da_append_many(sb, buf, size)
#ifdef JRK_SHORTNAMES
#define Arena jrk_Arena
#define StringBuilder jrk_StringBuilder
#define sb_appendf jrk_sb_appendf
#define sb_append_null jrk_sb_append_null
#define sb_append_buf jrk_sb_append_buf
#define sb_append_cstr jrk_sb_append_cstr
#define sb_free jrk_sb_free
#define ecalloc jrk_ecalloc
#define erealloc jrk_erealloc
#define emalloc jrk_emalloc
#define da_reserve jrk_da_reserve
#define da_append jrk_da_append
#define da_append_many jrk_da_append_many
#define da_foreach jrk_da_foreach
#define da_create jrk_da_create
#define da_free jrk_da_free
#define arena_create jrk_arena_create
#define arena_destroy jrk_arena_destroy
#define arena_push_struct jrk_arena_push_struct
#define arena_push_array jrk_arena_push_array
#define arena_expand jrk_arena_expand
#define rand_num jrk_rand_num
#define rand_num_range jrk_rand_num_range
#endif // JRK_SHORTNAMES
#ifdef JRK_IMPLEMENTATION
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define jrk_die(x) do { fprintf(stderr, "%s:%d: error: "x"\n", __FILE__, __LINE__); exit(69); } while(0)
#define jrk_edie(x) do { fprintf(stderr, "%s:%d: error: "x": %s\n", __FILE__, __LINE__, strerror(errno)); exit(69); } while(0)
#ifdef JRK_SHORTNAMES
#define die jrk_die
#define edie jrk_edie
#endif // JRK_SHORTNAMES
void *
jrk_ecalloc(u64 nmemb, u64 size)
{
void *p;
if (!(p = calloc(nmemb, size)))
jrk_edie("jrk_ecalloc");
return p;
}
void *
jrk_erealloc(void *ptr, u64 size)
{
void *p;
if (!(p = realloc(ptr, size)))
edie("jrk_erealloc");
return p;
}
jrk_Arena
jrk_arena_create(u64 n)
{
jrk_Arena result;
result.length = 0;
result.capacity = n;
result.data = jrk_ecalloc(result.capacity, 1);
return result;
}
void *
jrk__arena_push(jrk_Arena *arena, u64 n)
{
while (arena->length + n >= arena->capacity)
jrk_arena_expand(arena, arena->capacity * 2);
void *result = &arena->data[arena->length];
arena->length += n;
return result;
}
void
jrk_arena_expand(jrk_Arena *arena, u64 new_capacity)
{
u8 *tmp = jrk_erealloc(arena->data, new_capacity);
arena->capacity = new_capacity;
arena->data = tmp;
}
i32
jrk_sb_appendf(jrk_StringBuilder *sb, const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
i32 n = vsnprintf(NULL, 0, fmt, args);
va_end(args);
jrk_da_reserve(sb, sb->count + n + 1);
va_start(args, fmt);
vsnprintf(sb->items + sb->count, n + 1, fmt, args);
va_end(args);
sb->count += n;
return n;
}
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
|
