krzosa/wasm_transcript_browser
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

porting text editor

Browse Source
This commit is contained in:
Krzosa Karol
2025-04-07 08:37:06 +02:00
parent f9d1f14c7c
commit c82eccc02a
13 changed files with 690 additions and 117 deletions
Download Patch File Download Diff File Expand all files Collapse all files

142
src/core/core_array.c
View File

@@ -1,41 +1,54 @@
typedef struct array_header_t array_header_t;
struct array_header_t {
ma_arena_t *arena;
typedef struct arr_header_t arr_header_t;
struct arr_header_t {
i64 len;
i64 cap;
ma_arena_t *arena;
};
#define array_header(arr) ((array_header_t *)(arr) - 1)
#define array_len(arr) (array_header(arr)->len)
#define array_cap(arr) (array_header(arr)->cap)
#define array_add(arr, x) (array_grow(&(arr), sizeof(*(arr)), 1), (arr)[array_len(arr)++] = (x))
#define array_addn(arr, count) (array_grow(&(arr), sizeof(*(arr)), (count)), array_len(arr) += (count), &(arr)[array_len(arr) - (count)])
#define array_set_len(arr, x) (array_len(arr) = (x))
#define array_set_cap(arr, x) (array__set_cap(&(arr), sizeof(*(arr)), (x)))
#define array_pop(arr) ((arr)[--array_len(arr)])
#define array_swapdel(arr, i) (assert_expr((i) < array_len(arr)), (arr)[(i)] = (arr)[--array_len(arr)])
#define array_create(arena, type, count) (type *)(array__create((arena), sizeof(type), (count)) + 1)
#define arr_header(arr) ((arr_header_t *)(arr) - 1)
#define arr_len(arr) (arr_header(arr)->len)
#define arr_cap(arr) (arr_header(arr)->cap)
#define arr_add(arr, x) (arr_grow(&(arr), sizeof(*(arr)), 1), (arr)[arr_len(arr)++] = (x))
#define arr_addn(arr, count) (arr_grow(&(arr), sizeof(*(arr)), (count)), arr_len(arr) += (count), &(arr)[arr_len(arr) - (count)])
#define arr_set_len(arr, x) (arr_len(arr) = (x))
#define arr_set_cap(arr, x) (arr__set_cap(&(arr), sizeof(*(arr)), (x)))
#define arr_pop(arr) ((arr)[--arr_len(arr)])
#define arr_swapdel(arr, i) (assert_expr((i) < arr_len(arr)), (arr)[(i)] = (arr)[--arr_len(arr)])
#define arr_del(arr, i) arr__del((arr), sizeof(*(arr)), (i), 1)
#define arr_deln(arr, i, count) arr__del((arr), sizeof(*(arr)), (i), (count))
#define arr_insert(arr, i, x) (arr__insert(&arr, sizeof(*(arr)), (i)), (arr)[(i)] = (x))
#define arr_create(arena, type, count) (type *)(arr__create((arena), sizeof(type), (count)) + 1)
#define arr_copy(arena, arr) arr__copy((arena), (arr), sizeof(*(arr)))
fn array_header_t *array__create(ma_arena_t *arena, i64 item_size, i64 item_count) {
array_header_t *hdr = (array_header_t *)ma_push_size(arena, item_size * item_count + sizeof(array_header_t));
fn arr_header_t *arr__create(ma_arena_t *arena, i64 item_size, i64 item_count) {
arr_header_t *hdr = (arr_header_t *)ma_push_size(arena, item_size * item_count + sizeof(arr_header_t));
hdr->arena = arena;
hdr->cap = item_count;
return hdr;
}
fn void array__set_cap(void **arr, i64 item_size, i64 item_count) {
array_header_t *hdr = array_header(*arr);
array_header_t *new_hdr = array__create(hdr->arena, item_size, item_count);
fn void *arr__copy(ma_arena_t *arena, void *arr, i64 item_size) {
arr_header_t *hdr = arr_header(arr);
arr_header_t *new_hdr = arr__create(arena, item_size, hdr->cap);
new_hdr->len = hdr->len;
memory_copy(new_hdr + 1, hdr + 1, new_hdr->len * item_size);
return new_hdr + 1;
}
fn void arr__set_cap(void **arr, i64 item_size, i64 item_count) {
assert(item_count >= 0);
arr_header_t *hdr = arr_header(*arr);
arr_header_t *new_hdr = arr__create(hdr->arena, item_size, item_count);
new_hdr->len = CLAMP(hdr->len, 0, item_count);
memory_copy(new_hdr + 1, hdr + 1, new_hdr->len * item_size);
*arr = new_hdr + 1;
}
fn void array_grow(void **arr, i64 item_size, i64 increment) {
fn void arr_grow(void **arr, i64 item_size, i64 increment) {
assert(increment >= 1);
array_header_t *hdr = array_header(*arr);
arr_header_t *hdr = arr_header(*arr);
if (hdr->len + increment > hdr->cap) {
array_header_t *new_hdr = array__create(hdr->arena, item_size, (hdr->cap + increment - 1) * 2);
arr_header_t *new_hdr = arr__create(hdr->arena, item_size, (hdr->cap + increment - 1) * 2);
memory_copy(new_hdr + 1, hdr + 1, hdr->len * item_size);
new_hdr->len = hdr->len;
*arr = new_hdr + 1;
@@ -43,56 +56,103 @@ fn void array_grow(void **arr, i64 item_size, i64 increment) {
}
}
fn_test void test_array(void) {
fn void arr__insert(void **arr, i64 item_size, i64 idx) {
arr_grow(arr, item_size, 1);
arr_header_t *hdr = arr_header(*arr);
assert(idx <= hdr->len);
assert(idx >= 0);
u8 *arr8 = (u8 *)*arr;
i64 right_len = hdr->len - idx;
memory_move(arr8 + (idx + 1)*item_size, arr8 + idx*item_size, item_size * right_len);
hdr->len += 1;
}
fn void arr__del(void *arr, i64 item_size, i64 idx, i64 count) {
arr_header_t *hdr = arr_header(arr);
assert(idx >= 0 && idx < hdr->len);
assert((idx + count) > 0 && (idx + count) <= hdr->len);
i64 right_len = hdr->len - idx - count;
u8 *arr8 = (u8 *)arr;
memmove(arr8+idx*item_size, arr8+(idx+count)*item_size, right_len*item_size);
hdr->len -= count;
}
fn_test void test_arr(void) {
ma_temp_t scratch = ma_begin_scratch();
int *arr = array_create(scratch.arena, int, 2);
int *arr = arr_create(scratch.arena, int, 2);
for (int i = 0; i < 512; i += 1) {
array_add(arr, i);
arr_add(arr, i);
}
for (int i = 0; i < 512; i += 1) {
assert(arr[i] == i);
}
assert(array_len(arr) == 512);
assert(array_cap(arr) == 512);
assert(arr_len(arr) == 512);
assert(arr_cap(arr) == 512);
for (int i = 511; i >= 0; i -= 1) {
int a = array_pop(arr);
int a = arr_pop(arr);
assert(a == i);
}
assert(array_len(arr) == 0);
assert(arr_len(arr) == 0);
{
int *a = array_addn(arr, 4);
int *a = arr_addn(arr, 4);
assert(arr == a);
assert(array_header(arr)->len == 4);
assert(arr_header(arr)->len == 4);
int *b = array_addn(arr, 12);
int *b = arr_addn(arr, 12);
assert(arr + 4 == b);
assert(array_header(arr)->len == 16);
assert(arr_header(arr)->len == 16);
array_set_len(arr, 0);
arr_set_len(arr, 0);
}
{
for (int i = 0; i < 512; i += 1) {
array_add(arr, i);
arr_add(arr, i);
}
array_swapdel(arr, 3);
arr_swapdel(arr, 3);
assert(arr[3] == 511);
assert(array_len(arr) == 511);
assert(arr_len(arr) == 511);
array_set_len(arr, 0);
arr_set_len(arr, 0);
}
{
for (int i = 0; i < 512; i += 1) {
array_add(arr, i);
arr_add(arr, i);
}
array_set_cap(arr, 256);
assert(array_len(arr) == 256);
assert(array_cap(arr) == 256);
arr_set_cap(arr, 256);
assert(arr_len(arr) == 256);
assert(arr_cap(arr) == 256);
arr_insert(arr, 256, 111);
assert(arr_len(arr) == 257);
assert(arr_cap(arr) > 256);
assert(arr[256] == 111);
arr_insert(arr, 4, 222);
assert(arr_len(arr) == 258);
assert(arr_cap(arr) > 256);
assert(arr[4] == 222);
assert(arr[3] == 3);
assert(arr[5] == 4);
arr_set_len(arr, 0);
}
{
for (int i = 0; i < 512; i += 1) {
arr_add(arr, i);
}
arr_deln(arr, 1, 10);
assert(arr[0] == 0);
assert(arr[1] == 11);
assert(arr_len(arr) == (512 - 10));
arr_del(arr, 0);
assert(arr[0] == 11);
}
ma_end_scratch(scratch);
}

48
src/core/core_math.gen.c
View File

@@ -370,8 +370,8 @@ fn r2f32_t r2f32_get_bottom(const r2f32_t *r, f32 value) { /* Y is down */
fn_inline r2f32_t r2f32_expand(r2f32_t rect, v2f32_t value) { return (r2f32_t){ v2f32_sub(rect.min, value), v2f32_add(rect.max, value) }; }
fn_inline r2f32_t r2f32_shrink(r2f32_t rect, v2f32_t value) { return (r2f32_t){ v2f32_add(rect.min, value), v2f32_sub(rect.max, value) }; }
fn_inline r2f32_t r2f32_shrinks(r2f32_t rect, f32 value) { return (r2f32_t){ v2f32_adds(rect.min, value), v2f32_subs(rect.max, value) }; }
fn_inline v2f32_t r2f32_get_size(r2f32_t r) { return (v2f32_t){r.max.x - r.min.x, r.max.y - r.min.y}; }
fn_inline v2f32_t r2f32_get_mid(r2f32_t r) { return v2f32_add(r.min, v2f32_divs(r2f32_get_size(r), 2)); }
fn_inline v2f32_t r2f32_size(r2f32_t r) { return (v2f32_t){r.max.x - r.min.x, r.max.y - r.min.y}; }
fn_inline v2f32_t r2f32_get_mid(r2f32_t r) { return v2f32_add(r.min, v2f32_divs(r2f32_size(r), 2)); }
fn_inline b32 r2f32_contains(r2f32_t rec, v2f32_t point) { return (point.x >= rec.min.x) && (point.x < rec.max.x) && (point.y >= rec.min.y) && (point.y < rec.max.y); }
fn_inline r2f32_t r2f32_intersect(r2f32_t a, r2f32_t b) { return (r2f32_t){ .min.x = MAX(a.min.x, b.min.x), .min.y = MAX(a.min.y, b.min.y), .max.x = MIN(a.max.x, b.max.x), .max.y = MIN(a.max.y, b.max.y) }; }
fn_inline r2f32_t r2f32_union(r2f32_t a, r2f32_t b) { return (r2f32_t){ .min.x = MIN(a.min.x, b.min.x), .min.y = MIN(a.min.y, b.min.y), .max.x = MAX(a.max.x, b.max.x), .max.y = MAX(a.max.y, b.max.y) }; }
@@ -381,8 +381,16 @@ fn_inline r1f32_t r1f32(f32 min, f32 max) { return (r1f32_t){min,max}; }
fn_inline r1f32_t r1f32_auto(f32 a, f32 b) { return (r1f32_t){MIN(a,b),MAX(a,b)}; }
fn_inline r1f32_t r1f32s(f32 a) { return (r1f32_t){a,a}; }
fn_inline r1f32_t r1f32_clamp(r1f32_t a, f32 min, f32 max) { return (r1f32_t){ .min = CLAMP(a.min, min, max), .max = CLAMP(a.max, min, max) }; }
fn_inline b32 r1f32_contains(r1f32_t rec, f32 point) { return (point >= rec.min) && (point < rec.max) && (point >= rec.min) && (point < rec.max); }
fn_inline b32 r1f32_are_equal(r1f32_t a, r1f32_t b) { return a.min == b.min && a.max == b.max; }
gb_read_only r1f32_t r1f32_null;
fn b32 r1f32_overlap(r1f32_t a, r1f32_t b) {
b32 r1 = (a.max >= b.min && a.max <= b.max) || (a.min >= b.min && a.min <= b.max);
b32 r2 = (b.max >= a.min && b.max <= a.max) || (b.min >= a.min && b.min <= a.max);
return r1 || r2;
}
fn v2f32_t v2f32_clamps(v2f32_t v, f32 min, f32 max) {
v2f32_t result = { CLAMP(v.x, min, max), CLAMP(v.y, min, max) };
return result;
@@ -515,8 +523,8 @@ fn r2f64_t r2f64_get_bottom(const r2f64_t *r, f64 value) { /* Y is down */
fn_inline r2f64_t r2f64_expand(r2f64_t rect, v2f64_t value) { return (r2f64_t){ v2f64_sub(rect.min, value), v2f64_add(rect.max, value) }; }
fn_inline r2f64_t r2f64_shrink(r2f64_t rect, v2f64_t value) { return (r2f64_t){ v2f64_add(rect.min, value), v2f64_sub(rect.max, value) }; }
fn_inline r2f64_t r2f64_shrinks(r2f64_t rect, f64 value) { return (r2f64_t){ v2f64_adds(rect.min, value), v2f64_subs(rect.max, value) }; }
fn_inline v2f64_t r2f64_get_size(r2f64_t r) { return (v2f64_t){r.max.x - r.min.x, r.max.y - r.min.y}; }
fn_inline v2f64_t r2f64_get_mid(r2f64_t r) { return v2f64_add(r.min, v2f64_divs(r2f64_get_size(r), 2)); }
fn_inline v2f64_t r2f64_size(r2f64_t r) { return (v2f64_t){r.max.x - r.min.x, r.max.y - r.min.y}; }
fn_inline v2f64_t r2f64_get_mid(r2f64_t r) { return v2f64_add(r.min, v2f64_divs(r2f64_size(r), 2)); }
fn_inline b32 r2f64_contains(r2f64_t rec, v2f64_t point) { return (point.x >= rec.min.x) && (point.x < rec.max.x) && (point.y >= rec.min.y) && (point.y < rec.max.y); }
fn_inline r2f64_t r2f64_intersect(r2f64_t a, r2f64_t b) { return (r2f64_t){ .min.x = MAX(a.min.x, b.min.x), .min.y = MAX(a.min.y, b.min.y), .max.x = MIN(a.max.x, b.max.x), .max.y = MIN(a.max.y, b.max.y) }; }
fn_inline r2f64_t r2f64_union(r2f64_t a, r2f64_t b) { return (r2f64_t){ .min.x = MIN(a.min.x, b.min.x), .min.y = MIN(a.min.y, b.min.y), .max.x = MAX(a.max.x, b.max.x), .max.y = MAX(a.max.y, b.max.y) }; }
@@ -526,8 +534,16 @@ fn_inline r1f64_t r1f64(f64 min, f64 max) { return (r1f64_t){min,max}; }
fn_inline r1f64_t r1f64_auto(f64 a, f64 b) { return (r1f64_t){MIN(a,b),MAX(a,b)}; }
fn_inline r1f64_t r1f64s(f64 a) { return (r1f64_t){a,a}; }
fn_inline r1f64_t r1f64_clamp(r1f64_t a, f64 min, f64 max) { return (r1f64_t){ .min = CLAMP(a.min, min, max), .max = CLAMP(a.max, min, max) }; }
fn_inline b32 r1f64_contains(r1f64_t rec, f64 point) { return (point >= rec.min) && (point < rec.max) && (point >= rec.min) && (point < rec.max); }
fn_inline b32 r1f64_are_equal(r1f64_t a, r1f64_t b) { return a.min == b.min && a.max == b.max; }
gb_read_only r1f64_t r1f64_null;
fn b32 r1f64_overlap(r1f64_t a, r1f64_t b) {
b32 r1 = (a.max >= b.min && a.max <= b.max) || (a.min >= b.min && a.min <= b.max);
b32 r2 = (b.max >= a.min && b.max <= a.max) || (b.min >= a.min && b.min <= a.max);
return r1 || r2;
}
fn v2f64_t v2f64_clamps(v2f64_t v, f64 min, f64 max) {
v2f64_t result = { CLAMP(v.x, min, max), CLAMP(v.y, min, max) };
return result;
@@ -660,8 +676,8 @@ fn r2i32_t r2i32_get_bottom(const r2i32_t *r, i32 value) { /* Y is down */
fn_inline r2i32_t r2i32_expand(r2i32_t rect, v2i32_t value) { return (r2i32_t){ v2i32_sub(rect.min, value), v2i32_add(rect.max, value) }; }
fn_inline r2i32_t r2i32_shrink(r2i32_t rect, v2i32_t value) { return (r2i32_t){ v2i32_add(rect.min, value), v2i32_sub(rect.max, value) }; }
fn_inline r2i32_t r2i32_shrinks(r2i32_t rect, i32 value) { return (r2i32_t){ v2i32_adds(rect.min, value), v2i32_subs(rect.max, value) }; }
fn_inline v2i32_t r2i32_get_size(r2i32_t r) { return (v2i32_t){r.max.x - r.min.x, r.max.y - r.min.y}; }
fn_inline v2i32_t r2i32_get_mid(r2i32_t r) { return v2i32_add(r.min, v2i32_divs(r2i32_get_size(r), 2)); }
fn_inline v2i32_t r2i32_size(r2i32_t r) { return (v2i32_t){r.max.x - r.min.x, r.max.y - r.min.y}; }
fn_inline v2i32_t r2i32_get_mid(r2i32_t r) { return v2i32_add(r.min, v2i32_divs(r2i32_size(r), 2)); }
fn_inline b32 r2i32_contains(r2i32_t rec, v2i32_t point) { return (point.x >= rec.min.x) && (point.x < rec.max.x) && (point.y >= rec.min.y) && (point.y < rec.max.y); }
fn_inline r2i32_t r2i32_intersect(r2i32_t a, r2i32_t b) { return (r2i32_t){ .min.x = MAX(a.min.x, b.min.x), .min.y = MAX(a.min.y, b.min.y), .max.x = MIN(a.max.x, b.max.x), .max.y = MIN(a.max.y, b.max.y) }; }
fn_inline r2i32_t r2i32_union(r2i32_t a, r2i32_t b) { return (r2i32_t){ .min.x = MIN(a.min.x, b.min.x), .min.y = MIN(a.min.y, b.min.y), .max.x = MAX(a.max.x, b.max.x), .max.y = MAX(a.max.y, b.max.y) }; }
@@ -671,8 +687,16 @@ fn_inline r1i32_t r1i32(i32 min, i32 max) { return (r1i32_t){min,max}; }
fn_inline r1i32_t r1i32_auto(i32 a, i32 b) { return (r1i32_t){MIN(a,b),MAX(a,b)}; }
fn_inline r1i32_t r1i32s(i32 a) { return (r1i32_t){a,a}; }
fn_inline r1i32_t r1i32_clamp(r1i32_t a, i32 min, i32 max) { return (r1i32_t){ .min = CLAMP(a.min, min, max), .max = CLAMP(a.max, min, max) }; }
fn_inline b32 r1i32_contains(r1i32_t rec, i32 point) { return (point >= rec.min) && (point < rec.max) && (point >= rec.min) && (point < rec.max); }
fn_inline b32 r1i32_are_equal(r1i32_t a, r1i32_t b) { return a.min == b.min && a.max == b.max; }
gb_read_only r1i32_t r1i32_null;
fn b32 r1i32_overlap(r1i32_t a, r1i32_t b) {
b32 r1 = (a.max >= b.min && a.max <= b.max) || (a.min >= b.min && a.min <= b.max);
b32 r2 = (b.max >= a.min && b.max <= a.max) || (b.min >= a.min && b.min <= a.max);
return r1 || r2;
}
fn v2i32_t v2i32_clamps(v2i32_t v, i32 min, i32 max) {
v2i32_t result = { CLAMP(v.x, min, max), CLAMP(v.y, min, max) };
return result;
@@ -805,8 +829,8 @@ fn r2i64_t r2i64_get_bottom(const r2i64_t *r, i64 value) { /* Y is down */
fn_inline r2i64_t r2i64_expand(r2i64_t rect, v2i64_t value) { return (r2i64_t){ v2i64_sub(rect.min, value), v2i64_add(rect.max, value) }; }
fn_inline r2i64_t r2i64_shrink(r2i64_t rect, v2i64_t value) { return (r2i64_t){ v2i64_add(rect.min, value), v2i64_sub(rect.max, value) }; }
fn_inline r2i64_t r2i64_shrinks(r2i64_t rect, i64 value) { return (r2i64_t){ v2i64_adds(rect.min, value), v2i64_subs(rect.max, value) }; }
fn_inline v2i64_t r2i64_get_size(r2i64_t r) { return (v2i64_t){r.max.x - r.min.x, r.max.y - r.min.y}; }
fn_inline v2i64_t r2i64_get_mid(r2i64_t r) { return v2i64_add(r.min, v2i64_divs(r2i64_get_size(r), 2)); }
fn_inline v2i64_t r2i64_size(r2i64_t r) { return (v2i64_t){r.max.x - r.min.x, r.max.y - r.min.y}; }
fn_inline v2i64_t r2i64_get_mid(r2i64_t r) { return v2i64_add(r.min, v2i64_divs(r2i64_size(r), 2)); }
fn_inline b32 r2i64_contains(r2i64_t rec, v2i64_t point) { return (point.x >= rec.min.x) && (point.x < rec.max.x) && (point.y >= rec.min.y) && (point.y < rec.max.y); }
fn_inline r2i64_t r2i64_intersect(r2i64_t a, r2i64_t b) { return (r2i64_t){ .min.x = MAX(a.min.x, b.min.x), .min.y = MAX(a.min.y, b.min.y), .max.x = MIN(a.max.x, b.max.x), .max.y = MIN(a.max.y, b.max.y) }; }
fn_inline r2i64_t r2i64_union(r2i64_t a, r2i64_t b) { return (r2i64_t){ .min.x = MIN(a.min.x, b.min.x), .min.y = MIN(a.min.y, b.min.y), .max.x = MAX(a.max.x, b.max.x), .max.y = MAX(a.max.y, b.max.y) }; }
@@ -816,8 +840,16 @@ fn_inline r1i64_t r1i64(i64 min, i64 max) { return (r1i64_t){min,max}; }
fn_inline r1i64_t r1i64_auto(i64 a, i64 b) { return (r1i64_t){MIN(a,b),MAX(a,b)}; }
fn_inline r1i64_t r1i64s(i64 a) { return (r1i64_t){a,a}; }
fn_inline r1i64_t r1i64_clamp(r1i64_t a, i64 min, i64 max) { return (r1i64_t){ .min = CLAMP(a.min, min, max), .max = CLAMP(a.max, min, max) }; }
fn_inline b32 r1i64_contains(r1i64_t rec, i64 point) { return (point >= rec.min) && (point < rec.max) && (point >= rec.min) && (point < rec.max); }
fn_inline b32 r1i64_are_equal(r1i64_t a, r1i64_t b) { return a.min == b.min && a.max == b.max; }
gb_read_only r1i64_t r1i64_null;
fn b32 r1i64_overlap(r1i64_t a, r1i64_t b) {
b32 r1 = (a.max >= b.min && a.max <= b.max) || (a.min >= b.min && a.min <= b.max);
b32 r2 = (b.max >= a.min && b.max <= a.max) || (b.min >= a.min && b.min <= a.max);
return r1 || r2;
}
fn v2i64_t v2i64_clamps(v2i64_t v, i64 min, i64 max) {
v2i64_t result = { CLAMP(v.x, min, max), CLAMP(v.y, min, max) };
return result;

12
src/core/core_math_gen.py
View File

@@ -318,8 +318,8 @@ fn r2f64_t r2f64_get_bottom(const r2f64_t *r, f64 value) { /* Y is down */
fn_inline r2f64_t r2f64_expand(r2f64_t rect, v2f64_t value) { return (r2f64_t){ v2f64_sub(rect.min, value), v2f64_add(rect.max, value) }; }
fn_inline r2f64_t r2f64_shrink(r2f64_t rect, v2f64_t value) { return (r2f64_t){ v2f64_add(rect.min, value), v2f64_sub(rect.max, value) }; }
fn_inline r2f64_t r2f64_shrinks(r2f64_t rect, f64 value) { return (r2f64_t){ v2f64_adds(rect.min, value), v2f64_subs(rect.max, value) }; }
fn_inline v2f64_t r2f64_get_size(r2f64_t r) { return (v2f64_t){r.max.x - r.min.x, r.max.y - r.min.y}; }
fn_inline v2f64_t r2f64_get_mid(r2f64_t r) { return v2f64_add(r.min, v2f64_divs(r2f64_get_size(r), 2)); }
fn_inline v2f64_t r2f64_size(r2f64_t r) { return (v2f64_t){r.max.x - r.min.x, r.max.y - r.min.y}; }
fn_inline v2f64_t r2f64_get_mid(r2f64_t r) { return v2f64_add(r.min, v2f64_divs(r2f64_size(r), 2)); }
fn_inline b32 r2f64_contains(r2f64_t rec, v2f64_t point) { return (point.x >= rec.min.x) && (point.x < rec.max.x) && (point.y >= rec.min.y) && (point.y < rec.max.y); }
fn_inline r2f64_t r2f64_intersect(r2f64_t a, r2f64_t b) { return (r2f64_t){ .min.x = MAX(a.min.x, b.min.x), .min.y = MAX(a.min.y, b.min.y), .max.x = MIN(a.max.x, b.max.x), .max.y = MIN(a.max.y, b.max.y) }; }
fn_inline r2f64_t r2f64_union(r2f64_t a, r2f64_t b) { return (r2f64_t){ .min.x = MIN(a.min.x, b.min.x), .min.y = MIN(a.min.y, b.min.y), .max.x = MAX(a.max.x, b.max.x), .max.y = MAX(a.max.y, b.max.y) }; }
@@ -329,8 +329,16 @@ fn_inline r1f64_t r1f64(f64 min, f64 max) { return (r1f64_t){min,max}; }
fn_inline r1f64_t r1f64_auto(f64 a, f64 b) { return (r1f64_t){MIN(a,b),MAX(a,b)}; }
fn_inline r1f64_t r1f64s(f64 a) { return (r1f64_t){a,a}; }
fn_inline r1f64_t r1f64_clamp(r1f64_t a, f64 min, f64 max) { return (r1f64_t){ .min = CLAMP(a.min, min, max), .max = CLAMP(a.max, min, max) }; }
fn_inline b32 r1f64_contains(r1f64_t rec, f64 point) { return (point >= rec.min) && (point < rec.max) && (point >= rec.min) && (point < rec.max); }
fn_inline b32 r1f64_are_equal(r1f64_t a, r1f64_t b) { return a.min == b.min && a.max == b.max; }
gb_read_only r1f64_t r1f64_null;
fn b32 r1f64_overlap(r1f64_t a, r1f64_t b) {
b32 r1 = (a.max >= b.min && a.max <= b.max) || (a.min >= b.min && a.min <= b.max);
b32 r2 = (b.max >= a.min && b.max <= a.max) || (b.min >= a.min && b.min <= a.max);
return r1 || r2;
}
fn v2f64_t v2f64_clamps(v2f64_t v, f64 min, f64 max) {
v2f64_t result = { CLAMP(v.x, min, max), CLAMP(v.y, min, max) };
return result;

15
src/core/core_string.c
View File

@@ -45,6 +45,21 @@ fn b32 char_is_alphanumeric(char a) {
return result;
}
fn b32 char_is_symbol(char w) {
b32 result = (w >= '!' && w <= '/') || (w >= ':' && w <= '@') || (w >= '[' && w <= '`') || (w >= '{' && w <= '~');
return result;
}
fn b32 char_is_non_word(char w) {
b32 result = w != '_' && (char_is_symbol(w) || char_is_whitespace(w));
return result;
}
fn b32 char_is_word(char w) {
b32 result = !char16_is_non_word(w);
return result;
}
fn s8_t s8_from_range(char *begin, char *end) {
assert(end >= begin);
intptr_t size = (intptr_t)end - (intptr_t)begin;

38
src/core/core_string16.c
View File

@@ -5,38 +5,38 @@ fn i64 str16_len(u16 *string) {
return len;
}
fn u16 u16_to_lower_case(u16 a) {
fn u16 char16_to_lower_case(u16 a) {
if (a >= 'A' && a <= 'Z') a += 32;
return a;
}
fn u16 u16_to_upper_case(u16 a) {
fn u16 char16_to_upper_case(u16 a) {
if (a >= 'a' && a <= 'z') a -= 32;
return a;
}
fn b32 u16_is_whitespace(u16 w) {
fn b32 char16_is_whitespace(u16 w) {
b32 result = w == '\n' || w == ' ' || w == '\t' || w == '\v' || w == '\r';
return result;
}
fn b32 u16_is_alphabetic(u16 a) {
fn b32 char16_is_alphabetic(u16 a) {
b32 result = (a >= 'a' && a <= 'z') || (a >= 'A' && a <= 'Z');
return result;
}
fn b32 u16_is_ident(u16 a) {
fn b32 char16_is_ident(u16 a) {
b32 result = (a >= 'a' && a <= 'z') || (a >= 'A' && a <= 'Z') || a == '_';
return result;
}
fn b32 u16_is_digit(u16 a) {
fn b32 char16_is_digit(u16 a) {
b32 result = a >= '0' && a <= '9';
return result;
}
fn b32 u16_is_alphanumeric(u16 a) {
b32 result = u16_is_digit(a) || u16_is_alphabetic(a);
fn b32 char16_is_alphanumeric(u16 a) {
b32 result = char16_is_digit(a) || char16_is_alphabetic(a);
return result;
}
@@ -73,8 +73,8 @@ fn b32 s16_are_equal_ex(s16_t a, s16_t b, b32 ignore_case) {
u16 A = a.str[i];
u16 B = b.str[i];
if (ignore_case) {
A = u16_to_lower_case(A);
B = u16_to_lower_case(B);
A = char16_to_lower_case(A);
B = char16_to_lower_case(B);
}
if (A != B)
return false;
@@ -206,14 +206,14 @@ fn s16_t s16_trim(s16_t string) {
i64 whitespace_begin = 0;
for (; whitespace_begin < string.len; whitespace_begin++) {
if (!u16_is_whitespace(string.str[whitespace_begin])) {
if (!char16_is_whitespace(string.str[whitespace_begin])) {
break;
}
}
i64 whitespace_end = string.len;
for (; whitespace_end != whitespace_begin; whitespace_end--) {
if (!u16_is_whitespace(string.str[whitespace_end - 1])) {
if (!char16_is_whitespace(string.str[whitespace_end - 1])) {
break;
}
}
@@ -231,7 +231,7 @@ fn s16_t s16_trim(s16_t string) {
fn s16_t s16_trim_end(s16_t string) {
i64 whitespace_end = string.len;
for (; whitespace_end != 0; whitespace_end--) {
if (!u16_is_whitespace(string.str[whitespace_end - 1])) {
if (!char16_is_whitespace(string.str[whitespace_end - 1])) {
break;
}
}
@@ -314,7 +314,7 @@ fn s16_t s16_get_name_no_ext(s16_t s) {
fn s16_t s16_to_lower_case(ma_arena_t *ma, s16_t s) {
s16_t copy = s16_copy(ma, s);
for (int64_t i = 0; i < copy.len; i++) {
copy.str[i] = u16_to_lower_case(copy.str[i]);
copy.str[i] = char16_to_lower_case(copy.str[i]);
}
return copy;
}
@@ -322,7 +322,7 @@ fn s16_t s16_to_lower_case(ma_arena_t *ma, s16_t s) {
fn s16_t s16_to_upper_case(ma_arena_t *ma, s16_t s) {
s16_t copy = s16_copy(ma, s);
for (int64_t i = 0; i < copy.len; i++) {
copy.str[i] = u16_to_upper_case(copy.str[i]);
copy.str[i] = char16_to_upper_case(copy.str[i]);
}
return copy;
}
@@ -491,10 +491,10 @@ fn_test void test_string16(void) {
}
{
assert(u16_to_upper_case('a') == char16('A'));
assert(u16_to_upper_case('a') == 'A');
assert(u16_to_upper_case(char16('a')) == 'A');
assert(u16_is_digit('3'));
assert(char16_to_upper_case('a') == char16('A'));
assert(char16_to_upper_case('a') == 'A');
assert(char16_to_upper_case(char16('a')) == 'A');
assert(char16_is_digit('3'));
}
{