mr4th-public
/
4coder
1
Fork 0
Code Issues Releases Activity
4coder/4coder_base_types.cpp

6133 lines
163 KiB
C++
Raw Normal View History

unifying use of working_set's table
2016-02-07 21:15:58 +00:00
/*
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
* 4coder base types
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
*/
// TOP
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
#if !defined(FCODER_BASE_TYPES_CPP)
#define FCODER_BASE_TYPES_CPP
simplified macro config stuff, just have FRED_INTERNAL now
2016-05-27 02:37:45 +00:00
#define C_MATH 1
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
static i32
ceil32(f32 v){
return(((v)>0)?( (v == (i32)(v))?((i32)(v)):((i32)((v)+1.f)) ):( ((i32)(v)) ));
}
static i32
floor32(f32 v){
return(((v)<0)?( (v == (i32)(v))?((i32)(v)):((i32)((v)-1.f)) ):( ((i32)(v)) ));
}
static i32
round32(f32 v){
return(floor32(v + 0.5f));
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static i8
round_up_i8(i8 x, i8 b){
x += b - 1;
x -= x%b;
return(x);
}
static u8
round_up_u8(u8 x, u8 b){
x += b - 1;
x -= x%b;
return(x);
}
static i16
round_up_i16(i16 x, i16 b){
x += b - 1;
x -= x%b;
return(x);
}
static u16
round_up_u16(u16 x, u16 b){
x += b - 1;
x -= x%b;
return(x);
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
}
static i32
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
round_up_i32(i32 x, i32 b){
x += b - 1;
x -= x%b;
return(x);
}
static u32
round_up_u32(u32 x, u32 b){
x += b - 1;
x -= x%b;
return(x);
}
static i64
round_up_i64(i64 x, i64 b){
x += b - 1;
x -= x%b;
return(x);
}
static u64
round_up_u64(u64 x, u64 b){
x += b - 1;
x -= x%b;
return(x);
}
static imem
round_up_imem(imem x, imem b){
x += b - 1;
x -= x%b;
return(x);
}
static umem
round_up_umem(umem x, umem b){
x += b - 1;
x -= x%b;
return(x);
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static i8
round_down_i8(i8 x, i8 b){
x -= x%b;
return(x);
}
static u8
round_down_u8(u8 x, u8 b){
x -= x%b;
return(x);
}
static i16
round_down_i16(i16 x, i16 b){
x -= x%b;
return(x);
}
static u16
round_down_u16(u16 x, u16 b){
x -= x%b;
return(x);
}
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
static i32
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
round_down_i32(i32 x, i32 b){
x -= x%b;
return(x);
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
}
static u32
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
round_down_u32(u32 x, u32 b){
x -= x%b;
return(x);
}
static i64
round_down_i64(i64 x, i64 b){
x -= x%b;
return(x);
}
static u64
round_down_u64(u64 x, u64 b){
x -= x%b;
return(x);
}
static imem
round_down_imem(imem x, imem b){
x -= x%b;
return(x);
}
static umem
round_down_umem(umem x, umem b){
x -= x%b;
return(x);
}
static f32
f32_integer(f32 x){
return((f32)((i32)x));
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static u32
round_up_pot_u32(u32 x){
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
--x;
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
++x;
return(x);
}
////////////////////////////////
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Data
make_data(void *memory, umem size){
Data data = {(u8*)memory, size};
return(data);
}
global_const Data zero_data = {};
#define data_initr(m,s) {(m), (s)}
#define data_initr_struct(s) {(s), sizeof(*(s))}
#define data_initr_array(a) {(a), sizeof(a)}
#define data_initr_string(s) {(s), sizeof(s) - 1}
////////////////////////////////
static void
block_zero(void *mem, umem size){
for (u8 *p = (u8*)mem, *e = p + size; p < e; p += 1){
*p = 0;
}
}
static void
block_fill_ones(void *mem, umem size){
for (u8 *p = (u8*)mem, *e = p + size; p < e; p += 1){
*p = 0xFF;
}
}
static void
block_copy(void *dst, void *src, umem size){
u8 *d = (u8*)dst;
u8 *s = (u8*)src;
if (d < s){
u8 *e = d + size;
for (; d < e; d += 1, s += 1){
*d = *s;
}
}
else if (d > s){
u8 *e = d;
d += size - 1;
s += size - 1;
for (; d >= e; d -= 1, s -= 1){
*d = *s;
}
}
}
static b32
block_match(void *a, void *b, umem size){
b32 result = true;
for (u8 *pa = (u8*)a, *pb = (u8*)b, *ea = pa + size; pa < ea; pa += 1, pb += 1){
if (*pa != *pb){
result = false;
break;
}
}
return(result);
}
static i32
block_compare(void *a, void *b, umem size){
i32 result = 0;
for (u8 *pa = (u8*)a, *pb = (u8*)b, *ea = pa + size; pa < ea; pa += 1, pb += 1){
i32 dif = (i32)*pa - (i32)*pb;
if (dif != 0){
result = (dif > 0)?1:-1;
break;
}
}
return(result);
}
static void
block_fill_u8(void *a, umem size, u8 val){
for (u8 *ptr = (u8*)a, *e = ptr + size; ptr < e; ptr += 1){
*ptr = val;
}
}
static void
block_fill_u16(void *a, umem size, u16 val){
Assert(size%sizeof(u16) == 0);
umem count = size/sizeof(u16);
for (u16 *ptr = (u16*)a, *e = ptr + count; ptr < e; ptr += 1){
*ptr = val;
}
}
static void
block_fill_u32(void *a, umem size, u32 val){
Assert(size%sizeof(u32) == 0);
umem count = size/sizeof(u32);
for (u32 *ptr = (u32*)a, *e = ptr + count; ptr < e; ptr += 1){
*ptr = val;
}
}
static void
block_fill_u64(void *a, umem size, u64 val){
Assert(size%sizeof(u64) == 0);
umem count = size/sizeof(u64);
for (u64 *ptr = (u64*)a, *e = ptr + count; ptr < e; ptr += 1){
*ptr = val;
}
}
#define block_zero_struct(p) block_zero((p), sizeof(*(p)))
#define block_zero_array(a) block_zero((a), sizeof(a))
#define block_copy_struct(d,s) block_copy((d), (s), sizeof(*(d)))
#define block_copy_array(d,s) block_copy((d), (s), sizeof(d))
#define block_copy_dynamic_array(d,s,c) block_copy((d), (s), sizeof(*(d))*(c))
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
#define block_match_struct(a,b) block_match((a), (b), sizeof(*(a)))
#define block_match_array(a,b) block_match((a), (b), sizeof(a))
////////////////////////////////
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
static f32
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
abs_f32(f32 x){
if (x < 0){
x = -x;
}
fixed wicked crazy bug in optimized build, warrants more investigation
2016-08-31 01:44:02 +00:00
return(x);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
fixed wicked crazy bug in optimized build, warrants more investigation
2016-08-31 01:44:02 +00:00
#if C_MATH
#include <math.h>
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
static f32
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
mod_f32(f32 x, i32 m){
finished getting through 4ed_app.cpp to build in MSVC 2017's compiler
2017-03-17 17:45:41 +00:00
f32 whole;
f32 frac = modff(x, &whole);
f32 r = ((i32)(whole) % m) + frac;
fixed wicked crazy bug in optimized build, warrants more investigation
2016-08-31 01:44:02 +00:00
return(r);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
added a bunch of GUI, stuff, broke everything
2016-05-25 02:12:49 +00:00
#endif
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
////////////////////////////////
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec2_i8
V2i8(i8 x, i8 y){
Vec2_i8 v = {x, y};
return(v);
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec3_i8
V3i8(i8 x, i8 y, i8 z){
Vec3_i8 v = {x, y, z};
return(v);
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec4_i8
V4i8(i8 x, i8 y, i8 z, i8 w){
Vec4_i8 v = {x, y, z, w};
return(v);
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec2_i16
V2i16(i16 x, i16 y){
Vec2_i16 v = {x, y};
return(v);
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec3_i16
V3i16(i16 x, i16 y, i16 z){
Vec3_i16 v = {x, y, z};
return(v);
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec4_i16
V4i16(i16 x, i16 y, i16 z, i16 w){
Vec4_i16 v = {x, y, z, w};
return(v);
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
}
static Vec2_i32
simplify gui scroll vars, switch things which should ints over to ints
2019-02-10 07:48:07 +00:00
V2i32(i32 x, i32 y){
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
Vec2_i32 v = {x, y};
return(v);
Full rewrite of panel layout system
2019-02-05 09:13:38 +00:00
}
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
static Vec3_i32
simplify gui scroll vars, switch things which should ints over to ints
2019-02-10 07:48:07 +00:00
V3i32(i32 x, i32 y, i32 z){
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
Vec3_i32 v = {x, y, z};
return(v);
Full rewrite of panel layout system
2019-02-05 09:13:38 +00:00
}
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
static Vec4_i32
simplify gui scroll vars, switch things which should ints over to ints
2019-02-10 07:48:07 +00:00
V4i32(i32 x, i32 y, i32 z, i32 w){
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
Vec4_i32 v = {x, y, z, w};
return(v);
}
static Vec2_f32
V2f32(f32 x, f32 y){
Vec2_f32 v = {x, y};
return(v);
}
static Vec3_f32
V3f32(f32 x, f32 y, f32 z){
Vec3_f32 v = {x, y, z};
return(v);
}
static Vec4_f32
V4f32(f32 x, f32 y, f32 z, f32 w){
Vec4_f32 v = {x, y, z, w};
return(v);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec2_i8
V2i8(Vec2_i8 o){
return(V2i8((i8)o.x, (i8)o.y));
}
static Vec2_i8
V2i8(Vec2_i16 o){
return(V2i8((i8)o.x, (i8)o.y));
}
static Vec2_i8
V2i8(Vec2_i32 o){
return(V2i8((i8)o.x, (i8)o.y));
}
static Vec2_i8
V2i8(Vec2_f32 o){
return(V2i8((i8)o.x, (i8)o.y));
}
static Vec3_i8
V3i8(Vec3_i8 o){
return(V3i8((i8)o.x, (i8)o.y, (i8)o.z));
}
static Vec3_i8
V3i8(Vec3_i16 o){
return(V3i8((i8)o.x, (i8)o.y, (i8)o.z));
}
static Vec3_i8
V3i8(Vec3_i32 o){
return(V3i8((i8)o.x, (i8)o.y, (i8)o.z));
}
static Vec3_i8
V3i8(Vec3_f32 o){
return(V3i8((i8)o.x, (i8)o.y, (i8)o.z));
}
static Vec4_i8
V4i8(Vec4_i8 o){
return(V4i8((i8)o.x, (i8)o.y, (i8)o.z, (i8)o.w));
}
static Vec4_i8
V4i8(Vec4_i16 o){
return(V4i8((i8)o.x, (i8)o.y, (i8)o.z, (i8)o.w));
}
static Vec4_i8
V4i8(Vec4_i32 o){
return(V4i8((i8)o.x, (i8)o.y, (i8)o.z, (i8)o.w));
}
static Vec4_i8
V4i8(Vec4_f32 o){
return(V4i8((i8)o.x, (i8)o.y, (i8)o.z, (i8)o.w));
}
static Vec2_i16
V2i16(Vec2_i8 o){
return(V2i16((i16)o.x, (i16)o.y));
}
static Vec2_i16
V2i16(Vec2_i16 o){
return(V2i16((i16)o.x, (i16)o.y));
}
static Vec2_i16
V2i16(Vec2_i32 o){
return(V2i16((i16)o.x, (i16)o.y));
}
static Vec2_i16
V2i16(Vec2_f32 o){
return(V2i16((i16)o.x, (i16)o.y));
}
static Vec3_i16
V3i16(Vec3_i8 o){
return(V3i16((i16)o.x, (i16)o.y, (i16)o.z));
}
static Vec3_i16
V3i16(Vec3_i16 o){
return(V3i16((i16)o.x, (i16)o.y, (i16)o.z));
}
static Vec3_i16
V3i16(Vec3_i32 o){
return(V3i16((i16)o.x, (i16)o.y, (i16)o.z));
}
static Vec3_i16
V3i16(Vec3_f32 o){
return(V3i16((i16)o.x, (i16)o.y, (i16)o.z));
}
static Vec4_i16
V4i16(Vec4_i8 o){
return(V4i16((i16)o.x, (i16)o.y, (i16)o.z, (i16)o.w));
}
static Vec4_i16
V4i16(Vec4_i16 o){
return(V4i16((i16)o.x, (i16)o.y, (i16)o.z, (i16)o.w));
}
static Vec4_i16
V4i16(Vec4_i32 o){
return(V4i16((i16)o.x, (i16)o.y, (i16)o.z, (i16)o.w));
}
static Vec4_i16
V4i16(Vec4_f32 o){
return(V4i16((i16)o.x, (i16)o.y, (i16)o.z, (i16)o.w));
}
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
static Vec2_i32
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
V2i32(Vec2_i8 o){
return(V2i32((i32)o.x, (i32)o.y));
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec2_i32
V2i32(Vec2_i16 o){
return(V2i32((i32)o.x, (i32)o.y));
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec2_i32
V2i32(Vec2_i32 o){
return(V2i32((i32)o.x, (i32)o.y));
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
}
static Vec2_i32
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
V2i32(Vec2_f32 o){
return(V2i32((i32)o.x, (i32)o.y));
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
}
static Vec3_i32
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
V3i32(Vec3_i8 o){
return(V3i32((i32)o.x, (i32)o.y, (i32)o.z));
}
static Vec3_i32
V3i32(Vec3_i16 o){
return(V3i32((i32)o.x, (i32)o.y, (i32)o.z));
}
static Vec3_i32
V3i32(Vec3_i32 o){
return(V3i32((i32)o.x, (i32)o.y, (i32)o.z));
}
static Vec3_i32
V3i32(Vec3_f32 o){
return(V3i32((i32)o.x, (i32)o.y, (i32)o.z));
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
}
static Vec4_i32
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
V4i32(Vec4_i8 o){
return(V4i32((i32)o.x, (i32)o.y, (i32)o.z, (i32)o.w));
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec4_i32
V4i32(Vec4_i16 o){
return(V4i32((i32)o.x, (i32)o.y, (i32)o.z, (i32)o.w));
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec4_i32
V4i32(Vec4_i32 o){
return(V4i32((i32)o.x, (i32)o.y, (i32)o.z, (i32)o.w));
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec4_i32
V4i32(Vec4_f32 o){
return(V4i32((i32)o.x, (i32)o.y, (i32)o.z, (i32)o.w));
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec2_f32
V2f32(Vec2_i8 o){
return(V2f32((f32)o.x, (f32)o.y));
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec2_f32
V2f32(Vec2_i16 o){
return(V2f32((f32)o.x, (f32)o.y));
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec2_f32
V2f32(Vec2_i32 o){
return(V2f32((f32)o.x, (f32)o.y));
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec2_f32
V2f32(Vec2_f32 o){
return(V2f32((f32)o.x, (f32)o.y));
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec3_f32
V3f32(Vec3_i8 o){
return(V3f32((f32)o.x, (f32)o.y, (f32)o.z));
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec3_f32
V3f32(Vec3_i16 o){
return(V3f32((f32)o.x, (f32)o.y, (f32)o.z));
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec3_f32
V3f32(Vec3_i32 o){
return(V3f32((f32)o.x, (f32)o.y, (f32)o.z));
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec3_f32
V3f32(Vec3_f32 o){
return(V3f32((f32)o.x, (f32)o.y, (f32)o.z));
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec4_f32
V4f32(Vec4_i8 o){
return(V4f32((f32)o.x, (f32)o.y, (f32)o.z, (f32)o.w));
}
static Vec4_f32
V4f32(Vec4_i16 o){
return(V4f32((f32)o.x, (f32)o.y, (f32)o.z, (f32)o.w));
}
static Vec4_f32
V4f32(Vec4_i32 o){
return(V4f32((f32)o.x, (f32)o.y, (f32)o.z, (f32)o.w));
4coder Jamm 2
2019-02-25 23:42:13 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec4_f32
V4f32(Vec4_f32 o){
return(V4f32((f32)o.x, (f32)o.y, (f32)o.z, (f32)o.w));
}
#define V2 V2f32
#define V3 V3f32
#define V4 V4f32
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec2_i8
operator+(Vec2_i8 a, Vec2_i8 b){
a.x += b.x;
a.y += b.y;
4coder Jamm 2
2019-02-25 23:42:13 +00:00
return(a);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec3_i8
operator+(Vec3_i8 a, Vec3_i8 b){
a.x += b.x;
a.y += b.y;
a.z += b.z;
4coder Jamm 2
2019-02-25 23:42:13 +00:00
return(a);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec4_i8
operator+(Vec4_i8 a, Vec4_i8 b){
a.x += b.x;
a.y += b.y;
a.z += b.z;
a.w += b.w;
4coder Jamm 2
2019-02-25 23:42:13 +00:00
return(a);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec2_i16
operator+(Vec2_i16 a, Vec2_i16 b){
a.x += b.x;
a.y += b.y;
4coder Jamm 2
2019-02-25 23:42:13 +00:00
return(a);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec3_i16
operator+(Vec3_i16 a, Vec3_i16 b){
a.x += b.x;
a.y += b.y;
a.z += b.z;
4coder Jamm 2
2019-02-25 23:42:13 +00:00
return(a);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec4_i16
operator+(Vec4_i16 a, Vec4_i16 b){
a.x += b.x;
a.y += b.y;
a.z += b.z;
a.w += b.w;
4coder Jamm 2
2019-02-25 23:42:13 +00:00
return(a);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec2_i32
operator+(Vec2_i32 a, Vec2_i32 b){
a.x += b.x;
a.y += b.y;
4coder Jamm 2
2019-02-25 23:42:13 +00:00
return(a);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec3_i32
operator+(Vec3_i32 a, Vec3_i32 b){
a.x += b.x;
a.y += b.y;
a.z += b.z;
4coder Jamm 2
2019-02-25 23:42:13 +00:00
return(a);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec4_i32
operator+(Vec4_i32 a, Vec4_i32 b){
a.x += b.x;
a.y += b.y;
a.z += b.z;
a.w += b.w;
4coder Jamm 2
2019-02-25 23:42:13 +00:00
return(a);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec2_f32
operator+(Vec2_f32 a, Vec2_f32 b){
a.x += b.x;
a.y += b.y;
return(a);
Full rewrite of panel layout system
2019-02-05 09:13:38 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec3_f32
operator+(Vec3_f32 a, Vec3_f32 b){
a.x += b.x;
a.y += b.y;
a.z += b.z;
return(a);
Full rewrite of panel layout system
2019-02-05 09:13:38 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec4_f32
operator+(Vec4_f32 a, Vec4_f32 b){
a.x += b.x;
a.y += b.y;
a.z += b.z;
a.w += b.w;
return(a);
Full rewrite of panel layout system
2019-02-05 09:13:38 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec2_i8&
operator+=(Vec2_i8 &a, Vec2_i8 b){
a.x += b.x;
a.y += b.y;
return(a);
Full rewrite of panel layout system
2019-02-05 09:13:38 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec3_i8&
operator+=(Vec3_i8 &a, Vec3_i8 b){
a.x += b.x;
a.y += b.y;
a.z += b.z;
return(a);
Full rewrite of panel layout system
2019-02-05 09:13:38 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec4_i8&
operator+=(Vec4_i8 &a, Vec4_i8 b){
a.x += b.x;
a.y += b.y;
a.z += b.z;
a.w += b.w;
return(a);
Full rewrite of panel layout system
2019-02-05 09:13:38 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec2_i16&
operator+=(Vec2_i16 &a, Vec2_i16 b){
a.x += b.x;
a.y += b.y;
return(a);
4coder Jamm 2
2019-02-25 23:42:13 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec3_i16&
operator+=(Vec3_i16 &a, Vec3_i16 b){
a.x += b.x;
a.y += b.y;
a.z += b.z;
return(a);
4coder Jamm 2
2019-02-25 23:42:13 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec4_i16&
operator+=(Vec4_i16 &a, Vec4_i16 b){
a.x += b.x;
a.y += b.y;
a.z += b.z;
a.w += b.w;
return(a);
}
static Vec2_i32&
operator+=(Vec2_i32 &a, Vec2_i32 b){
a.x += b.x;
a.y += b.y;
return(a);
}
static Vec3_i32&
operator+=(Vec3_i32 &a, Vec3_i32 b){
a.x += b.x;
a.y += b.y;
a.z += b.z;
return(a);
}
static Vec4_i32&
operator+=(Vec4_i32 &a, Vec4_i32 b){
a.x += b.x;
a.y += b.y;
a.z += b.z;
a.w += b.w;
return(a);
}
static Vec2_f32&
operator+=(Vec2_f32 &a, Vec2_f32 b){
a.x += b.x;
a.y += b.y;
return(a);
}
static Vec3_f32&
operator+=(Vec3_f32 &a, Vec3_f32 b){
a.x += b.x;
a.y += b.y;
a.z += b.z;
return(a);
}
static Vec4_f32&
operator+=(Vec4_f32 &a, Vec4_f32 b){
a.x += b.x;
a.y += b.y;
a.z += b.z;
a.w += b.w;
return(a);
4coder Jamm 2
2019-02-25 23:42:13 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec2_i8
operator-(Vec2_i8 a, Vec2_i8 b){
a.x -= b.x;
a.y -= b.y;
return(a);
}
static Vec3_i8
operator-(Vec3_i8 a, Vec3_i8 b){
a.x -= b.x;
a.y -= b.y;
a.z -= b.z;
return(a);
}
static Vec4_i8
operator-(Vec4_i8 a, Vec4_i8 b){
a.x -= b.x;
a.y -= b.y;
a.z -= b.z;
a.w -= b.w;
return(a);
}
static Vec2_i16
operator-(Vec2_i16 a, Vec2_i16 b){
a.x -= b.x;
a.y -= b.y;
return(a);
}
static Vec3_i16
operator-(Vec3_i16 a, Vec3_i16 b){
a.x -= b.x;
a.y -= b.y;
a.z -= b.z;
return(a);
}
static Vec4_i16
operator-(Vec4_i16 a, Vec4_i16 b){
a.x -= b.x;
a.y -= b.y;
a.z -= b.z;
a.w -= b.w;
return(a);
}
4coder Jamm 2
2019-02-25 23:42:13 +00:00
static Vec2_i32
operator-(Vec2_i32 a, Vec2_i32 b){
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
a.x -= b.x;
a.y -= b.y;
return(a);
4coder Jamm 2
2019-02-25 23:42:13 +00:00
}
static Vec3_i32
operator-(Vec3_i32 a, Vec3_i32 b){
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
a.x -= b.x;
a.y -= b.y;
a.z -= b.z;
return(a);
4coder Jamm 2
2019-02-25 23:42:13 +00:00
}
static Vec4_i32
operator-(Vec4_i32 a, Vec4_i32 b){
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
a.x -= b.x;
a.y -= b.y;
a.z -= b.z;
a.w -= b.w;
return(a);
4coder Jamm 2
2019-02-25 23:42:13 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec2_f32
operator-(Vec2_f32 a, Vec2_f32 b){
a.x -= b.x;
a.y -= b.y;
return(a);
4coder Jamm 2
2019-02-25 23:42:13 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec3_f32
operator-(Vec3_f32 a, Vec3_f32 b){
a.x -= b.x;
a.y -= b.y;
a.z -= b.z;
return(a);
4coder Jamm 2
2019-02-25 23:42:13 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec4_f32
operator-(Vec4_f32 a, Vec4_f32 b){
a.x -= b.x;
a.y -= b.y;
a.z -= b.z;
a.w -= b.w;
return(a);
4coder Jamm 2
2019-02-25 23:42:13 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec2_i8&
operator-=(Vec2_i8 &a, Vec2_i8 b){
a.x -= b.x;
a.y -= b.y;
return(a);
4coder Jamm 2
2019-02-25 23:42:13 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec3_i8&
operator-=(Vec3_i8 &a, Vec3_i8 b){
a.x -= b.x;
a.y -= b.y;
a.z -= b.z;
return(a);
4coder Jamm 2
2019-02-25 23:42:13 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec4_i8&
operator-=(Vec4_i8 &a, Vec4_i8 b){
a.x -= b.x;
a.y -= b.y;
a.z -= b.z;
a.w -= b.w;
4coder Jamm 2
2019-02-25 23:42:13 +00:00
return(a);
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec2_i16&
operator-=(Vec2_i16 &a, Vec2_i16 b){
a.x -= b.x;
a.y -= b.y;
4coder Jamm 2
2019-02-25 23:42:13 +00:00
return(a);
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec3_i16&
operator-=(Vec3_i16 &a, Vec3_i16 b){
a.x -= b.x;
a.y -= b.y;
a.z -= b.z;
return(a);
}
static Vec4_i16&
operator-=(Vec4_i16 &a, Vec4_i16 b){
a.x -= b.x;
a.y -= b.y;
a.z -= b.z;
a.w -= b.w;
4coder Jamm 2
2019-02-25 23:42:13 +00:00
return(a);
}
static Vec2_i32&
operator-=(Vec2_i32 &a, Vec2_i32 b){
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
a.x -= b.x;
a.y -= b.y;
4coder Jamm 2
2019-02-25 23:42:13 +00:00
return(a);
}
static Vec3_i32&
operator-=(Vec3_i32 &a, Vec3_i32 b){
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
a.x -= b.x;
a.y -= b.y;
a.z -= b.z;
4coder Jamm 2
2019-02-25 23:42:13 +00:00
return(a);
}
static Vec4_i32&
operator-=(Vec4_i32 &a, Vec4_i32 b){
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
a.x -= b.x;
a.y -= b.y;
a.z -= b.z;
a.w -= b.w;
4coder Jamm 2
2019-02-25 23:42:13 +00:00
return(a);
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec2_f32&
operator-=(Vec2_f32 &a, Vec2_f32 b){
a.x -= b.x;
a.y -= b.y;
4coder Jamm 2
2019-02-25 23:42:13 +00:00
return(a);
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec3_f32&
operator-=(Vec3_f32 &a, Vec3_f32 b){
a.x -= b.x;
a.y -= b.y;
a.z -= b.z;
return(a);
}
static Vec4_f32&
operator-=(Vec4_f32 &a, Vec4_f32 b){
a.x -= b.x;
a.y -= b.y;
a.z -= b.z;
a.w -= b.w;
4coder Jamm 2
2019-02-25 23:42:13 +00:00
return(a);
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static Vec2_i8
operator*(i8 s, Vec2_i8 v){
v.x *= s;
v.y *= s;
return(v);
}
static Vec2_i8
operator*(Vec2_i8 v, i8 s){
v.x *= s;
v.y *= s;
return(v);
}
static Vec3_i8
operator*(i8 s, Vec3_i8 v){
v.x *= s;
v.y *= s;
v.z *= s;
return(v);
}
static Vec3_i8
operator*(Vec3_i8 v, i8 s){
v.x *= s;
v.y *= s;
v.z *= s;
return(v);
}
static Vec4_i8
operator*(i8 s, Vec4_i8 v){
v.x *= s;
v.y *= s;
v.z *= s;
v.w *= s;
return(v);
}
static Vec4_i8
operator*(Vec4_i8 v, i8 s){
v.x *= s;
v.y *= s;
v.z *= s;
v.w *= s;
return(v);
}
static Vec2_i16
operator*(i16 s, Vec2_i16 v){
v.x *= s;
v.y *= s;
return(v);
}
static Vec2_i16
operator*(Vec2_i16 v, i16 s){
v.x *= s;
v.y *= s;
return(v);
}
static Vec3_i16
operator*(i16 s, Vec3_i16 v){
v.x *= s;
v.y *= s;
v.z *= s;
return(v);
}
static Vec3_i16
operator*(Vec3_i16 v, i16 s){
v.x *= s;
v.y *= s;
v.z *= s;
return(v);
}
static Vec4_i16
operator*(i16 s, Vec4_i16 v){
v.x *= s;
v.y *= s;
v.z *= s;
v.w *= s;
return(v);
}
static Vec4_i16
operator*(Vec4_i16 v, i16 s){
v.x *= s;
v.y *= s;
v.z *= s;
v.w *= s;
return(v);
}
static Vec2_i32
operator*(i32 s, Vec2_i32 v){
v.x *= s;
v.y *= s;
return(v);
}
static Vec2_i32
operator*(Vec2_i32 v, i32 s){
v.x *= s;
v.y *= s;
return(v);
}
static Vec3_i32
operator*(i32 s, Vec3_i32 v){
v.x *= s;
v.y *= s;
v.z *= s;
return(v);
}
static Vec3_i32
operator*(Vec3_i32 v, i32 s){
v.x *= s;
v.y *= s;
v.z *= s;
return(v);
}
static Vec4_i32
operator*(i32 s, Vec4_i32 v){
v.x *= s;
v.y *= s;
v.z *= s;
v.w *= s;
return(v);
}
static Vec4_i32
operator*(Vec4_i32 v, i32 s){
v.x *= s;
v.y *= s;
v.z *= s;
v.w *= s;
return(v);
}
static Vec2_f32
operator*(f32 s, Vec2_f32 v){
v.x *= s;
v.y *= s;
return(v);
}
static Vec2_f32
operator*(Vec2_f32 v, f32 s){
v.x *= s;
v.y *= s;
return(v);
}
static Vec3_f32
operator*(f32 s, Vec3_f32 v){
v.x *= s;
v.y *= s;
v.z *= s;
return(v);
}
static Vec3_f32
operator*(Vec3_f32 v, f32 s){
v.x *= s;
v.y *= s;
v.z *= s;
return(v);
}
static Vec4_f32
operator*(f32 s, Vec4_f32 v){
v.x *= s;
v.y *= s;
v.z *= s;
v.w *= s;
return(v);
}
static Vec4_f32
operator*(Vec4_f32 v, f32 s){
v.x *= s;
v.y *= s;
v.z *= s;
v.w *= s;
return(v);
}
static Vec2_i8&
operator*=(Vec2_i8 &v, i8 s){
v.x *= s;
v.y *= s;
return(v);
}
static Vec3_i8&
operator*=(Vec3_i8 &v, i8 s){
v.x *= s;
v.y *= s;
v.z *= s;
return(v);
}
static Vec4_i8&
operator*=(Vec4_i8 &v, i8 s){
v.x *= s;
v.y *= s;
v.z *= s;
v.w *= s;
return(v);
}
static Vec2_i16&
operator*=(Vec2_i16 &v, i16 s){
v.x *= s;
v.y *= s;
return(v);
}
static Vec3_i16&
operator*=(Vec3_i16 &v, i16 s){
v.x *= s;
v.y *= s;
v.z *= s;
return(v);
}
static Vec4_i16&
operator*=(Vec4_i16 &v, i16 s){
v.x *= s;
v.y *= s;
v.z *= s;
v.w *= s;
return(v);
}
static Vec2_i32&
operator*=(Vec2_i32 &v, i32 s){
v.x *= s;
v.y *= s;
return(v);
}
static Vec3_i32&
operator*=(Vec3_i32 &v, i32 s){
v.x *= s;
v.y *= s;
v.z *= s;
return(v);
}
4coder Jamm 2
2019-02-25 23:42:13 +00:00
static Vec4_i32&
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
operator*=(Vec4_i32 &v, i32 s){
v.x *= s;
v.y *= s;
v.z *= s;
v.w *= s;
return(v);
}
static Vec2_f32&
operator*=(Vec2_f32 &v, f32 s){
v.x *= s;
v.y *= s;
return(v);
}
static Vec3_f32&
operator*=(Vec3_f32 &v, f32 s){
v.x *= s;
v.y *= s;
v.z *= s;
return(v);
}
static Vec4_f32&
operator*=(Vec4_f32 &v, f32 s){
v.x *= s;
v.y *= s;
v.z *= s;
v.w *= s;
return(v);
}
static Vec2_i8
operator/(Vec2_i8 v, i8 s){
v.x /= s;
v.y /= s;
return(v);
}
static Vec3_i8
operator/(Vec3_i8 v, i8 s){
v.x /= s;
v.y /= s;
v.z /= s;
return(v);
}
static Vec4_i8
operator/(Vec4_i8 v, i8 s){
v.x /= s;
v.y /= s;
v.z /= s;
v.w /= s;
return(v);
}
static Vec2_i16
operator/(Vec2_i16 v, i16 s){
v.x /= s;
v.y /= s;
return(v);
}
static Vec3_i16
operator/(Vec3_i16 v, i16 s){
v.x /= s;
v.y /= s;
v.z /= s;
return(v);
}
static Vec4_i16
operator/(Vec4_i16 v, i16 s){
v.x /= s;
v.y /= s;
v.z /= s;
v.w /= s;
return(v);
}
static Vec2_i32
operator/(Vec2_i32 v, i32 s){
v.x /= s;
v.y /= s;
return(v);
}
static Vec3_i32
operator/(Vec3_i32 v, i32 s){
v.x /= s;
v.y /= s;
v.z /= s;
return(v);
}
static Vec4_i32
operator/(Vec4_i32 v, i32 s){
v.x /= s;
v.y /= s;
v.z /= s;
v.w /= s;
return(v);
}
static Vec2_f32
operator/(Vec2_f32 v, f32 s){
v.x /= s;
v.y /= s;
return(v);
}
static Vec3_f32
operator/(Vec3_f32 v, f32 s){
v.x /= s;
v.y /= s;
v.z /= s;
return(v);
}
static Vec4_f32
operator/(Vec4_f32 v, f32 s){
v.x /= s;
v.y /= s;
v.z /= s;
v.w /= s;
return(v);
}
static Vec2_i8&
operator/=(Vec2_i8 &v, i8 s){
v.x /= s;
v.y /= s;
return(v);
}
static Vec3_i8&
operator/=(Vec3_i8 &v, i8 s){
v.x /= s;
v.y /= s;
v.z /= s;
return(v);
}
static Vec4_i8&
operator/=(Vec4_i8 &v, i8 s){
v.x /= s;
v.y /= s;
v.z /= s;
v.w /= s;
return(v);
}
static Vec2_i16&
operator/=(Vec2_i16 &v, i16 s){
v.x /= s;
v.y /= s;
return(v);
}
static Vec3_i16&
operator/=(Vec3_i16 &v, i16 s){
v.x /= s;
v.y /= s;
v.z /= s;
return(v);
}
static Vec4_i16&
operator/=(Vec4_i16 &v, i16 s){
v.x /= s;
v.y /= s;
v.z /= s;
v.w /= s;
return(v);
}
static Vec2_i32&
operator/=(Vec2_i32 &v, i32 s){
v.x /= s;
v.y /= s;
return(v);
}
static Vec3_i32&
operator/=(Vec3_i32 &v, i32 s){
v.x /= s;
v.y /= s;
v.z /= s;
return(v);
}
static Vec4_i32&
operator/=(Vec4_i32 &v, i32 s){
v.x /= s;
v.y /= s;
v.z /= s;
v.w /= s;
return(v);
}
static Vec2_f32&
operator/=(Vec2_f32 &v, f32 s){
v.x /= s;
v.y /= s;
return(v);
}
static Vec3_f32&
operator/=(Vec3_f32 &v, f32 s){
v.x /= s;
v.y /= s;
v.z /= s;
return(v);
}
static Vec4_f32&
operator/=(Vec4_f32 &v, f32 s){
v.x /= s;
v.y /= s;
v.z /= s;
v.w /= s;
return(v);
4coder Jamm 2
2019-02-25 23:42:13 +00:00
}
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
static b32
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
operator==(Vec2_i8 a, Vec2_i8 b){
Full rewrite of panel layout system
2019-02-05 09:13:38 +00:00
return(a.x == b.x && a.y == b.y);
}
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
static b32
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
operator==(Vec3_i8 a, Vec3_i8 b){
return(a.x == b.x && a.y == b.y && a.z == b.z);
Full rewrite of panel layout system
2019-02-05 09:13:38 +00:00
}
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
static b32
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
operator==(Vec4_i8 a, Vec4_i8 b){
return(a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w);
}
static b32
operator==(Vec2_i16 a, Vec2_i16 b){
return(a.x == b.x && a.y == b.y);
}
static b32
operator==(Vec3_i16 a, Vec3_i16 b){
Full rewrite of panel layout system
2019-02-05 09:13:38 +00:00
return(a.x == b.x && a.y == b.y && a.z == b.z);
}
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
static b32
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
operator==(Vec4_i16 a, Vec4_i16 b){
return(a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w);
}
static b32
operator==(Vec2_i32 a, Vec2_i32 b){
return(a.x == b.x && a.y == b.y);
}
static b32
operator==(Vec3_i32 a, Vec3_i32 b){
return(a.x == b.x && a.y == b.y && a.z == b.z);
Full rewrite of panel layout system
2019-02-05 09:13:38 +00:00
}
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
static b32
Full rewrite of panel layout system
2019-02-05 09:13:38 +00:00
operator==(Vec4_i32 a, Vec4_i32 b){
return(a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w);
}
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
static b32
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
operator==(Vec2_f32 a, Vec2_f32 b){
return(a.x == b.x && a.y == b.y);
Full rewrite of panel layout system
2019-02-05 09:13:38 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static b32
operator==(Vec3_f32 a, Vec3_f32 b){
return(a.x == b.x && a.y == b.y && a.z == b.z);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static b32
operator==(Vec4_f32 a, Vec4_f32 b){
return(a.x == b.x && a.y == b.y && a.z == b.z && a.w == b.w);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static b32
operator!=(Vec2_i8 a, Vec2_i8 b){
return(a.x != b.x || a.y != b.y);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static b32
operator!=(Vec3_i8 a, Vec3_i8 b){
return(a.x != b.x || a.y != b.y || a.z != b.z);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static b32
operator!=(Vec4_i8 a, Vec4_i8 b){
return(a.x != b.x || a.y != b.y || a.z != b.z || a.w != b.w);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static b32
operator!=(Vec2_i16 a, Vec2_i16 b){
return(a.x != b.x || a.y != b.y);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static b32
operator!=(Vec3_i16 a, Vec3_i16 b){
return(a.x != b.x || a.y != b.y || a.z != b.z);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static b32
operator!=(Vec4_i16 a, Vec4_i16 b){
return(a.x != b.x || a.y != b.y || a.z != b.z || a.w != b.w);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static b32
operator!=(Vec2_i32 a, Vec2_i32 b){
return(a.x != b.x || a.y != b.y);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static b32
operator!=(Vec3_i32 a, Vec3_i32 b){
return(a.x != b.x || a.y != b.y || a.z != b.z);
}
static b32
operator!=(Vec4_i32 a, Vec4_i32 b){
return(a.x != b.x || a.y != b.y || a.z != b.z || a.w != b.w);
}
static b32
operator!=(Vec2_f32 a, Vec2_f32 b){
return(a.x != b.x || a.y != b.y);
}
static b32
operator!=(Vec3_f32 a, Vec3_f32 b){
return(a.x != b.x || a.y != b.y || a.z != b.z);
}
static b32
operator!=(Vec4_f32 a, Vec4_f32 b){
return(a.x != b.x || a.y != b.y || a.z != b.z || a.w != b.w);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
////////////////////////////////
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
static f32
scroll bar 99 ready
2016-03-31 04:05:47 +00:00
lerp(f32 a, f32 t, f32 b){
return(a + (b-a)*t);
}
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
static i32
scroll bar 99 ready
2016-03-31 04:05:47 +00:00
lerp(i32 a, f32 t, i32 b){
Setup basics for visible markers, fixed some stability issues
2018-09-17 18:47:06 +00:00
return((i32)(lerp((f32)a, t, (f32)b)));
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
static Vec2
scroll bar 99 ready
2016-03-31 04:05:47 +00:00
lerp(Vec2 a, f32 t, Vec2 b){
return(a + (b-a)*t);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
static Vec3
scroll bar 99 ready
2016-03-31 04:05:47 +00:00
lerp(Vec3 a, f32 t, Vec3 b){
return(a + (b-a)*t);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
static Vec4
scroll bar 99 ready
2016-03-31 04:05:47 +00:00
lerp(Vec4 a, f32 t, Vec4 b){
return(a + (b-a)*t);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
static f32
scroll bar 99 ready
2016-03-31 04:05:47 +00:00
unlerp(f32 a, f32 x, f32 b){
f32 r = x;
Full rewrite of panel layout system
2019-02-05 09:13:38 +00:00
if (b != a){
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
r = (x - a)/(b - a);
lots of organization to files, figured out a good way to solve the build.cpp string problem and set it up
2017-01-07 02:59:55 +00:00
}
scroll bar 99 ready
2016-03-31 04:05:47 +00:00
return(r);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
////////////////////////////////
setup the page loading on request, setup the rendering with the new system, still fixing bugs
2017-03-13 23:48:11 +00:00
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
// TODO(allen): Convert colors to Vec4
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
static u32
got new organization system working on linux
2017-01-23 06:19:43 +00:00
color_blend(u32 a, f32 t, u32 b){
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
union{
u8 byte[4];
u32 comp;
} A, B, R;
A.comp = a;
B.comp = b;
R.byte[0] = (u8)lerp(A.byte[0], t, B.byte[0]);
R.byte[1] = (u8)lerp(A.byte[1], t, B.byte[1]);
R.byte[2] = (u8)lerp(A.byte[2], t, B.byte[2]);
R.byte[3] = (u8)lerp(A.byte[3], t, B.byte[3]);
4coder Jamm 2
2019-02-25 23:42:13 +00:00
return(R.comp);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
static Vec3
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
unpack_color3(u32 color){
Vec3 result;
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
result.r = ((color >> 16) & 0xFF)/255.f;
result.g = ((color >> 8) & 0xFF)/255.f;
result.b = ((color >> 0) & 0xFF)/255.f;
4coder Jamm 2
2019-02-25 23:42:13 +00:00
return(result);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
static Vec4
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
unpack_color4(u32 color){
Vec4 result;
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
result.a = ((color >> 24) & 0xFF)/255.f;
result.r = ((color >> 16) & 0xFF)/255.f;
result.g = ((color >> 8) & 0xFF)/255.f;
result.b = ((color >> 0) & 0xFF)/255.f;
4coder Jamm 2
2019-02-25 23:42:13 +00:00
return(result);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
static u32
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
pack_color4(Vec4 color){
u32 result =
Setup basics for visible markers, fixed some stability issues
2018-09-17 18:47:06 +00:00
((u8)(color.a*255) << 24) |
((u8)(color.r*255) << 16) |
((u8)(color.g*255) << 8) |
((u8)(color.b*255) << 0);
4coder Jamm 2
2019-02-25 23:42:13 +00:00
return(result);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
static Vec4
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
rgba_to_hsla(Vec4 rgba){
Vec4 hsla = {};
got new organization system working on linux
2017-01-23 06:19:43 +00:00
f32 max, min, delta;
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
i32 maxc;
hsla.a = rgba.a;
max = rgba.r; min = rgba.r;
maxc = 0;
if (rgba.r < rgba.g){
max = rgba.g;
maxc = 1;
}
if (rgba.b > max){
max = rgba.b;
maxc = 2;
}
if (rgba.r > rgba.g){
min = rgba.g;
}
if (rgba.b < min){
min = rgba.b;
}
delta = max - min;
Setup basics for visible markers, fixed some stability issues
2018-09-17 18:47:06 +00:00
hsla.z = (max + min)*.5f;
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
if (delta == 0){
hsla.x = 0.f;
hsla.y = 0.f;
}
else{
switch (maxc){
lots of organization to files, figured out a good way to solve the build.cpp string problem and set it up
2017-01-07 02:59:55 +00:00
case 0:
{
hsla.x = (rgba.g - rgba.b) / delta;
Setup basics for visible markers, fixed some stability issues
2018-09-17 18:47:06 +00:00
hsla.x += (rgba.g < rgba.b)*6.f;
lots of organization to files, figured out a good way to solve the build.cpp string problem and set it up
2017-01-07 02:59:55 +00:00
}break;
case 1:
{
hsla.x = (rgba.b - rgba.r) / delta;
hsla.x += 2.f;
}break;
case 2:
{
hsla.x = (rgba.r - rgba.g) / delta;
hsla.x += 4.f;
}break;
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Setup basics for visible markers, fixed some stability issues
2018-09-17 18:47:06 +00:00
hsla.x *= (1/6.f); //*60 / 360
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
hsla.y = delta / (1.f - abs_f32(2.f*hsla.z - 1.f));
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
4coder Jamm 2
2019-02-25 23:42:13 +00:00
return(hsla);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
static Vec4
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
hsla_to_rgba(Vec4 hsla){
simplify gui scroll vars, switch things which should ints over to ints
2019-02-10 07:48:07 +00:00
if (hsla.h >= 1.f){
hsla.h = 0.f;
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
f32 C = (1.f - abs_f32(2*hsla.z - 1.f))*hsla.y;
f32 X = C*(1.f-abs_f32(mod_f32(hsla.x*6.f, 2)-1.f));
got new organization system working on linux
2017-01-23 06:19:43 +00:00
f32 m = hsla.z - C*.5f;
Setup basics for visible markers, fixed some stability issues
2018-09-17 18:47:06 +00:00
i32 H = floor32(hsla.x*6.f);
simplify gui scroll vars, switch things which should ints over to ints
2019-02-10 07:48:07 +00:00
Vec4 rgba = {};
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
rgba.a = hsla.a;
switch (H){
got new organization system working on linux
2017-01-23 06:19:43 +00:00
case 0: rgba.r = C; rgba.g = X; rgba.b = 0; break;
case 1: rgba.r = X; rgba.g = C; rgba.b = 0; break;
case 2: rgba.r = 0; rgba.g = C; rgba.b = X; break;
case 3: rgba.r = 0; rgba.g = X; rgba.b = C; break;
case 4: rgba.r = X; rgba.g = 0; rgba.b = C; break;
case 5: rgba.r = C; rgba.g = 0; rgba.b = X; break;
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
rgba.r += m;
rgba.g += m;
rgba.b += m;
got new organization system working on linux
2017-01-23 06:19:43 +00:00
return(rgba);
}
Key event buffer overflow crash fixed; switched draw_string over to Vec2 and returning the distance measured in deltas
2019-02-24 22:54:57 +00:00
////////////////////////////////
got new organization system working on linux
2017-01-23 06:19:43 +00:00
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Interval_i32
Ii32(i32 a, i32 b){
Interval_i32 interval = {a, b};
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
if (b < a){
interval.min = b;
interval.max = a;
}
return(interval);
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Interval_i64
Ii64(i64 a, i64 b){
Interval_i64 interval = {a, b};
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
if (b < a){
interval.min = b;
interval.max = a;
}
return(interval);
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Interval_u64
Iu64(u64 a, u64 b){
Interval_u64 interval = {a, b};
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
if (b < a){
interval.min = b;
interval.max = a;
}
return(interval);
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Interval_f32
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
If32(f32 a, f32 b){
Interval_f32 interval = {a, b};
if (b < a){
interval.min = b;
interval.max = a;
}
return(interval);
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Interval_i32
Ii32(i32 a){
Interval_i32 interval = {a, a};
return(interval);
}
internal Interval_i64
Ii64(i64 a){
Interval_i64 interval = {a, a};
return(interval);
}
internal Interval_u64
Iu64(u64 a){
Interval_u64 interval = {a, a};
return(interval);
}
internal Interval_f32
If32(f32 a){
Interval_f32 interval = {a, a};
return(interval);
}
#define make_range Ii32
#define make_range_i32 Ii32
#define make_range_i64 Ii64
#define make_range_u64 Iu64
#define make_range_f32 If32
internal Interval_i32
range_margin(Interval_i32 range, i32 margin){
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
range.min += margin;
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
range.max += margin;
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
return(range);
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Interval_i64
range_margin(Interval_i64 range, i64 margin){
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
range.min += margin;
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
range.max += margin;
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
return(range);
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Interval_u64
range_margin(Interval_u64 range, u64 margin){
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
range.min += margin;
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
range.max += margin;
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
return(range);
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Interval_f32
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
range_margin(Interval_f32 range, f32 margin){
range.min += margin;
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
range.max += margin;
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
return(range);
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal b32
range_overlap(Interval_i32 a, Interval_i32 b){
return(a.min < b.max && b.min < a.max);
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal b32
range_overlap(Interval_i64 a, Interval_i64 b){
return(a.min < b.max && b.min < a.max);
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal b32
range_overlap(Interval_u64 a, Interval_u64 b){
return(a.min < b.max && b.min < a.max);
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal b32
range_overlap(Interval_f32 a, Interval_f32 b){
return(a.min < b.max && b.min < a.max);
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal b32
range_contains(Interval_i32 a, i32 p){
return(a.min <= p && p < a.max);
text layout space conversions
2019-04-01 06:14:31 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal b32
range_contains(Interval_i64 a, i64 p){
return(a.min <= p && p < a.max);
text layout space conversions
2019-04-01 06:14:31 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal b32
range_contains(Interval_u64 a, u64 p){
return(a.min <= p && p < a.max);
Cleanup cleanup cleanup; shrinking api implementation file size mostly
2019-04-05 23:30:24 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal b32
range_contains(Interval_f32 a, f32 p){
return(a.min <= p && p < a.max);
text layout space conversions
2019-04-01 06:14:31 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal i32
range_size(Interval_i32 a){
i32 size = a.max - a.min;
size = clamp_bot(0, size);
return(size);
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal i64
range_size(Interval_i64 a){
i64 size = a.max - a.min;
size = clamp_bot(0, size);
return(size);
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal u64
range_size(Interval_u64 a){
u64 size = a.max - a.min;
size = clamp_bot(0, size);
return(size);
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal f32
range_size(Interval_f32 a){
f32 size = a.max - a.min;
size = clamp_bot(0, size);
return(size);
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Interval_i32
rectify(Interval_i32 a){
return(Ii32(a.min, a.max));
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Interval_i64
rectify(Interval_i64 a){
return(Ii64(a.min, a.max));
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Interval_u64
rectify(Interval_u64 a){
return(Iu64(a.min, a.max));
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Interval_f32
rectify(Interval_f32 a){
return(If32(a.min, a.max));
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Interval_i32
range_clamp_size(Interval_i32 a, i32 max_size){
i32 max = a.min + max_size;
a.max = clamp_top(a.max, max);
return(a);
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Interval_i64
range_clamp_size(Interval_i64 a, i64 max_size){
i64 max = a.min + max_size;
a.max = clamp_top(a.max, max);
return(a);
text layout space conversions
2019-04-01 06:14:31 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Interval_u64
range_clamp_size(Interval_u64 a, u64 max_size){
u64 max = a.min + max_size;
a.max = clamp_top(a.max, max);
return(a);
Buffer_Summary completely shifted into transition files
2019-04-05 02:03:36 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Interval_f32
range_clamp_size(Interval_f32 a, f32 max_size){
f32 max = a.min + max_size;
a.max = clamp_top(a.max, max);
return(a);
text layout space conversions
2019-04-01 06:14:31 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal b32
range_is_valid(Interval_i32 a){
return(a.min <= a.max);
text layout space conversions
2019-04-01 06:14:31 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal b32
range_is_valid(Interval_i64 a){
return(a.min <= a.max);
Buffer_Summary completely shifted into transition files
2019-04-05 02:03:36 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal b32
range_is_valid(Interval_u64 a){
return(a.min <= a.max);
}
internal b32
range_is_valid(Interval_f32 a){
return(a.min <= a.max);
Buffer_Summary completely shifted into transition files
2019-04-05 02:03:36 +00:00
}
Switching the API return method
2019-06-19 02:31:59 +00:00
internal i32
range_side(Interval_i32 a, Side side){
return(side == Side_Min?a.min:a.max);
}
internal i64
range_side(Interval_i64 a, Side side){
return(side == Side_Min?a.min:a.max);
}
internal u64
range_side(Interval_u64 a, Side side){
return(side == Side_Min?a.min:a.max);
}
internal f32
range_side(Interval_f32 a, Side side){
return(side == Side_Min?a.min:a.max);
}
Moving towards a much simpler 'search' system
2019-06-21 02:31:22 +00:00
internal i32
range_distance(Interval_i32 a, Interval_i32 b){
i32 result = 0;
if (!range_overlap(a, b)){
if (a.max < b.min){
result = b.min - a.max;
}
else{
result = a.min - b.max;
}
}
return(result);
}
internal i64
range_distance(Interval_i64 a, Interval_i64 b){
i64 result = 0;
if (!range_overlap(a, b)){
if (a.max < b.min){
result = b.min - a.max;
}
else{
result = a.min - b.max;
}
}
return(result);
}
internal u64
range_distance(Interval_u64 a, Interval_u64 b){
u64 result = 0;
if (!range_overlap(a, b)){
if (a.max < b.min){
result = b.min - a.max;
}
else{
result = a.min - b.max;
}
}
return(result);
}
internal f32
range_distance(Interval_f32 a, Interval_f32 b){
f32 result = 0;
if (!range_overlap(a, b)){
if (a.max < b.min){
result = b.min - a.max;
}
else{
result = a.min - b.max;
}
}
return(result);
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
////////////////////////////////
internal i32
Fixed the replace in range bug
2019-06-14 20:28:20 +00:00
replace_range_compute_shift(i32 replace_length, i32 insert_length){
return(insert_length - replace_length);
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal i32
replace_range_compute_shift(i32 start, i32 end, i32 insert_length){
return(insert_length - (end - start));
Cleanup cleanup cleanup; shrinking api implementation file size mostly
2019-04-05 23:30:24 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal i32
replace_range_compute_shift(Interval_i32 range, i32 insert_length){
return(insert_length - (range.end - range.start));
}
internal i64
replace_range_compute_shift(i64 replace_length, i64 insert_length){
return(insert_length - replace_length);
}
internal i64
replace_range_compute_shift(i64 start, i64 end, i64 insert_length){
return(insert_length - (end - start));
}
internal i64
replace_range_compute_shift(Interval_i64 range, i64 insert_length){
return(insert_length - (range.end - range.start));
Cleanup cleanup cleanup; shrinking api implementation file size mostly
2019-04-05 23:30:24 +00:00
}
Switching the API over to i64 and Range_i64 for positions inside buffers
2019-06-20 23:43:27 +00:00
internal i64
replace_range_compute_shift(u64 replace_length, u64 insert_length){
return((i64)insert_length - replace_length);
}
internal i64
replace_range_compute_shift(i64 start, i64 end, u64 insert_length){
return((i64)insert_length - (end - start));
}
internal i64
replace_range_compute_shift(Interval_i64 range, u64 insert_length){
return((i64)insert_length - (range.end - range.start));
}
Cleanup cleanup cleanup; shrinking api implementation file size mostly
2019-04-05 23:30:24 +00:00
text layout space conversions
2019-04-01 06:14:31 +00:00
////////////////////////////////
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Rect_i32
Ri32(i32 x0, i32 y0, i32 x1, i32 y1){
Rect_i32 rect = {x0, y0, x1, y1};
got new organization system working on linux
2017-01-23 06:19:43 +00:00
return(rect);
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Rect_f32
Rf32(f32 x0, f32 y0, f32 x1, f32 y1){
Rect_f32 rect = {x0, y0, x1, y1};
return(rect);
4coder Jamm 1
2019-02-24 07:22:16 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Rect_i32
Ri32(Vec2_i32 p0, Vec2_i32 p1){
Rect_i32 rect = {p0.x, p0.y, p1.x, p1.y};
Theme Preview Block UI Type
2018-08-07 09:08:01 +00:00
return(rect);
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Rect_f32
Rf32(Vec2_f32 p0, Vec2_f32 p1){
Rect_f32 rect = {p0.x, p0.y, p1.x, p1.y};
got new organization system working on linux
2017-01-23 06:19:43 +00:00
return(rect);
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Rect_i32
Ri32(Rect_f32 o){
Switching the API return method
2019-06-19 02:31:59 +00:00
Rect_i32 rect = {(i32)(o.x0), (i32)(o.y0), (i32)(o.x1), (i32)(o.y1)};
4coder Jamm 2
2019-02-25 23:42:13 +00:00
return(rect);
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Rect_f32
Rf32(Rect_i32 o){
Switching the API return method
2019-06-19 02:31:59 +00:00
Rect_f32 rect = {(f32)(o.x0), (f32)(o.y0), (f32)(o.x1), (f32)(o.y1)};
got new organization system working on linux
2017-01-23 06:19:43 +00:00
return(rect);
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
#define i32R Ri32
#define f32R Rf32
got new organization system working on linux
2017-01-23 06:19:43 +00:00
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Rect_i32
Ri32_xy_wh(i32 x0, i32 y0, i32 w, i32 h){
Rect_i32 rect = {x0, y0, x0 + w, y0 + h};
return(rect);
}
internal Rect_f32
Rf32_xy_wh(f32 x0, f32 y0, f32 w, f32 h){
Rect_f32 rect = {x0, y0, x0 + w, y0 + h};
return(rect);
4coder Jamm 2
2019-02-25 23:42:13 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Rect_i32
Ri32_xy_wh(Vec2_i32 p0, Vec2_i32 d){
Rect_i32 rect = {p0.x, p0.y, p0.x + d.x, p0.y + d.y};
return(rect);
}
internal Rect_f32
Rf32_xy_wh(Vec2_f32 p0, Vec2_f32 d){
Rect_f32 rect = {p0.x, p0.y, p0.x + d.x, p0.y + d.y};
return(rect);
4coder Jamm 2
2019-02-25 23:42:13 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
#define i32R_xy_wh
#define f32R_xy_wh
internal b32
rect_equals(Rect_i32 a, Rect_i32 b){
return(a.x0 == b.x0 && a.y0 == b.y0 && a.x1 == b.x1 && a.y1 == b.y1);
}
internal b32
rect_equals(Rect_f32 a, Rect_f32 b){
return(a.x0 == b.x0 && a.y0 == b.y0 && a.x1 == b.x1 && a.y1 == b.y1);
got new organization system working on linux
2017-01-23 06:19:43 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal b32
rect_contains_point(Rect_i32 a, Vec2_i32 b){
return(a.x0 <= b.x && b.x < a.x1 && a.y0 <= b.y && b.y < a.y1);
}
internal b32
rect_contains_point(Rect_f32 a, Vec2_f32 b){
return(a.x0 <= b.x && b.x < a.x1 && a.y0 <= b.y && b.y < a.y1);
4coder Jamm 2
2019-02-25 23:42:13 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Rect_i32
rect_inner(Rect_i32 r, i32 m){
r.x0 += m;
r.y0 += m;
r.x1 -= m;
r.y1 -= m;
4.0.15 various bug fixes, feature polish, added experimental scope command
2017-01-29 00:03:23 +00:00
return(r);
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Rect_f32
rect_inner(Rect_f32 r, f32 m){
r.x0 += m;
r.y0 += m;
r.x1 -= m;
r.y1 -= m;
4.0.15 various bug fixes, feature polish, added experimental scope command
2017-01-29 00:03:23 +00:00
return(r);
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Vec2_i32
rect_dim(Rect_i32 r){
Vec2_i32 v = {r.x1 - r.x0, r.y1 - r.y0};
return(v);
simplify gui scroll vars, switch things which should ints over to ints
2019-02-10 07:48:07 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal i32
rect_width(Rect_i32 r){
return(r.x1 - r.x0);
simplify gui scroll vars, switch things which should ints over to ints
2019-02-10 07:48:07 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal i32
rect_height(Rect_i32 r){
return(r.y1 - r.y0);
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Vec2_f32
rect_dim(Rect_f32 r){
Vec2_f32 v = {r.x1 - r.x0, r.y1 - r.y0};
return(v);
simplify gui scroll vars, switch things which should ints over to ints
2019-02-10 07:48:07 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal f32
rect_width(Rect_f32 r){
return(r.x1 - r.x0);
}
internal f32
rect_height(Rect_f32 r){
return(r.y1 - r.y0);
simplify gui scroll vars, switch things which should ints over to ints
2019-02-10 07:48:07 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Interval_i32
rect_range_x(Rect_i32 r){
return(Ii32(r.x0, r.x1));
}
internal Interval_i32
rect_range_y(Rect_i32 r){
return(Ii32(r.y0, r.y1));
}
internal Interval_f32
rect_range_x(Rect_f32 r){
return(If32(r.x0, r.x1));
}
internal Interval_f32
rect_range_y(Rect_f32 r){
return(If32(r.y0, r.y1));
Progress on GUI scrolling
2018-07-17 03:21:22 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal b32
rect_overlap(Rect_i32 a, Rect_i32 b){
return(range_overlap(rect_range_x(a), rect_range_x(b)) &&
range_overlap(rect_range_y(a), rect_range_y(b)));
}
internal b32
rect_overlap(Rect_f32 a, Rect_f32 b){
return(range_overlap(rect_range_x(a), rect_range_x(b)) &&
range_overlap(rect_range_y(a), rect_range_y(b)));
buffer space <-> layout space conversions; on screen range and height in text layout
2019-04-01 06:40:24 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Vec2_i32
rect_center(Rect_i32 r){
return(rect_dim(r)/2);
}
internal Vec2_f32
rect_center(Rect_f32 r){
return(rect_dim(r)/2);
Buffer_Summary completely shifted into transition files
2019-04-05 02:03:36 +00:00
}
#define center_of rect_center
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Rect_i32
rect_intersect(Rect_i32 a, Rect_i32 b){
a.x0 = Max(a.x0, b.x0);
a.y0 = Max(a.y0, b.y0);
a.x1 = Min(a.x1, b.x1);
a.y1 = Min(a.y1, b.y1);
return(a);
Clipboard, Process, and Cliprect Changes - Added clipboard change hook - Added Process_State query for getting the state of exec_system_command operations, retrieved via Get_Process_State - Added intersection_of and union_of for i32_Rect and f32_Rect - Fixed what I believe is a bug in the clipboard number updating in the win32 layer (it didn't used to record the new number correctly) - Added screen_space_to_view_space for Vec2 and f32_Rect - Made Draw_String return the ending point, as we decided - Added Draw_Clip_Push and Draw_Clip_Pop - Changed the behavior of Render_Push_Clip_Sig to allow input clipping rectangles to be anything, and they are simply intersected with the parent rectangle, rather than asserted to not go outside. -
2019-03-15 08:38:28 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Rect_i32
rect_union(Rect_i32 a, Rect_i32 b){
a.x0 = Min(a.x0, b.x0);
a.y0 = Min(a.y0, b.y0);
a.x1 = Max(a.x1, b.x1);
a.y1 = Max(a.y1, b.y1);
return(a);
Clipboard, Process, and Cliprect Changes - Added clipboard change hook - Added Process_State query for getting the state of exec_system_command operations, retrieved via Get_Process_State - Added intersection_of and union_of for i32_Rect and f32_Rect - Fixed what I believe is a bug in the clipboard number updating in the win32 layer (it didn't used to record the new number correctly) - Added screen_space_to_view_space for Vec2 and f32_Rect - Made Draw_String return the ending point, as we decided - Added Draw_Clip_Push and Draw_Clip_Pop - Changed the behavior of Render_Push_Clip_Sig to allow input clipping rectangles to be anything, and they are simply intersected with the parent rectangle, rather than asserted to not go outside. -
2019-03-15 08:38:28 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Rect_f32
rect_intersect(Rect_f32 a, Rect_f32 b){
a.x0 = Max(a.x0, b.x0);
a.y0 = Max(a.y0, b.y0);
a.x1 = Min(a.x1, b.x1);
a.y1 = Min(a.y1, b.y1);
return(a);
Clipboard, Process, and Cliprect Changes - Added clipboard change hook - Added Process_State query for getting the state of exec_system_command operations, retrieved via Get_Process_State - Added intersection_of and union_of for i32_Rect and f32_Rect - Fixed what I believe is a bug in the clipboard number updating in the win32 layer (it didn't used to record the new number correctly) - Added screen_space_to_view_space for Vec2 and f32_Rect - Made Draw_String return the ending point, as we decided - Added Draw_Clip_Push and Draw_Clip_Pop - Changed the behavior of Render_Push_Clip_Sig to allow input clipping rectangles to be anything, and they are simply intersected with the parent rectangle, rather than asserted to not go outside. -
2019-03-15 08:38:28 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
internal Rect_f32
rect_union(Rect_f32 a, Rect_f32 b){
a.x0 = Min(a.x0, b.x0);
a.y0 = Min(a.y0, b.y0);
a.x1 = Max(a.x1, b.x1);
a.y1 = Max(a.y1, b.y1);
return(a);
Clipboard, Process, and Cliprect Changes - Added clipboard change hook - Added Process_State query for getting the state of exec_system_command operations, retrieved via Get_Process_State - Added intersection_of and union_of for i32_Rect and f32_Rect - Fixed what I believe is a bug in the clipboard number updating in the win32 layer (it didn't used to record the new number correctly) - Added screen_space_to_view_space for Vec2 and f32_Rect - Made Draw_String return the ending point, as we decided - Added Draw_Clip_Push and Draw_Clip_Pop - Changed the behavior of Render_Push_Clip_Sig to allow input clipping rectangles to be anything, and they are simply intersected with the parent rectangle, rather than asserted to not go outside. -
2019-03-15 08:38:28 +00:00
}
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
#define intersection_of rect_intersect
#define union_of rect_union
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
////////////////////////////////
Deeply reorganizing code from seek.cpp; more 'enclose' operations
2019-06-09 21:05:57 +00:00
internal Scan_Direction
flip_direction(Scan_Direction direction){
switch (direction){
case Scan_Forward:
{
direction = Scan_Backward;
}break;
case Scan_Backward:
{
direction = Scan_Forward;
}break;
}
return(direction);
}
Generalizing the ideas of 'stop spots' and 'enclose' operations even more
2019-06-11 05:01:57 +00:00
internal Side
flip_side(Side side){
switch (side){
case Side_Min:
{
side = Side_Max;
}break;
case Side_Max:
{
side = Side_Min;
}break;
}
return(side);
}
Deeply reorganizing code from seek.cpp; more 'enclose' operations
2019-06-09 21:05:57 +00:00
////////////////////////////////
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static void*
base_reserve__noop(void *user_data, umem size, umem *size_out){
*size_out = 0;
return(0);
}
static void
base_commit__noop(void *user_data, void *ptr, umem size){}
static void
base_uncommit__noop(void *user_data, void *ptr, umem size){}
static void
base_free__noop(void *user_data, void *ptr){}
static void
base_set_access__noop(void *user_data, void *ptr, umem size, Access_Flag flags){}
static Base_Allocator
make_base_allocator(Base_Allocator_Reserve_Signature *func_reserve,
Base_Allocator_Commit_Signature *func_commit,
Base_Allocator_Uncommit_Signature *func_uncommit,
Base_Allocator_Free_Signature *func_free,
Base_Allocator_Set_Access_Signature *func_set_access,
void *user_data){
if (func_reserve == 0){
func_reserve = base_reserve__noop;
}
if (func_commit == 0){
func_commit = base_commit__noop;
}
if (func_uncommit == 0){
func_uncommit = base_uncommit__noop;
}
if (func_free == 0){
func_free = base_free__noop;
}
if (func_set_access == 0){
func_set_access = base_set_access__noop;
}
Base_Allocator base_allocator = {
func_reserve,
func_commit,
func_uncommit,
func_free,
func_set_access,
user_data,
};
return(base_allocator);
}
static Data
base_allocate(Base_Allocator *allocator, umem size){
umem full_size = 0;
void *memory = allocator->reserve(allocator->user_data, size, &full_size);
allocator->commit(allocator->user_data, memory, full_size);
return(make_data(memory, full_size));
}
static void
base_free(Base_Allocator *allocator, void *ptr){
allocator->free(allocator->user_data, ptr);
}
////////////////////////////////
static Cursor
make_cursor(void *base, umem size){
Cursor cursor = {(u8*)base, 0, size};
return(cursor);
}
static Cursor
make_cursor(Data data){
return(make_cursor(data.data, data.size));
}
static Cursor
make_cursor(Base_Allocator *allocator, umem size){
Data memory = base_allocate(allocator, size);
return(make_cursor(memory));
}
static Data
linalloc_push(Cursor *cursor, umem size){
Data result = {};
if (cursor->pos + size <= cursor->cap){
result.data = cursor->base + cursor->pos;
result.size = size;
cursor->pos += size;
}
return(result);
}
static void
linalloc_pop(Cursor *cursor, umem size){
if (cursor->pos > size){
cursor->pos -= size;
}
else{
cursor->pos = 0;
}
}
static Data
linalloc_align(Cursor *cursor, umem alignment){
umem pos = round_up_umem(cursor->pos, alignment);
umem new_size = pos - cursor->pos;
return(linalloc_push(cursor, new_size));
}
static Temp_Memory_Cursor
linalloc_begin_temp(Cursor *cursor){
Temp_Memory_Cursor temp = {cursor, cursor->pos};
return(temp);
}
static void
linalloc_end_temp(Temp_Memory_Cursor temp){
temp.cursor->pos = temp.pos;
}
static void
linalloc_clear(Cursor *cursor){
cursor->pos = 0;
}
static Arena
make_arena(Base_Allocator *allocator, umem chunk_size, umem alignment){
Arena arena = {allocator, 0, chunk_size, alignment};
return(arena);
}
static Arena
make_arena(Base_Allocator *allocator, umem chunk_size){
return(make_arena(allocator, chunk_size, 8));
}
static Arena
make_arena(Base_Allocator *allocator){
return(make_arena(allocator, KB(16), 8));
}
static Cursor_Node*
arena__new_node(Arena *arena, umem min_size){
min_size = clamp_bot(min_size, arena->chunk_size);
Data memory = base_allocate(arena->base_allocator, min_size + sizeof(Cursor_Node));
Cursor_Node *cursor_node = (Cursor_Node*)memory.data;
cursor_node->cursor = make_cursor(cursor_node + 1, memory.size - sizeof(Cursor_Node));
sll_stack_push(arena->cursor_node, cursor_node);
return(cursor_node);
}
static Data
linalloc_push(Arena *arena, umem size){
Data result = {};
if (size > 0){
Cursor_Node *cursor_node = arena->cursor_node;
if (cursor_node == 0){
cursor_node = arena__new_node(arena, size);
}
result = linalloc_push(&cursor_node->cursor, size);
if (result.data == 0){
cursor_node = arena__new_node(arena, size);
result = linalloc_push(&cursor_node->cursor, size);
}
Data alignment_data = linalloc_align(&cursor_node->cursor, arena->alignment);
result.size += alignment_data.size;
}
return(result);
}
static void
linalloc_pop(Arena *arena, umem size){
Base_Allocator *allocator = arena->base_allocator;
Cursor_Node *cursor_node = arena->cursor_node;
for (Cursor_Node *prev = 0;
cursor_node != 0 && size != 0;
cursor_node = prev){
prev = cursor_node->prev;
if (size >= cursor_node->cursor.pos){
size -= cursor_node->cursor.pos;
base_free(allocator, cursor_node);
}
else{
linalloc_pop(&cursor_node->cursor, size);
break;
}
}
arena->cursor_node = cursor_node;
}
static Data
linalloc_align(Arena *arena, umem alignment){
arena->alignment = alignment;
Data data = {};
Cursor_Node *cursor_node = arena->cursor_node;
if (cursor_node != 0){
data = linalloc_align(&cursor_node->cursor, arena->alignment);
}
return(data);
}
static Temp_Memory_Arena
linalloc_begin_temp(Arena *arena){
Cursor_Node *cursor_node = arena->cursor_node;
Temp_Memory_Arena temp = {arena, cursor_node,
cursor_node == 0?0:cursor_node->cursor.pos};
return(temp);
}
static void
linalloc_end_temp(Temp_Memory_Arena temp){
Base_Allocator *allocator = temp.arena->base_allocator;
Cursor_Node *cursor_node = temp.arena->cursor_node;
for (Cursor_Node *prev = 0;
cursor_node != temp.cursor_node && cursor_node != 0;
cursor_node = prev){
prev = cursor_node->prev;
base_free(allocator, cursor_node);
}
temp.arena->cursor_node = cursor_node;
if (cursor_node != 0){
if (temp.pos > 0){
cursor_node->cursor.pos = temp.pos;
}
else{
temp.arena->cursor_node = cursor_node->prev;
base_free(allocator, cursor_node);
}
}
}
static void
linalloc_clear(Arena *arena){
Temp_Memory_Arena temp = {arena, 0, 0};
linalloc_end_temp(temp);
}
static void
arena_tap(Arena *arena){
Cursor_Node *cursor_node = arena->cursor_node;
if (cursor_node == 0){
arena__new_node(arena, 0);
}
else if (cursor_node->cursor.pos == cursor_node->cursor.cap){
arena__new_node(arena, 0);
}
}
static Cursor*
arena_as_cursor(Arena *arena){
Cursor *cursor = 0;
arena_tap(arena);
Cursor_Node *node = arena->cursor_node;
if (node != 0){
cursor = &node->cursor;
}
return(cursor);
}
static void*
linalloc_wrap_unintialized(Data data){
return(data.data);
}
static void*
linalloc_wrap_zero(Data data){
block_zero(data.data, data.size);
return(data.data);
}
static void*
linalloc_wrap_write(Data data, umem size, void *src){
block_copy(data.data, src, clamp_top(data.size, size));
return(data.data);
}
#define push_array(a,T,c) ((T*)linalloc_wrap_unintialized(linalloc_push((a), sizeof(T)*(c))))
#define push_array_zero(a,T,c) ((T*)linalloc_wrap_zero(linalloc_push((a), sizeof(T)*(c))))
#define push_array_write(a,T,c,s) ((T*)linalloc_wrap_write(linalloc_push((a), sizeof(T)*(c)), sizeof(T)*(c), (s)))
#define pop_array(a,T,c) (linalloc_pop((a), sizeof(T)*(c)))
#define push_align(a,b) (linalloc_align((a), (b)))
#define push_align_zero(a,b) (linalloc_wrap_zero(linalloc_align((a), (b))))
static Temp_Memory
begin_temp(Cursor *cursor){
Temp_Memory temp = {LinearAllocatorKind_Cursor};
temp.temp_memory_cursor = linalloc_begin_temp(cursor);
return(temp);
}
static Temp_Memory
begin_temp(Arena *arena){
Temp_Memory temp = {LinearAllocatorKind_Arena};
temp.temp_memory_arena = linalloc_begin_temp(arena);
return(temp);
}
static void
end_temp(Temp_Memory temp){
switch (temp.kind){
case LinearAllocatorKind_Cursor:
{
linalloc_end_temp(temp.temp_memory_cursor);
}break;
case LinearAllocatorKind_Arena:
{
linalloc_end_temp(temp.temp_memory_arena);
}break;
}
}
////////////////////////////////
static Data
push_data(Arena *arena, umem size){
Data result = {};
result.data = push_array(arena, u8, size);
result.size = size;
return(result);
}
static Data
push_data_copy(Arena *arena, Data data){
Data result = {};
result.data = push_array_write(arena, u8, data.size, data.data);
result.size = data.size;
return(result);
}
static b32
data_match(Data a, Data b){
return(a.size == b.size && block_match(a.data, b.data, a.size));
}
////////////////////////////////
static b32
character_is_slash(char c){
return((c == '/') || (c == '\\'));
}
static b32
character_is_slash(u8 c){
return((c == '/') || (c == '\\'));
}
static b32
character_is_slash(u16 c){
return((c == '/') || (c == '\\'));
}
static b32
character_is_slash(u32 c){
return((c == '/') || (c == '\\'));
}
static b32
character_is_upper(char c){
return(('A' <= c) && (c <= 'Z'));
}
static b32
character_is_upper(u8 c){
return(('A' <= c) && (c <= 'Z'));
}
static b32
character_is_upper(u16 c){
return(('A' <= c) && (c <= 'Z'));
}
static b32
character_is_upper(u32 c){
return(('A' <= c) && (c <= 'Z'));
}
static b32
character_is_lower(char c){
return(('a' <= c) && (c <= 'z'));
}
static b32
character_is_lower(u8 c){
return(('a' <= c) && (c <= 'z'));
}
static b32
character_is_lower(u16 c){
return(('a' <= c) && (c <= 'z'));
}
static b32
character_is_lower(u32 c){
return(('a' <= c) && (c <= 'z'));
}
static b32
character_is_lower_unicode(u8 c){
return((('a' <= c) && (c <= 'z')) || c >= 128);
}
static b32
character_is_lower_unicode(u16 c){
return((('a' <= c) && (c <= 'z')) || c >= 128);
}
static b32
character_is_lower_unicode(u32 c){
return((('a' <= c) && (c <= 'z')) || c >= 128);
}
static char
character_to_upper(char c){
if (('a' <= c) && (c <= 'z')){
c -= 'a' - 'A';
}
return(c);
}
static u8
character_to_upper(u8 c){
if (('a' <= c) && (c <= 'z')){
c -= 'a' - 'A';
}
return(c);
}
static u16
character_to_upper(u16 c){
if (('a' <= c) && (c <= 'z')){
c -= 'a' - 'A';
}
return(c);
}
static u32
character_to_upper(u32 c){
if (('a' <= c) && (c <= 'z')){
c -= 'a' - 'A';
}
return(c);
}
static char
character_to_lower(char c){
if (('A' <= c) && (c <= 'Z')){
c += 'a' - 'A';
}
return(c);
}
static u8
character_to_lower(u8 c){
if (('A' <= c) && (c <= 'Z')){
c += 'a' - 'A';
}
return(c);
}
static u16
character_to_lower(u16 c){
if (('A' <= c) && (c <= 'Z')){
c += 'a' - 'A';
}
return(c);
}
static u32
character_to_lower(u32 c){
if (('A' <= c) && (c <= 'Z')){
c += 'a' - 'A';
}
return(c);
}
static b32
character_is_whitespace(char c){
return(c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == '\f' || c == '\v');
}
static b32
character_is_whitespace(u8 c){
return(c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == '\f' || c == '\v');
}
static b32
character_is_whitespace(u16 c){
return(c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == '\f' || c == '\v');
}
static b32
character_is_whitespace(u32 c){
return(c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == '\f' || c == '\v');
}
static b32
character_is_base10(char c){
return('0' <= c && c <= '9');
}
static b32
character_is_base10(u8 c){
return('0' <= c && c <= '9');
}
static b32
character_is_base10(u16 c){
return('0' <= c && c <= '9');
}
static b32
character_is_base10(u32 c){
return('0' <= c && c <= '9');
}
static b32
character_is_base16(char c){
return(('0' <= c && c <= '9') || ('A' <= c && c <= 'F'));
}
static b32
character_is_base16(u8 c){
return(('0' <= c && c <= '9') || ('A' <= c && c <= 'F'));
}
static b32
character_is_base16(u16 c){
return(('0' <= c && c <= '9') || ('A' <= c && c <= 'F'));
}
static b32
character_is_base16(u32 c){
return(('0' <= c && c <= '9') || ('A' <= c && c <= 'F'));
}
static b32
character_is_base64(char c){
return(('0' <= c && c <= '9') ||
('a' <= c && c <= 'z') ||
('A' <= c && c <= 'Z') ||
c == '_' || c == '$' || c == '?');
}
static b32
character_is_base64(u8 c){
return(('0' <= c && c <= '9') ||
('a' <= c && c <= 'z') ||
('A' <= c && c <= 'Z') ||
c == '_' || c == '$' || c == '?');
}
static b32
character_is_base64(u16 c){
return(('0' <= c && c <= '9') ||
('a' <= c && c <= 'z') ||
('A' <= c && c <= 'Z') ||
c == '_' || c == '$' || c == '?');
}
static b32
character_is_base64(u32 c){
return(('0' <= c && c <= '9') ||
('a' <= c && c <= 'z') ||
('A' <= c && c <= 'Z') ||
c == '_' || c == '$' || c == '?');
}
static b32
character_is_alpha(char c){
return( (('a' <= c) && (c <= 'z')) || (('A' <= c) && (c <= 'Z')) || c == '_');
}
static b32
character_is_alpha(u8 c){
return( (('a' <= c) && (c <= 'z')) || (('A' <= c) && (c <= 'Z')) || c == '_');
}
static b32
character_is_alpha(u16 c){
return( (('a' <= c) && (c <= 'z')) || (('A' <= c) && (c <= 'Z')) || c == '_');
}
static b32
character_is_alpha(u32 c){
return( (('a' <= c) && (c <= 'z')) || (('A' <= c) && (c <= 'Z')) || c == '_');
}
static b32
character_is_alpha_numeric(char c){
return((('a' <= c) && (c <= 'z')) || (('A' <= c) && (c <= 'Z')) || (('0' <= c) && (c <= '9')) || c == '_');
}
static b32
character_is_alpha_numeric(u8 c){
return((('a' <= c) && (c <= 'z')) || (('A' <= c) && (c <= 'Z')) || (('0' <= c) && (c <= '9')) || c == '_');
}
static b32
character_is_alpha_numeric(u16 c){
return((('a' <= c) && (c <= 'z')) || (('A' <= c) && (c <= 'Z')) || (('0' <= c) && (c <= '9')) || c == '_');
}
static b32
character_is_alpha_numeric(u32 c){
return((('a' <= c) && (c <= 'z')) || (('A' <= c) && (c <= 'Z')) || (('0' <= c) && (c <= '9')) || c == '_');
}
static b32
character_is_alpha_unicode(u8 c){
return( (('a' <= c) && (c <= 'z')) || (('A' <= c) && (c <= 'Z')) || c == '_' || c >= 128);
}
static b32
character_is_alpha_unicode(u16 c){
return( (('a' <= c) && (c <= 'z')) || (('A' <= c) && (c <= 'Z')) || c == '_' || c >= 128);
}
static b32
character_is_alpha_unicode(u32 c){
return( (('a' <= c) && (c <= 'z')) || (('A' <= c) && (c <= 'Z')) || c == '_' || c >= 128);
}
static b32
character_is_alpha_numeric_unicode(u8 c){
return((('a' <= c) && (c <= 'z')) || (('A' <= c) && (c <= 'Z')) || (('0' <= c) && (c <= '9')) || c == '_' || c >= 128);
}
static b32
character_is_alpha_numeric_unicode(u16 c){
return((('a' <= c) && (c <= 'z')) || (('A' <= c) && (c <= 'Z')) || (('0' <= c) && (c <= '9')) || c == '_' || c >= 128);
}
static b32
character_is_alpha_numeric_unicode(u32 c){
return((('a' <= c) && (c <= 'z')) || (('A' <= c) && (c <= 'Z')) || (('0' <= c) && (c <= '9')) || c == '_' || c >= 128);
}
static umem
cstring_length(char *str){
umem length = 0;
for (;str[length] != 0; length += 1);
return(length);
}
static umem
cstring_length(u8 *str){
umem length = 0;
for (;str[length] != 0; length += 1);
return(length);
}
static umem
cstring_length(u16 *str){
umem length = 0;
for (;str[length] != 0; length += 1);
return(length);
}
static umem
cstring_length(u32 *str){
umem length = 0;
for (;str[length] != 0; length += 1);
return(length);
}
static String_char
Schar(char *str, umem size, umem cap){
String_char string = {str, size, cap};
return(string);
}
static String_u8
Su8(u8 *str, umem size, umem cap){
String_u8 string = {str, size, cap};
return(string);
}
static String_u16
Su16(u16 *str, umem size, umem cap){
String_u16 string = {str, size, cap};
return(string);
}
static String_u32
Su32(u32 *str, umem size, umem cap){
String_u32 string = {str, size, cap};
return(string);
}
static String_Any
Sany(void *str, umem size, umem cap, String_Encoding encoding){
String_Any string = {encoding};
switch (encoding){
case StringEncoding_ASCII: string.s_char = Schar((char*)str, size, cap); break;
case StringEncoding_UTF8: string.s_u8 = Su8((u8*)str, size, cap); break;
case StringEncoding_UTF16: string.s_u16 = Su16((u16*)str, size, cap); break;
case StringEncoding_UTF32: string.s_u32 = Su32((u32*)str, size, cap); break;
}
return(string);
}
static String_char
Schar(char *str, umem size){
String_char string = {str, size, size + 1};
return(string);
}
static String_u8
Su8(u8 *str, umem size){
String_u8 string = {str, size, size + 1};
return(string);
}
static String_u16
Su16(u16 *str, umem size){
String_u16 string = {str, size, size + 1};
return(string);
}
static String_u32
Su32(u32 *str, umem size){
String_u32 string = {str, size, size + 1};
return(string);
}
static String_Any
Sany(void *str, umem size, String_Encoding encoding){
String_Any string = {encoding};
switch (encoding){
case StringEncoding_ASCII: string.s_char = Schar((char*)str, size); break;
case StringEncoding_UTF8: string.s_u8 = Su8((u8*)str, size); break;
case StringEncoding_UTF16: string.s_u16 = Su16((u16*)str, size); break;
case StringEncoding_UTF32: string.s_u32 = Su32((u32*)str, size); break;
}
return(string);
}
static String_char
Schar(char *str, char *one_past_last){
return(Schar(str, (umem)(one_past_last - str)));
}
static String_u8
Su8(u8 *str, u8 *one_past_last){
return(Su8(str, (umem)(one_past_last - str)));
}
static String_u16
Su16(u16 *str, u16 *one_past_last){
return(Su16(str, (umem)(one_past_last - str)));
}
static String_u32
Su32(u32 *str, u32 *one_past_last){
return(Su32(str, (umem)(one_past_last - str)));
}
static String_Any
Sany(void *str, void *one_past_last, String_Encoding encoding){
String_Any string = {encoding};
switch (encoding){
case StringEncoding_ASCII: string.s_char = Schar((char*)str, (char*)one_past_last); break;
case StringEncoding_UTF8: string.s_u8 = Su8((u8*)str, (u8*)one_past_last); break;
case StringEncoding_UTF16: string.s_u16 = Su16((u16*)str, (u16*)one_past_last); break;
case StringEncoding_UTF32: string.s_u32 = Su32((u32*)str, (u32*)one_past_last); break;
}
return(string);
}
static String_char
Schar(char *str){
umem size = cstring_length(str);
String_char string = {str, size, size + 1};
return(string);
}
static String_u8
Su8(u8 *str){
umem size = cstring_length(str);
String_u8 string = {str, size, size + 1};
return(string);
}
static String_u16
Su16(u16 *str){
umem size = cstring_length(str);
String_u16 string = {str, size, size + 1};
return(string);
}
static String_u32
Su32(u32 *str){
umem size = cstring_length(str);
String_u32 string = {str, size, size + 1};
return(string);
}
static String_Any
Sany(void *str, String_Encoding encoding){
String_Any string = {encoding};
switch (encoding){
case StringEncoding_ASCII: string.s_char = Schar((char*)str); break;
case StringEncoding_UTF8: string.s_u8 = Su8((u8*)str); break;
case StringEncoding_UTF16: string.s_u16 = Su16((u16*)str); break;
case StringEncoding_UTF32: string.s_u32 = Su32((u32*)str); break;
}
return(string);
}
static String_char
Schar(String_Const_char str, umem cap){
String_char string = {str.str, str.size, cap};
return(string);
}
static String_u8
Su8(String_Const_u8 str, umem cap){
String_u8 string = {str.str, str.size, cap};
return(string);
}
static String_u16
Su16(String_Const_u16 str, umem cap){
String_u16 string = {str.str, str.size, cap};
return(string);
}
static String_u32
Su32(String_Const_u32 str, umem cap){
String_u32 string = {str.str, str.size, cap};
return(string);
}
static String_Any
SCany(String_char str){
String_Any string = {StringEncoding_ASCII};
string.s_char = str;
return(string);
}
static String_Any
SCany(String_u8 str){
String_Any string = {StringEncoding_UTF8};
string.s_u8 = str;
return(string);
}
static String_Any
SCany(String_u16 str){
String_Any string = {StringEncoding_UTF16};
string.s_u16 = str;
return(string);
}
static String_Any
SCany(String_u32 str){
String_Any string = {StringEncoding_UTF32};
string.s_u32 = str;
return(string);
}
static String_Const_char
SCchar(char *str, umem size){
String_Const_char string = {str, size};
return(string);
}
static String_Const_u8
SCu8(u8 *str, umem size){
String_Const_u8 string = {str, size};
return(string);
}
static String_Const_u16
SCu16(u16 *str, umem size){
String_Const_u16 string = {str, size};
return(string);
}
static String_Const_u32
SCu32(u32 *str, umem size){
String_Const_u32 string = {str, size};
return(string);
}
static String_Const_Any
SCany(void *str, umem size, String_Encoding encoding){
String_Const_Any string = {encoding};
switch (encoding){
case StringEncoding_ASCII: string.s_char = SCchar((char*)str, size); break;
case StringEncoding_UTF8: string.s_u8 = SCu8((u8*)str, size); break;
case StringEncoding_UTF16: string.s_u16 = SCu16((u16*)str, size); break;
case StringEncoding_UTF32: string.s_u32 = SCu32((u32*)str, size); break;
}
return(string);
}
static String_Const_char
SCchar(void){
String_Const_char string = {};
return(string);
}
static String_Const_u8
SCu8(void){
String_Const_u8 string = {};
return(string);
}
static String_Const_u16
SCu16(void){
String_Const_u16 string = {};
return(string);
}
static String_Const_u32
SCu32(void){
String_Const_u32 string = {};
return(string);
}
static String_Const_char
SCchar(char *str, char *one_past_last){
return(SCchar(str, (umem)(one_past_last - str)));
}
static String_Const_u8
SCu8(u8 *str, u8 *one_past_last){
return(SCu8(str, (umem)(one_past_last - str)));
}
static String_Const_u16
SCu16(u16 *str, u16 *one_past_last){
return(SCu16(str, (umem)(one_past_last - str)));
}
static String_Const_u32
SCu32(u32 *str, u32 *one_past_last){
return(SCu32(str, (umem)(one_past_last - str)));
}
static String_Const_Any
SCany(void *str, void *one_past_last, String_Encoding encoding){
String_Const_Any string = {encoding};
switch (encoding){
case StringEncoding_ASCII: string.s_char = SCchar((char*)str, (char*)one_past_last); break;
case StringEncoding_UTF8: string.s_u8 = SCu8((u8*)str, (u8*)one_past_last); break;
case StringEncoding_UTF16: string.s_u16 = SCu16((u16*)str, (u16*)one_past_last); break;
case StringEncoding_UTF32: string.s_u32 = SCu32((u32*)str, (u32*)one_past_last); break;
}
return(string);
}
static String_Const_char
SCchar(char *str){
umem size = cstring_length(str);
String_Const_char string = {str, size};
return(string);
}
static String_Const_u8
SCu8(u8 *str){
umem size = cstring_length(str);
String_Const_u8 string = {str, size};
return(string);
}
static String_Const_u16
SCu16(u16 *str){
umem size = cstring_length(str);
String_Const_u16 string = {str, size};
return(string);
}
static String_Const_u32
SCu32(u32 *str){
umem size = cstring_length(str);
String_Const_u32 string = {str, size};
return(string);
}
static String_Const_char
SCchar(String_Const_u8 str){
return(SCchar((char*)str.str, str.size));
}
static String_Const_u8
SCu8(String_Const_char str){
return(SCu8((u8*)str.str, str.size));
}
unifying use of working_set's table
2016-02-07 21:15:58 +00:00
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static String_Const_u8
SCu8(char *str, umem length){
return(SCu8((u8*)str, length));
}
static String_Const_u8
SCu8(char *first, char *one_past_last){
return(SCu8((u8*)first, (u8*)one_past_last));
}
static String_Const_u8
SCu8(char *str){
return(SCu8((u8*)str));
}
static String_Const_u8
SCu8(Data data){
return(SCu8((u8*)data.data, data.size));
}
static String_Const_u16
SCu16(wchar_t *str, umem size){
return(SCu16((u16*)str, size));
}
static String_Const_u16
SCu16(wchar_t *str){
return(SCu16((u16*)str));
}
static String_Const_Any
SCany(void *str, String_Encoding encoding){
String_Const_Any string = {encoding};
switch (encoding){
case StringEncoding_ASCII: string.s_char = SCchar((char*)str); break;
case StringEncoding_UTF8: string.s_u8 = SCu8((u8*)str); break;
case StringEncoding_UTF16: string.s_u16 = SCu16((u16*)str); break;
case StringEncoding_UTF32: string.s_u32 = SCu32((u32*)str); break;
}
return(string);
}
static String_Const_Any
SCany(String_Const_char str){
String_Const_Any string = {StringEncoding_ASCII};
string.s_char = str;
return(string);
}
static String_Const_Any
SCany(String_Const_u8 str){
String_Const_Any string = {StringEncoding_UTF8};
string.s_u8 = str;
return(string);
}
static String_Const_Any
SCany(String_Const_u16 str){
String_Const_Any string = {StringEncoding_UTF16};
string.s_u16 = str;
return(string);
}
static String_Const_Any
SCany(String_Const_u32 str){
String_Const_Any string = {StringEncoding_UTF32};
string.s_u32 = str;
return(string);
}
#define string_litexpr(s) SCchar((s), sizeof(s) - 1)
#define string_litinit(s) {(s), sizeof(s) - 1}
#define string_u8_litexpr(s) SCu8((u8*)(s), sizeof(s) - 1)
#define string_u8_litinit(s) {(u8*)(s), sizeof(s) - 1}
#define string_expand(s) (i32)(s).size, (char*)(s).str
Switching the API over to i64 and Range_i64 for positions inside buffers
2019-06-20 23:43:27 +00:00
static String_Const_char string_empty = {"", 0};
static String_Const_u8 string_u8_empty = {"", 0};
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static char
string_get_character(String_Const_char str, umem i){
char r = 0;
if (i < str.size){
r = str.str[i];
}
return(r);
}
static u8
string_get_character(String_Const_u8 str, umem i){
u8 r = 0;
if (i < str.size){
r = str.str[i];
}
return(r);
}
static u16
string_get_character(String_Const_u16 str, umem i){
u16 r = 0;
if (i < str.size){
r = str.str[i];
}
return(r);
}
static u32
string_get_character(String_Const_u32 str, umem i){
u32 r = 0;
if (i < str.size){
r = str.str[i];
}
return(r);
}
static String_Const_char
string_prefix(String_Const_char str, umem size){
size = clamp_top(size, str.size);
str.size = size;
return(str);
}
static String_Const_u8
string_prefix(String_Const_u8 str, umem size){
size = clamp_top(size, str.size);
str.size = size;
return(str);
}
static String_Const_u16
string_prefix(String_Const_u16 str, umem size){
size = clamp_top(size, str.size);
str.size = size;
return(str);
}
static String_Const_u32
string_prefix(String_Const_u32 str, umem size){
size = clamp_top(size, str.size);
str.size = size;
return(str);
}
static String_Const_Any
string_prefix(String_Const_Any str, umem size){
switch (str.encoding){
case StringEncoding_ASCII: str.s_char = string_prefix(str.s_char, size); break;
case StringEncoding_UTF8: str.s_u8 = string_prefix(str.s_u8 , size); break;
case StringEncoding_UTF16: str.s_u16 = string_prefix(str.s_u16 , size); break;
case StringEncoding_UTF32: str.s_u32 = string_prefix(str.s_u32 , size); break;
}
return(str);
}
static String_Const_char
string_postfix(String_Const_char str, umem size){
size = clamp_top(size, str.size);
str.str += (str.size - size);
str.size = size;
return(str);
}
static String_Const_u8
string_postfix(String_Const_u8 str, umem size){
size = clamp_top(size, str.size);
str.str += (str.size - size);
str.size = size;
return(str);
}
static String_Const_u16
string_postfix(String_Const_u16 str, umem size){
size = clamp_top(size, str.size);
str.str += (str.size - size);
str.size = size;
return(str);
}
static String_Const_u32
string_postfix(String_Const_u32 str, umem size){
size = clamp_top(size, str.size);
str.str += (str.size - size);
str.size = size;
return(str);
}
static String_Const_Any
string_postfix(String_Const_Any str, umem size){
switch (str.encoding){
case StringEncoding_ASCII: str.s_char = string_postfix(str.s_char, size); break;
case StringEncoding_UTF8: str.s_u8 = string_postfix(str.s_u8 , size); break;
case StringEncoding_UTF16: str.s_u16 = string_postfix(str.s_u16 , size); break;
case StringEncoding_UTF32: str.s_u32 = string_postfix(str.s_u32 , size); break;
}
return(str);
}
static String_Const_char
string_skip(String_Const_char str, umem n){
n = clamp_top(n, str.size);
str.str += n;;
str.size -= n;
return(str);
}
static String_Const_u8
string_skip(String_Const_u8 str, umem n){
n = clamp_top(n, str.size);
str.str += n;;
str.size -= n;
return(str);
}
static String_Const_u16
string_skip(String_Const_u16 str, umem n){
n = clamp_top(n, str.size);
str.str += n;;
str.size -= n;
return(str);
}
static String_Const_u32
string_skip(String_Const_u32 str, umem n){
n = clamp_top(n, str.size);
str.str += n;;
str.size -= n;
return(str);
}
static String_Const_Any
string_skip(String_Const_Any str, umem n){
switch (str.encoding){
case StringEncoding_ASCII: str.s_char = string_skip(str.s_char, n); break;
case StringEncoding_UTF8: str.s_u8 = string_skip(str.s_u8 , n); break;
case StringEncoding_UTF16: str.s_u16 = string_skip(str.s_u16 , n); break;
case StringEncoding_UTF32: str.s_u32 = string_skip(str.s_u32 , n); break;
}
return(str);
}
static String_Const_char
string_chop(String_Const_char str, umem n){
n = clamp_top(n, str.size);
str.size -= n;
return(str);
}
static String_Const_u8
string_chop(String_Const_u8 str, umem n){
n = clamp_top(n, str.size);
str.size -= n;
return(str);
}
static String_Const_u16
string_chop(String_Const_u16 str, umem n){
n = clamp_top(n, str.size);
str.size -= n;
return(str);
}
static String_Const_u32
string_chop(String_Const_u32 str, umem n){
n = clamp_top(n, str.size);
str.size -= n;
return(str);
}
static String_Const_Any
string_chop(String_Const_Any str, umem n){
switch (str.encoding){
case StringEncoding_ASCII: str.s_char = string_chop(str.s_char, n); break;
case StringEncoding_UTF8: str.s_u8 = string_chop(str.s_u8 , n); break;
case StringEncoding_UTF16: str.s_u16 = string_chop(str.s_u16 , n); break;
case StringEncoding_UTF32: str.s_u32 = string_chop(str.s_u32 , n); break;
}
return(str);
}
Switching the API over to i64 and Range_i64 for positions inside buffers
2019-06-20 23:43:27 +00:00
static String_Const_char
string_substring(String_Const_char str, Range_i64 range){
return(SCchar(str.str + range.min, str.str + range.max));
}
static String_Const_u8
string_substring(String_Const_u8 str, Range_i64 range){
return(SCu8(str.str + range.min, str.str + range.max));
}
static String_Const_u16
string_substring(String_Const_u16 str, Range_i64 range){
return(SCu16(str.str + range.min, str.str + range.max));
}
static String_Const_u32
string_substring(String_Const_u32 str, Range_i64 range){
return(SCu32(str.str + range.min, str.str + range.max));
}
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
static umem
string_find_first(String_Const_char str, char c){
umem i = 0;
for (;i < str.size && c != str.str[i]; i += 1);
return(i);
}
static umem
string_find_first(String_Const_u8 str, u8 c){
umem i = 0;
for (;i < str.size && c != str.str[i]; i += 1);
return(i);
}
static umem
string_find_first(String_Const_u16 str, u16 c){
umem i = 0;
for (;i < str.size && c != str.str[i]; i += 1);
return(i);
}
static umem
string_find_first(String_Const_u32 str, u32 c){
umem i = 0;
for (;i < str.size && c != str.str[i]; i += 1);
return(i);
}
static imem
string_find_last(String_Const_char str, char c){
imem size = (imem)str.size;
imem i = size - 1;
for (;i >= 0 && c != str.str[i]; i -= 1);
return(i);
}
static imem
string_find_last(String_Const_u8 str, u8 c){
imem size = (imem)str.size;
imem i = size - 1;
for (;i >= 0 && c != str.str[i]; i -= 1);
return(i);
}
static imem
string_find_last(String_Const_u16 str, u16 c){
imem size = (imem)str.size;
imem i = size - 1;
for (;i >= 0 && c != str.str[i]; i -= 1);
return(i);
}
static imem
string_find_last(String_Const_u32 str, u32 c){
imem size = (imem)str.size;
imem i = size - 1;
for (;i >= 0 && c != str.str[i]; i -= 1);
return(i);
}
static umem
string_find_first_non_whitespace(String_Const_char str){
umem i = 0;
for (;i < str.size && character_is_whitespace(str.str[i]); i += 1);
return(i);
}
static umem
string_find_first_non_whitespace(String_Const_u8 str){
umem i = 0;
for (;i < str.size && character_is_whitespace(str.str[i]); i += 1);
return(i);
}
static umem
string_find_first_non_whitespace(String_Const_u16 str){
umem i = 0;
for (;i < str.size && character_is_whitespace(str.str[i]); i += 1);
return(i);
}
static umem
string_find_first_non_whitespace(String_Const_u32 str){
umem i = 0;
for (;i < str.size && character_is_whitespace(str.str[i]); i += 1);
return(i);
}
static imem
string_find_last_non_whitespace(String_Const_char str){
imem size = (imem)str.size;
imem i = size - 1;
for (;i >= 0 && character_is_whitespace(str.str[i]); i -= 1);
return(i);
}
static imem
string_find_last_non_whitespace(String_Const_u8 str){
imem size = (imem)str.size;
imem i = size - 1;
for (;i >= 0 && character_is_whitespace(str.str[i]); i -= 1);
return(i);
}
static imem
string_find_last_non_whitespace(String_Const_u16 str){
imem size = (imem)str.size;
imem i = size - 1;
for (;i >= 0 && character_is_whitespace(str.str[i]); i -= 1);
return(i);
}
static imem
string_find_last_non_whitespace(String_Const_u32 str){
imem size = (imem)str.size;
imem i = size - 1;
for (;i >= 0 && character_is_whitespace(str.str[i]); i -= 1);
return(i);
}
static umem
string_find_first_slash(String_Const_char str){
umem i = 0;
for (;i < str.size && !character_is_slash(str.str[i]); i += 1);
return(i);
}
static umem
string_find_first_slash(String_Const_u8 str){
umem i = 0;
for (;i < str.size && !character_is_slash(str.str[i]); i += 1);
return(i);
}
static umem
string_find_first_slash(String_Const_u16 str){
umem i = 0;
for (;i < str.size && !character_is_slash(str.str[i]); i += 1);
Extended String_Match struct; regularized range and rect type code
2019-06-18 04:47:00 +00:00
return(i);
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
}
static umem
string_find_first_slash(String_Const_u32 str){
umem i = 0;
for (;i < str.size && !character_is_slash(str.str[i]); i += 1);
return(i);
}
static imem
string_find_last_slash(String_Const_char str){
imem size = (imem)str.size;
imem i = size - 1;
for (;i >= 0 && !character_is_slash(str.str[i]); i -= 1);
return(i);
}
static imem
string_find_last_slash(String_Const_u8 str){
imem size = (imem)str.size;
imem i = size - 1;
for (;i >= 0 && !character_is_slash(str.str[i]); i -= 1);
return(i);
}
static imem
string_find_last_slash(String_Const_u16 str){
imem size = (imem)str.size;
imem i = size - 1;
for (;i >= 0 && !character_is_slash(str.str[i]); i -= 1);
return(i);
}
static imem
string_find_last_slash(String_Const_u32 str){
imem size = (imem)str.size;
imem i = size - 1;
for (;i >= 0 && !character_is_slash(str.str[i]); i -= 1);
return(i);
}
static String_Const_char
string_remove_last_folder(String_Const_char str){
if (str.size > 0){
str.size -= 1;
}
imem slash_pos = string_find_last_slash(str);
if (slash_pos < 0){
str.size = 0;
}
else{
str.size = slash_pos + 1;
}
return(str);
}
static String_Const_u8
string_remove_last_folder(String_Const_u8 str){
if (str.size > 0){
str.size -= 1;
}
imem slash_pos = string_find_last_slash(str);
if (slash_pos < 0){
str.size = 0;
}
else{
str.size = slash_pos + 1;
}
return(str);
}
static String_Const_u16
string_remove_last_folder(String_Const_u16 str){
if (str.size > 0){
str.size -= 1;
}
imem slash_pos = string_find_last_slash(str);
if (slash_pos < 0){
str.size = 0;
}
else{
str.size = slash_pos + 1;
}
return(str);
}
static String_Const_u32
string_remove_last_folder(String_Const_u32 str){
if (str.size > 0){
str.size -= 1;
}
imem slash_pos = string_find_last_slash(str);
if (slash_pos < 0){
str.size = 0;
}
else{
str.size = slash_pos + 1;
}
return(str);
}
static String_Const_char
string_front_of_path(String_Const_char str){
imem slash_pos = string_find_last_slash(str);
if (slash_pos >= 0){
str = string_skip(str, slash_pos + 1);
}
return(str);
}
static String_Const_u8
string_front_of_path(String_Const_u8 str){
imem slash_pos = string_find_last_slash(str);
if (slash_pos >= 0){
str = string_skip(str, slash_pos + 1);
}
return(str);
}
static String_Const_u16
string_front_of_path(String_Const_u16 str){
imem slash_pos = string_find_last_slash(str);
if (slash_pos >= 0){
str = string_skip(str, slash_pos + 1);
}
return(str);
}
static String_Const_u32
string_front_of_path(String_Const_u32 str){
imem slash_pos = string_find_last_slash(str);
if (slash_pos >= 0){
str = string_skip(str, slash_pos + 1);
}
return(str);
}
static String_Const_char
string_file_extension(String_Const_char string){
return(string_skip(string, string_find_last(string, '.') + 1));
}
static String_Const_u8
string_file_extension(String_Const_u8 string){
return(string_skip(string, string_find_last(string, '.') + 1));
}
static String_Const_u16
string_file_extension(String_Const_u16 string){
return(string_skip(string, string_find_last(string, '.') + 1));
}
static String_Const_u32
string_file_extension(String_Const_u32 string){
return(string_skip(string, string_find_last(string, '.') + 1));
}
static String_Const_char
string_file_without_extension(String_Const_char string){
imem pos = string_find_last(string, '.');
if (pos > 0){
string = string_prefix(string, pos);
}
return(string);
}
static String_Const_u8
string_file_without_extension(String_Const_u8 string){
imem pos = string_find_last(string, '.');
if (pos > 0){
string = string_prefix(string, pos);
}
return(string);
}
static String_Const_u16
string_file_without_extension(String_Const_u16 string){
imem pos = string_find_last(string, '.');
if (pos > 0){
string = string_prefix(string, pos);
}
return(string);
}
static String_Const_u32
string_file_without_extension(String_Const_u32 string){
imem pos = string_find_last(string, '.');
if (pos > 0){
string = string_prefix(string, pos);
}
return(string);
}
static String_Const_char
string_skip_whitespace(String_Const_char str){
umem f = string_find_first_non_whitespace(str);
str = string_skip(str, f);
return(str);
}
static String_Const_u8
string_skip_whitespace(String_Const_u8 str){
umem f = string_find_first_non_whitespace(str);
str = string_skip(str, f);
return(str);
}
static String_Const_u16
string_skip_whitespace(String_Const_u16 str){
umem f = string_find_first_non_whitespace(str);
str = string_skip(str, f);
return(str);
}
static String_Const_u32
string_skip_whitespace(String_Const_u32 str){
umem f = string_find_first_non_whitespace(str);
str = string_skip(str, f);
return(str);
}
static String_Const_char
string_chop_whitespace(String_Const_char str){
imem e = string_find_last_non_whitespace(str);
str = string_prefix(str, (umem)(e + 1));
return(str);
}
static String_Const_u8
string_chop_whitespace(String_Const_u8 str){
imem e = string_find_last_non_whitespace(str);
str = string_prefix(str, (umem)(e + 1));
return(str);
}
static String_Const_u16
string_chop_whitespace(String_Const_u16 str){
imem e = string_find_last_non_whitespace(str);
str = string_prefix(str, (umem)(e + 1));
return(str);
}
static String_Const_u32
string_chop_whitespace(String_Const_u32 str){
imem e = string_find_last_non_whitespace(str);
str = string_prefix(str, (umem)(e + 1));
return(str);
}
static String_Const_char
string_skip_chop_whitespace(String_Const_char str){
umem f = string_find_first_non_whitespace(str);
str = string_skip(str, f);
imem e = string_find_last_non_whitespace(str);
str = string_prefix(str, (umem)(e + 1));
return(str);
}
static String_Const_u8
string_skip_chop_whitespace(String_Const_u8 str){
umem f = string_find_first_non_whitespace(str);
str = string_skip(str, f);
imem e = string_find_last_non_whitespace(str);
str = string_prefix(str, (umem)(e + 1));
return(str);
}
static String_Const_u16
string_skip_chop_whitespace(String_Const_u16 str){
umem f = string_find_first_non_whitespace(str);
str = string_skip(str, f);
imem e = string_find_last_non_whitespace(str);
str = string_prefix(str, (umem)(e + 1));
return(str);
}
static String_Const_u32
string_skip_chop_whitespace(String_Const_u32 str){
umem f = string_find_first_non_whitespace(str);
str = string_skip(str, f);
imem e = string_find_last_non_whitespace(str);
str = string_prefix(str, (umem)(e + 1));
return(str);
}
static b32
string_match(String_Const_char a, String_Const_char b){
b32 result = false;
if (a.size == b.size){
result = true;
for (umem i = 0; i < a.size; i += 1){
if (a.str[i] != b.str[i]){
result = false;
break;
}
}
}
return(result);
}
static b32
string_match(String_Const_u8 a, String_Const_u8 b){
b32 result = false;
if (a.size == b.size){
result = true;
for (umem i = 0; i < a.size; i += 1){
if (a.str[i] != b.str[i]){
result = false;
break;
}
}
}
return(result);
}
static b32
string_match(String_Const_u16 a, String_Const_u16 b){
b32 result = false;
if (a.size == b.size){
result = true;
for (umem i = 0; i < a.size; i += 1){
if (a.str[i] != b.str[i]){
result = false;
break;
}
}
}
return(result);
}
static b32
string_match(String_Const_u32 a, String_Const_u32 b){
b32 result = false;
if (a.size == b.size){
result = true;
for (umem i = 0; i < a.size; i += 1){
if (a.str[i] != b.str[i]){
result = false;
break;
}
}
}
return(result);
}
static b32
string_match(String_Const_Any a, String_Const_Any b){
b32 result = false;
if (a.encoding == b.encoding){
switch (a.encoding){
case StringEncoding_ASCII: result = string_match(a.s_char, b.s_char); break;
case StringEncoding_UTF8: result = string_match(a.s_u8 , b.s_u8 ); break;
case StringEncoding_UTF16: result = string_match(a.s_u16 , b.s_u16 ); break;
case StringEncoding_UTF32: result = string_match(a.s_u32 , b.s_u32 ); break;
}
}
return(result);
}
static b32
string_match_insensitive(String_Const_char a, String_Const_char b){
b32 result = false;
if (a.size == b.size){
result = true;
for (umem i = 0; i < a.size; i += 1){
if (character_to_upper(a.str[i]) != character_to_upper(b.str[i])){
result = false;
break;
}
}
}
return(result);
}
static b32
string_match_insensitive(String_Const_u8 a, String_Const_u8 b){
b32 result = false;
if (a.size == b.size){
result = true;
for (umem i = 0; i < a.size; i += 1){
if (character_to_upper(a.str[i]) != character_to_upper(b.str[i])){
result = false;
break;
}
}
}
return(result);
}
static b32
string_match_insensitive(String_Const_u16 a, String_Const_u16 b){
b32 result = false;
if (a.size == b.size){
result = true;
for (umem i = 0; i < a.size; i += 1){
if (character_to_upper(a.str[i]) != character_to_upper(b.str[i])){
result = false;
break;
}
}
}
return(result);
}
static b32
string_match_insensitive(String_Const_u32 a, String_Const_u32 b){
b32 result = false;
if (a.size == b.size){
result = true;
for (umem i = 0; i < a.size; i += 1){
if (character_to_upper(a.str[i]) != character_to_upper(b.str[i])){
result = false;
break;
}
}
}
return(result);
}
static b32
string_match(String_Const_char a, String_Const_char b, String_Match_Rule rule){
b32 result = false;
switch (rule){
case StringMatch_Exact:
{
result = string_match(a, b);
}break;
case StringMatch_CaseInsensitive:
{
result = string_match_insensitive(a, b);
}break;
}
return(result);
}
static b32
string_match(String_Const_u8 a, String_Const_u8 b, String_Match_Rule rule){
b32 result = false;
switch (rule){
case StringMatch_Exact:
{
result = string_match(a, b);
}break;
case StringMatch_CaseInsensitive:
{
result = string_match_insensitive(a, b);
}break;
}
return(result);
}
static b32
string_match(String_Const_u16 a, String_Const_u16 b, String_Match_Rule rule){
b32 result = false;
switch (rule){
case StringMatch_Exact:
{
result = string_match(a, b);
}break;
case StringMatch_CaseInsensitive:
{
result = string_match_insensitive(a, b);
}break;
}
return(result);
}
static b32
string_match(String_Const_u32 a, String_Const_u32 b, String_Match_Rule rule){
b32 result = false;
switch (rule){
case StringMatch_Exact:
{
result = string_match(a, b);
}break;
case StringMatch_CaseInsensitive:
{
result = string_match_insensitive(a, b);
}break;
}
return(result);
}
static umem
string_find_first(String_Const_char str, String_Const_char needle, String_Match_Rule rule){
umem i = 0;
if (needle.size > 0){
i = str.size;
if (str.size >= needle.size){
i = 0;
umem one_past_last = str.size - needle.size + 1;
for (;i < one_past_last; i += 1){
if (str.str[i] == needle.str[0]){
String_Const_char source_part = string_prefix(string_skip(str, i), needle.size);
if (string_match(source_part, needle, rule)){
break;
}
}
}
if (i == one_past_last){
i = str.size;
}
}
}
return(i);
}
static umem
string_find_first(String_Const_u8 str, String_Const_u8 needle, String_Match_Rule rule){
umem i = 0;
if (needle.size > 0){
i = str.size;
if (str.size >= needle.size){
i = 0;
umem one_past_last = str.size - needle.size + 1;
for (;i < one_past_last; i += 1){
if (str.str[i] == needle.str[0]){
String_Const_u8 source_part = string_prefix(string_skip(str, i), needle.size);
if (string_match(source_part, needle, rule)){
break;
}
}
}
if (i == one_past_last){
i = str.size;
}
}
}
return(i);
}
static umem
string_find_first(String_Const_u16 str, String_Const_u16 needle, String_Match_Rule rule){
umem i = 0;
if (needle.size > 0){
i = str.size;
if (str.size >= needle.size){
i = 0;
umem one_past_last = str.size - needle.size + 1;
for (;i < one_past_last; i += 1){
if (str.str[i] == needle.str[0]){
String_Const_u16 source_part = string_prefix(string_skip(str, i), needle.size);
if (string_match(source_part, needle, rule)){
break;
}
}
}
if (i == one_past_last){
i = str.size;
}
}
}
return(i);
}
static umem
string_find_first(String_Const_u32 str, String_Const_u32 needle, String_Match_Rule rule){
umem i = 0;
if (needle.size > 0){
i = str.size;
if (str.size >= needle.size){
i = 0;
umem one_past_last = str.size - needle.size + 1;
for (;i < one_past_last; i += 1){
if (str.str[i] == needle.str[0]){
String_Const_u32 source_part = string_prefix(string_skip(str, i), needle.size);
if (string_match(source_part, needle, rule)){
break;
}
}
}
if (i == one_past_last){
i = str.size;
}
}
}
return(i);
}
static umem
string_find_first(String_Const_char str, String_Const_char needle){
return(string_find_first(str, needle, StringMatch_Exact));
}
static umem
string_find_first(String_Const_u8 str, String_Const_u8 needle){
return(string_find_first(str, needle, StringMatch_Exact));
}
static umem
string_find_first(String_Const_u16 str, String_Const_u16 needle){
return(string_find_first(str, needle, StringMatch_Exact));
}
static umem
string_find_first(String_Const_u32 str, String_Const_u32 needle){
return(string_find_first(str, needle, StringMatch_Exact));
}
static umem
string_find_first_insensitive(String_Const_char str, String_Const_char needle){
return(string_find_first(str, needle, StringMatch_CaseInsensitive));
}
static umem
string_find_first_insensitive(String_Const_u8 str, String_Const_u8 needle){
return(string_find_first(str, needle, StringMatch_CaseInsensitive));
}
static umem
string_find_first_insensitive(String_Const_u16 str, String_Const_u16 needle){
return(string_find_first(str, needle, StringMatch_CaseInsensitive));
}
static umem
string_find_first_insensitive(String_Const_u32 str, String_Const_u32 needle){
return(string_find_first(str, needle, StringMatch_CaseInsensitive));
}
static i32
string_compare(String_Const_char a, String_Const_char b){
i32 result = 0;
for (umem i = 0; i < a.size || i < b.size; i += 1){
char ca = (i < a.size)?0:a.str[i];
char cb = (i < b.size)?0:b.str[i];
i32 dif = (ca) != (cb);
if (dif != 0){
result = (dif > 0)?1:-1;
break;
}
}
return(result);
}
static i32
string_compare(String_Const_u8 a, String_Const_u8 b){
i32 result = 0;
for (umem i = 0; i < a.size || i < b.size; i += 1){
u8 ca = (i < a.size)?0:a.str[i];
u8 cb = (i < b.size)?0:b.str[i];
i32 dif = (ca) != (cb);
if (dif != 0){
result = (dif > 0)?1:-1;
break;
}
}
return(result);
}
static i32
string_compare(String_Const_u16 a, String_Const_u16 b){
i32 result = 0;
for (umem i = 0; i < a.size || i < b.size; i += 1){
u16 ca = (i < a.size)?0:a.str[i];
u16 cb = (i < b.size)?0:b.str[i];
i32 dif = (ca) != (cb);
if (dif != 0){
result = (dif > 0)?1:-1;
break;
}
}
return(result);
}
static i32
string_compare(String_Const_u32 a, String_Const_u32 b){
i32 result = 0;
for (umem i = 0; i < a.size || i < b.size; i += 1){
u32 ca = (i < a.size)?0:a.str[i];
u32 cb = (i < b.size)?0:b.str[i];
i32 dif = (ca) != (cb);
if (dif != 0){
result = (dif > 0)?1:-1;
break;
}
}
return(result);
}
static i32
string_compare_insensitive(String_Const_char a, String_Const_char b){
i32 result = 0;
for (umem i = 0; i < a.size || i < b.size; i += 1){
char ca = (i <= a.size)?0:a.str[i];
char cb = (i <= b.size)?0:b.str[i];
i32 dif = character_to_upper(ca) - character_to_upper(cb);
if (dif != 0){
result = (dif > 0)?1:-1;
break;
}
}
return(result);
}
static i32
string_compare_insensitive(String_Const_u8 a, String_Const_u8 b){
i32 result = 0;
for (umem i = 0; i < a.size || i < b.size; i += 1){
u8 ca = (i <= a.size)?0:a.str[i];
u8 cb = (i <= b.size)?0:b.str[i];
i32 dif = character_to_upper(ca) - character_to_upper(cb);
if (dif != 0){
result = (dif > 0)?1:-1;
break;
}
}
return(result);
}
static i32
string_compare_insensitive(String_Const_u16 a, String_Const_u16 b){
i32 result = 0;
for (umem i = 0; i < a.size || i < b.size; i += 1){
u16 ca = (i <= a.size)?0:a.str[i];
u16 cb = (i <= b.size)?0:b.str[i];
i32 dif = character_to_upper(ca) - character_to_upper(cb);
if (dif != 0){
result = (dif > 0)?1:-1;
break;
}
}
return(result);
}
static i32
string_compare_insensitive(String_Const_u32 a, String_Const_u32 b){
i32 result = 0;
for (umem i = 0; i < a.size || i < b.size; i += 1){
u32 ca = (i <= a.size)?0:a.str[i];
u32 cb = (i <= b.size)?0:b.str[i];
i32 dif = character_to_upper(ca) - character_to_upper(cb);
if (dif != 0){
result = (dif > 0)?1:-1;
break;
}
}
return(result);
}
static String_Const_char
string_mod_upper(String_Const_char str){
for (umem i = 0; i < str.size; i += 1){
str.str[i] = character_to_upper(str.str[i]);
}
return(str);
}
static String_Const_u8
string_mod_upper(String_Const_u8 str){
for (umem i = 0; i < str.size; i += 1){
str.str[i] = character_to_upper(str.str[i]);
}
return(str);
}
static String_Const_u16
string_mod_upper(String_Const_u16 str){
for (umem i = 0; i < str.size; i += 1){
str.str[i] = character_to_upper(str.str[i]);
}
return(str);
}
static String_Const_u32
string_mod_upper(String_Const_u32 str){
for (umem i = 0; i < str.size; i += 1){
str.str[i] = character_to_upper(str.str[i]);
}
return(str);
}
static String_Const_char
string_mod_lower(String_Const_char str){
for (umem i = 0; i < str.size; i += 1){
str.str[i] = character_to_lower(str.str[i]);
}
return(str);
}
static String_Const_u8
string_mod_lower(String_Const_u8 str){
for (umem i = 0; i < str.size; i += 1){
str.str[i] = character_to_lower(str.str[i]);
}
return(str);
}
static String_Const_u16
string_mod_lower(String_Const_u16 str){
for (umem i = 0; i < str.size; i += 1){
str.str[i] = character_to_lower(str.str[i]);
}
return(str);
}
static String_Const_u32
string_mod_lower(String_Const_u32 str){
for (umem i = 0; i < str.size; i += 1){
str.str[i] = character_to_lower(str.str[i]);
}
return(str);
}
static String_Const_char
string_mod_replace_character(String_Const_char str, char o, char n){
for (umem i = 0; i < str.size; i += 1){
char c = str.str[i];
str.str[i] = (c == o)?(n):(c);
}
return(str);
}
static String_Const_u8
string_mod_replace_character(String_Const_u8 str, u8 o, u8 n){
for (umem i = 0; i < str.size; i += 1){
u8 c = str.str[i];
str.str[i] = (c == o)?(n):(c);
}
return(str);
}
static String_Const_u16
string_mod_replace_character(String_Const_u16 str, u16 o, u16 n){
for (umem i = 0; i < str.size; i += 1){
u16 c = str.str[i];
str.str[i] = (c == o)?(n):(c);
}
return(str);
}
static String_Const_u32
string_mod_replace_character(String_Const_u32 str, u32 o, u32 n){
for (umem i = 0; i < str.size; i += 1){
u32 c = str.str[i];
str.str[i] = (c == o)?(n):(c);
}
return(str);
}
static b32
string_append(String_char *dst, String_Const_char src){
b32 result = false;
umem available = dst->cap - dst->size;
if (src.size <= available){
result = true;
}
umem copy_size = clamp_top(src.size, available);
block_copy(dst->str + dst->size, src.str, copy_size);
dst->size += copy_size;
return(result);
}
static b32
string_append(String_u8 *dst, String_Const_u8 src){
b32 result = false;
umem available = dst->cap - dst->size;
if (src.size <= available){
result = true;
}
umem copy_size = clamp_top(src.size, available);
block_copy(dst->str + dst->size, src.str, copy_size);
dst->size += copy_size;
return(result);
}
static b32
string_append(String_u16 *dst, String_Const_u16 src){
b32 result = false;
umem available = dst->cap - dst->size;
if (src.size <= available){
result = true;
}
umem copy_size = clamp_top(src.size, available);
block_copy(dst->str + dst->size, src.str, copy_size);
dst->size += copy_size;
return(result);
}
static b32
string_append(String_u32 *dst, String_Const_u32 src){
b32 result = false;
umem available = dst->cap - dst->size;
if (src.size <= available){
result = true;
}
umem copy_size = clamp_top(src.size, available);
block_copy(dst->str + dst->size, src.str, copy_size);
dst->size += copy_size;
return(result);
}
static b32
string_append_character(String_char *dst, char c){
return(string_append(dst, SCchar(&c, 1)));
}
static b32
string_append_character(String_u8 *dst, u8 c){
return(string_append(dst, SCu8(&c, 1)));
}
static b32
string_append_character(String_u16 *dst, u16 c){
return(string_append(dst, SCu16(&c, 1)));
}
static b32
string_append_character(String_u32 *dst, u32 c){
return(string_append(dst, SCu32(&c, 1)));
}
static b32
string_null_terminate(String_char *str){
b32 result = false;
if (str->size < str->cap){
str->str[str->size] = 0;
}
return(result);
}
static b32
string_null_terminate(String_u8 *str){
b32 result = false;
if (str->size < str->cap){
str->str[str->size] = 0;
}
return(result);
}
static b32
string_null_terminate(String_u16 *str){
b32 result = false;
if (str->size < str->cap){
str->str[str->size] = 0;
}
return(result);
}
static b32
string_null_terminate(String_u32 *str){
b32 result = false;
if (str->size < str->cap){
str->str[str->size] = 0;
}
return(result);
}
static String_char
string_char_push(Arena *arena, umem size){
String_char string = {};
string.str = push_array(arena, char, size);
string.cap = size;
return(string);
}
static String_u8
string_u8_push(Arena *arena, umem size){
String_u8 string = {};
string.str = push_array(arena, u8, size);
string.cap = size;
return(string);
}
static String_u16
string_u16_push(Arena *arena, umem size){
String_u16 string = {};
string.str = push_array(arena, u16, size);
string.cap = size;
return(string);
}
static String_u32
string_u32_push(Arena *arena, umem size){
String_u32 string = {};
string.str = push_array(arena, u32, size);
string.cap = size;
return(string);
}
static String_Any
string_any_push(Arena *arena, umem size, String_Encoding encoding){
String_Any string = {};
switch (encoding){
case StringEncoding_ASCII: string.s_char = string_char_push(arena, size); break;
case StringEncoding_UTF8: string.s_u8 = string_u8_push (arena, size); break;
case StringEncoding_UTF16: string.s_u16 = string_u16_push (arena, size); break;
case StringEncoding_UTF32: string.s_u32 = string_u32_push (arena, size); break;
}
return(string);
}
static String_Const_char
string_const_char_push(Arena *arena, umem size){
String_Const_char string = {};
string.str = push_array(arena, char, size);
string.size = size;
return(string);
}
static String_Const_u8
string_const_u8_push(Arena *arena, umem size){
String_Const_u8 string = {};
string.str = push_array(arena, u8, size);
string.size = size;
return(string);
}
static String_Const_u16
string_const_u16_push(Arena *arena, umem size){
String_Const_u16 string = {};
string.str = push_array(arena, u16, size);
string.size = size;
return(string);
}
static String_Const_u32
string_const_u32_push(Arena *arena, umem size){
String_Const_u32 string = {};
string.str = push_array(arena, u32, size);
string.size = size;
return(string);
}
static String_Const_Any
string_const_any_push(Arena *arena, umem size, String_Encoding encoding){
String_Const_Any string = {};
switch (encoding){
case StringEncoding_ASCII: string.s_char = string_const_char_push(arena, size); break;
case StringEncoding_UTF8: string.s_u8 = string_const_u8_push (arena, size); break;
case StringEncoding_UTF16: string.s_u16 = string_const_u16_push (arena, size); break;
case StringEncoding_UTF32: string.s_u32 = string_const_u32_push (arena, size); break;
}
return(string);
}
static String_Const_char
Deprecated old table and arena code
2019-07-13 00:43:17 +00:00
push_string_copy(Arena *arena, String_Const_char src){
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
String_Const_char string = {};
string.str = push_array(arena, char, src.size + 1);
string.size = src.size;
block_copy_dynamic_array(string.str, src.str, src.size);
string.str[string.size] = 0;
return(string);
}
static String_Const_u8
Deprecated old table and arena code
2019-07-13 00:43:17 +00:00
push_string_copy(Arena *arena, String_Const_u8 src){
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
String_Const_u8 string = {};
string.str = push_array(arena, u8, src.size + 1);
string.size = src.size;
block_copy_dynamic_array(string.str, src.str, src.size);
string.str[string.size] = 0;
return(string);
}
static String_Const_u16
Deprecated old table and arena code
2019-07-13 00:43:17 +00:00
push_string_copy(Arena *arena, String_Const_u16 src){
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
String_Const_u16 string = {};
string.str = push_array(arena, u16, src.size + 1);
string.size = src.size;
block_copy_dynamic_array(string.str, src.str, src.size);
string.str[string.size] = 0;
return(string);
}
static String_Const_u32
Deprecated old table and arena code
2019-07-13 00:43:17 +00:00
push_string_copy(Arena *arena, String_Const_u32 src){
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
String_Const_u32 string = {};
string.str = push_array(arena, u32, src.size + 1);
string.size = src.size;
block_copy_dynamic_array(string.str, src.str, src.size);
string.str[string.size] = 0;
return(string);
}
static String_Const_Any
Deprecated old table and arena code
2019-07-13 00:43:17 +00:00
push_string_copy(Arena *arena, umem size, String_Const_Any src){
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
String_Const_Any string = {};
switch (src.encoding){
Deprecated old table and arena code
2019-07-13 00:43:17 +00:00
case StringEncoding_ASCII: string.s_char = push_string_copy(arena, src.s_char); break;
case StringEncoding_UTF8: string.s_u8 = push_string_copy(arena, src.s_u8 ); break;
case StringEncoding_UTF16: string.s_u16 = push_string_copy(arena, src.s_u16 ); break;
case StringEncoding_UTF32: string.s_u32 = push_string_copy(arena, src.s_u32 ); break;
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
}
return(string);
}
static void
string_list_push(Arena *arena, List_String_Const_char *list, String_Const_char string){
Node_String_Const_char *node = push_array(arena, Node_String_Const_char, 1);
sll_queue_push(list->first, list->last, node);
node->string = string;
list->node_count += 1;
list->total_size += string.size;
}
static void
string_list_push(Arena *arena, List_String_Const_u8 *list, String_Const_u8 string){
Node_String_Const_u8 *node = push_array(arena, Node_String_Const_u8, 1);
sll_queue_push(list->first, list->last, node);
node->string = string;
list->node_count += 1;
list->total_size += string.size;
}
static void
string_list_push(Arena *arena, List_String_Const_u16 *list, String_Const_u16 string){
Node_String_Const_u16 *node = push_array(arena, Node_String_Const_u16, 1);
sll_queue_push(list->first, list->last, node);
node->string = string;
list->node_count += 1;
list->total_size += string.size;
}
static void
string_list_push(Arena *arena, List_String_Const_u32 *list, String_Const_u32 string){
Node_String_Const_u32 *node = push_array(arena, Node_String_Const_u32, 1);
sll_queue_push(list->first, list->last, node);
node->string = string;
list->node_count += 1;
list->total_size += string.size;
}
static void
string_list_push(Arena *arena, List_String_Const_Any *list, String_Const_Any string){
Node_String_Const_Any *node = push_array(arena, Node_String_Const_Any, 1);
sll_queue_push(list->first, list->last, node);
node->string = string;
list->node_count += 1;
list->total_size += string.size;
}
#define string_list_push_lit(a,l,s) string_list_push((a), (l), string_litexpr(s))
#define string_list_push_u8_lit(a,l,s) string_list_push((a), (l), string_u8_litexpr(s))
static void
string_list_push(List_String_Const_char *list, List_String_Const_char *src_list){
sll_queue_push_multiple(list->first, list->last, src_list->first, src_list->last);
list->node_count += src_list->node_count;
list->total_size += src_list->total_size;
block_zero_array(src_list);
}
static void
string_list_push(List_String_Const_u8 *list, List_String_Const_u8 *src_list){
sll_queue_push_multiple(list->first, list->last, src_list->first, src_list->last);
list->node_count += src_list->node_count;
list->total_size += src_list->total_size;
block_zero_array(src_list);
}
static void
string_list_push(List_String_Const_u16 *list, List_String_Const_u16 *src_list){
sll_queue_push_multiple(list->first, list->last, src_list->first, src_list->last);
list->node_count += src_list->node_count;
list->total_size += src_list->total_size;
block_zero_array(src_list);
}
static void
string_list_push(List_String_Const_u32 *list, List_String_Const_u32 *src_list){
sll_queue_push_multiple(list->first, list->last, src_list->first, src_list->last);
list->node_count += src_list->node_count;
list->total_size += src_list->total_size;
block_zero_array(src_list);
}
static void
string_list_push(List_String_Const_Any *list, List_String_Const_Any *src_list){
sll_queue_push_multiple(list->first, list->last, src_list->first, src_list->last);
list->node_count += src_list->node_count;
list->total_size += src_list->total_size;
block_zero_array(src_list);
}
static void
string_list_push_overlap(Arena *arena, List_String_Const_char *list, char overlap, String_Const_char string){
b32 tail_has_overlap = false;
b32 string_has_overlap = false;
if (list->last != 0){
String_Const_char tail = list->last->string;
if (string_get_character(tail, tail.size - 1) == overlap){
tail_has_overlap = true;
}
}
if (string_get_character(string, 0) == overlap){
string_has_overlap = true;
}
if (tail_has_overlap == string_has_overlap){
if (!tail_has_overlap){
Deprecated old table and arena code
2019-07-13 00:43:17 +00:00
string_list_push(arena, list, push_string_copy(arena, SCchar(&overlap, 1)));
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
}
else{
string = string_skip(string, 1);
}
}
if (string.size > 0){
string_list_push(arena, list, string);
}
}
static void
string_list_push_overlap(Arena *arena, List_String_Const_u8 *list, u8 overlap, String_Const_u8 string){
b32 tail_has_overlap = false;
b32 string_has_overlap = false;
if (list->last != 0){
String_Const_u8 tail = list->last->string;
if (string_get_character(tail, tail.size - 1) == overlap){
tail_has_overlap = true;
}
}
if (string_get_character(string, 0) == overlap){
string_has_overlap = true;
}
if (tail_has_overlap == string_has_overlap){
if (!tail_has_overlap){
Deprecated old table and arena code
2019-07-13 00:43:17 +00:00
string_list_push(arena, list, push_string_copy(arena, SCu8(&overlap, 1)));
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
}
else{
string = string_skip(string, 1);
}
}
if (string.size > 0){
string_list_push(arena, list, string);
}
}
static void
string_list_push_overlap(Arena *arena, List_String_Const_u16 *list, u16 overlap, String_Const_u16 string){
b32 tail_has_overlap = false;
b32 string_has_overlap = false;
if (list->last != 0){
String_Const_u16 tail = list->last->string;
if (string_get_character(tail, tail.size - 1) == overlap){
tail_has_overlap = true;
}
}
if (string_get_character(string, 0) == overlap){
string_has_overlap = true;
}
if (tail_has_overlap == string_has_overlap){
if (!tail_has_overlap){
Deprecated old table and arena code
2019-07-13 00:43:17 +00:00
string_list_push(arena, list, push_string_copy(arena, SCu16(&overlap, 1)));
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
}
else{
string = string_skip(string, 1);
}
}
if (string.size > 0){
string_list_push(arena, list, string);
}
}
static void
string_list_push_overlap(Arena *arena, List_String_Const_u32 *list, u32 overlap, String_Const_u32 string){
b32 tail_has_overlap = false;
b32 string_has_overlap = false;
if (list->last != 0){
String_Const_u32 tail = list->last->string;
if (string_get_character(tail, tail.size - 1) == overlap){
tail_has_overlap = true;
}
}
if (string_get_character(string, 0) == overlap){
string_has_overlap = true;
}
if (tail_has_overlap == string_has_overlap){
if (!tail_has_overlap){
Deprecated old table and arena code
2019-07-13 00:43:17 +00:00
string_list_push(arena, list, push_string_copy(arena, SCu32(&overlap, 1)));
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
}
else{
string = string_skip(string, 1);
}
}
if (string.size > 0){
string_list_push(arena, list, string);
}
}
typedef String_Const_char String_char_Mod_Function_Type(String_Const_char string);
typedef String_Const_u8 String_u8_Mod_Function_Type(String_Const_u8 string);
typedef String_Const_u16 String_u16_Mod_Function_Type(String_Const_u16 string);
typedef String_Const_u32 String_u32_Mod_Function_Type(String_Const_u32 string);
static String_Const_char
string_list_flatten(Arena *arena, List_String_Const_char list, String_char_Mod_Function_Type *mod, String_Const_char separator, String_Separator_Flag separator_flags, String_Fill_Terminate_Rule rule){
umem term_padding = (rule == StringFill_NullTerminate)?(1):(0);b32 before_first = HasFlag(separator_flags, StringSeparator_BeforeFirst);
b32 after_last = HasFlag(separator_flags, StringSeparator_AfterLast);
umem separator_size = separator.size*(list.node_count + before_first + after_last - 1);
String_char string = string_char_push(arena, list.total_size + separator_size + term_padding);
if (before_first){
string_append(&string, separator);
}
for (Node_String_Const_char *node = list.first;
node != 0;
node = node->next){
block_copy_dynamic_array(string.str + string.size, node->string.str, node->string.size);
if (mod != 0){
mod(SCchar(string.str + string.size, node->string.size));
}
string.size += node->string.size;
string_append(&string, separator);
}
if (after_last){
string_append(&string, separator);
}
if (term_padding == 1){
string_null_terminate(&string);
}
return(string.string);
}
static String_Const_u8
string_list_flatten(Arena *arena, List_String_Const_u8 list, String_u8_Mod_Function_Type *mod, String_Const_u8 separator, String_Separator_Flag separator_flags, String_Fill_Terminate_Rule rule){
umem term_padding = (rule == StringFill_NullTerminate)?(1):(0);b32 before_first = HasFlag(separator_flags, StringSeparator_BeforeFirst);
b32 after_last = HasFlag(separator_flags, StringSeparator_AfterLast);
umem separator_size = separator.size*(list.node_count + before_first + after_last - 1);
String_u8 string = string_u8_push(arena, list.total_size + separator_size + term_padding);
if (before_first){
string_append(&string, separator);
}
for (Node_String_Const_u8 *node = list.first;
node != 0;
node = node->next){
block_copy_dynamic_array(string.str + string.size, node->string.str, node->string.size);
if (mod != 0){
mod(SCu8(string.str + string.size, node->string.size));
}
string.size += node->string.size;
string_append(&string, separator);
}
if (after_last){
string_append(&string, separator);
}
if (term_padding == 1){
string_null_terminate(&string);
}
return(string.string);
}
static String_Const_u16
string_list_flatten(Arena *arena, List_String_Const_u16 list, String_u16_Mod_Function_Type *mod, String_Const_u16 separator, String_Separator_Flag separator_flags, String_Fill_Terminate_Rule rule){
umem term_padding = (rule == StringFill_NullTerminate)?(1):(0);b32 before_first = HasFlag(separator_flags, StringSeparator_BeforeFirst);
b32 after_last = HasFlag(separator_flags, StringSeparator_AfterLast);
umem separator_size = separator.size*(list.node_count + before_first + after_last - 1);
String_u16 string = string_u16_push(arena, list.total_size + separator_size + term_padding);
if (before_first){
string_append(&string, separator);
}
for (Node_String_Const_u16 *node = list.first;
node != 0;
node = node->next){
block_copy_dynamic_array(string.str + string.size, node->string.str, node->string.size);
if (mod != 0){
mod(SCu16(string.str + string.size, node->string.size));
}
string.size += node->string.size;
string_append(&string, separator);
}
if (after_last){
string_append(&string, separator);
}
if (term_padding == 1){
string_null_terminate(&string);
}
return(string.string);
}
static String_Const_u32
string_list_flatten(Arena *arena, List_String_Const_u32 list, String_u32_Mod_Function_Type *mod, String_Const_u32 separator, String_Separator_Flag separator_flags, String_Fill_Terminate_Rule rule){
umem term_padding = (rule == StringFill_NullTerminate)?(1):(0);b32 before_first = HasFlag(separator_flags, StringSeparator_BeforeFirst);
b32 after_last = HasFlag(separator_flags, StringSeparator_AfterLast);
umem separator_size = separator.size*(list.node_count + before_first + after_last - 1);
String_u32 string = string_u32_push(arena, list.total_size + separator_size + term_padding);
if (before_first){
string_append(&string, separator);
}
for (Node_String_Const_u32 *node = list.first;
node != 0;
node = node->next){
block_copy_dynamic_array(string.str + string.size, node->string.str, node->string.size);
if (mod != 0){
mod(SCu32(string.str + string.size, node->string.size));
}
string.size += node->string.size;
string_append(&string, separator);
}
if (after_last){
string_append(&string, separator);
}
if (term_padding == 1){
string_null_terminate(&string);
}
return(string.string);
}
static String_Const_char
string_list_flatten(Arena *arena, List_String_Const_char list, String_Const_char separator, String_Separator_Flag separator_flags, String_Fill_Terminate_Rule rule){
return(string_list_flatten(arena, list, 0, separator, separator_flags, rule));
}
static String_Const_u8
string_list_flatten(Arena *arena, List_String_Const_u8 list, String_Const_u8 separator, String_Separator_Flag separator_flags, String_Fill_Terminate_Rule rule){
return(string_list_flatten(arena, list, 0, separator, separator_flags, rule));
}
static String_Const_u16
string_list_flatten(Arena *arena, List_String_Const_u16 list, String_Const_u16 separator, String_Separator_Flag separator_flags, String_Fill_Terminate_Rule rule){
return(string_list_flatten(arena, list, 0, separator, separator_flags, rule));
}
static String_Const_u32
string_list_flatten(Arena *arena, List_String_Const_u32 list, String_Const_u32 separator, String_Separator_Flag separator_flags, String_Fill_Terminate_Rule rule){
return(string_list_flatten(arena, list, 0, separator, separator_flags, rule));
}
static String_Const_char
string_list_flatten(Arena *arena, List_String_Const_char list, String_char_Mod_Function_Type *mod, String_Fill_Terminate_Rule rule){
return(string_list_flatten(arena, list, mod, SCchar(), 0, rule));
}
static String_Const_u8
string_list_flatten(Arena *arena, List_String_Const_u8 list, String_u8_Mod_Function_Type *mod, String_Fill_Terminate_Rule rule){
return(string_list_flatten(arena, list, mod, SCu8(), 0, rule));
}
static String_Const_u16
string_list_flatten(Arena *arena, List_String_Const_u16 list, String_u16_Mod_Function_Type *mod, String_Fill_Terminate_Rule rule){
return(string_list_flatten(arena, list, mod, SCu16(), 0, rule));
}
static String_Const_u32
string_list_flatten(Arena *arena, List_String_Const_u32 list, String_u32_Mod_Function_Type *mod, String_Fill_Terminate_Rule rule){
return(string_list_flatten(arena, list, mod, SCu32(), 0, rule));
}
static String_Const_char
string_list_flatten(Arena *arena, List_String_Const_char string, String_Fill_Terminate_Rule rule){
return(string_list_flatten(arena, string, 0, SCchar(), 0, rule));
}
static String_Const_u8
string_list_flatten(Arena *arena, List_String_Const_u8 string, String_Fill_Terminate_Rule rule){
return(string_list_flatten(arena, string, 0, SCu8(), 0, rule));
}
static String_Const_u16
string_list_flatten(Arena *arena, List_String_Const_u16 string, String_Fill_Terminate_Rule rule){
return(string_list_flatten(arena, string, 0, SCu16(), 0, rule));
}
static String_Const_u32
string_list_flatten(Arena *arena, List_String_Const_u32 string, String_Fill_Terminate_Rule rule){
return(string_list_flatten(arena, string, 0, SCu32(), 0, rule));
}
static String_Const_char
string_list_flatten(Arena *arena, List_String_Const_char string){
return(string_list_flatten(arena, string, 0, SCchar(), 0, StringFill_NoTerminate));
}
static String_Const_u8
string_list_flatten(Arena *arena, List_String_Const_u8 string){
return(string_list_flatten(arena, string, 0, SCu8(), 0, StringFill_NoTerminate));
}
static String_Const_u16
string_list_flatten(Arena *arena, List_String_Const_u16 string){
return(string_list_flatten(arena, string, 0, SCu16(), 0, StringFill_NoTerminate));
}
static String_Const_u32
string_list_flatten(Arena *arena, List_String_Const_u32 string){
return(string_list_flatten(arena, string, 0, SCu32(), 0, StringFill_NoTerminate));
}
static List_String_Const_char
string_split(Arena *arena, String_Const_char string, char *split_characters, i32 split_character_count){
List_String_Const_char list = {};
for (;;){
umem i = string.size;
String_Const_char prefix = string;
for (i32 j = 0; j < split_character_count; j += 1){
umem pos = string_find_first(prefix, split_characters[j]);
prefix = string_prefix(prefix, pos);
i = min(i, pos);
}
if (prefix.size > 0){
string_list_push(arena, &list, prefix);
}
string = string_skip(string, i + 1);
if (string.size == 0){
break;
}
}
return(list);
}
static List_String_Const_u8
string_split(Arena *arena, String_Const_u8 string, u8 *split_characters, i32 split_character_count){
List_String_Const_u8 list = {};
for (;;){
umem i = string.size;
String_Const_u8 prefix = string;
for (i32 j = 0; j < split_character_count; j += 1){
umem pos = string_find_first(prefix, split_characters[j]);
prefix = string_prefix(prefix, pos);
i = min(i, pos);
}
if (prefix.size > 0){
string_list_push(arena, &list, prefix);
}
string = string_skip(string, i + 1);
if (string.size == 0){
break;
}
}
return(list);
}
static List_String_Const_u16
string_split(Arena *arena, String_Const_u16 string, u16 *split_characters, i32 split_character_count){
List_String_Const_u16 list = {};
for (;;){
umem i = string.size;
String_Const_u16 prefix = string;
for (i32 j = 0; j < split_character_count; j += 1){
umem pos = string_find_first(prefix, split_characters[j]);
prefix = string_prefix(prefix, pos);
i = min(i, pos);
}
if (prefix.size > 0){
string_list_push(arena, &list, prefix);
}
string = string_skip(string, i + 1);
if (string.size == 0){
break;
}
}
return(list);
}
static List_String_Const_u32
string_split(Arena *arena, String_Const_u32 string, u32 *split_characters, i32 split_character_count){
List_String_Const_u32 list = {};
for (;;){
umem i = string.size;
String_Const_u32 prefix = string;
for (i32 j = 0; j < split_character_count; j += 1){
umem pos = string_find_first(prefix, split_characters[j]);
prefix = string_prefix(prefix, pos);
i = min(i, pos);
}
if (prefix.size > 0){
string_list_push(arena, &list, prefix);
}
string = string_skip(string, i + 1);
if (string.size == 0){
break;
}
}
return(list);
}
static List_String_Const_char
string_split_needle(Arena *arena, String_Const_char string, String_Const_char needle){
List_String_Const_char list = {};
for (;string.size > 0;){
umem pos = string_find_first(string, needle);
String_Const_char prefix = string_prefix(string, pos);
if (pos < string.size){
string_list_push(arena, &list, needle);
}
if (prefix.size > 0){
string_list_push(arena, &list, prefix);
}
string = string_skip(string, prefix.size + needle.size);
}
return(list);
}
static List_String_Const_u8
string_split_needle(Arena *arena, String_Const_u8 string, String_Const_u8 needle){
List_String_Const_u8 list = {};
for (;string.size > 0;){
umem pos = string_find_first(string, needle);
String_Const_u8 prefix = string_prefix(string, pos);
if (pos < string.size){
string_list_push(arena, &list, needle);
}
if (prefix.size > 0){
string_list_push(arena, &list, prefix);
}
string = string_skip(string, prefix.size + needle.size);
}
return(list);
}
static List_String_Const_u16
string_split_needle(Arena *arena, String_Const_u16 string, String_Const_u16 needle){
List_String_Const_u16 list = {};
for (;string.size > 0;){
umem pos = string_find_first(string, needle);
String_Const_u16 prefix = string_prefix(string, pos);
if (pos < string.size){
string_list_push(arena, &list, needle);
}
if (prefix.size > 0){
string_list_push(arena, &list, prefix);
}
string = string_skip(string, prefix.size + needle.size);
}
return(list);
}
static List_String_Const_u32
string_split_needle(Arena *arena, String_Const_u32 string, String_Const_u32 needle){
List_String_Const_u32 list = {};
for (;string.size > 0;){
umem pos = string_find_first(string, needle);
String_Const_u32 prefix = string_prefix(string, pos);
if (pos < string.size){
string_list_push(arena, &list, needle);
}
if (prefix.size > 0){
string_list_push(arena, &list, prefix);
}
string = string_skip(string, prefix.size + needle.size);
}
return(list);
}
static void
string_list_insert_separators(Arena *arena, List_String_Const_char *list, String_Const_char separator, String_Separator_Flag flags){
Node_String_Const_char *last = list->last;
for (Node_String_Const_char *node = list->first, *next = 0;
node != last;
node = next){
next = node->next;
Node_String_Const_char *new_node = push_array(arena, Node_String_Const_char, 1);
node->next = new_node;
new_node->next = next;
new_node->string = separator;
list->node_count += 1;
list->total_size += separator.size;
}
if (HasFlag(flags, StringSeparator_BeforeFirst)){
Node_String_Const_char *new_node = push_array(arena, Node_String_Const_char, 1);
new_node->next = list->first;
list->first = new_node;
new_node->string = separator;
list->node_count += 1;
list->total_size += separator.size;
}
if (HasFlag(flags, StringSeparator_AfterLast)){
Node_String_Const_char *new_node = push_array(arena, Node_String_Const_char, 1);
list->last->next = new_node;
list->last = new_node;
new_node->next = 0;
new_node->string = separator;
list->node_count += 1;
list->total_size += separator.size;
}
}
static void
string_list_insert_separators(Arena *arena, List_String_Const_u8 *list, String_Const_u8 separator, String_Separator_Flag flags){
Node_String_Const_u8 *last = list->last;
for (Node_String_Const_u8 *node = list->first, *next = 0;
node != last;
node = next){
next = node->next;
Node_String_Const_u8 *new_node = push_array(arena, Node_String_Const_u8, 1);
node->next = new_node;
new_node->next = next;
new_node->string = separator;
list->node_count += 1;
list->total_size += separator.size;
}
if (HasFlag(flags, StringSeparator_BeforeFirst)){
Node_String_Const_u8 *new_node = push_array(arena, Node_String_Const_u8, 1);
new_node->next = list->first;
list->first = new_node;
new_node->string = separator;
list->node_count += 1;
list->total_size += separator.size;
}
if (HasFlag(flags, StringSeparator_AfterLast)){
Node_String_Const_u8 *new_node = push_array(arena, Node_String_Const_u8, 1);
list->last->next = new_node;
list->last = new_node;
new_node->next = 0;
new_node->string = separator;
list->node_count += 1;
list->total_size += separator.size;
}
}
static void
string_list_insert_separators(Arena *arena, List_String_Const_u16 *list, String_Const_u16 separator, String_Separator_Flag flags){
Node_String_Const_u16 *last = list->last;
for (Node_String_Const_u16 *node = list->first, *next = 0;
node != last;
node = next){
next = node->next;
Node_String_Const_u16 *new_node = push_array(arena, Node_String_Const_u16, 1);
node->next = new_node;
new_node->next = next;
new_node->string = separator;
list->node_count += 1;
list->total_size += separator.size;
}
if (HasFlag(flags, StringSeparator_BeforeFirst)){
Node_String_Const_u16 *new_node = push_array(arena, Node_String_Const_u16, 1);
new_node->next = list->first;
list->first = new_node;
new_node->string = separator;
list->node_count += 1;
list->total_size += separator.size;
}
if (HasFlag(flags, StringSeparator_AfterLast)){
Node_String_Const_u16 *new_node = push_array(arena, Node_String_Const_u16, 1);
list->last->next = new_node;
list->last = new_node;
new_node->next = 0;
new_node->string = separator;
list->node_count += 1;
list->total_size += separator.size;
}
}
static void
string_list_insert_separators(Arena *arena, List_String_Const_u32 *list, String_Const_u32 separator, String_Separator_Flag flags){
Node_String_Const_u32 *last = list->last;
for (Node_String_Const_u32 *node = list->first, *next = 0;
node != last;
node = next){
next = node->next;
Node_String_Const_u32 *new_node = push_array(arena, Node_String_Const_u32, 1);
node->next = new_node;
new_node->next = next;
new_node->string = separator;
list->node_count += 1;
list->total_size += separator.size;
}
if (HasFlag(flags, StringSeparator_BeforeFirst)){
Node_String_Const_u32 *new_node = push_array(arena, Node_String_Const_u32, 1);
new_node->next = list->first;
list->first = new_node;
new_node->string = separator;
list->node_count += 1;
list->total_size += separator.size;
}
if (HasFlag(flags, StringSeparator_AfterLast)){
Node_String_Const_u32 *new_node = push_array(arena, Node_String_Const_u32, 1);
list->last->next = new_node;
list->last = new_node;
new_node->next = 0;
new_node->string = separator;
list->node_count += 1;
list->total_size += separator.size;
}
}
static void
string_list_rewrite_nodes(Arena *arena, List_String_Const_char *list, String_Const_char needle, String_Const_char new_value){
for (Node_String_Const_char *node = list->first;
node != 0;
node = node->next){
if (string_match(node->string, needle)){
node->string = new_value;
list->total_size += new_value.size;
list->total_size -= needle.size;
}
}
}
static void
string_list_rewrite_nodes(Arena *arena, List_String_Const_u8 *list, String_Const_u8 needle, String_Const_u8 new_value){
for (Node_String_Const_u8 *node = list->first;
node != 0;
node = node->next){
if (string_match(node->string, needle)){
node->string = new_value;
list->total_size += new_value.size;
list->total_size -= needle.size;
}
}
}
static void
string_list_rewrite_nodes(Arena *arena, List_String_Const_u16 *list, String_Const_u16 needle, String_Const_u16 new_value){
for (Node_String_Const_u16 *node = list->first;
node != 0;
node = node->next){
if (string_match(node->string, needle)){
node->string = new_value;
list->total_size += new_value.size;
list->total_size -= needle.size;
}
}
}
static void
string_list_rewrite_nodes(Arena *arena, List_String_Const_u32 *list, String_Const_u32 needle, String_Const_u32 new_value){
for (Node_String_Const_u32 *node = list->first;
node != 0;
node = node->next){
if (string_match(node->string, needle)){
node->string = new_value;
list->total_size += new_value.size;
list->total_size -= needle.size;
}
}
}
static String_Const_char
string_condense_whitespace(Arena *arena, String_Const_char string){
char split_characters[] = { ' ', '\t', '\n', '\r', '\f', '\v', };
List_String_Const_char list = string_split(arena, string, split_characters, ArrayCount(split_characters));
string_list_insert_separators(arena, &list, SCchar(split_characters, 1), StringSeparator_NoFlags);
return(string_list_flatten(arena, list, StringFill_NullTerminate));
}
static String_Const_u8
string_condense_whitespace(Arena *arena, String_Const_u8 string){
u8 split_characters[] = { ' ', '\t', '\n', '\r', '\f', '\v', };
List_String_Const_u8 list = string_split(arena, string, split_characters, ArrayCount(split_characters));
string_list_insert_separators(arena, &list, SCu8(split_characters, 1), StringSeparator_NoFlags);
return(string_list_flatten(arena, list, StringFill_NullTerminate));
}
static String_Const_u16
string_condense_whitespace(Arena *arena, String_Const_u16 string){
u16 split_characters[] = { ' ', '\t', '\n', '\r', '\f', '\v', };
List_String_Const_u16 list = string_split(arena, string, split_characters, ArrayCount(split_characters));
string_list_insert_separators(arena, &list, SCu16(split_characters, 1), StringSeparator_NoFlags);
return(string_list_flatten(arena, list, StringFill_NullTerminate));
}
static String_Const_u32
string_condense_whitespace(Arena *arena, String_Const_u32 string){
u32 split_characters[] = { ' ', '\t', '\n', '\r', '\f', '\v', };
List_String_Const_u32 list = string_split(arena, string, split_characters, ArrayCount(split_characters));
string_list_insert_separators(arena, &list, SCu32(split_characters, 1), StringSeparator_NoFlags);
return(string_list_flatten(arena, list, StringFill_NullTerminate));
}
static List_String_Const_u8
string_split_wildcards(Arena *arena, String_Const_u8 string){
List_String_Const_u8 list = {};
if (string_get_character(string, 0) == '*'){
string_list_push(arena, &list, SCu8());
}
{
List_String_Const_u8 splits = string_split(arena, string, (u8*)"*", 1);
string_list_push(&list, &splits);
}
if (string.size > 1 && string_get_character(string, string.size - 1) == '*'){
string_list_push(arena, &list, SCu8());
}
return(list);
}
static b32
string_wildcard_match(List_String_Const_u8 list, String_Const_u8 string, String_Match_Rule rule){
b32 success = true;
if (list.node_count > 0){
String_Const_u8 head = list.first->string;
if (!string_match(head, string_prefix(string, head.size), rule)){
success = false;
}
else if (list.node_count > 1){
string = string_skip(string, head.size);
String_Const_u8 tail = list.last->string;
if (!string_match(tail, string_postfix(string, tail.size), rule)){
success = false;
}
else if (list.node_count > 2){
string = string_chop(string, tail.size);
Node_String_Const_u8 *one_past_last = list.last;
for (Node_String_Const_u8 *node = list.first->next;
node != one_past_last;
node = node->next){
umem position = string_find_first(string, node->string, rule);
if (position < string.size){
string = string_skip(string, position + node->string.size);
}
else{
success = false;
break;
}
}
}
}
}
return(success);
}
static b32
string_wildcard_match(List_String_Const_u8 list, String_Const_u8 string){
return(string_wildcard_match(list, string, StringMatch_Exact));
}
static b32
string_wildcard_match_insensitive(List_String_Const_u8 list, String_Const_u8 string){
return(string_wildcard_match(list, string, StringMatch_CaseInsensitive));
}
////////////////////////////////
global_const u8 utf8_class[32] = {
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,2,2,2,2,3,3,4,5,
};
static Character_Consume_Result
utf8_consume(u8 *str, umem max){
Character_Consume_Result result = {1, max_u32};
u8 byte = str[0];
u8 byte_class = utf8_class[byte >> 3];
switch (byte_class){
case 1:
{
result.codepoint = byte;
}break;
case 2:
{
if (1 < max){
u8 cont_byte = str[1];
if (utf8_class[cont_byte >> 3] == 0){
result.codepoint = (byte & bitmask_5) << 6;
result.codepoint |= (cont_byte & bitmask_6);
result.inc = 2;
}
}
}break;
case 3:
{
if (2 < max){
u8 cont_byte[2] = {str[1], str[2]};
if (utf8_class[cont_byte[0] >> 3] == 0 &&
utf8_class[cont_byte[1] >> 3] == 0){
result.codepoint = (byte & bitmask_4) << 12;
result.codepoint |= ((cont_byte[0] & bitmask_6) << 6);
result.codepoint |= (cont_byte[1] & bitmask_6);
result.inc = 3;
}
}
}break;
case 4:
{
if (3 < max){
u8 cont_byte[3] = {str[1], str[2], str[3]};
if (utf8_class[cont_byte[0] >> 3] == 0 &&
utf8_class[cont_byte[1] >> 3] == 0 &&
utf8_class[cont_byte[2] >> 3] == 0){
result.codepoint = (byte & bitmask_3) << 18;
result.codepoint |= ((cont_byte[0] & bitmask_6) << 12);
result.codepoint |= ((cont_byte[1] & bitmask_6) << 6);
result.codepoint |= (cont_byte[2] & bitmask_6);
result.inc = 4;
}
}
}break;
}
return(result);
}
static Character_Consume_Result
utf16_consume(u16 *str, umem max){
Character_Consume_Result result = {1, max_u32};
result.codepoint = str[0];
result.inc = 1;
if (0xD800 <= str[0] && str[0] < 0xDC00 && max > 1 && 0xDC00 <= str[1] && str[1] < 0xE000){
result.codepoint = ((str[0] - 0xD800) << 10) | (str[1] - 0xDC00);
result.inc = 2;
}
return(result);
}
static u32
utf8_write(u8 *str, u32 codepoint){
u32 inc = 0;
if (codepoint <= 0x7F){
str[0] = (u8)codepoint;
inc = 1;
}
else if (codepoint <= 0x7FF){
str[0] = (bitmask_2 << 6) | ((codepoint >> 6) & bitmask_5);
str[1] = bit_8 | (codepoint & bitmask_6);
inc = 2;
}
else if (codepoint <= 0xFFFF){
str[0] = (bitmask_3 << 5) | ((codepoint >> 12) & bitmask_4);
str[1] = bit_8 | ((codepoint >> 6) & bitmask_6);
str[2] = bit_8 | ( codepoint & bitmask_6);
inc = 3;
}
else if (codepoint <= 0x10FFFF){
str[0] = (bitmask_4 << 3) | ((codepoint >> 18) & bitmask_3);
str[1] = bit_8 | ((codepoint >> 12) & bitmask_6);
str[2] = bit_8 | ((codepoint >> 6) & bitmask_6);
str[3] = bit_8 | ( codepoint & bitmask_6);
inc = 4;
}
else{
str[0] = '?';
inc = 1;
}
return(inc);
}
static u32
utf16_write(u16 *str, u32 codepoint){
u32 inc = 1;
if (codepoint == max_u32){
str[0] = (u16)'?';
}
else if (codepoint < 0x10000){
str[0] = (u16)codepoint;
}
else{
u32 v = codepoint - 0x10000;
str[0] = 0xD800 + (u16)(v >> 10);
str[1] = 0xDC00 + (v & bitmask_10);
inc = 2;
}
return(inc);
}
////////////////////////////////
static String_u8
string_u8_from_string_char(Arena *arena, String_Const_char string, String_Fill_Terminate_Rule rule){
String_u8 out = {};
out.cap = string.size;
if (rule == StringFill_NullTerminate){
out.cap += 1;
}
out.str = push_array(arena, u8, out.cap);
for (umem i = 0; i < string.size; i += 1){
out.str[i] = ((u8)string.str[i])&bitmask_7;
}
out.size = string.size;
if (rule == StringFill_NullTerminate){
string_null_terminate(&out);
}
return(out);
}
static String_u16
string_u16_from_string_char(Arena *arena, String_Const_char string, String_Fill_Terminate_Rule rule){
String_u16 out = {};
out.cap = string.size;
if (rule == StringFill_NullTerminate){
out.cap += 1;
}
out.str = push_array(arena, u16, out.cap);
for (umem i = 0; i < string.size; i += 1){
out.str[i] = ((u16)string.str[i])&bitmask_7;
}
out.size = string.size;
if (rule == StringFill_NullTerminate){
string_null_terminate(&out);
}
return(out);
}
static String_u32
string_u32_from_string_char(Arena *arena, String_Const_char string, String_Fill_Terminate_Rule rule){
String_u32 out = {};
out.cap = string.size;
if (rule == StringFill_NullTerminate){
out.cap += 1;
}
out.str = push_array(arena, u32, string.size);
for (umem i = 0; i < string.size; i += 1){
out.str[i] = ((u32)string.str[i])&bitmask_7;
}
out.size = string.size;
if (rule == StringFill_NullTerminate){
string_null_terminate(&out);
}
return(out);
}
static String_char
string_char_from_string_u8(Arena *arena, String_Const_u8 string, String_Fill_Terminate_Rule rule){
String_char out = {};
out.cap = string.size;
if (rule == StringFill_NullTerminate){
out.cap += 1;
}
out.str = push_array(arena, char, out.cap);
u8 *ptr = string.str;
u8 *one_past_last = ptr + string.size;
umem cap = string.size;
Character_Consume_Result consume;
for (;ptr < one_past_last; ptr += consume.inc, cap -= consume.inc){
consume = utf8_consume(ptr, cap);
out.str[out.size++] = (consume.codepoint <= 127)?((char)consume.codepoint):('?');
}
if (rule == StringFill_NullTerminate){
string_null_terminate(&out);
}
return(out);
}
static String_u16
string_u16_from_string_u8(Arena *arena, String_Const_u8 string, String_Fill_Terminate_Rule rule){
String_u16 out = {};
out.cap = string.size;
if (rule == StringFill_NullTerminate){
out.cap += 1;
}
out.str = push_array(arena, u16, out.cap);
u8 *ptr = string.str;
u8 *one_past_last = ptr + string.size;
umem cap = string.size;
Character_Consume_Result consume;
for (;ptr < one_past_last; ptr += consume.inc, cap -= consume.inc){
consume = utf8_consume(ptr, cap);
out.size += utf16_write(out.str + out.size, consume.codepoint);
}
if (rule == StringFill_NullTerminate){
string_null_terminate(&out);
}
return(out);
}
static String_u32
string_u32_from_string_u8(Arena *arena, String_Const_u8 string, String_Fill_Terminate_Rule rule){
String_u32 out = {};
out.cap = string.size;
if (rule == StringFill_NullTerminate){
out.cap += 1;
}
out.str = push_array(arena, u32, out.cap);
u8 *ptr = string.str;
u8 *one_past_last = ptr + string.size;
umem cap = string.size;
Character_Consume_Result consume;
for (;ptr < one_past_last; ptr += consume.inc, cap -= consume.inc){
consume = utf8_consume(ptr, cap);
out.str[out.size++] = (consume.codepoint == max_u32)?(u64)'?':(consume.codepoint);
}
if (rule == StringFill_NullTerminate){
string_null_terminate(&out);
}
return(out);
}
static String_char
string_char_from_string_u16(Arena *arena, String_Const_u16 string, String_Fill_Terminate_Rule rule){
String_char out = {};
out.cap = string.size;
if (rule == StringFill_NullTerminate){
out.cap += 1;
}
out.str = push_array(arena, char, out.cap);
u16 *ptr = string.str;
u16 *one_past_last = ptr + string.size;
umem cap = string.size;
Character_Consume_Result consume;
for (;ptr < one_past_last; ptr += consume.inc, cap -= consume.inc){
consume = utf16_consume(ptr, cap);
out.str[out.size++] = (consume.codepoint <= 127)?((char)consume.codepoint):('?');
}
if (rule == StringFill_NullTerminate){
string_null_terminate(&out);
}
return(out);
}
static String_u8
string_u8_from_string_u16(Arena *arena, String_Const_u16 string, String_Fill_Terminate_Rule rule){
String_u8 out = {};
out.cap = string.size*3;
if (rule == StringFill_NullTerminate){
out.cap += 1;
}
out.str = push_array(arena, u8, out.cap);
u16 *ptr = string.str;
u16 *one_past_last = ptr + string.size;
umem cap = string.size;
Character_Consume_Result consume;
for (;ptr < one_past_last; ptr += consume.inc, cap -= consume.inc){
consume = utf16_consume(ptr, cap);
out.size += utf8_write(out.str + out.size, consume.codepoint);
}
if (rule == StringFill_NullTerminate){
string_null_terminate(&out);
}
return(out);
}
static String_u32
string_u32_from_string_u16(Arena *arena, String_Const_u16 string, String_Fill_Terminate_Rule rule){
String_u32 out = {};
out.cap = string.size;
if (rule == StringFill_NullTerminate){
out.cap += 1;
}
out.str = push_array(arena, u32, out.cap);
u16 *ptr = string.str;
u16 *one_past_last = ptr + string.size;
umem cap = string.size;
Character_Consume_Result consume;
for (;ptr < one_past_last; ptr += consume.inc, cap -= consume.inc){
consume = utf16_consume(ptr, cap);
out.str[out.size++] = consume.codepoint;
}
if (rule == StringFill_NullTerminate){
string_null_terminate(&out);
}
return(out);
}
static String_char
string_char_from_string_u32(Arena *arena, String_Const_u32 string, String_Fill_Terminate_Rule rule){
String_char out = {};
out.cap = string.size;
if (rule == StringFill_NullTerminate){
out.cap += 1;
}
out.str = push_array(arena, char, string.size);
u32 *ptr = string.str;
u32 *one_past_last = ptr + string.size;
for (;ptr < one_past_last; ptr += 1){
u32 codepoint = *ptr;
out.str[out.size++] = (codepoint <= 127)?((char)codepoint):('?');
}
if (rule == StringFill_NullTerminate){
string_null_terminate(&out);
}
return(out);
}
static String_u8
string_u8_from_string_u32(Arena *arena, String_Const_u32 string, String_Fill_Terminate_Rule rule){
String_u8 out = {};
out.cap = string.size*4;
if (rule == StringFill_NullTerminate){
out.cap += 1;
}
out.str = push_array(arena, u8, out.cap);
u32 *ptr = string.str;
u32 *one_past_last = ptr + string.size;
for (;ptr < one_past_last; ptr += 1){
out.size += utf8_write(out.str + out.size, *ptr);
}
if (rule == StringFill_NullTerminate){
string_null_terminate(&out);
}
return(out);
}
static String_u16
string_u16_from_string_u32(Arena *arena, String_Const_u32 string, String_Fill_Terminate_Rule rule){
String_u16 out = {};
out.cap = string.size*2;
if (rule == StringFill_NullTerminate){
out.cap += 1;
}
out.str = push_array(arena, u16, out.cap);
u32 *ptr = string.str;
u32 *one_past_last = ptr + string.size;
for (;ptr < one_past_last; ptr += 1){
out.size += utf16_write(out.str + out.size, *ptr);
}
if (rule == StringFill_NullTerminate){
string_null_terminate(&out);
}
return(out);
}
////////////////////////////////
static String_char
string_char_from_string_u8(Arena *arena, String_Const_u8 string){
return(string_char_from_string_u8(arena, string, StringFill_NoTerminate));
}
static String_char
string_char_from_string_u16(Arena *arena, String_Const_u16 string){
return(string_char_from_string_u16(arena, string, StringFill_NoTerminate));
}
static String_char
string_char_from_string_u32(Arena *arena, String_Const_u32 string){
return(string_char_from_string_u32(arena, string, StringFill_NoTerminate));
}
static String_u8
string_u8_from_string_char(Arena *arena, String_Const_char string){
return(string_u8_from_string_char(arena, string, StringFill_NoTerminate));
}
static String_u8
string_u8_from_string_u16(Arena *arena, String_Const_u16 string){
return(string_u8_from_string_u16(arena, string, StringFill_NoTerminate));
}
static String_u8
string_u8_from_string_u32(Arena *arena, String_Const_u32 string){
return(string_u8_from_string_u32(arena, string, StringFill_NoTerminate));
}
static String_u16
string_u16_from_string_char(Arena *arena, String_Const_char string){
return(string_u16_from_string_char(arena, string, StringFill_NoTerminate));
}
static String_u16
string_u16_from_string_u8(Arena *arena, String_Const_u8 string){
return(string_u16_from_string_u8(arena, string, StringFill_NoTerminate));
}
static String_u16
string_u16_from_string_u32(Arena *arena, String_Const_u32 string){
return(string_u16_from_string_u32(arena, string, StringFill_NoTerminate));
}
static String_u32
string_u32_from_string_char(Arena *arena, String_Const_char string){
return(string_u32_from_string_char(arena, string, StringFill_NoTerminate));
}
static String_u32
string_u32_from_string_u8(Arena *arena, String_Const_u8 string){
return(string_u32_from_string_u8(arena, string, StringFill_NoTerminate));
}
static String_u32
string_u32_from_string_u16(Arena *arena, String_Const_u16 string){
return(string_u32_from_string_u16(arena, string, StringFill_NoTerminate));
}
////////////////////////////////
static String_Const_char
string_char_from_any(Arena *arena, String_Const_Any string){
String_Const_char result = {};
switch (string.encoding){
case StringEncoding_ASCII: result = string.s_char; break;
case StringEncoding_UTF8: result = string_char_from_string_u8 (arena, string.s_u8 ).string; break;
case StringEncoding_UTF16: result = string_char_from_string_u16(arena, string.s_u16).string; break;
case StringEncoding_UTF32: result = string_char_from_string_u32(arena, string.s_u32).string; break;
}
return(result);
}
static String_Const_u8
string_u8_from_any(Arena *arena, String_Const_Any string){
String_Const_u8 result = {};
switch (string.encoding){
case StringEncoding_ASCII: result = string_u8_from_string_char(arena, string.s_char).string; break;
case StringEncoding_UTF8: result = string.s_u8; break;
case StringEncoding_UTF16: result = string_u8_from_string_u16(arena, string.s_u16).string; break;
case StringEncoding_UTF32: result = string_u8_from_string_u32(arena, string.s_u32).string; break;
}
return(result);
}
static String_Const_u16
string_u16_from_any(Arena *arena, String_Const_Any string){
String_Const_u16 result = {};
switch (string.encoding){
case StringEncoding_ASCII: result = string_u16_from_string_char(arena, string.s_char).string; break;
case StringEncoding_UTF8: result = string_u16_from_string_u8 (arena, string.s_u8 ).string; break;
case StringEncoding_UTF16: result = string.s_u16; break;
case StringEncoding_UTF32: result = string_u16_from_string_u32(arena, string.s_u32).string; break;
}
return(result);
}
static String_Const_u32
string_u32_from_any(Arena *arena, String_Const_Any string){
String_Const_u32 result = {};
switch (string.encoding){
case StringEncoding_ASCII: result = string_u32_from_string_char(arena, string.s_char).string; break;
case StringEncoding_UTF8: result = string_u32_from_string_u8 (arena, string.s_u8 ).string; break;
case StringEncoding_UTF16: result = string_u32_from_string_u16 (arena, string.s_u16 ).string; break;
case StringEncoding_UTF32: result = string.s_u32; break;
}
return(result);
}
static String_Const_Any
string_any_from_any(Arena *arena, String_Encoding encoding, String_Const_Any string){
String_Const_Any result = {encoding};
switch (encoding){
case StringEncoding_ASCII: result.s_char = string_char_from_any(arena, string); break;
case StringEncoding_UTF8: result.s_u8 = string_u8_from_any (arena, string); break;
case StringEncoding_UTF16: result.s_u16 = string_u16_from_any (arena, string); break;
case StringEncoding_UTF32: result.s_u32 = string_u32_from_any (arena, string); break;
}
return(result);
}
static List_String_Const_char
string_list_char_from_any(Arena *arena, List_String_Const_Any list){
List_String_Const_char result = {};
for (Node_String_Const_Any *node = list.first;
node != 0;
node = node->next){
string_list_push(arena, &result, string_char_from_any(arena, node->string));
}
return(result);
}
static List_String_Const_u8
string_list_u8_from_any(Arena *arena, List_String_Const_Any list){
List_String_Const_u8 result = {};
for (Node_String_Const_Any *node = list.first;
node != 0;
node = node->next){
string_list_push(arena, &result, string_u8_from_any(arena, node->string));
}
return(result);
}
static List_String_Const_u16
string_list_u16_from_any(Arena *arena, List_String_Const_Any list){
List_String_Const_u16 result = {};
for (Node_String_Const_Any *node = list.first;
node != 0;
node = node->next){
string_list_push(arena, &result, string_u16_from_any(arena, node->string));
}
return(result);
}
static List_String_Const_u32
string_list_u32_from_any(Arena *arena, List_String_Const_Any list){
List_String_Const_u32 result = {};
for (Node_String_Const_Any *node = list.first;
node != 0;
node = node->next){
string_list_push(arena, &result, string_u32_from_any(arena, node->string));
}
return(result);
}
////////////////////////////////
static List_String_Const_char
string_replace_list(Arena *arena, String_Const_char source, String_Const_char needle, String_Const_char replacement){
List_String_Const_char list = {};
for (;;){
umem i = string_find_first(source, needle);
string_list_push(arena, &list, string_prefix(source, i));
if (i < source.size){
string_list_push(arena, &list, replacement);
source = string_skip(source, i + needle.size);
}
else{
break;
}
}
return(list);
}
static List_String_Const_u8
string_replace_list(Arena *arena, String_Const_u8 source, String_Const_u8 needle, String_Const_u8 replacement){
List_String_Const_u8 list = {};
for (;;){
umem i = string_find_first(source, needle);
string_list_push(arena, &list, string_prefix(source, i));
if (i < source.size){
string_list_push(arena, &list, replacement);
source = string_skip(source, i + needle.size);
}
else{
break;
}
}
return(list);
}
static List_String_Const_u16
string_replace_list(Arena *arena, String_Const_u16 source, String_Const_u16 needle, String_Const_u16 replacement){
List_String_Const_u16 list = {};
for (;;){
umem i = string_find_first(source, needle);
string_list_push(arena, &list, string_prefix(source, i));
if (i < source.size){
string_list_push(arena, &list, replacement);
source = string_skip(source, i + needle.size);
}
else{
break;
}
}
return(list);
}
static List_String_Const_u32
string_replace_list(Arena *arena, String_Const_u32 source, String_Const_u32 needle, String_Const_u32 replacement){
List_String_Const_u32 list = {};
for (;;){
umem i = string_find_first(source, needle);
string_list_push(arena, &list, string_prefix(source, i));
if (i < source.size){
string_list_push(arena, &list, replacement);
source = string_skip(source, i + needle.size);
}
else{
break;
}
}
return(list);
}
static String_Const_char
string_replace(Arena *arena, String_Const_char source, String_Const_char needle, String_Const_char replacement, String_Fill_Terminate_Rule rule){
List_String_Const_char list = string_replace_list(arena, source, needle, replacement);
return(string_list_flatten(arena, list, rule));
}
static String_Const_u8
string_replace(Arena *arena, String_Const_u8 source, String_Const_u8 needle, String_Const_u8 replacement, String_Fill_Terminate_Rule rule){
List_String_Const_u8 list = string_replace_list(arena, source, needle, replacement);
return(string_list_flatten(arena, list, rule));
}
static String_Const_u16
string_replace(Arena *arena, String_Const_u16 source, String_Const_u16 needle, String_Const_u16 replacement, String_Fill_Terminate_Rule rule){
List_String_Const_u16 list = string_replace_list(arena, source, needle, replacement);
return(string_list_flatten(arena, list, rule));
}
static String_Const_u32
string_replace(Arena *arena, String_Const_u32 source, String_Const_u32 needle, String_Const_u32 replacement, String_Fill_Terminate_Rule rule){
List_String_Const_u32 list = string_replace_list(arena, source, needle, replacement);
return(string_list_flatten(arena, list, rule));
}
static String_Const_char
string_replace(Arena *arena, String_Const_char source, String_Const_char needle, String_Const_char replacement){
return(string_replace(arena, source, needle, replacement, StringFill_NoTerminate));
}
static String_Const_u8
string_replace(Arena *arena, String_Const_u8 source, String_Const_u8 needle, String_Const_u8 replacement){
return(string_replace(arena, source, needle, replacement, StringFill_NoTerminate));
}
static String_Const_u16
string_replace(Arena *arena, String_Const_u16 source, String_Const_u16 needle, String_Const_u16 replacement){
return(string_replace(arena, source, needle, replacement, StringFill_NoTerminate));
}
static String_Const_u32
string_replace(Arena *arena, String_Const_u32 source, String_Const_u32 needle, String_Const_u32 replacement){
return(string_replace(arena, source, needle, replacement, StringFill_NoTerminate));
}
////////////////////////////////
static b32
byte_is_ascii(u8 byte){
return(byte == '\r' || byte == '\n' || byte == '\t' || (' ' <= byte && byte <= '~'));
}
static b32
data_is_ascii(Data data){
u8 *ptr = (u8*)data.data;
u8 *one_past_last = ptr + data.size;
b32 result = true;
for (;ptr < one_past_last; ptr += 1){
if (!byte_is_ascii(*ptr) && !(*ptr == 0 && ptr + 1 == one_past_last)){
result = false;
break;
}
}
return(result);
}
////////////////////////////////
static String_Const_char
string_interpret_escapes(Arena *arena, String_Const_char string){
char *space = push_array(arena, char, string.size + 1);
String_char result = Schar(space, 0, string.size);
for (;;){
umem back_slash_pos = string_find_first(string, '\\');
string_append(&result, string_prefix(string, back_slash_pos));
string = string_skip(string, back_slash_pos + 1);
if (string.size == 0){
break;
}
switch (string.str[0]){
case '\\':
{
string_append_character(&result, '\\');
}break;
case 'n':
{
string_append_character(&result, '\n');
}break;
case 't':
{
string_append_character(&result, '\t');
}break;
case '"':
{
string_append_character(&result, '\"');
}break;
case '0':
{
string_append_character(&result, '\0');
}break;
default:
{
char c[2] = {'\\'};
c[1] = string.str[0];
string_append(&result, SCchar(c, 2));
}break;
}
string = string_skip(string, 1);
}
result.str[result.size] = 0;
pop_array(arena, char, result.cap - result.size);
return(result.string);
}
static String_Const_u8
string_interpret_escapes(Arena *arena, String_Const_u8 string){
return(SCu8(string_interpret_escapes(arena, SCchar(string))));
}
global_const u8 integer_symbols[] = {
'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F',
};
global_const u8 integer_symbol_reverse[128] = {
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,0x10,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
};
global_const u8 base64[64] = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'_', '$',
};
global_const u8 base64_reverse[128] = {
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0xFF,0xFF,0xFF,0xFF,0x3F,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0xFF,0xFF,0xFF,0xFF,0xFF,0x00,
0xFF,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,0x30,0x31,0x32,
0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0xFF,0xFF,0xFF,0xFF,0x3E,
0xFF,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,
0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,0x20,0x21,0x22,0x23,0xFF,0xFF,0xFF,0xFF,0xFF,
};
static umem
digit_count_from_integer(u64 x, u32 radix){
umem result = {};
if (radix >= 2 && radix <= 16){
if (x == 0){
result = 1;
}
else{
do{
x /= radix;
result += 1;
} while(x > 0);
}
}
return(result);
}
static String_Const_u8
string_from_integer(Arena *arena, u64 x, u32 radix){
String_Const_u8 result = {};
if (radix >= 2 && radix <= 16){
if (x == 0){
Deprecated old table and arena code
2019-07-13 00:43:17 +00:00
result = push_string_copy(arena, string_u8_litexpr("0"));
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
}
else{
u8 string_space[64];
umem length = 0;
for (u64 X = x;
X > 0;
X /= radix, length += 1){
string_space[length] = integer_symbols[X%radix];
}
for (umem j = 0, i = length - 1;
j < i;
j += 1, i -= 1){
Swap(u8, string_space[i], string_space[j]);
}
Deprecated old table and arena code
2019-07-13 00:43:17 +00:00
result = push_string_copy(arena, SCu8(string_space, length));
Merge non-sense, who knows, here goes
2019-06-01 23:58:28 +00:00
}
}
return(result);
}
static b32
string_is_integer(String_Const_u8 string, u32 radix){
b32 is_integer = false;
if (radix <= 16){
is_integer = true;
for (umem i = 0; i < string.size; i += 1){
if (string.str[i] < 128){
u8 x = integer_symbol_reverse[character_to_upper(string.str[i])];
if (x >= radix){
is_integer = false;
break;
}
}
else{
is_integer = false;
break;
}
}
}
return(is_integer);
}
static u64
string_to_integer(String_Const_u8 string, u32 radix){
u64 x = 0;
if (radix <= 16){
for (umem i = 0; i < string.size; i += 1){
x *= radix;
if (string.str[i] < 128){
x += integer_symbol_reverse[character_to_upper(string.str[i])];
}
else{
x += 0xFF;
}
}
}
return(x);
}
static u64
string_to_integer(String_Const_char string, u32 radix){
return(string_to_integer(SCu8((u8*)string.str, string.size), radix));
}
static String_Const_u8
string_base64_encode_from_binary(Arena *arena, void *data, umem size){
umem char_count = div_round_up_positive(size*8, 6);
char_count = round_up_umem(char_count, 4);
String_Const_u8 string = string_const_u8_push(arena, char_count);
u8 *s = string.str;
u8 *d = (u8*)data;
u8 *de = d + size;
for (;d < de; d += 3, s += 4){
i32 in_byte_count = (i32)(de - d);
u8 *D = d;
b32 partial_fill = (in_byte_count < 3);
u8 D_space[3] = {};
if (partial_fill){
block_copy(D_space, d, clamp_top(sizeof(D_space), in_byte_count));
D = D_space;
}
s[0] = D[0] &bitmask_6;
s[1] = ((D[0] >> 6)&bitmask_2) | ((D[1]&bitmask_4) << 2);
s[2] = ((D[1] >> 4)&bitmask_4) | ((D[2]&bitmask_2) << 4);
s[3] = (D[2] >> 2)&bitmask_6;
for (i32 j = 0; j < 4; j += 1){
s[j] = base64[s[j]];
}
switch (in_byte_count){
case 1:
{
s[2] = '?';
s[3] = '?';
}break;
case 2:
{
s[3] = '?';
}break;
}
}
return(string);
}
static Data
data_decode_from_base64(Arena *arena, u8 *str, umem size){
Data data = {};
if (size%4 == 0){
umem data_size = size*6/8;
if (str[size - 2] == '?'){
data_size -= 2;
}
else if (str[size - 1] == '?'){
data_size -= 1;
}
data = push_data(arena, data_size);
u8 *s = str;
u8 *se = s + size;
u8 *d = (u8*)data.data;
u8 *de = d + data_size;
for (;s < se; d += 3, s += 4){
u8 *D = d;
i32 out_byte_count = (i32)(de - d);
b32 partial_fill = (out_byte_count < 3);
u8 D_space[2];
if (partial_fill){
D = D_space;
}
u8 S[4];
for (i32 j = 0; j < 4; j += 1){
if (s[j] < 128){
S[j] = base64_reverse[s[j]];
}
else{
S[j] = 0xFF;
}
}
D[0] = ( S[0] &bitmask_6) | ((S[1]&bitmask_2) << 6);
D[1] = ((S[1] >> 2)&bitmask_4) | ((S[2]&bitmask_4) << 4);
D[2] = ((S[2] >> 4)&bitmask_2) | ((S[3]&bitmask_6) << 2);
if (partial_fill){
Assert(out_byte_count <= sizeof(D_space));
block_copy(D, D_space, out_byte_count);
}
}
}
return(data);
}
////////////////////////////////
#if defined(FSTRING_GUARD)
static String
string_old_from_new(String_Const_char string){
return(make_string(string.str, (i32)string.size));
}
static String
string_old_from_new(String_Const_u8 string){
return(make_string((char*)string.str, (i32)string.size));
}
static String_Const_char
string_new_from_old(String string){
return(SCchar(string.str, (umem)string.size));
}
static String_Const_u8
string_new_u8_from_old(String string){
return(SCu8((u8*)string.str, (umem)string.size));
}
#endif
#endif
// BOTTOM