commit 641b9a04eac3b067542843fca0f657b93256fa43
parent c905041a59e85fbddc993117a14ccb17e5fea95a
Author: Jake Koroman <jake@jakekoroman.com>
Date: Sat, 21 Feb 2026 14:25:33 -0500
code style change.
Diffstat:
| M | jrk.h | | | 474 | ++++++++++++++++++++++++++++++++++++++++---------------------------------------- |
1 file changed, 237 insertions(+), 237 deletions(-)
diff --git a/jrk.h b/jrk.h
@@ -402,153 +402,153 @@ 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 *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;
+ 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);
+ 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;
- }
+ 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);
- 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;
- }
+ 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;
+ }
- return true;
+ 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 (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);
- }
+ 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);
+ 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;
+ 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);
- }
+ 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);
+ if (!jrk_sb_append_buf(sb, buf, filesize)) jrk_return_defer(false);
defer:
- free(buf);
- return result;
+ 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;
- }
+ 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;
+ 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);
+ 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;
+ 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);
+ 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;
+ jrk_fd_close(fd);
+ return result;
}
void *
jrk_ecalloc(u64 nmemb, u64 size)
{
- void *p;
+ void *p;
- if (!(p = calloc(nmemb, size)))
- jrk_ediev("jrk_ecalloc(%ld, %ld): buy more ram lol", nmemb, size);
- return 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;
+ void *p;
- if (!(p = realloc(ptr, size)))
- jrk_ediev("jrk_erealloc(%p, %ld): buy more ram lol", ptr, size);
- return 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
@@ -558,288 +558,288 @@ static u32 jrk__tmpstrings_idx = 0;
char *
jrk_tmpstrings_push(char *str)
{
- char *result;
- result = jrk_tmpstrings_pushf(str);
- return result;
+ char *result;
+ result = jrk_tmpstrings_pushf(str);
+ return result;
}
char *
jrk_tmpstrings_pushf(char *fmt, ...)
{
- char *result = jrk__tmpstrings[jrk__tmpstrings_idx];
+ 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);
+ 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;
+ if (++jrk__tmpstrings_idx >= JRK_TMPSTRINGS_ARR_CAPACITY)
+ jrk__tmpstrings_idx = 0;
- return result;
+ 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;
+ 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;
- }
+ 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);
+ void *result = &arena->data[arena->offset];
+ arena->prev_offset = arena->offset;
+ arena->offset += n;
+ memset(result, 0, n);
- return result;
+ return result;
}
char *
jrk_arena_push_strf(jrk_Arena *arena, char *fmt, ...)
{
- char *result = NULL;
+ char *result = NULL;
- va_list args;
- va_start(args, fmt);
- i32 n = vsnprintf(NULL, 0, fmt, args);
- va_end(args);
+ 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;
+ 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);
+ va_start(args, fmt);
+ vsnprintf(result, n + 1, fmt, args);
+ va_end(args);
- return result;
+ 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;
+ 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);
+ 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;
- }
+ 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;
- }
+ 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;
+ *size = statbuf.st_size;
+ return true;
}
void
jrk_fd_close(i32 fd)
{
- close(fd);
+ close(fd);
}
i32
jrk_fd_open_read(char *path)
{
- i32 result = open(path, O_RDONLY);
+ i32 result = open(path, O_RDONLY);
- if (result < 0) {
- jrk_eerrorv("jrk_fd_open_read(%s)", path);
- return -1;
- }
+ if (result < 0) {
+ jrk_eerrorv("jrk_fd_open_read(%s)", path);
+ return -1;
+ }
- return result;
+ 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);
+ 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;
- }
+ if (result < 0) {
+ jrk_eerrorv("jrk_fd_open_write(%s)", path);
+ return -1;
+ }
- return result;
+ 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);
+ 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;
- }
+ if (result < 0) {
+ jrk_eerrorv("jrk_fd_open_write_append(%s)", path);
+ return -1;
+ }
- return result;
+ 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 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 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);
+ 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);
+ 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));
+ 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;
+ u64 i = 0;
+ while (i < sv->size && sv->data[i] != delim)
+ ++i;
- jrk_StringView result = jrk_sv_from_parts(sv->data, 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;
- }
+ if (i < sv->size) {
+ sv->data += i + 1;
+ sv->size -= i + 1;
+ } else {
+ sv->data += i;
+ sv->size -= i;
+ }
- return result;
+ 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;
+ for (u64 i = 0; i < JRK_MIN(a->size, b->size); ++i)
+ if (a->data[i] != b->data[i]) return false;
- return true;
+ return true;
}
bool
jrk_sv_equals_exact(jrk_StringView *a, jrk_StringView *b)
{
- if (a->size != b->size) return false;
+ if (a->size != b->size) return false;
- for (u64 i = 0; i < a->size; ++i)
- if (a->data[i] != b->data[i]) return false;
+ for (u64 i = 0; i < a->size; ++i)
+ if (a->data[i] != b->data[i]) return false;
- return true;
+ return true;
}
u64 jrk_fnv1a_64(u8 *data, u64 size)
{
- u64 result = JRK_FNV1A_64_OFFSET_BASIS;
- for (u64 i = 0; i < size; ++i) {
- result ^= data[i];
- result *= JRK_FNV1A_64_PRIME;
- }
- return result;
+ u64 result = JRK_FNV1A_64_OFFSET_BASIS;
+ for (u64 i = 0; i < size; ++i) {
+ result ^= data[i];
+ result *= JRK_FNV1A_64_PRIME;
+ }
+ return result;
}
i32
jrk_rand_num(i32 upbound)
{
- return rand() % upbound + 1;
+ return rand() % upbound + 1;
}
i32
jrk_rand_num_range(i32 min, i32 max)
{
- return rand() % (max - min + 1) + min;
+ return rand() % (max - min + 1) + min;
}
#endif // JRK_IMPLEMENTATION
