mr4th-public
/
c-scripting
3
Fork 0
Code Issues Releases Activity
c-scripting/src/mr4th/mr4th_base.c

5862 lines
140 KiB
C
Raw Blame History

////////////////////////////////////////////////
////////////////////////////////////////////////
/////////// BASE IMPLEMENTATION ////////////
////////////////////////////////////////////////
////////////////////////////////////////////////
////////////////////////////////
// Functions: Numerical/Math
// infinity
MR4TH_SYMBOL B32
is_inf_or_nan_F32(F32 x){
U32 u = *(U32*)&x;
B32 result = ((u&0x7f800000) == 0x7f800000);
return(result);
}
MR4TH_SYMBOL B32
is_inf_or_nan_F64(F64 x){
U64 u = *(U64*)&x;
B64 result = ((u&0x7ff0000000000000) == 0x7ff0000000000000);
return(result);
}
// float signs, rounding, and modulus
MR4TH_SYMBOL F32
abs_F32(F32 x){
union{ F32 f; U32 u; } r;
r.f = x;
r.u &= 0x7fffffff;
return(r.f);
}
MR4TH_SYMBOL F32
sign_F32(F32 x){
union{ F32 f; U32 u; } r;
r.f = x;
F32 result = (r.u&0x80000000)?-1.f:1.f;
return(result);
}
MR4TH_SYMBOL F32
trunc_F32(F32 x){
return((x < 0x1p23)?(F32)(S32)x:x);
}
MR4TH_SYMBOL F32
floor_F32(F32 x){
F32 r = trunc_F32(x);
if (x < r){
r -= 1.f;
}
return(r);
}
MR4TH_SYMBOL F32
ceil_F32(F32 x){
F32 r = trunc_F32(x);
if (x > r){
r += 1.f;
}
return(r);
}
MR4TH_SYMBOL F32
nearest_F32(F32 x){
F32 r = floor_F32(x + 0.5f);
return(r);
}
MR4TH_SYMBOL F32
mod_F32(F32 x, F32 m){
Assert(m > 0.f);
// + | -
F32 q = (x/m); // (x/m) | (x/m)
S32 q_s32 = (S32)q; // floor(x/m) | ceil(x/m)
F32 r = m*(F32)q_s32;// m*floor(x/m) | m*ceil(x/m)
// <= x | >= x
F32 d = x - r;
if (d < 0){
d += m;
}
return(d);
}
MR4TH_SYMBOL F32
frac_F32(F32 x){
// + | -
F32 q = (x); // (x) | (x)
S32 q_s32 = (S32)q; // floor(x) | ceil(x)
F32 r = (F32)q_s32; // floor(x) | ceil(x)
// <= x | >= x
F32 d = x - r;
return(d);
}
MR4TH_SYMBOL F64
abs_F64(F64 x){
union{ F64 f; U64 u; } r;
r.f = x;
r.u &= 0x7fffffffffffffff;
return(r.f);
}
MR4TH_SYMBOL F64
sign_F64(F64 x){
union{ F64 f; U32 u; } r;
r.f = x;
F64 result = (r.u&0x8000000000000000)?-1.:1.;
return(result);
}
MR4TH_SYMBOL F64
trunc_F64(F64 x){
return((x < 0x1p52)?(F64)(S64)x:x);
}
MR4TH_SYMBOL F64
floor_F64(F64 x){
F64 r = trunc_F64(x);
if (x < r){
r -= 1.f;
}
return(r);
}
MR4TH_SYMBOL F64
ceil_F64(F64 x){
F64 r = trunc_F64(x);
if (x > r){
r += 1.f;
}
return(r);
}
MR4TH_SYMBOL F64
nearest_F64(F64 x){
F64 r = floor_F64(x + 0.5f);
return(r);
}
MR4TH_SYMBOL F64
mod_F64(F64 x, F64 m){
Assert(m > 0.f);
// + | -
F64 q = (x/m); // (x/m) | (x/m)
S64 q_s64 = (S64)q; // floor(x/m) | ceil(x/m)
F64 r = m*(F64)q_s64;// m*floor(x/m) | m*ceil(x/m)
// <= x | >= x
F64 d = x - r;
if (d < 0){
d += m;
}
return(d);
}
MR4TH_SYMBOL F64
frac_F64(F64 x){
// + | -
F64 q = (x); // (x) | (x)
S64 q_s64 = (S64)q; // floor(x) | ceil(x)
F64 r = (F64)q_s64; // floor(x) | ceil(x)
// <= x | >= x
F64 d = x - r;
return(d);
}
// transcendental functions
#include <math.h>
MR4TH_SYMBOL F32
sin_F32(F32 x){
return(sinf(x*tau_F32));
}
MR4TH_SYMBOL F32
cos_F32(F32 x){
return(cosf(x*tau_F32));
}
MR4TH_SYMBOL F32
tan_F32(F32 x){
return(tanf(x*tau_F32));
}
MR4TH_SYMBOL F32
atan_F32(F32 x){
return(atanf(x)/tau_F32);
}
MR4TH_SYMBOL F32
atan2_F32(F32 x, F32 y){
return(atan2f(y, x)/tau_F32);
}
MR4TH_SYMBOL F32
sqrt_F32(F32 x){
return(sqrtf(x));
}
MR4TH_SYMBOL F32
inv_sqrt_F32(F32 x){
return(1.f/sqrtf(x));
}
MR4TH_SYMBOL F32
ln_F32(F32 x){
return(logf(x));
}
MR4TH_SYMBOL F32
pow_F32(F32 base, F32 x){
return(powf(base, x));
}
MR4TH_SYMBOL F64
sin_F64(F64 x){
return(sin(x*tau_F64));
}
MR4TH_SYMBOL F64
cos_F64(F64 x){
return(cos(x*tau_F64));
}
MR4TH_SYMBOL F64
tan_F64(F64 x){
return(tan(x*tau_F64));
}
MR4TH_SYMBOL F64
atan_F64(F64 x){
return(atan(x)/tau_F64);
}
MR4TH_SYMBOL F64
atan2_F64(F64 x, F64 y){
return(atan2(x, y)/tau_F64);
}
MR4TH_SYMBOL F64
sqrt_F64(F64 x){
return(sqrt(x));
}
MR4TH_SYMBOL F64
inv_sqrt_F64(F64 x){
return(1.f/sqrt(x));
}
MR4TH_SYMBOL F64
ln_F64(F64 x){
return(log(x));
}
MR4TH_SYMBOL F64
pow_F64(F64 base, F64 x){
return(powf(base, x));
}
// linear interpolation
MR4TH_SYMBOL F32
lerp(F32 a, F32 t, F32 b){
F32 x = a + (b - a)*t;
return(x);
}
MR4TH_SYMBOL F32
unlerp(F32 a, F32 x, F32 b){
F32 t = 0.f;
if (a != b){
t = (x - a)/(b - a);
}
return(t);
}
// integer rounding
MR4TH_SYMBOL U32
next_pow2_U32(U32 x){
U32 result = x;
if (result == 0){
result = 1;
}
else{
// TODO(allen): speed up with bit scan intrinsic
result -= 1;
result |= (result >> 1);
result |= (result >> 2);
result |= (result >> 4);
result |= (result >> 8);
result |= (result >> 16);
result += 1;
}
return(result);
}
MR4TH_SYMBOL S32
sign_extend_S32(S32 x, U32 bitidx){
U32 shiftn = (31 - bitidx);
x = x << shiftn;
x = x >> shiftn;
return(x);
}
MR4TH_SYMBOL U64
next_pow2_U64(U32 x){
U64 result = x;
if (result == 0){
result = 1;
}
else{
// TODO(allen): speed up with bit scan intrinsic
result -= 1;
result |= (result >> 1);
result |= (result >> 2);
result |= (result >> 4);
result |= (result >> 8);
result |= (result >> 16);
result |= (result >> 32);
result += 1;
}
return(result);
}
MR4TH_SYMBOL S64
sign_extend_S64(S64 x, U32 bitidx){
U32 shiftn = (63 - bitidx);
x = x << shiftn;
x = x >> shiftn;
return(x);
}
////////////////////////////////
// Functions: Compound Types
// 2d vectors
MR4TH_SYMBOL V2F32
v2_polar(F32 theta, F32 radius){
V2F32 result = {radius*cos_F32(theta), radius*sin_F32(theta)};
return(result);
}
MR4TH_SYMBOL F32
angle_from_v2f32(V2F32 v){
F32 result = atan2_F32(v.x, v.y);
return(result);
}
MR4TH_SYMBOL V2F32
v2_unit(V2F32 v){
F32 recip = inv_sqrt_F32(v.x*v.x + v.y*v.y);
V2F32 r = {0};
r.x = v.x*recip;
r.y = v.y*recip;
return(r);
}
// 3d vectors
MR4TH_SYMBOL V3F32
v3_spherical(F32 theta_xz, F32 theta_yz, F32 radius){
F32 sxz = sin_F32(theta_xz);
F32 syz = sin_F32(theta_yz);
F32 cxz = cos_F32(theta_xz);
F32 cyz = cos_F32(theta_yz);
V3F32 result = {0};
result.x = radius*sxz;
result.y = radius*syz;
result.z = radius*cxz*cyz;
return(result);
}
MR4TH_SYMBOL V3F32
v3_cross(V3F32 a, V3F32 b){
V3F32 result = {
a.y*b.z - a.z*b.y,
a.z*b.x - a.x*b.z,
a.x*b.y - a.y*b.x,
};
return(result);
}
MR4TH_SYMBOL V3F32
v3_unit(V3F32 v){
F32 recip = inv_sqrt_F32(v.x*v.x + v.y*v.y + v.z*v.z);
V3F32 r = {0};
r.x = v.x*recip;
r.y = v.y*recip;
r.z = v.z*recip;
return(r);
}
// 4x4 matrix
MR4TH_SYMBOL B32
mat4x4_inv(F32 *in, F32 *out){
/* credit: https://github.com/niswegmann/small-matrix-inverse/tree/master */
out[0] =
+ in[ 5]*in[10]*in[15]
- in[ 5]*in[11]*in[14]
- in[ 9]*in[ 6]*in[15]
+ in[ 9]*in[ 7]*in[14]
+ in[13]*in[ 6]*in[11]
- in[13]*in[ 7]*in[10];
out[1] =
- in[ 1]*in[10]*in[15]
+ in[ 1]*in[11]*in[14]
+ in[ 9]*in[ 2]*in[15]
- in[ 9]*in[ 3]*in[14]
- in[13]*in[ 2]*in[11]
+ in[13]*in[ 3]*in[10];
out[2] =
+ in[ 1]*in[ 6]*in[15]
- in[ 1]*in[ 7]*in[14]
- in[ 5]*in[ 2]*in[15]
+ in[ 5]*in[ 3]*in[14]
+ in[13]*in[ 2]*in[ 7]
- in[13]*in[ 3]*in[ 6];
out[3] =
- in[ 1]*in[ 6]*in[11]
+ in[ 1]*in[ 7]*in[10]
+ in[ 5]*in[ 2]*in[11]
- in[ 5]*in[ 3]*in[10]
- in[ 9]*in[ 2]*in[ 7]
+ in[ 9]*in[ 3]*in[ 6];
out[4] =
- in[ 4]*in[10]*in[15]
+ in[ 4]*in[11]*in[14]
+ in[ 8]*in[ 6]*in[15]
- in[ 8]*in[ 7]*in[14]
- in[12]*in[ 6]*in[11]
+ in[12]*in[ 7]*in[10];
out[5] =
+ in[ 0]*in[10]*in[15]
- in[ 0]*in[11]*in[14]
- in[ 8]*in[ 2]*in[15]
+ in[ 8]*in[ 3]*in[14]
+ in[12]*in[ 2]*in[11]
- in[12]*in[ 3]*in[10];
out[6] =
- in[ 0]*in[ 6]*in[15]
+ in[ 0]*in[ 7]*in[14]
+ in[ 4]*in[ 2]*in[15]
- in[ 4]*in[ 3]*in[14]
- in[12]*in[ 2]*in[ 7]
+ in[12]*in[ 3]*in[ 6];
out[7] =
+ in[ 0]*in[ 6]*in[11]
- in[ 0]*in[ 7]*in[10]
- in[ 4]*in[ 2]*in[11]
+ in[ 4]*in[ 3]*in[10]
+ in[ 8]*in[ 2]*in[ 7]
- in[ 8]*in[ 3]*in[ 6];
out[8] =
+ in[ 4]*in[ 9]*in[15]
- in[ 4]*in[11]*in[13]
- in[ 8]*in[ 5]*in[15]
+ in[ 8]*in[ 7]*in[13]
+ in[12]*in[ 5]*in[11]
- in[12]*in[ 7]*in[ 9];
out[9] =
- in[ 0]*in[ 9]*in[15]
+ in[ 0]*in[11]*in[13]
+ in[ 8]*in[ 1]*in[15]
- in[ 8]*in[ 3]*in[13]
- in[12]*in[ 1]*in[11]
+ in[12]*in[ 3]*in[ 9];
out[10] =
+ in[ 0]*in[ 5]*in[15]
- in[ 0]*in[ 7]*in[13]
- in[ 4]*in[ 1]*in[15]
+ in[ 4]*in[ 3]*in[13]
+ in[12]*in[ 1]*in[ 7]
- in[12]*in[ 3]*in[ 5];
out[11] =
- in[ 0]*in[ 5]*in[11]
+ in[ 0]*in[ 7]*in[ 9]
+ in[ 4]*in[ 1]*in[11]
- in[ 4]*in[ 3]*in[ 9]
- in[ 8]*in[ 1]*in[ 7]
+ in[ 8]*in[ 3]*in[ 5];
out[12] =
- in[ 4]*in[ 9]*in[14]
+ in[ 4]*in[10]*in[13]
+ in[ 8]*in[ 5]*in[14]
- in[ 8]*in[ 6]*in[13]
- in[12]*in[ 5]*in[10]
+ in[12]*in[ 6]*in[ 9];
out[13] =
+ in[ 0]*in[ 9]*in[14]
- in[ 0]*in[10]*in[13]
- in[ 8]*in[ 1]*in[14]
+ in[ 8]*in[ 2]*in[13]
+ in[12]*in[ 1]*in[10]
- in[12]*in[ 2]*in[ 9];
out[14] =
- in[ 0]*in[ 5]*in[14]
+ in[ 0]*in[ 6]*in[13]
+ in[ 4]*in[ 1]*in[14]
- in[ 4]*in[ 2]*in[13]
- in[12]*in[ 1]*in[ 6]
+ in[12]*in[ 2]*in[ 5];
out[15] =
+ in[ 0]*in[ 5]*in[10]
- in[ 0]*in[ 6]*in[ 9]
- in[ 4]*in[ 1]*in[10]
+ in[ 4]*in[ 2]*in[ 9]
+ in[ 8]*in[ 1]*in[ 6]
- in[ 8]*in[ 2]*in[ 5];
F32 det = in[0]*out[0] + in[1]*out[4] + in[2]*out[8] + in[3]*out[12];
B32 result = 0;
if (det != 0.f){
F32 invdet = 1.f/det;
for (U32 i = 0; i < 16; i += 1){
out[i] *= invdet;
}
result = 1;
}
return(result);
}
MR4TH_SYMBOL void
mat4x4_mul(F32 *a, F32 *b, F32 *out){
out[ 0] = a[ 0]*b[ 0] + a[ 1]*b[ 4] + a[ 2]*b[ 8] + a[ 3]*b[12];
out[ 1] = a[ 0]*b[ 1] + a[ 1]*b[ 5] + a[ 2]*b[ 9] + a[ 3]*b[13];
out[ 2] = a[ 0]*b[ 2] + a[ 1]*b[ 6] + a[ 2]*b[10] + a[ 3]*b[14];
out[ 3] = a[ 0]*b[ 3] + a[ 1]*b[ 7] + a[ 2]*b[11] + a[ 3]*b[15];
out[ 4] = a[ 4]*b[ 0] + a[ 5]*b[ 4] + a[ 6]*b[ 8] + a[ 7]*b[12];
out[ 5] = a[ 4]*b[ 1] + a[ 5]*b[ 5] + a[ 6]*b[ 9] + a[ 7]*b[13];
out[ 6] = a[ 4]*b[ 2] + a[ 5]*b[ 6] + a[ 6]*b[10] + a[ 7]*b[14];
out[ 7] = a[ 4]*b[ 3] + a[ 5]*b[ 7] + a[ 6]*b[11] + a[ 7]*b[15];
out[ 8] = a[ 8]*b[ 0] + a[ 9]*b[ 4] + a[10]*b[ 8] + a[11]*b[12];
out[ 9] = a[ 8]*b[ 1] + a[ 9]*b[ 5] + a[10]*b[ 9] + a[11]*b[13];
out[10] = a[ 8]*b[ 2] + a[ 9]*b[ 6] + a[10]*b[10] + a[11]*b[14];
out[11] = a[ 8]*b[ 3] + a[ 9]*b[ 7] + a[10]*b[11] + a[11]*b[15];
out[12] = a[12]*b[ 0] + a[13]*b[ 4] + a[14]*b[ 8] + a[15]*b[12];
out[13] = a[12]*b[ 1] + a[13]*b[ 5] + a[14]*b[ 9] + a[15]*b[13];
out[14] = a[12]*b[ 2] + a[13]*b[ 6] + a[14]*b[10] + a[15]*b[14];
out[15] = a[12]*b[ 3] + a[13]*b[ 7] + a[14]*b[11] + a[15]*b[15];
}
////////////////////////////////
// Functions: Memory Operations
MR4TH_SYMBOL void
memory_zero(void *ptr, U64 size){
U64 z64 = size/8;
U64 z8 = size%8;
U64 *p64 = (U64*)ptr;
for (;z64 > 0;){
*p64 = 0;
p64 += 1;
z64 -= 1;
}
U8 *p8 = (U8*)p64;
for (;z8 > 0;){
*p8 = 0;
p8 += 1;
z8 -= 1;
}
}
MR4TH_SYMBOL void
memory_fill(void *ptr, U64 size, U8 fillbyte){
U64 fillqword = fillbyte;
{
fillqword |= fillqword << 8;
fillqword |= fillqword << 16;
fillqword |= fillqword << 32;
}
U64 z64 = size/8;
U64 z8 = size%8;
U64 *p64 = (U64*)ptr;
for (;z64 > 0;){
*p64 = fillqword;
p64 += 1;
z64 -= 1;
}
U8 *p8 = (U8*)p64;
for (;z8 > 0;){
*p8 = fillbyte;
p8 += 1;
z8 -= 1;
}
}
MR4TH_SYMBOL B32
memory_match(void *a, void *b, U64 size){
U64 z64 = size/8;
U64 z8 = size%8;
U64 *a64 = (U64*)a;
U64 *b64 = (U64*)b;
for (;z64 > 0;){
if (*a64 != *b64){
return(0);
}
a64 += 1;
b64 += 1;
z64 -= 1;
}
U8 *a8 = (U8*)a64;
U8 *b8 = (U8*)b64;
for (;z8 > 0;){
if (*a8 != *b8){
return(0);
}
a8 += 1;
b8 += 1;
z8 -= 1;
}
return(1);
}
MR4TH_SYMBOL void*
memory_move(void *dst, void *src, U64 size){
U64 z64 = size/8;
U64 z8 = size%8;
// backwards
if ((U8*)src < (U8*)dst){
U8 *dst8 = ((U8*)dst) + size;
U8 *src8 = ((U8*)src) + size;
for (;z8 > 0;){
dst8 -= 1;
src8 -= 1;
*dst8 = *src8;
z8 -= 1;
}
U64 *dst64 = (U64*)dst8;
U64 *src64 = (U64*)src8;
for (;z64 > 0;){
dst64 -= 1;
src64 -= 1;
*dst64 = *src64;
z64 -= 1;
}
}
// forwards
else if ((U8*)src > (U8*)dst){
U64 *dst64 = (U64*)dst;
U64 *src64 = (U64*)src;
for (;z64 > 0;){
*dst64 = *src64;
dst64 += 1;
src64 += 1;
z64 -= 1;
}
U8 *dst8 = (U8*)dst64;
U8 *src8 = (U8*)src64;
for (;z8 > 0;){
*dst8 = *src8;
dst8 += 1;
src8 += 1;
z8 -= 1;
}
}
return(dst);
}
////////////////////////////////
// Functions: Symbolic Constants
MR4TH_SYMBOL OperatingSystem
operating_system_from_context(void){
OperatingSystem result = OperatingSystem_Null;
#if OS_WINDOWS
result = OperatingSystem_Windows;
#elif OS_LINUX
result = OperatingSystem_Linux;
#elif OS_MAC
result = OperatingSystem_Mac;
#endif
return(result);
}
MR4TH_SYMBOL Architecture
architecture_from_context(void){
Architecture result = Architecture_Null;
#if ARCH_X64
result = Architecture_X64;
#elif ARCH_X86
result = Architecture_X86;
#elif ARCH_ARM
result = Architecture_Arm;
#elif ARCH_ARM64
result = Architecture_Arm64;
#endif
return(result);
}
MR4TH_SYMBOL char*
string_from_operating_system(OperatingSystem os){
char *result = "(null)";
switch (os){
default:break;
case OperatingSystem_Windows:
{
result = "windows";
}break;
case OperatingSystem_Linux:
{
result = "linux";
}break;
case OperatingSystem_Mac:
{
result = "mac";
}break;
}
return(result);
}
MR4TH_SYMBOL char*
string_from_architecture(Architecture arch){
char *result = "(null)";
switch (arch){
default:break;
case Architecture_X64:
{
result = "x64";
}break;
case Architecture_X86:
{
result = "x86";
}break;
case Architecture_Arm:
{
result = "arm";
}break;
case Architecture_Arm64:
{
result = "armm64";
}break;
}
return(result);
}
MR4TH_SYMBOL char*
string_from_month(Month month){
char *result = "(null)";
switch (month){
case Month_Jan:
{
result = "jan";
}break;
case Month_Feb:
{
result = "feb";
}break;
case Month_Mar:
{
result = "mar";
}break;
case Month_Apr:
{
result = "apr";
}break;
case Month_May:
{
result = "may";
}break;
case Month_Jun:
{
result = "jun";
}break;
case Month_Jul:
{
result = "jul";
}break;
case Month_Aug:
{
result = "aug";
}break;
case Month_Sep:
{
result = "sep";
}break;
case Month_Oct:
{
result = "oct";
}break;
case Month_Nov:
{
result = "nov";
}break;
case Month_Dec:
{
result = "dec";
}break;
}
return(result);
}
MR4TH_SYMBOL char*
string_from_day_of_week(DayOfWeek day_of_week){
char *result = "(null)";
switch (day_of_week){
case DayOfWeek_Sunday:
{
result = "sunday";
}break;
case DayOfWeek_Monday:
{
result = "monday";
}break;
case DayOfWeek_Tuesday:
{
result = "tuesday";
}break;
case DayOfWeek_Wednesday:
{
result = "wednesday";
}break;
case DayOfWeek_Thursday:
{
result = "thursday";
}break;
case DayOfWeek_Friday:
{
result = "friday";
}break;
case DayOfWeek_Saturday:
{
result = "saturday";
}break;
}
return(result);
}
////////////////////////////////
// Functions: Time
MR4TH_SYMBOL DenseTime
dense_time_from_date_time(DateTime *in){
U32 year_encoded = (U32)((S32)in->year + 0x8000);
DenseTime result = 0;
result += year_encoded;
result *= 12;
result += (in->mon - 1);
result *= 31;
result += (in->day - 1);
result *= 24;
result += in->hour;
result *= 60;
result += in->min;
result *= 61;
result += in->sec;
result *= 1000;
result += in->msec;
return(result);
}
MR4TH_SYMBOL DateTime
date_time_from_dense_time(DenseTime in){
DateTime result = {0};
result.msec = in%1000;
in /= 1000;
result.sec = in%61;
in /= 61;
result.min = in%60;
in /= 60;
result.hour = in%24;
in /= 24;
result.day = (in%31) + 1;
in /= 31;
result.mon = (in%12) + 1;
in /= 12;
S32 year_encoded = (S32)in;
result.year = (year_encoded - 0x8000);
return(result);
}
////////////////////////////////
// Functions: Arena
// arena core implementation
#define MR4TH_MEM_COMMIT_BLOCK_SIZE MB(64)
#define MR4TH_MEM_MAX_ALIGN 64
#define MR4TH_MEM_SCRATCH_POOL_COUNT 2
struct Arena{
Arena *current;
Arena *prev;
U64 default_reserve_size;
U16 alignment;
B8 growing;
U8 filler[5];
U64 base_pos;
U64 chunk_cap;
U64 chunk_pos;
U64 chunk_commit_pos;
};
#define MEM_INITIAL_COMMIT KB(4)
#define MEM_INTERNAL_MIN_SIZE AlignUpPow2(sizeof(Arena), MR4TH_MEM_MAX_ALIGN)
#if !MR4TH_PLUGIN_MODE
// arena pre-requisites
StaticAssert(sizeof(Arena) <= MEM_INITIAL_COMMIT, mem_check_arena_size);
StaticAssert(IsPow2OrZero(MR4TH_MEM_COMMIT_BLOCK_SIZE) &&
MR4TH_MEM_COMMIT_BLOCK_SIZE != 0,
mem_check_commit_block_size);
StaticAssert(IsPow2OrZero(MR4TH_MEM_MAX_ALIGN) && MR4TH_MEM_MAX_ALIGN != 0,
mem_check_max_align);
// arena functions
MR4TH_SYMBOL_MUST_SHARE Arena*
arena_new(U64 reserve_size, U64 alignment, B32 growing){
ProfBeginFunc();
Arena *result = 0;
if (reserve_size >= MEM_INITIAL_COMMIT){
void *memory = os_memory_reserve(reserve_size);
if (os_memory_commit(memory, MEM_INITIAL_COMMIT)){
AsanPoison(memory, reserve_size);
AsanUnpoison(memory, MEM_INTERNAL_MIN_SIZE);
result = (Arena*)memory;
result->current = result;
result->prev = 0;
result->alignment = alignment;
result->default_reserve_size = reserve_size;
result->growing = growing;
result->base_pos = 0;
result->chunk_cap = reserve_size;
result->chunk_pos = MEM_INTERNAL_MIN_SIZE;
result->chunk_commit_pos = MEM_INITIAL_COMMIT;
}
}
Assert(result != 0);
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL_MUST_SHARE void
arena_release(Arena *arena){
ProfBeginFunc();
Arena *ptr = arena->current;
for (;ptr != 0;){
Arena *prev = ptr->prev;
AsanPoison(ptr, ptr->chunk_cap);
os_memory_release(ptr, ptr->chunk_cap);
ptr = prev;
}
ProfEndFunc();
}
MR4TH_SYMBOL_MUST_SHARE void*
arena_push_no_zero(Arena *arena, U64 size){
ProfBeginFunc();
void *result = 0;
Arena *current = arena->current;
// allocate new chunk if necessary
if (arena->growing){
U64 next_chunk_pos = AlignUpPow2(current->chunk_pos, arena->alignment);
next_chunk_pos += size;
if (next_chunk_pos > current->chunk_cap){
U64 new_reserve_size = arena->default_reserve_size;
U64 enough_to_fit = size + MEM_INTERNAL_MIN_SIZE;
if (new_reserve_size < enough_to_fit){
new_reserve_size = AlignUpPow2(enough_to_fit, KB(4));
}
void *memory = os_memory_reserve(new_reserve_size);
if (os_memory_commit(memory, MEM_INITIAL_COMMIT)){
AsanPoison(memory, new_reserve_size);
AsanUnpoison(memory, MEM_INTERNAL_MIN_SIZE);
Arena *new_chunk = (Arena*)memory;
new_chunk->prev = current;
new_chunk->base_pos = current->base_pos + current->chunk_cap;
new_chunk->chunk_cap = new_reserve_size;
new_chunk->chunk_pos = MEM_INTERNAL_MIN_SIZE;
new_chunk->chunk_commit_pos = MEM_INITIAL_COMMIT;
current = arena->current = new_chunk;
}
}
}
{
// if there is room in this chunk's reserve ...
U64 result_pos = AlignUpPow2(current->chunk_pos, arena->alignment);
U64 next_chunk_pos = result_pos + size;
if (next_chunk_pos <= current->chunk_cap){
// commit more memory if necessary
if (next_chunk_pos > current->chunk_commit_pos){
U64 next_commit_pos_aligned =
AlignUpPow2(next_chunk_pos, MR4TH_MEM_COMMIT_BLOCK_SIZE);
U64 next_commit_pos =
ClampTop(next_commit_pos_aligned, current->chunk_cap);
U64 commit_size = next_commit_pos - current->chunk_commit_pos;
if (os_memory_commit((U8*)current + current->chunk_commit_pos, commit_size)){
current->chunk_commit_pos = next_commit_pos;
}
}
// if there is room in the commit range, return memory & advance pos
if (next_chunk_pos <= current->chunk_commit_pos){
AsanUnpoison((U8*)current + current->chunk_pos,
next_chunk_pos - current->chunk_pos);
result = (U8*)current + result_pos;
current->chunk_pos = next_chunk_pos;
}
}
}
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL_MUST_SHARE void
arena_pop_to(Arena *arena, U64 pos){
ProfBeginFunc();
U64 clamped_total_pos = ClampBot(pos, MEM_INTERNAL_MIN_SIZE);
Arena *current = arena->current;
U64 total_pos = current->base_pos + current->chunk_pos;
if (clamped_total_pos < total_pos){
// release all chunks that begin after this pos
for (; clamped_total_pos < current->base_pos; ){
Arena *prev = current->prev;
AsanPoison(current, current->chunk_cap);
os_memory_release(current, current->chunk_cap);
current = prev;
}
// update arena's current
{
arena->current = current;
}
// update the chunk position of the chunk in
// the chain that contains this position.
{
U64 chunk_pos = clamped_total_pos - current->base_pos;
U64 clamped_chunk_pos = ClampBot(chunk_pos, MEM_INTERNAL_MIN_SIZE);
AsanPoison((U8*)current + clamped_chunk_pos,
current->chunk_pos - clamped_chunk_pos);
current->chunk_pos = clamped_chunk_pos;
}
}
ProfEndFunc();
}
MR4TH_SYMBOL_MUST_SHARE U64
arena_current_pos(Arena *arena){
Arena *current = arena->current;
U64 result = current->base_pos + current->chunk_pos;
return(result);
}
MR4TH_SYMBOL_MUST_SHARE U64
arena_current_align(Arena *arena){
return(arena->alignment);
}
MR4TH_SYMBOL_MUST_SHARE void
arena_set_align(Arena *arena, U64 alignment){
arena->alignment = alignment;
}
MR4TH_SYMBOL_STATIC MR4TH_THREADVAR
Arena *arena__scratch_pool[MR4TH_MEM_SCRATCH_POOL_COUNT] = {0};
MR4TH_SYMBOL_MUST_SHARE ArenaTemp
arena_get_scratch(Arena **conflict_array, U32 count){
ProfBeginFunc();
// init on first time
if (arena__scratch_pool[0] == 0){
Arena **scratch_slot = arena__scratch_pool;
for (U64 i = 0;
i < MR4TH_MEM_SCRATCH_POOL_COUNT;
i += 1, scratch_slot += 1){
*scratch_slot = arena_alloc();
}
}
// get non-conflicting arena
ArenaTemp result = {0};
Arena **scratch_slot = arena__scratch_pool;
for (U64 i = 0;
i < MR4TH_MEM_SCRATCH_POOL_COUNT;
i += 1, scratch_slot += 1){
B32 is_non_conflict = 1;
Arena **conflict_ptr = conflict_array;
for (U32 j = 0; j < count; j += 1, conflict_ptr += 1){
if (*scratch_slot == *conflict_ptr){
is_non_conflict = 0;
break;
}
}
if (is_non_conflict){
result = arena_begin_temp(*scratch_slot);
break;
}
}
ProfEndFunc();
return(result);
}
#endif /* arena core implementation */
// arena helpers
#if !defined(MR4TH_MEM_DEFAULT_RESERVE_SIZE)
# define MR4TH_MEM_DEFAULT_RESERVE_SIZE GB(1)
#endif
#if !defined(MR4TH_MEM_DEFAULT_ALIGNMENT)
# define MR4TH_MEM_DEFAULT_ALIGNMENT sizeof(void*)
#endif
MR4TH_SYMBOL Arena*
arena_alloc(void){
Arena *result = arena_new(MR4TH_MEM_DEFAULT_RESERVE_SIZE, MR4TH_MEM_DEFAULT_ALIGNMENT, 1);
return(result);
}
MR4TH_SYMBOL void*
arena_push(Arena *arena, U64 size){
void *result = arena_push_no_zero(arena, size);
MemoryZero(result, size);
return(result);
}
MR4TH_SYMBOL void
arena_pop_amount(Arena *arena, U64 amount){
U64 pos = arena_current_pos(arena);
U64 new_pos = 0;
if (pos > amount){
new_pos = pos - amount;
}
arena_pop_to(arena, new_pos);
}
MR4TH_SYMBOL void
arena_align(Arena *arena, U64 pow2_align){
Assert(IsPow2OrZero(pow2_align) && pow2_align != 0 &&
pow2_align <= MR4TH_MEM_MAX_ALIGN);
U64 pos = arena_current_pos(arena);
U64 align_pos = AlignUpPow2(pos, pow2_align);
U64 z = align_pos - pos;
if (z > 0){
arena_push(arena, z);
}
}
MR4TH_SYMBOL ArenaTemp
arena_begin_temp(Arena *arena){
U64 pos = arena_current_pos(arena);
ArenaTemp temp = {arena, pos};
return(temp);
}
MR4TH_SYMBOL void
arena_end_temp(ArenaTemp *temp){
arena_pop_to(temp->arena, temp->pos);
}
////////////////////////////////
// Functions: Strings
// characters
MR4TH_SYMBOL B32
char_is_whitespace(U8 c){
return(c == ' ' || c == '\n' || c == '\t' ||
c == '\r' || c == '\f' || c == '\v');
}
MR4TH_SYMBOL B32
char_is_slash(U8 c){
return(c == '/' || c == '\\');
}
MR4TH_SYMBOL B32
char_is_digit(U8 c){
return('0' <= c && c <= '9');
}
MR4TH_SYMBOL U8
char_to_uppercase(U8 c){
if ('a' <= c && c <= 'z'){
c += 'A' - 'a';
}
return(c);
}
MR4TH_SYMBOL U8
char_to_lowercase(U8 c){
if ('A' <= c && c <= 'Z'){
c += 'a' - 'A';
}
return(c);
}
// in-place constructors
MR4TH_SYMBOL String8
str8_range(U8 *first, U8 *opl){
String8 result = {first, (U64)(opl - first)};
return(result);
}
MR4TH_SYMBOL String8
str8_cstring(U8 *cstr){
U8 *ptr = cstr;
for (;*ptr != 0; ptr += 1);
String8 result = str8_range(cstr, ptr);
return(result);
}
MR4TH_SYMBOL String8
str8_cstring_capped(U8 *cstr, U8 *opl){
U8 *ptr = cstr;
for (;ptr < opl && *ptr != 0; ptr += 1);
String8 result = str8_range(cstr, ptr);
return(result);
}
MR4TH_SYMBOL String16
str16_cstring(U16 *cstr){
U16 *ptr = cstr;
for (;*ptr != 0; ptr += 1);
String16 result = {cstr, (U64)(ptr - cstr)};
return(result);
}
// compound constructors
MR4TH_SYMBOL void
str8_list_push(Arena *arena, String8List *list, String8 string){
String8Node *node = push_array(arena, String8Node, 1);
node->string = string;
SLLQueuePush(list->first, list->last, node);
list->node_count += 1;
list->total_size += string.size;
}
MR4TH_SYMBOL void
str8_list_push_front(Arena *arena, String8List *list, String8 string){
String8Node *node = push_array(arena, String8Node, 1);
node->string = string;
SLLQueuePushFront(list->first, list->last, node);
list->node_count += 1;
list->total_size += string.size;
}
MR4TH_SYMBOL String8List
str8_list_copy(Arena *arena, String8List *list){
String8List result = {0};
for (String8Node *node = list->first;
node != 0;
node = node->next){
String8 string = str8_push_copy(arena, node->string);
str8_list_push(arena, &result, string);
}
return(result);
}
MR4TH_SYMBOL String8
str8_join(Arena *arena, String8List *list, StringJoin *join_optional){
ProfBeginFunc();
// setup join parameters
MR4TH_SYMBOL_STATIC StringJoin dummy_join = {0};
StringJoin *join = join_optional;
if (join == 0){
join = &dummy_join;
}
// compute total size
U64 size = (join->pre.size +
join->post.size +
((list->node_count>0)?
(join->mid.size*(list->node_count - 1)):0) +
list->total_size);
// begin string build
U8 *str = push_array(arena, U8, size + 1);
U8 *ptr = str;
// write pre
MemoryCopy(ptr, join->pre.str, join->pre.size);
ptr += join->pre.size;
B32 is_mid = 0;
for (String8Node *node = list->first;
node != 0;
node = node->next){
// write mid
if (is_mid){
MemoryCopy(ptr, join->mid.str, join->mid.size);
ptr += join->mid.size;
}
// write node string
MemoryCopy(ptr, node->string.str, node->string.size);
ptr += node->string.size;
is_mid = 1;
}
// write post
MemoryCopy(ptr, join->post.str, join->post.size);
ptr += join->post.size;
// write null
*ptr = 0;
String8 result = CLiteral(String8){str, size};
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL String8List
str8_split(Arena *arena, String8 string, U8 *splits, U32 count){
ProfBeginFunc();
String8List result = {0};
U8 *ptr = string.str;
U8 *word_first = ptr;
U8 *opl = string.str + string.size;
for (;ptr < opl; ptr += 1){
// is this a split
U8 byte = *ptr;
B32 is_split_byte = 0;
for (U32 i = 0; i < count; i += 1){
if (byte == splits[i]){
is_split_byte = 1;
break;
}
}
if (is_split_byte){
// try to emit word, advance word first pointer
if (word_first < ptr){
str8_list_push(arena, &result, str8_range(word_first, ptr));
}
word_first = ptr + 1;
}
}
// try to emit final word
if (word_first < ptr){
str8_list_push(arena, &result, str8_range(word_first, ptr));
}
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL String8
str8_pushfv(Arena *arena, char *fmt, va_list args){
ProfBeginFunc();
// in case we need to try a second time
va_list args2;
va_copy(args2, args);
// try to build the string in 1024 bytes
U64 buffer_size = 1024;
U8 *buffer = push_array(arena, U8, buffer_size);
U64 actual_size = m4_vsnprintf((char*)buffer, buffer_size, fmt, args);
String8 result = {0};
if (actual_size < buffer_size){
// if first try worked, put back what we didn't use and finish
arena_pop_amount(arena, buffer_size - actual_size - 1);
result = CLiteral(String8){buffer, actual_size};
}
else{
// if first try failed, reset and try again with correct size
arena_pop_amount(arena, buffer_size);
U8 *fixed_buffer = push_array(arena, U8, actual_size + 1);
U64 final_size = m4_vsnprintf((char*)fixed_buffer, actual_size + 1, fmt, args2);
result = CLiteral(String8){fixed_buffer, final_size};
}
// end args2
va_end(args2);
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL String8
str8_pushf(Arena *arena, char *fmt, ...){
va_list args;
va_start(args, fmt);
String8 result = str8_pushfv(arena, fmt, args);
va_end(args);
return(result);
}
MR4TH_SYMBOL void
str8_list_pushf(Arena *arena, String8List *list, char *fmt, ...){
va_list args;
va_start(args, fmt);
String8 string = str8_pushfv(arena, fmt, args);
va_end(args);
str8_list_push(arena, list, string);
}
MR4TH_SYMBOL String8
str8_push_copy(Arena *arena, String8 string){
String8 result = {0};
result.str = push_array(arena, U8, string.size + 1);
result.size = string.size;
MemoryCopy(result.str, string.str, string.size);
result.str[result.size] = 0;
return(result);
}
// substrings
MR4TH_SYMBOL String8
str8_prefix(String8 str, U64 size){
U64 size_clamped = ClampTop(size, str.size);
String8 result = {str.str, size_clamped};
return(result);
}
MR4TH_SYMBOL String8
str8_chop(String8 str, U64 amount){
U64 amount_clamped = ClampTop(amount, str.size);
U64 remaining_size = str.size - amount_clamped;
String8 result = {str.str, remaining_size};
return(result);
}
MR4TH_SYMBOL String8
str8_postfix(String8 str, U64 size){
U64 size_clamped = ClampTop(size, str.size);
U64 skip_to = str.size - size_clamped;
String8 result = {str.str + skip_to, size_clamped};
return(result);
}
MR4TH_SYMBOL String8
str8_skip(String8 str, U64 amount){
U64 amount_clamped = ClampTop(amount, str.size);
U64 remaining_size = str.size - amount_clamped;
String8 result = {str.str + amount_clamped, remaining_size};
return(result);
}
MR4TH_SYMBOL String8
str8_skip_chop_whitespace(String8 str){
String8 result = str;
if (result.size > 0){
U8 *sptr = str.str;
U8 *eptr = str.str + str.size - 1;
for (;sptr < eptr && char_is_whitespace(*sptr); sptr += 1);
for (;sptr < eptr && char_is_whitespace(*eptr); eptr -= 1);
result = str8_range(sptr, eptr + 1);
}
return(result);
}
// hash
MR4TH_SYMBOL U64
str8_hash(String8 str){
U64 hash = 5381;
for (U8 *ptr = str.str, *opl = str.str + str.size;
ptr < opl;
ptr += 1){
U8 c = *ptr;
hash = (hash*33)^c;
}
return(hash);
}
// compare
MR4TH_SYMBOL B32
str8_match(String8 a, String8 b, StringMatchFlags flags){
ProfBeginFunc();
B32 result = 0;
if ((flags & StringMatchFlag_PrefixMatch) != 0 || a.size == b.size){
U64 size = a.size;
if ((flags & StringMatchFlag_PrefixMatch) != 0){
size = Min(a.size, b.size);
}
result = 1;
B32 no_case = ((flags & StringMatchFlag_NoCase) != 0);
for (U64 i = 0; i < size; i += 1){
U8 ac = a.str[i];
U8 bc = b.str[i];
if (no_case){
ac = char_to_uppercase(ac);
bc = char_to_uppercase(bc);
}
if (ac != bc){
result = 0;
break;
}
}
}
ProfEndFunc();
return(result);
}
// path helpers
MR4TH_SYMBOL String8
str8_chop_last_slash(String8 string){
String8 result = string;
if (string.size > 0){
// pos one past last slash
U64 pos = string.size;
for (S64 i = string.size - 1; i >= 0; i -= 1){
if (char_is_slash(string.str[i])){
pos = i;
break;
}
}
// chop result string
result.size = pos;
}
return(result);
}
MR4TH_SYMBOL String8
str8_file_name_from_path(String8 full_file_name){
String8 result = {0};
if (full_file_name.size > 0){
U8 *opl = full_file_name.str + full_file_name.size;
U8 *ptr = opl;
for (;ptr > full_file_name.str; ptr -= 1){
U8 c = ptr[-1];
if (c == '/' || c == '\\'){
break;
}
}
result = str8_range(ptr, opl);
}
return(result);
}
MR4TH_SYMBOL String8
str8_base_name_from_file_name(String8 file_name){
String8 result = {0};
if (file_name.size > 0){
U8 *opl = file_name.str + file_name.size;
U8 *ptr = file_name.str;
for (;ptr < opl; ptr += 1){
U8 c = ptr[0];
if (c == '.'){
break;
}
}
result = str8_range(file_name.str, ptr);
}
return(result);
}
// stylized constructors
MR4TH_SYMBOL String8
str8_join_flags(Arena *arena, String8List *list){
StringJoin join = {0};
join.mid = str8_lit(" | ");
String8 result = str8_join(arena, list, &join);
if (result.size == 0){
result = str8_lit("0");
}
return(result);
}
// unicode
MR4TH_SYMBOL StringDecode
str_decode_utf8(U8 *str, U32 cap){
ProfBeginFunc();
MR4TH_SYMBOL_STATIC U8 length[] = {
1, 1, 1, 1, // 000xx
1, 1, 1, 1,
1, 1, 1, 1,
1, 1, 1, 1,
0, 0, 0, 0, // 100xx
0, 0, 0, 0,
2, 2, 2, 2, // 110xx
3, 3, // 1110x
4, // 11110
0, // 11111
};
MR4TH_SYMBOL_STATIC U8 first_byte_mask[] = { 0, 0x7F, 0x1F, 0x0F, 0x07 };
MR4TH_SYMBOL_STATIC U8 final_shift[] = { 0, 18, 12, 6, 0 };
StringDecode result = {0};
if (cap > 0){
result.codepoint = '#';
result.size = 1;
U8 byte = str[0];
U8 l = length[byte >> 3];
if (0 < l && l <= cap){
U32 cp = (byte & first_byte_mask[l]) << 18;
switch (l){
case 4: cp |= ((str[3] & 0x3F) << 0);
case 3: cp |= ((str[2] & 0x3F) << 6);
case 2: cp |= ((str[1] & 0x3F) << 12);
default: break;
}
cp >>= final_shift[l];
result.codepoint = cp;
result.size = l;
}
}
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL U32
str_encode_utf8(U8 *dst, U32 codepoint){
ProfBeginFunc();
U32 size = 0;
if (codepoint < (1 << 7)){
dst[0] = codepoint;
size = 1;
}
else if (codepoint < (1 << 11)){
dst[0] = 0xC0 | (codepoint >> 6);
dst[1] = 0x80 | (codepoint & 0x3F);
size = 2;
}
else if (codepoint < (1 << 16)){
dst[0] = 0xE0 | (codepoint >> 12);
dst[1] = 0x80 | ((codepoint >> 6) & 0x3F);
dst[2] = 0x80 | (codepoint & 0x3F);
size = 3;
}
else if (codepoint < (1 << 21)){
dst[0] = 0xF0 | (codepoint >> 18);
dst[1] = 0x80 | ((codepoint >> 12) & 0x3F);
dst[2] = 0x80 | ((codepoint >> 6) & 0x3F);
dst[3] = 0x80 | (codepoint & 0x3F);
size = 4;
}
else{
dst[0] = '#';
size = 1;
}
ProfEndFunc();
return(size);
}
MR4TH_SYMBOL StringDecode
str_decode_utf16(U16 *str, U32 cap){
ProfBeginFunc();
StringDecode result = {'#', 1};
U16 x = str[0];
if (x < 0xD800 || 0xDFFF < x){
result.codepoint = x;
}
else if (cap >= 2){
U16 y = str[1];
if (0xD800 <= x && x < 0xDC00 &&
0xDC00 <= y && y < 0xE000){
U16 xj = x - 0xD800;
U16 yj = y - 0xDc00;
U32 xy = (xj << 10) | yj;
result.codepoint = xy + 0x10000;
result.size = 2;
}
}
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL U32
str_encode_utf16(U16 *dst, U32 codepoint){
ProfBeginFunc();
U32 size = 0;
if (codepoint < 0x10000){
dst[0] = codepoint;
size = 1;
}
else{
U32 cpj = codepoint - 0x10000;
dst[0] = (cpj >> 10) + 0xD800;
dst[1] = (cpj & 0x3FF) + 0xDC00;
size = 2;
}
ProfEndFunc();
return(size);
}
MR4TH_SYMBOL String32
str32_from_str8(Arena *arena, String8 string){
ProfBeginFunc();
U32 *memory = push_array(arena, U32, string.size + 1);
U32 *dptr = memory;
U8 *ptr = string.str;
U8 *opl = string.str + string.size;
for (; ptr < opl;){
StringDecode decode = str_decode_utf8(ptr, (U64)(opl - ptr));
*dptr = decode.codepoint;
ptr += decode.size;
dptr += 1;
}
*dptr = 0;
U64 alloc_count = string.size + 1;
U64 string_count = (U64)(dptr - memory);
U64 unused_count = alloc_count - string_count - 1;
arena_pop_amount(arena, unused_count*sizeof(*memory));
String32 result = {memory, string_count};
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL String8
str8_from_str32(Arena *arena, String32 string){
ProfBeginFunc();
U8 *memory = push_array(arena, U8, string.size*4 + 1);
U8 *dptr = memory;
U32 *ptr = string.str;
U32 *opl = string.str + string.size;
for (; ptr < opl;){
U32 size = str_encode_utf8(dptr, *ptr);
ptr += 1;
dptr += size;
}
*dptr = 0;
U64 alloc_count = string.size*4 + 1;
U64 string_count = (U64)(dptr - memory);
U64 unused_count = alloc_count - string_count - 1;
arena_pop_amount(arena, unused_count*sizeof(*memory));
String8 result = {memory, string_count};
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL String16
str16_from_str8(Arena *arena, String8 string){
ProfBeginFunc();
U16 *memory = push_array(arena, U16, string.size*2 + 1);
U16 *dptr = memory;
U8 *ptr = string.str;
U8 *opl = string.str + string.size;
for (; ptr < opl;){
StringDecode decode = str_decode_utf8(ptr, (U64)(opl - ptr));
U32 enc_size = str_encode_utf16(dptr, decode.codepoint);
ptr += decode.size;
dptr += enc_size;
}
*dptr = 0;
U64 alloc_count = string.size*2 + 1;
U64 string_count = (U64)(dptr - memory);
U64 unused_count = alloc_count - string_count - 1;
arena_pop_amount(arena, unused_count*sizeof(*memory));
String16 result = {memory, string_count};
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL String8
str8_from_str16(Arena *arena, String16 string){
ProfBeginFunc();
U8 *memory = push_array(arena, U8, string.size*3 + 1);
U8 *dptr = memory;
U16 *ptr = string.str;
U16 *opl = string.str + string.size;
for (; ptr < opl;){
StringDecode decode = str_decode_utf16(ptr, (U64)(opl - ptr));
U16 enc_size = str_encode_utf8(dptr, decode.codepoint);
ptr += decode.size;
dptr += enc_size;
}
*dptr = 0;
U64 alloc_count = string.size*3 + 1;
U64 string_count = (U64)(dptr - memory);
U64 unused_count = alloc_count - string_count - 1;
arena_pop_amount(arena, unused_count*sizeof(*memory));
String8 result = {memory, string_count};
ProfEndFunc();
return(result);
}
// numeric conversion
MR4TH_SYMBOL B32
str8_is_u64(String8 string, U32 radix){
Assert(2 <= radix && radix <= 16);
B32 result = 1;
{
U8 *ptr = string.str;
U8 *opl = string.str + string.size;
for (; ptr < opl; ptr += 1){
U8 num = 0xFF;
// extract
U8 s = *ptr - '0';
if (s <= 9){
num = s;
}
else{
s = *ptr - 'A';
if (s <= 5){
num = 0xA + s;
}
else{
s = *ptr - 'a';
if (s <= 5){
num = 0xA + s;
}
}
}
// bad parse check
if (num >= radix){
result = 0;
break;
}
}
}
return(result);
}
MR4TH_SYMBOL U64
u64_from_str8(String8 string, U32 radix){
Assert(2 <= radix && radix <= 16);
U64 result = 0;
{
U8 *ptr = string.str;
U8 *opl = string.str + string.size;
for (; ptr < opl; ptr += 1){
U8 num = 0xFF;
// extract
U8 s = *ptr - '0';
if (s <= 9){
num = s;
}
else{
s = *ptr - 'A';
if (s <= 5){
num = 0xA + s;
}
else{
s = *ptr - 'a';
if (s <= 5){
num = 0xA + s;
}
}
}
// bad parse check
if (num >= radix){
result = 0;
break;
}
// increment result
result *= radix;
result += num;
}
}
return(result);
}
MR4TH_SYMBOL U64
u64_from_str8_c_syntax(String8 string){
U8 *ptr = string.str;
U8 *opl = string.str + string.size;
U32 radix = 10;
if (ptr < opl && *ptr == '0'){
radix = 010;
ptr += 1;
if (ptr < opl && *ptr == 'x'){
radix = 0x10;
ptr += 1;
}
else if (ptr < opl && *ptr == 'b'){
radix = 2;
ptr += 1;
}
}
U64 result = u64_from_str8(str8_range(ptr, opl), radix);
return(result);
}
MR4TH_SYMBOL S64
s64_from_str8_c_syntax(String8 string){
U8 *ptr = string.str;
U8 *opl = string.str + string.size;
B32 negative = 0;
if (ptr < opl){
if (*ptr == '-'){
negative = 1;
ptr += 1;
}
else if (*ptr == '+'){
ptr += 1;
}
}
S64 result = u64_from_str8_c_syntax(str8_range(ptr, opl));
if (negative){
result = -result;
}
return(result);
}
MR4TH_SYMBOL F64
f64_from_str8(String8 string){
F64 result = 0.f;
U8 *ptr = string.str;
U8 *opl = string.str + string.size;
B32 negative = 0;
if (ptr < opl){
if (*ptr == '-'){
negative = 1;
ptr += 1;
}
else if (*ptr == '+'){
ptr += 1;
}
}
for (; ptr < opl; ptr += 1){
if (*ptr == '.'){
ptr += 1;
break;
}
U32 x = 0;
if ('0' <= *ptr && *ptr <= '9'){
x = *ptr - '0';
}
result *= 10.f;
result += x;
}
F32 mul = 0.1f;
for (; ptr < opl; ptr += 1){
U32 x = 0;
if ('0' <= *ptr && *ptr <= '9'){
x = *ptr - '0';
}
result += x*mul;
mul /= 10.f;
}
if (negative){
result = -result;
}
return(result);
}
////////////////////////////////
// Functions: Stream
// stream core implementation
typedef struct STREAM_Node{
struct STREAM_Node *next;
U64 size;
U8 data[0];
} STREAM_Node;
#define STREAM_NODE_FROM_DATA(d) (STREAM_Node*)((U8*)(d) - sizeof(STREAM_Node))
struct STREAM{
Arena *arena;
U64 clear_pos;
STREAM_Node *first_node;
STREAM_Node *last_node;
U64 buffer_cap;
U64 total_size;
STREAM_Node *unused_node;
};
#define STREAM_ALLOC_SIZE MB(16)
#if !MR4TH_PLUGIN_MODE
MR4TH_SYMBOL_MUST_SHARE STREAM*
stream_new(void){
Arena *arena = arena_alloc();
STREAM *stream = push_array(arena, STREAM, 1);
stream->arena = arena;
stream->clear_pos = arena_current_pos(arena);
return(stream);
}
MR4TH_SYMBOL_MUST_SHARE void
stream_release(STREAM *stream){
stream_clear(stream);
}
MR4TH_SYMBOL_MUST_SHARE void
stream_clear(STREAM *stream){
Arena *arena = stream->arena;
U64 clear_pos = stream->clear_pos;
arena_pop_to(arena, clear_pos);
MemoryZeroStruct(stream);
stream->arena = arena;
stream->clear_pos = clear_pos;
}
MR4TH_SYMBOL_MUST_SHARE void
stream_write(STREAM *stream, String8 data){
U64 data_pos = 0;
for (;data_pos < data.size;){
U64 remaining_size = data.size - data_pos;
// try to get a node with buffer space from the stream
// (don't return a node with no space!)
STREAM_Node *node = 0;
{
if (stream->buffer_cap > 0){
node = stream->last_node;
}
if (node != 0 && stream->buffer_cap <= node->size){
node = 0;
}
}
// if we didn't get a buffer, try the unused node
if (node == 0){
if (stream->unused_node != 0){
node = stream->unused_node;
stream->unused_node = 0;
stream->buffer_cap = node->size;
node->size = 0;
SLLQueuePush(stream->first_node, stream->last_node, node);
}
}
// if we didn't get a buffer, make one now
if (node == 0){
U64 alloc_size = sizeof(STREAM_Node) + remaining_size;
alloc_size = ClampBot(STREAM_ALLOC_SIZE, alloc_size);
node = (STREAM_Node*)push_array_no_zero(stream->arena, U8, alloc_size);
SLLQueuePush(stream->first_node, stream->last_node, node);
node->size = 0;
stream->buffer_cap = alloc_size - sizeof(STREAM_Node);
}
// get buffer from the node
U8 *buffer = node->data + node->size;
U64 buffer_size = stream->buffer_cap - node->size;
// calculate amount to copy
U64 copy_amount = ClampTop(remaining_size, buffer_size);
// copy memory and increment counters
MemoryCopy(buffer, data.str + data_pos, copy_amount);
node->size += copy_amount;
stream->total_size += copy_amount;
data_pos += copy_amount;
}
}
MR4TH_SYMBOL_MUST_SHARE U8*
stream_alloc(STREAM *stream, U64 size){
// try to get a node with buffer space
// (don't return a node with no space)
STREAM_Node *node = 0;
{
if (stream->buffer_cap > 0){
node = stream->last_node;
}
if (node != 0 && stream->buffer_cap <= node->size){
node = 0;
}
}
// if there is a node but it's not big enough...
if (node != 0 && stream->buffer_cap - node->size < size){
U64 remaining_cap = stream->buffer_cap - node->size;
U64 unused_ptr = IntFromPtr(node->data) + node->size;
U64 unused_opl = IntFromPtr(node->data) + stream->buffer_cap;
U64 unused_ptr_aligned = AlignUpPow2(unused_ptr, sizeof(void*));
if (unused_opl > unused_ptr_aligned &&
unused_opl - unused_ptr_aligned >= sizeof(STREAM_Node) + 32){
STREAM_Node *unused_node = (STREAM_Node*)PtrFromInt(unused_ptr_aligned);
U64 leftover_buffer_size = unused_opl - unused_ptr_aligned - sizeof(STREAM_Node);
unused_node->size = leftover_buffer_size;
SLLStackPush(stream->unused_node, unused_node);
}
node = 0;
}
// if we don't have a node then setup a new node with sufficient space.
if (node == 0){
U64 alloc_size = sizeof(STREAM_Node) + size;
alloc_size = ClampBot(STREAM_ALLOC_SIZE, alloc_size);
node = (STREAM_Node*)push_array_no_zero(stream->arena, U8, alloc_size);
SLLQueuePush(stream->first_node, stream->last_node, node);
node->size = 0;
stream->buffer_cap = alloc_size - sizeof(STREAM_Node);
}
// return the buffer
U8 *result = node->data + node->size;
node->size += size;
stream->total_size += size;
return(result);
}
MR4TH_SYMBOL_MUST_SHARE U64
stream_total_size(STREAM *stream){
return(stream->total_size);
}
MR4TH_SYMBOL_MUST_SHARE STREAM_Handle*
stream_next_chunk(STREAM *stream, STREAM_Handle *handle, String8 *chunk_out){
STREAM_Node *node = (STREAM_Node*)handle;
if (node == 0){
node = stream->first_node;
}
else{
node = node->next;
}
if (node != 0){
chunk_out->size = node->size;
chunk_out->str = node->data;
}
else{
chunk_out->size = 0;
chunk_out->str = 0;
}
return((STREAM_Handle*)node);
}
#endif /* stream core implementation */
// stream helpers
MR4TH_SYMBOL String8
stream_read(Arena *arena, STREAM *stream){
String8 result = {0};
result.str = push_array(arena, U8, stream->total_size);
result.size = stream->total_size;
U64 pos = 0;
for (STREAM_Node *node = stream->first_node;
node != 0;
node = node->next){
MemoryCopy(result.str + pos, node->data, node->size);
pos += node->size;
}
return(result);
}
MR4TH_SYMBOL void
stream_printfv(STREAM *stream, char *fmt, va_list args){
// in case we need to try a second time
va_list args2;
va_copy(args2, args);
// try to get a buffer from the stream
STREAM_Node *node = 0;
U8 *buffer = 0;
U64 buffer_size = 0;
if (stream->buffer_cap > 0){
node = stream->last_node;
buffer = node->data + node->size;
buffer_size = stream->buffer_cap - node->size;
}
// try to build the string in the current block
U64 actual_size = 0;
if (buffer_size > 0){
actual_size = m4_vsnprintf((char*)buffer, buffer_size, fmt, args);
}
else{
actual_size = m4_vsnprintf(0, 0, fmt, args);
}
// if first try worked, increment block size
if (actual_size <= buffer_size){
node->size += actual_size;
stream->total_size += actual_size;
}
// if first try failed, reset and try again with correct size
else{
// TODO(allen): super annoying extra buffer copy, need to fix.
ArenaTemp scratch = arena_get_scratch(0, 0);
U8 *temp_buffer = push_array(scratch.arena, U8,actual_size + 1);
U64 final_size = m4_vsnprintf((char*)temp_buffer, actual_size + 1, fmt, args2);
Assert(final_size == actual_size);
U8 *new_buffer = stream_alloc(stream, actual_size);
MemoryCopy(new_buffer, temp_buffer, actual_size);
arena_release_scratch(&scratch);
}
// end args2
va_end(args2);
}
MR4TH_SYMBOL void
stream_printf(STREAM *stream, char *fmt, ...){
va_list args;
va_start(args, fmt);
stream_printfv(stream, fmt, args);
va_end(args);
}
////////////////////////////////
// Functions: Buffer
MR4TH_SYMBOL void
buffer_alloc(BUFFER *buffer, U64 size){
MemoryZeroStruct(buffer);
U64 real_size = AlignUpPow2(size, KB(4));
buffer->base = os_memory_reserve(real_size);
if (buffer->base != 0){
buffer->size = real_size;
buffer->commit_pos = 0;
}
}
MR4TH_SYMBOL void
buffer_release(BUFFER *buffer){
os_memory_release(buffer->base, buffer->size);
}
MR4TH_SYMBOL void
buffer_reset(BUFFER *buffer){
if (buffer->commit_pos > 0){
os_memory_decommit((U8*)buffer->base, buffer->commit_pos);
}
buffer->commit_pos = 0;
}
MR4TH_SYMBOL void
buffer_commit_off__call(BUFFER *buffer, U64 off){
U64 new_commit_pos = AlignUpPow2(off, MR4TH_MEM_COMMIT_BLOCK_SIZE);
new_commit_pos = ClampTop(new_commit_pos, buffer->size);
if (os_memory_commit((U8*)buffer->base + buffer->commit_pos, new_commit_pos - buffer->commit_pos)){
buffer->commit_pos = new_commit_pos;
}
}
////////////////////////////////
// Types: Hash Table
MR4TH_SYMBOL void
hash_buckets_init(BUFFER *buckets, U64 count){
Assert(count > 0 && IsPow2OrZero(count));
buffer_commit_off(buckets, sizeof(void*)*count);
}
MR4TH_SYMBOL HASH_Node*
hash_buckets_first(BUFFER *buckets, U64 hash){
U64 count = buckets->commit_pos/sizeof(void*);
U64 bidx = hash&(count - 1);
HASH_Node *result = ((HASH_Node**)buckets->base)[bidx];
return(result);
}
MR4TH_SYMBOL void
hash_buckets_expand(BUFFER *buckets, U64 capacity){
static const U32 ALPHA_NUMERATOR = 7;
static const U32 ALPHA_DENOMINATOR = 8;
U64 count = buckets->commit_pos/sizeof(void*);
U64 max = buckets->size/sizeof(void*);
U32 dbl_count = count*2;
if (capacity*ALPHA_DENOMINATOR > count*ALPHA_NUMERATOR &&
dbl_count <= max){
U32 old_count = count;
U32 new_count = count*4;
if (new_count > max){
new_count = dbl_count;
}
buffer_commit_off(buckets, sizeof(void*)*new_count);
U64 mask = new_count - 1;
U64 rehash_mask = mask&~(old_count - 1);
HASH_Node **buckets_base = (HASH_Node**)buckets->base;
for (U32 i = 0; i < old_count; i += 1){
for (HASH_Node **ptr = buckets_base + i;
*ptr != 0;){
HASH_Node *node = *ptr;
if ((node->hash&rehash_mask) != 0){
U64 bidx = node->hash&mask;
*ptr = (*ptr)->next;
SLLStackPush(buckets_base[bidx], node);
}
else{
ptr = &node->next;
}
}
}
}
}
MR4TH_SYMBOL void
hash_buckets_insert(Arena *arena, BUFFER *buckets, U64 hash, U64 val){
U64 count = buckets->commit_pos/sizeof(void*);
U64 bucket_idx = hash&(count - 1);
HASH_Node *bucket = push_array(arena, HASH_Node, 1);
bucket->hash = hash;
bucket->val = val;
SLLStackPush(((HASH_Node**)buckets->base)[bucket_idx], bucket);
}
////////////////////////////////
// Functions: Log
MR4TH_SYMBOL_MUST_SHARE MR4TH_THREADVAR
LOG_ThreadVars *log_vars = 0;
MR4TH_SYMBOL void
log_accum_begin(LOG_LogToProc *proc, void *uptr){
LOG_ThreadVars *vars = log_vars;
if (vars == 0){
Arena *arena = arena_alloc();
vars = log_vars = push_array(arena, LOG_ThreadVars, 1);
vars->arena = arena;
}
U64 pos = arena_current_pos(vars->arena);
LOG_Node *node = push_array(vars->arena, LOG_Node, 1);
node->pos = pos;
node->logto = proc;
node->uptr = uptr;
SLLStackPush(vars->stack, node);
}
MR4TH_SYMBOL B32
log_gathering(void){
LOG_ThreadVars *vars = log_vars;
return(vars != 0 && vars->stack != 0);
}
MR4TH_SYMBOL void
log_emit(String8 message){
LOG_ThreadVars *vars = log_vars;
if (vars != 0 && vars->stack != 0){
LOG_Node *node = vars->stack;
String8 msg_copy = str8_push_copy(vars->arena, message);
str8_list_push(vars->arena, &node->log, msg_copy);
if (node->logto != 0){
node->logto(node->uptr, msg_copy);
}
}
}
MR4TH_SYMBOL void
log_emitf(char *fmt, ...){
LOG_ThreadVars *vars = log_vars;
if (vars != 0 && vars->stack != 0){
LOG_Node *node = vars->stack;
va_list args;
va_start(args, fmt);
String8 string = str8_pushfv(vars->arena, fmt, args);
va_end(args);
str8_list_push(vars->arena, &node->log, string);
if (node->logto != 0){
node->logto(node->uptr, string);
}
}
}
MR4TH_SYMBOL String8
log_accum_end(Arena *arena){
String8 result = {0};
LOG_ThreadVars *vars = log_vars;
if (vars != 0){
LOG_Node *node = vars->stack;
if (node != 0){
result = str8_join(arena, &node->log, 0);
SLLStackPop(vars->stack);
arena_pop_to(vars->arena, node->pos);
}
}
return(result);
}
////////////////////////////////
// Functions: Errors
// IMPORTANT: It is important that strings get pushed
// *on top* of the node that holds them within the arena.
// basically: Assert((U8*)node < (U8*)node->error.str);
// except that stops working if the arena is chained...
MR4TH_SYMBOL_MUST_SHARE MR4TH_THREADVAR
ER_ThreadVars *er_vars = 0;
MR4TH_SYMBOL void
er_accum_begin(void){
ER_ThreadVars *vars = er_vars;
if (vars == 0){
Arena *arena = arena_new(KB(64), 1, 0);
vars = er_vars = push_array(arena, ER_ThreadVars, 1);
vars->arena = arena;
}
U64 pos = arena_current_pos(vars->arena);
ER_Node *node = push_array(vars->arena, ER_Node, 1);
if (node == 0){
vars->over_stack += 1;
}
else{
node->pos = pos;
SLLStackPush(vars->stack, node);
}
}
MR4TH_SYMBOL void
er_emit(String8 error){
ER_ThreadVars *vars = er_vars;
if (vars != 0 &&
vars->over_stack == 0){
ER_Node *node = vars->stack;
if (node != 0 && node->error.size == 0){
node->error = str8_push_copy(vars->arena, error);
}
}
}
MR4TH_SYMBOL void
er_emitf(char *fmt, ...){
ER_ThreadVars *vars = er_vars;
if (vars != 0 &&
vars->over_stack == 0){
ER_Node *node = vars->stack;
if (node != 0 && node->error.size == 0){
va_list args;
va_start(args, fmt);
String8 string = str8_pushfv(vars->arena, fmt, args);
va_end(args);
node->error = string;
}
}
}
MR4TH_SYMBOL String8
er_accum_end(Arena *arena){
String8 result = {0};
ER_ThreadVars *vars = er_vars;
if (vars != 0){
if (vars->over_stack == 0){
ER_Node *node = vars->stack;
if (node != 0){
result = str8_push_copy(arena, node->error);
SLLStackPop(vars->stack);
arena_pop_to(vars->arena, node->pos);
}
}
else{
vars->over_stack -= 1;
}
}
return(result);
}
////////////////////////////////////////////////
////////////////////////////////////////////////
//////// OS IMPLEMENTATION SHARED //////////
////////////////////////////////////////////////
////////////////////////////////////////////////
////////////////////////////////
// Helper Implementation: File Handling
MR4TH_SYMBOL B32
os_file_write(String8 file_name, String8 data){
String8Node node = {0};
node.string = data;
B32 result = os_file_write_list(file_name, &node);
return(result);
}
MR4TH_SYMBOL String8
os__file_write_callback__list(void *udata){
String8Node **ptr = (String8Node**)udata;
String8 result = {0};
if (*ptr != 0){
result = (*ptr)->string;
(*ptr) = (*ptr)->next;
}
return(result);
}
MR4TH_SYMBOL B32
os_file_write_list(String8 file_name, String8Node *first_node){
B32 result = os_file_write_callback(file_name, &first_node, os__file_write_callback__list);
return(result);
}
MR4TH_SYMBOL String8
os__file_write_callback__stream(void *udata){
STREAM *stream = *(STREAM**) ((void**)udata + 0);
STREAM_Handle**handle = (STREAM_Handle**)((void**)udata + 1);
String8 result = {0};
*handle = stream_next_chunk(stream, *handle, &result);
return(result);
}
MR4TH_SYMBOL B32
os_file_write_stream(String8 file_name, STREAM *stream){
void *udata[2] = { stream, 0 };
B32 result = os_file_write_callback(file_name, udata, os__file_write_callback__stream);
return(result);
}
////////////////////////////////
// Helper Implementation: Libraries
MR4TH_SYMBOL OS_VRange
os_this_image(void){
OS_VRange result = {0};
OS_Library *this_lib = os_lib_from_addr((void*)os_this_image);
if (this_lib != 0){
result = os_lib_image_range(this_lib);
}
return(result);
}
/*******************************
** Begin Base Win32 **
*******************************/
#if OS_WINDOWS
////////////////////////////////
// Win32 Implementation: Global Variables
MR4TH_SYMBOL_STATIC U64 w32_ticks_per_second = 1;
MR4TH_SYMBOL_STATIC Arena *w32_perm_arena = 0;
MR4TH_SYMBOL_STATIC String8 w32_binary_path = {0};
MR4TH_SYMBOL_STATIC String8 w32_user_path = {0};
MR4TH_SYMBOL_STATIC String8 w32_temp_path = {0};
MR4TH_SYMBOL_STATIC String8List w32_cmd_line = {0};
////////////////////////////////
// Win32 Implementation: Process Setup
MR4TH_SYMBOL void
os_main_init(int argc, char **argv){
ProfBeginFunc();
// setup precision time
LARGE_INTEGER perf_freq = {0};
if (QueryPerformanceFrequency(&perf_freq)){
w32_ticks_per_second = ((U64)perf_freq.HighPart << 32) | perf_freq.LowPart;
}
timeBeginPeriod(1);
// arena
w32_perm_arena = arena_alloc();
// command line arguments
for (int i = 0; i < argc; i += 1){
String8 arg = str8_cstring((U8*)argv[i]);
str8_list_push(w32_perm_arena, &w32_cmd_line, arg);
}
// paths
ArenaTemp scratch = arena_get_scratch(0, 0);
// binary path
{
DWORD cap = 2048;
U16 *buffer = 0;
DWORD size = 0;
for (U64 r = 0; r < 4; r += 1, cap *= 4){
U16 *try_buffer = push_array(scratch.arena, U16, cap);
DWORD try_size = GetModuleFileNameW(0, (WCHAR*)try_buffer, cap);
if (try_size == cap && GetLastError() == ERROR_INSUFFICIENT_BUFFER){
arena_end_temp(&scratch);
}
else{
buffer = try_buffer;
size = try_size;
break;
}
}
String8 full_path = str8_from_str16(scratch.arena, CLiteral(String16){buffer, size});
String8 binary_path = str8_chop_last_slash(full_path);
w32_binary_path = str8_push_copy(w32_perm_arena, binary_path);
}
// user data
{
HANDLE token = GetCurrentProcessToken();
DWORD cap = 2048;
U16 *buffer = push_array(scratch.arena, U16, cap);
if (!GetUserProfileDirectoryW(token, (WCHAR*)buffer, &cap)){
arena_end_temp(&scratch);
buffer = push_array(scratch.arena, U16, cap + 1);
if (GetUserProfileDirectoryW(token, (WCHAR*)buffer, &cap)){
buffer = 0;
}
}
if (buffer != 0){
// the docs make it sound like we can only count on
// cap getting the size on failure; so we're just going to cstring
// this to be safe.
w32_user_path = str8_from_str16(w32_perm_arena, str16_cstring(buffer));
}
}
// temp data
{
DWORD cap = 2048;
U16 *buffer = push_array(scratch.arena, U16, cap);
DWORD size = GetTempPathW(cap, (WCHAR*)buffer);
if (size >= cap){
arena_end_temp(&scratch);
buffer = push_array(scratch.arena, U16, size + 1);
size = GetTempPathW(size + 1, (WCHAR*)buffer);
}
// size - 1, because this particular string function
// in the Win32 API is different from the others and it includes
// the trailing backslash. We want consistency, so the "- 1" removes it.
w32_temp_path = str8_from_str16(w32_perm_arena, CLiteral(String16){buffer, size - 1});
}
arena_release_scratch(&scratch);
ProfEndFunc();
}
MR4TH_SYMBOL String8List
os_command_line_arguments(void){
String8List result = w32_cmd_line;
return(result);
}
MR4TH_SYMBOL void
os_exit_process(U32 code){
ProfClose();
ExitProcess(code);
}
////////////////////////////////
// Win32 Implementation: Memory Functions
MR4TH_SYMBOL void*
os_memory_reserve(U64 size){
void *result = VirtualAlloc(0, size, MEM_RESERVE, PAGE_READWRITE);
return(result);
}
MR4TH_SYMBOL B32
os_memory_commit(void *ptr, U64 size){
B32 result = (VirtualAlloc(ptr, size, MEM_COMMIT, PAGE_READWRITE) != 0);
return(result);
}
MR4TH_SYMBOL void
os_memory_decommit(void *ptr, U64 size){
VirtualFree(ptr, size, MEM_DECOMMIT);
}
MR4TH_SYMBOL void
os_memory_release(void *ptr, U64 size){
VirtualFree(ptr, 0, MEM_RELEASE);
}
MR4TH_SYMBOL B32
os_memory_protect(void *ptr, U64 size, DataAccessFlags access_flags){
DWORD protect = PAGE_NOACCESS;
switch (access_flags&0x7){
case 0: protect = PAGE_NOACCESS; break;
case DataAccessFlag_Read: protect = PAGE_READONLY; break;
case DataAccessFlag_Write:
case DataAccessFlag_Read|DataAccessFlag_Write: protect = PAGE_READWRITE; break;
case DataAccessFlag_Execute: protect = PAGE_EXECUTE; break;
case DataAccessFlag_Read|DataAccessFlag_Execute: protect = PAGE_EXECUTE_READ; break;
case DataAccessFlag_Write|DataAccessFlag_Execute:
case DataAccessFlag_Read|DataAccessFlag_Write|DataAccessFlag_Execute: protect = PAGE_EXECUTE_READWRITE; break;
}
DWORD dummy = 0;
B32 result = VirtualProtect(ptr, size, protect, &dummy);
return(result);
}
////////////////////////////////
// Win32 Implementation: File Handling
MR4TH_SYMBOL String8
os_file_read(Arena *arena, String8 file_name){
ProfBeginFunc();
// get handle
ArenaTemp scratch = arena_get_scratch(&arena, 1);
String16 file_name16 = str16_from_str8(scratch.arena, file_name);
HANDLE file = CreateFileW((WCHAR*)file_name16.str,
GENERIC_READ, 0, 0,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,
0);
String8 result = {0};
if (file != INVALID_HANDLE_VALUE){
// get size
DWORD hi_size = 0;
DWORD lo_size = GetFileSize(file, &hi_size);
U64 total_size = (((U64)hi_size) << 32) | (U64)lo_size;
// allocate buffer
ArenaTemp restore_point = arena_begin_temp(arena);
U8 *buffer = push_array_no_zero(arena, U8, total_size + 1);
// read
U8 *ptr = buffer;
U8 *opl = buffer + total_size;
B32 success = 1;
for (;ptr < opl;){
U64 total_to_read = (U64)(opl - ptr);
DWORD to_read = (DWORD)total_to_read;
if (total_to_read > max_U32){
to_read = max_U32;
}
DWORD actual_read = 0;
if (!ReadFile(file, ptr, to_read, &actual_read, 0)){
success = 0;
break;
}
ptr += actual_read;
}
// set result or reset memory
if (success){
buffer[total_size] = 0;
result.str = buffer;
result.size = total_size;
}
else{
arena_end_temp(&restore_point);
}
CloseHandle(file);
}
arena_release_scratch(&scratch);
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL B32
os_file_write_callback(String8 file_name, void *udata, OS_FileWriteCallback *callback){
ProfBeginFunc();
// get handle
ArenaTemp scratch = arena_get_scratch(0, 0);
String16 file_name16 = str16_from_str8(scratch.arena, file_name);
HANDLE file = CreateFileW((WCHAR*)file_name16.str,
GENERIC_WRITE, 0, 0,
CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL,
0);
B32 result = 0;
if (file != INVALID_HANDLE_VALUE){
result = 1;
for (;;){
String8 chunk = callback(udata);
if (chunk.size == 0){
break;
}
U8 *ptr = chunk.str;
U8 *opl = chunk.str + chunk.size;
for (;ptr < opl;){
U64 total_to_write = (U64)(opl - ptr);
DWORD to_write = total_to_write;
if (total_to_write > max_U32){
to_write = max_U32;
}
DWORD actual_write = 0;
if (!WriteFile(file, ptr, to_write, &actual_write, 0)){
result = 0;
goto dblbreak;
}
ptr += actual_write;
}
}
dblbreak:;
// close file
CloseHandle(file);
}
arena_release_scratch(&scratch);
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL B32
os_file_write_list(String8 file_name, String8Node *first_node){
ProfBeginFunc();
// get handle
ArenaTemp scratch = arena_get_scratch(0, 0);
String16 file_name16 = str16_from_str8(scratch.arena, file_name);
HANDLE file = CreateFileW((WCHAR*)file_name16.str,
GENERIC_WRITE, 0, 0,
CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL,
0);
B32 result = 0;
if (file != INVALID_HANDLE_VALUE){
result = 1;
for (String8Node *node = first_node;
node != 0;
node = node->next){
U8 *ptr = node->string.str;
U8 *opl = ptr + node->string.size;
for (;ptr < opl;){
U64 total_to_write = (U64)(opl - ptr);
DWORD to_write = total_to_write;
if (total_to_write > max_U32){
to_write = max_U32;
}
DWORD actual_write = 0;
if (!WriteFile(file, ptr, to_write, &actual_write, 0)){
result = 0;
goto dblbreak;
}
ptr += actual_write;
}
}
dblbreak:;
CloseHandle(file);
}
arena_release_scratch(&scratch);
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL FileProperties
os_file_properties(String8 file_name){
ProfBeginFunc();
// convert name
ArenaTemp scratch = arena_get_scratch(0, 0);
String16 file_name16 = str16_from_str8(scratch.arena, file_name);
// get attribs and convert to properties
FileProperties result = {0};
WIN32_FILE_ATTRIBUTE_DATA attribs = {0};
if (GetFileAttributesExW((WCHAR*)file_name16.str, GetFileExInfoStandard,
&attribs)){
result.size = ((U64)attribs.nFileSizeHigh << 32) | (U64)attribs.nFileSizeLow;
result.flags = w32_prop_flags_from_attribs(attribs.dwFileAttributes);
result.create_time = w32_dense_time_from_file_time(&attribs.ftCreationTime);
result.modify_time = w32_dense_time_from_file_time(&attribs.ftLastWriteTime);
result.access = w32_access_from_attributes(attribs.dwFileAttributes);
}
arena_release_scratch(&scratch);
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL B32
os_file_delete(String8 file_name){
ProfBeginFunc();
// convert name
ArenaTemp scratch = arena_get_scratch(0, 0);
String16 file_name16 = str16_from_str8(scratch.arena, file_name);
// delete file
B32 result = DeleteFileW((WCHAR*)file_name16.str);
arena_release_scratch(&scratch);
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL B32
os_file_rename(String8 og_name, String8 new_name){
ProfBeginFunc();
// convert name
ArenaTemp scratch = arena_get_scratch(0, 0);
String16 og_name16 = str16_from_str8(scratch.arena, og_name);
String16 new_name16 = str16_from_str8(scratch.arena, new_name);
// rename file
B32 result = MoveFileW((WCHAR*)og_name16.str, (WCHAR*)new_name16.str);
arena_release_scratch(&scratch);
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL B32
os_file_make_directory(String8 path){
ProfBeginFunc();
// convert name
ArenaTemp scratch = arena_get_scratch(0, 0);
String16 path16 = str16_from_str8(scratch.arena, path);
// make directory
B32 result = CreateDirectoryW((WCHAR*)path16.str, 0);
arena_release_scratch(&scratch);
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL B32
os_file_delete_directory(String8 path){
ProfBeginFunc();
// convert name
ArenaTemp scratch = arena_get_scratch(0, 0);
String16 path16 = str16_from_str8(scratch.arena, path);
// make directory
B32 result = RemoveDirectoryW((WCHAR*)path16.str);
arena_release_scratch(&scratch);
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL OS_FileIter
os_file_iter_init(Arena *arena, String8 path){
ProfBeginFunc();
// convert name
String8Node nodes[2];
String8List list;
nodes[0].string = path;
nodes[0].next = nodes + 1;
nodes[1].string = str8_lit("\\*");
nodes[1].next = 0;
list.first = nodes + 0;
list.last = nodes + 1;
list.node_count = 2;
list.total_size = path.size + 2;
ArenaTemp scratch = arena_get_scratch(&arena, 1);
String8 path_star = str8_join(scratch.arena, &list, 0);
// TODO(allen): Better unicode conversions here
String16 path16 = str16_from_str8(scratch.arena, path_star);
// store into iter
OS_FileIter result = {0};
W32_FileIter *w32_iter = (W32_FileIter*)&result;
w32_iter->handle = FindFirstFileW((WCHAR*)path16.str, &w32_iter->find_data);
arena_release_scratch(&scratch);
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL B32
os_file_iter_next(Arena *arena, OS_FileIter *iter,
String8 *name, FileProperties *props){
ProfBeginFunc();
B32 result = 0;
W32_FileIter *w32_iter = (W32_FileIter*)iter;
if (w32_iter->handle != 0 &&
w32_iter->handle != INVALID_HANDLE_VALUE){
for (;!w32_iter->done;){
// check for . and ..
WCHAR *file_name = w32_iter->find_data.cFileName;
B32 is_dot = (file_name[0] == '.' && file_name[1] == 0);
B32 is_dotdot = (file_name[0] == '.' && file_name[1] == '.' &&
file_name[2] == 0);
// setup to emit
B32 emit = (!is_dot && !is_dotdot);
WIN32_FIND_DATAW data = {0};
if (emit){
MemoryCopyStruct(&data, &w32_iter->find_data);
}
// increment the iterator
if (!FindNextFileW(w32_iter->handle, &w32_iter->find_data)){
w32_iter->done = 1;
}
// do the emit if we saved one earlier
if (emit){
*name = str8_from_str16(arena, str16_cstring((U16*)data.cFileName));
props->size = ((U64)data.nFileSizeHigh << 32) | (U64)data.nFileSizeLow;
props->flags = w32_prop_flags_from_attribs(data.dwFileAttributes);
props->create_time = w32_dense_time_from_file_time(&data.ftCreationTime);
props->modify_time = w32_dense_time_from_file_time(&data.ftLastWriteTime);
props->access = w32_access_from_attributes(data.dwFileAttributes);
result = 1;
break;
}
}
}
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL void
os_file_iter_end(OS_FileIter *iter){
ProfBeginFunc();
W32_FileIter *w32_iter = (W32_FileIter*)iter;
if (w32_iter->handle != 0 &&
w32_iter->handle != INVALID_HANDLE_VALUE){
FindClose(w32_iter->handle);
}
ProfEndFunc();
}
MR4TH_SYMBOL String8
os_file_path(Arena *arena, OS_SystemPath path){
ProfBeginFunc();
String8 result = {0};
switch (path){
case OS_SystemPath_CurrentDirectory:
{
ArenaTemp scratch = arena_get_scratch(&arena, 1);
DWORD cap = 2048;
U16 *buffer = push_array(scratch.arena, U16, cap);
DWORD size = GetCurrentDirectoryW(cap, (WCHAR*)buffer);
if (size >= cap){
arena_end_temp(&scratch);
buffer = push_array(scratch.arena, U16, size + 1);
size = GetCurrentDirectoryW(size + 1, (WCHAR*)buffer);
}
result = str8_from_str16(arena, CLiteral(String16){buffer, size});
arena_release_scratch(&scratch);
}break;
case OS_SystemPath_Binary:
{
result = str8_push_copy(arena, w32_binary_path);
}break;
case OS_SystemPath_UserData:
{
result = str8_push_copy(arena, w32_user_path);
}break;
case OS_SystemPath_TempData:
{
result = str8_push_copy(arena, w32_temp_path);
}break;
}
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL void
os_set_current_directory(String8 path){
ArenaTemp scratch = arena_get_scratch(0, 0);
String16 path16 = str16_from_str8(scratch.arena, path);
SetCurrentDirectoryW((WCHAR*)path16.str);
arena_release_scratch(&scratch);
}
////////////////////////////////
// Win32 Implementation: Time
MR4TH_SYMBOL DateTime
os_now_universal_time(void){
SYSTEMTIME system_time = {0};
GetSystemTime(&system_time);
DateTime result = w32_date_time_from_system_time(&system_time);
return(result);
}
MR4TH_SYMBOL DateTime
os_local_time_from_universal(DateTime *univ_date_time){
SYSTEMTIME univ_system_time = w32_system_time_from_date_time(univ_date_time);
FILETIME univ_file_time = {0};
SystemTimeToFileTime(&univ_system_time, &univ_file_time);
FILETIME local_file_time = {0};
FileTimeToLocalFileTime(&univ_file_time, &local_file_time);
SYSTEMTIME local_system_time = {0};
FileTimeToSystemTime(&local_file_time, &local_system_time);
DateTime result = w32_date_time_from_system_time(&local_system_time);
return(result);
}
MR4TH_SYMBOL DateTime
os_universal_time_from_local(DateTime *local_date_time){
SYSTEMTIME local_system_time = w32_system_time_from_date_time(local_date_time);
FILETIME local_file_time = {0};
SystemTimeToFileTime(&local_system_time, &local_file_time);
FILETIME univ_file_time = {0};
LocalFileTimeToFileTime(&local_file_time, &univ_file_time);
SYSTEMTIME univ_system_time = {0};
FileTimeToSystemTime(&univ_file_time, &univ_system_time);
DateTime result = w32_date_time_from_system_time(&univ_system_time);
return(result);
}
MR4TH_SYMBOL U32
os_time_stamp_32_from_date_time(DateTime *date_time){
SYSTEMTIME system_time = w32_system_time_from_date_time(date_time);
FILETIME file_time = {0};
SystemTimeToFileTime(&system_time, &file_time);
U64 file_time64 = ( (U64) file_time.dwLowDateTime +
((U64)(file_time.dwHighDateTime) << 32ll)
);
U32 result = (U32) ((file_time64 - 116444736000000000ll)/10000000ll);
return(result);
}
MR4TH_SYMBOL U64
os_now_ticks(void){
U64 result = 0;
LARGE_INTEGER perf_counter = {0};
if (QueryPerformanceCounter(&perf_counter)){
result = ((U64)perf_counter.HighPart << 32) | perf_counter.LowPart;
}
return(result);
}
MR4TH_SYMBOL void
os_get_microseconds_per_tick(U64 *usecs_out, U64 *ticks_out){
*usecs_out = Million(1);
*ticks_out = w32_ticks_per_second;
}
MR4TH_SYMBOL void
os_sleep_milliseconds(U32 t){
Sleep(t);
}
////////////////////////////////
// Win32 Implementation: Libraries
MR4TH_SYMBOL OS_Library*
os_lib_load(String8 path){
ArenaTemp scratch = arena_get_scratch(0, 0);
String16 path16 = str16_from_str8(scratch.arena, path);
OS_Library *result = (OS_Library*)(LoadLibraryW((WCHAR*)path16.str));
arena_release_scratch(&scratch);
return(result);
}
MR4TH_SYMBOL VoidFunc*
os_lib_get_proc(OS_Library *lib, char *name){
HMODULE module = (HMODULE)(lib);
VoidFunc *result = (VoidFunc*)(GetProcAddress(module, name));
return(result);
}
MR4TH_SYMBOL void
os_lib_release(OS_Library *lib){
HMODULE module = (HMODULE)(lib);
FreeLibrary(module);
}
MR4TH_SYMBOL OS_Library*
os_lib_from_addr(void *addr){
HMODULE module = 0;
GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
(LPWSTR)addr, &module);
return((OS_Library*)module);
}
MR4TH_SYMBOL OS_VRange
os_lib_image_range(OS_Library *lib){
OS_VRange result = {0};
HANDLE process = GetCurrentProcess();
MODULEINFO module_info = {0};
if (GetModuleInformation(process, (HMODULE)lib,
&module_info, sizeof(module_info))){
result.addr = (U8*)module_info.lpBaseOfDll;
result.size = module_info.SizeOfImage;
}
return(result);
}
////////////////////////////////
// Win32 Implementation: Entropy
MR4TH_SYMBOL void
os_get_entropy(void *data, U64 size){
HCRYPTPROV prov = 0;
CryptAcquireContextW(&prov, 0, 0, PROV_DSS, CRYPT_VERIFYCONTEXT);
CryptGenRandom(prov, size, (BYTE*)data);
CryptReleaseContext(prov, 0);
}
////////////////////////////////
// Win32 Functions: Specialized Init for WinMain
MR4TH_SYMBOL_STATIC HINSTANCE w32_instance = 0;
MR4TH_SYMBOL void
w32_WinMain_init(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nShowCmd){
int argc = __argc;
char **argv = __argv;
w32_instance = hInstance;
os_main_init(argc, argv);
}
MR4TH_SYMBOL HINSTANCE
w32_get_instance(void){
if (w32_instance == 0){
w32_instance = GetModuleHandle(0);
}
return(w32_instance);
}
////////////////////////////////
// Win32 Functions: Time Helpers
MR4TH_SYMBOL DateTime
w32_date_time_from_system_time(SYSTEMTIME *in){
DateTime result = {0};
result.year = in->wYear;
result.mon = (U8)in->wMonth;
result.day = in->wDay;
result.hour = in->wHour;
result.min = in->wMinute;
result.sec = in->wSecond;
result.msec = in->wMilliseconds;
return(result);
}
MR4TH_SYMBOL SYSTEMTIME
w32_system_time_from_date_time(DateTime *in){
SYSTEMTIME result = {0};
result.wYear = in->year;
result.wMonth = in->mon;
result.wDay = in->day;
result.wHour = in->hour;
result.wMinute = in->min;
result.wSecond = in->sec;
result.wMilliseconds = in->msec;
return(result);
}
MR4TH_SYMBOL DenseTime
w32_dense_time_from_file_time(FILETIME *file_time){
SYSTEMTIME system_time = {0};
FileTimeToSystemTime(file_time, &system_time);
DateTime date_time = w32_date_time_from_system_time(&system_time);
DenseTime result = dense_time_from_date_time(&date_time);
return(result);
}
////////////////////////////////
// Win32 Functions: File Helpers
MR4TH_SYMBOL FilePropertyFlags
w32_prop_flags_from_attribs(DWORD attribs){
FilePropertyFlags result = 0;
if (attribs & FILE_ATTRIBUTE_DIRECTORY){
result |= FilePropertyFlag_IsFolder;
}
return(result);
}
MR4TH_SYMBOL DataAccessFlags
w32_access_from_attributes(DWORD attribs){
DataAccessFlags result = DataAccessFlag_Read|DataAccessFlag_Execute;
if (!(attribs & FILE_ATTRIBUTE_READONLY)){
result |= DataAccessFlag_Write;
}
return(result);
}
#endif /* OS_WINDOWS */
/*******************************
** End Base Win32 **
*******************************/
/*******************************
** Begin Base Linux **
*******************************/
#if OS_LINUX
////////////////////////////////
// Linux Implementation: Global Variables
MR4TH_SYMBOL_STATIC Arena *lnx_perm_arena = 0;
MR4TH_SYMBOL_STATIC String8 lnx_binary_path = {0};
MR4TH_SYMBOL_STATIC String8 lnx_user_path = {0};
MR4TH_SYMBOL_STATIC String8 lnx_temp_path = {0};
MR4TH_SYMBOL_STATIC String8List lnx_cmd_line = {0};
////////////////////////////////
// Linux Implementation: Process Setup
MR4TH_SYMBOL void
os_main_init(int argc, char **argv){
ProfBeginFunc();
// arena
lnx_perm_arena = arena_alloc();
// command line arguments
for (int i = 0; i < argc; i += 1){
String8 arg = str8_cstring((U8*)argv[i]);
str8_list_push(lnx_perm_arena, &lnx_cmd_line, arg);
}
// paths
ArenaTemp scratch = arena_get_scratch(0, 0);
// binary path
{
B32 got_final_result = 0;
U8 *buffer = 0;
int size = 0;
for (U64 cap = PATH_MAX, r = 0; r < 4; cap *= 2, r += 1){
arena_end_temp(&scratch);
buffer = push_array_no_zero(scratch.arena, U8, cap);
size = readlink("/proc/self/exe", (char*)buffer, cap);
if (size < cap){
got_final_result = 1;
break;
}
}
if (got_final_result && size > 0){
String8 full_name = str8(buffer, (U64)size);
String8 name_chopped = str8_chop_last_slash(full_name);
lnx_binary_path = str8_push_copy(lnx_perm_arena, name_chopped);
}
}
// user data path
{
char *home = getenv("HOME");
lnx_user_path = str8_cstring((U8*)home);
}
// temp data path
{
lnx_temp_path = str8_lit("/var/tmp");
}
arena_release_scratch(&scratch);
ProfEndFunc();
}
MR4TH_SYMBOL String8List
os_command_line_arguments(void){
String8List result = lnx_cmd_line;
return(result);
}
MR4TH_SYMBOL void
os_exit_process(U32 code){
ProfClose();
exit((int)code);
}
////////////////////////////////
// Linux Implementation: Memory Functions
MR4TH_SYMBOL void*
os_memory_reserve(U64 size){
void *result = mmap(0, size, PROT_NONE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
if (result == MAP_FAILED){
result = 0;
}
return(result);
}
MR4TH_SYMBOL B32
os_memory_commit(void *ptr, U64 size){
B32 result = 0;
if (mprotect(ptr, size, PROT_READ|PROT_WRITE) == 0){
result = 1;
}
return(result);
}
MR4TH_SYMBOL void
os_memory_decommit(void *ptr, U64 size){
madvise(ptr, size, MADV_DONTNEED);
mprotect(ptr, size, PROT_NONE);
}
MR4TH_SYMBOL void
os_memory_release(void *ptr, U64 size){
munmap(ptr, size);
}
MR4TH_SYMBOL B32
os_memory_protect(void *ptr, U64 size, DataAccessFlags access_flags){
int prot = PROT_NONE;
if ((access_flags&DataAccessFlag_Read) == 0){
prot |= PROT_READ;
}
if ((access_flags&DataAccessFlag_Write) == 0){
prot |= PROT_WRITE;
}
if ((access_flags&DataAccessFlag_Execute) == 0){
prot |= PROT_EXEC;
}
B32 result = (mprotect(ptr, size, prot));
return(result);
}
////////////////////////////////
// Linux Implementation: File Handling
MR4TH_SYMBOL String8
os_file_read(Arena *arena, String8 file_name){
ProfBeginFunc();
// get handle
ArenaTemp scratch = arena_get_scratch(&arena, 1);
// (this ensures file_name8 has a null terminator)
String8 file_name8 = str8_push_copy(scratch.arena, file_name);
int file = open((char*)file_name8.str, O_RDONLY);
String8 result = {0};
if (file >= 0){
// get size
struct stat file_stat = {0};
U64 size = 0;
if (fstat(file, &file_stat) == 0){
size = file_stat.st_size;
}
// allocate buffer
if (size > 0){
ArenaTemp restore_point = arena_begin_temp(arena);
U8 *buffer = push_array_no_zero(arena, U8, size + 1);
// read
U8 *ptr = buffer;
U8 *opl = buffer + size;
B32 success = 1;
for (;ptr < opl;){
U64 total_to_read = (U64)(opl - ptr);
U32 to_read = (U32)total_to_read;
if (total_to_read > max_U32){
to_read = max_U32;
}
int read_result = read(file, buffer, to_read);
if (read_result < 0){
success = 0;
break;
}
else if (read_result == 0){
break;
}
ptr += read_result;
}
// set result or reset memory
if (success){
U64 final_size = (U64)(ptr - buffer);
final_size = ClampTop(final_size, size);
buffer[final_size] = 0;
result.str = buffer;
result.size = final_size;
}
else{
arena_end_temp(&restore_point);
}
}
// close file
close(file);
}
arena_release_scratch(&scratch);
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL B32
os_file_write_callback(String8 file_name, void *udata, OS_FileWriteCallback *callback){
ProfBeginFunc();
// get handle
ArenaTemp scratch = arena_get_scratch(0, 0);
String8 file_name8 = str8_push_copy(scratch.arena, file_name);
int file = open((char*)file_name8.str, O_CREAT|O_WRONLY|O_TRUNC, 0666);
B32 result = 0;
if (file >= 0){
result = 1;
for (;;){
String8 chunk = callback(udata);
if (chunk.size == 0){
break;
}
U8 *ptr = chunk.str;
U8 *opl = chunk.str + chunk.size;
for (;ptr < opl;){
U64 total_to_write = (U64)(opl - ptr);
U32 to_write = total_to_write;
if (total_to_write > (U32)SSIZE_MAX){
to_write = (U32)SSIZE_MAX;
}
int write_result = write(file, ptr, to_write);
if (write_result <= 0){
result = 0;
goto dblbreak;
}
ptr += write_result;
}
}
dblbreak:;
// close file
close(file);
}
arena_release_scratch(&scratch);
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL FileProperties
os_file_properties(String8 file_name){
ProfBeginFunc();
// convert name
ArenaTemp scratch = arena_get_scratch(0, 0);
// (this ensures file_name8 has a null terminator)
String8 file_name8 = str8_push_copy(scratch.arena, file_name);
int file = open((char*)file_name8.str, O_RDONLY);
// get file stat and convert to properties
FileProperties result = {0};
struct stat file_stat = {0};
if (fstat(file, &file_stat) == 0){
result = lnx_file_properties_from_stat(&file_stat);
}
arena_release_scratch(&scratch);
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL B32
os_file_delete(String8 file_name){
ProfBeginFunc();
ArenaTemp scratch = arena_get_scratch(0, 0);
String8 file_name8 = str8_push_copy(scratch.arena, file_name);
B32 result = 0;
if (remove((char*)file_name8.str) >= 0){
result = 1;
}
arena_end_temp(&scratch);
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL B32
os_file_rename(String8 og_name, String8 new_name){
ProfBeginFunc();
ArenaTemp scratch = arena_get_scratch(0, 0);
String8 og_name8 = str8_push_copy(scratch.arena, og_name);
String8 new_name8 = str8_push_copy(scratch.arena, new_name);
int rename_result = rename((char*)og_name8.str, (char*)new_name8.str);
B32 result = (rename_result >= 0);
arena_release_scratch(&scratch);
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL B32
os_file_make_directory(String8 path){
ProfBeginFunc();
ArenaTemp scratch = arena_get_scratch(0, 0);
String8 path8 = str8_push_copy(scratch.arena, path);
B32 result = 0;
if (mkdir((char*)path8.str, 0755) >= 0){
result = 1;
}
arena_release_scratch(&scratch);
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL B32
os_file_delete_directory(String8 path){
ProfBeginFunc();
ArenaTemp scratch = arena_get_scratch(0, 0);
String8 path8 = str8_push_copy(scratch.arena, path);
B32 result = 0;
if (rmdir((char*)path8.str) >= 0){
result = 1;
}
arena_release_scratch(&scratch);
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL OS_FileIter
os_file_iter_init(Arena *arena, String8 path){
ProfBeginFunc();
String8 path8 = str8_push_copy(arena, path);
OS_FileIter result = {0};
LNX_FileIter *lnx_iter = (LNX_FileIter*)&result;
lnx_iter->dir = opendir((char*)path8.str);
lnx_iter->path = path8;
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL B32
os_file_iter_next(Arena *arena, OS_FileIter *iter,
String8 *name, FileProperties *props){
B32 result = 0;
LNX_FileIter *lnx_iter = (LNX_FileIter*)iter;
String8 path = lnx_iter->path;
for (;lnx_iter->dir != 0;){
struct dirent *dp = readdir(lnx_iter->dir);
result = (dp != 0);
String8 file_name = {0};
if (result){
file_name = str8_cstring((U8*)dp->d_name);
}
struct stat st = {0};
int stat_result = 0;
if (result){
ArenaTemp scratch = arena_get_scratch(&arena, 1);
String8 full_path = {0};
full_path.size = path.size + 1 + file_name.size;
full_path.str = push_array_no_zero(scratch.arena, U8, full_path.size + 1);
MemoryCopy(full_path.str, path.str, path.size);
full_path.str[path.size] = '/';
MemoryCopy(full_path.str, file_name.str, file_name.size);
full_path.str[full_path.size] = 0;
stat_result = stat((char*)full_path.str, &st);
arena_release_scratch(&scratch);
}
B32 filtered = 0;
if (result){
if (file_name.str != 0 &&
((file_name.str[0] == '.' && file_name.str[1] == 0) ||
(file_name.str[0] == '.' && file_name.str[1] == 0 && file_name.str[2] == 0))){
filtered = 1;
}
}
if (result && !filtered){
*name = str8_push_copy(arena, file_name);
if (stat_result >= 0){
*props = lnx_file_properties_from_stat(&st);
}
result = 1;
break;
}
}
return(result);
}
MR4TH_SYMBOL void
os_file_iter_end(OS_FileIter *iter){
ProfBeginFunc();
LNX_FileIter *lnx_iter = (LNX_FileIter*)iter;
if (lnx_iter->dir != 0){
closedir(lnx_iter->dir);
lnx_iter->dir = 0;
}
ProfEndFunc();
}
MR4TH_SYMBOL String8
os_file_path(Arena *arena, OS_SystemPath path){
ProfBeginFunc();
String8 result = {0};
switch (path){
default:break;
case OS_SystemPath_CurrentDirectory:
{
char *cwd = getcwd(0, 0);
result = str8_push_copy(arena, str8_cstring((U8*)cwd));
free(cwd);
}break;
case OS_SystemPath_Binary:
{
result = str8_push_copy(arena, lnx_binary_path);
}break;
case OS_SystemPath_UserData:
{
result = str8_push_copy(arena, lnx_user_path);
}break;
case OS_SystemPath_TempData:
{
result = str8_push_copy(arena, lnx_temp_path);
}break;
}
ProfEndFunc();
return(result);
}
MR4TH_SYMBOL void
os_set_current_directory(String8 path){
ArenaTemp scratch = arena_get_scratch(0, 0);
String8 path8 = str8_push_copy(scratch.arena, path);
chdir((char*)path8.str);
arena_release_scratch(&scratch);
}
////////////////////////////////
// Linux Implementation: Time
MR4TH_SYMBOL DateTime
os_now_universal_time(void){
time_t t = time(0);
struct tm tm = {0};
struct tm *tmptr = gmtime_r(&t, &tm);
DateTime result = {0};
if (tmptr != 0){
result = lnx_date_time_from_tm(&tm);
}
return(result);
}
MR4TH_SYMBOL DateTime
os_local_time_from_universal(DateTime *date_time){
struct tm univ_tm = lnx_tm_from_date_time(date_time);
univ_tm.tm_isdst = -1;
time_t univ_time_t = timegm(&univ_tm);
struct tm local_tm = {0};
localtime_r(&univ_time_t, &local_tm);
DateTime result = lnx_date_time_from_tm(&local_tm);
return(result);
}
MR4TH_SYMBOL DateTime
os_universal_time_from_local(DateTime *date_time){
struct tm local_tm = lnx_tm_from_date_time(date_time);
local_tm.tm_isdst = -1;
time_t univ_time_t = mktime(&local_tm);
struct tm univ_tm = {0};
gmtime_r(&univ_time_t, &univ_tm);
DateTime result = lnx_date_time_from_tm(&univ_tm);
return(result);
}
MR4TH_SYMBOL U32
os_time_stamp_32_from_date_time(DateTime *date_time){
struct tm tm = lnx_tm_from_date_time(date_time);
time_t t = timegm(&tm);
return((U32)t);
}
MR4TH_SYMBOL U64
os_now_ticks(void){
struct timespec t = {0};
clock_gettime(CLOCK_MONOTONIC, &t);
U64 result = t.tv_sec*Million(1) + t.tv_nsec/Thousand(1);
return(result);
}
MR4TH_SYMBOL void
os_get_microseconds_per_tick(U64 *usecs_out, U64 *ticks_out){
*usecs_out = 1;
*ticks_out = 1;
}
MR4TH_SYMBOL void
os_sleep_milliseconds(U32 t){
usleep(t*Thousand(1));
}
////////////////////////////////
// Linux Implementation: Libraries
MR4TH_SYMBOL OS_Library*
os_lib_load(String8 path){
ArenaTemp scratch = arena_get_scratch(0, 0);
String8 path8 = str8_push_copy(scratch.arena, path);
OS_Library *result = (OS_Library*)dlopen((char*)path8.str, RTLD_LAZY|RTLD_LOCAL);
arena_release_scratch(&scratch);
return(result);
}
MR4TH_SYMBOL VoidFunc*
os_lib_get_proc(OS_Library *lib, char *name){
VoidFunc *proc = (VoidFunc*)dlsym((void*)lib, name);
return(proc);
}
MR4TH_SYMBOL void
os_lib_release(OS_Library *lib){
dlclose((void*)lib);
}
MR4TH_SYMBOL OS_Library*
os_lib_from_addr(void *addr){
UAddr addrx = IntFromPtr(addr);
ArenaTemp scratch = arena_get_scratch(0, 0);
// NOTE(allen):
// Implementing this on Linux is a lot less solidly
// supported than it is on Windows.
//
// As far as I can tell, reading "/proc/self/maps" is the
// only portable way to get at the information. The fact
// that this information is in only available in this text
// based unaccelerated structured is unfortunate.
//
// But even worse is the fact that, even with this info,
// to actually get one of the opaque handles to the
// library, we have to call dlopen again -- no other API
// appears to exist which can return the required information.
//
// But that also means that the library gets a reference
// count from this call and so we have to then call dlclose
// on the handle just to decrement that reference counter.
//
// I don't even know yet if this handles the base executable
// of the program correctly.
// read "/proc/self/maps"
B32 got_result = 0;
U8 *buffer = 0;
int size = 0;
for (U64 cap = KB(4), r = 0; r < 6; cap *= 64, r += 1){
arena_end_temp(&scratch);
buffer = push_array_no_zero(scratch.arena, U8, cap);
size = readlink("/proc/self/maps", (char*)buffer, cap);
if (size < cap){
got_result = 1;
break;
}
}
// parse contents from "/proc/self/maps"
String8 contents = str8(buffer, (U64)size);
String8List lines = str8_split(scratch.arena, contents, (U8*)"\n", 1);
for (String8Node *node = lines.first;
node != 0;
node = node->next){
String8 line = node->string;
U8 *opl = line.str + line.size;
U8 *dash_ptr = line.str;
for (;dash_ptr < opl && *dash_ptr != '-'; dash_ptr += 1);
U8 *addr_max_opl = dash_ptr;
for (;dash_ptr < opl && *dash_ptr != ' '; dash_ptr += 1);
U8 *slash_ptr = addr_max_opl;
for (;slash_ptr < opl && *slash_ptr != '/'; slash_ptr += 1);
U64 addr_min = u64_from_str8(str8_range(line.str, dash_ptr), 0x10);
U64 addr_max = u64_from_str8(str8_range(dash_ptr + 1, addr_max_opl), 0x10);
String8 path = str8_range(slash_ptr, opl);
}
push_array_no_zero(scratch.arena, U8, size);
arena_release_scratch(&scratch);
OS_Library *library = 0;
return(library);
}
MR4TH_SYMBOL OS_VRange
os_lib_image_range(OS_Library *lib){
OS_VRange result = {0};
// TODO(allen):
return(result);
}
////////////////////////////////
// Linux Implementation: Entropy
MR4TH_SYMBOL void
os_get_entropy(void *data, U64 size){
getrandom(data, size, 0);
}
////////////////////////////////
// Linux Functions: Time Helpers
MR4TH_SYMBOL DateTime
lnx_date_time_from_tm(struct tm *tm){
DateTime result = {0};
result.year = tm->tm_year + 1900;
result.mon = tm->tm_mon + 1;
result.day = tm->tm_mday;
result.hour = tm->tm_hour;
result.min = tm->tm_min;
result.sec = tm->tm_sec;
result.msec = 0;
return(result);
}
MR4TH_SYMBOL DenseTime
lnx_dense_time_from_time_t(time_t time){
struct tm system_time = *gmtime(&time);
DateTime date_time = lnx_date_time_from_tm(&system_time);
DenseTime result = dense_time_from_date_time(&date_time);
return(result);
}
MR4TH_SYMBOL struct tm
lnx_tm_from_date_time(DateTime *date_time){
struct tm result = {0};
result.tm_sec = date_time->sec;
result.tm_min = date_time->min;
result.tm_hour = date_time->hour;
result.tm_mday = date_time->day;
result.tm_mon = date_time->mon - 1;
result.tm_year = date_time->year;
return(result);
}
////////////////////////////////
// Linux Functions: File Helpers
MR4TH_SYMBOL FilePropertyFlags
lnx_prop_flags_from_mode(mode_t mode){
FilePropertyFlags result = 0;
if ((mode&S_IFDIR) != 0){
result |= FilePropertyFlag_IsFolder;
}
return(result);
}
MR4TH_SYMBOL DataAccessFlags
lnx_access_from_mode(mode_t mode){
DataAccessFlags result = 0;
if ((mode&(S_IRUSR|S_IRGRP)) != 0){
result |= DataAccessFlag_Read;
}
if ((mode&(S_IWUSR|S_IWGRP)) != 0){
result |= DataAccessFlag_Write;
}
if ((mode&(S_IXUSR|S_IXGRP)) != 0){
result |= DataAccessFlag_Execute;
}
return(result);
}
MR4TH_SYMBOL FileProperties
lnx_file_properties_from_stat(struct stat *st){
FileProperties result = {0};
result.size = st->st_size;
result.flags = lnx_prop_flags_from_mode(st->st_mode);
result.create_time = lnx_dense_time_from_time_t(st->st_ctime);
result.modify_time = lnx_dense_time_from_time_t(st->st_mtime);
// TODO(allen): research:
// how do these flags from fstat behave?
// S_IRUSR, S_IWUSR, S_IXUSR
// S_IRGRP, S_IWGRP, S_IXGRP
// S_IROTH, S_IWOTH, S_IXOTH
result.access = lnx_access_from_mode(st->st_mode);
return(result);
}
MR4TH_SYMBOL String8
lnx_proc_file_read(Arena *arena, char *path){
ArenaTemp scratch = arena_get_scratch(&arena, 1);
int file = open(path, O_RDONLY);
String8List list = {0};
if (file >= 0){
S64 cap = KB(4);
for (;;){
U8 *buffer = push_array_no_zero(scratch.arena, U8, cap);
int size = read(file, buffer, cap);
if (size > 0){
str8_list_push(scratch.arena, &list, str8(buffer, (U64)size));
}
if (size < cap){
break;
}
cap *= 4;
}
}
String8 result = str8_join(arena, &list, 0);
arena_release_scratch(&scratch);
return(result);
}
#endif /* OS_LINUX */
/*******************************
** End Base Linux **
*******************************/
////////////////////////////////////////////////
////////////////////////////////////////////////
///////////////// M4 Printf ////////////////
////////////////////////////////////////////////
////////////////////////////////////////////////
// stb_sprintf.h STB_SPRINTF_IMPLEMENTATION
#define stbsp__uint32 U32
#define stbsp__int32 S32
#define stbsp__uint64 U64
#define stbsp__int64 S64
#define stbsp__uint16 U16
#define stbsp__uintptr UAddr
// NOTE: modification - removed STB_SPRINTF_MSVC_MODE -- compatibility mode for behavior from MSVC2013 and earlier
#ifdef STB_SPRINTF_NOUNALIGNED // define this before inclusion to force stbsp_sprintf to always use aligned accesses
#define STBSP__UNALIGNED(code)
#else
#define STBSP__UNALIGNED(code) code
#endif
// internal float utility functions
static stbsp__int32 stbsp__real_to_str(char const **start, stbsp__uint32 *len, char *out, stbsp__int32 *decimal_pos, double value, stbsp__uint32 frac_digits);
static stbsp__int32 stbsp__real_to_parts(stbsp__int64 *bits, stbsp__int32 *expo, double value);
#define STBSP__SPECIAL 0x7000
static char stbsp__period = '.';
static char stbsp__comma = ',';
static struct{
short temp; // force next field to be 2-byte aligned
char pair[201];
} stbsp__digitpair =
{
0,
"00010203040506070809101112131415161718192021222324"
"25262728293031323334353637383940414243444546474849"
"50515253545556575859606162636465666768697071727374"
"75767778798081828384858687888990919293949596979899"
};
STBSP__PUBLICDEF void m4_set_separators(char pcomma, char pperiod)
{
stbsp__period = pperiod;
stbsp__comma = pcomma;
}
#define STBSP__LEFTJUST 1
#define STBSP__LEADINGPLUS 2
#define STBSP__LEADINGSPACE 4
#define STBSP__LEADING_0X 8
#define STBSP__LEADINGZERO 16
#define STBSP__INTMAX 32
#define STBSP__TRIPLET_COMMA 64
#define STBSP__NEGATIVE 128
#define STBSP__MEMORY_SIZES 256
#define STBSP__HALFWIDTH 512
static void stbsp__lead_sign(stbsp__uint32 fl, char *sign)
{
sign[0] = 0;
if (fl & STBSP__NEGATIVE) {
sign[0] = 1;
sign[1] = '-';
} else if (fl & STBSP__LEADINGSPACE) {
sign[0] = 1;
sign[1] = ' ';
} else if (fl & STBSP__LEADINGPLUS) {
sign[0] = 1;
sign[1] = '+';
}
}
static STBSP__ASAN stbsp__uint32 stbsp__strlen_limited(char const *s, stbsp__uint32 limit)
{
char const * sn = s;
// get up to 4-byte alignment
for (;;) {
if (((stbsp__uintptr)sn & 3) == 0)
break;
if (!limit || *sn == 0)
return (stbsp__uint32)(sn - s);
++sn;
--limit;
}
// scan over 4 bytes at a time to find terminating 0
// this will intentionally scan up to 3 bytes past the end of buffers,
// but becase it works 4B aligned, it will never cross page boundaries
// (hence the STBSP__ASAN markup; the over-read here is intentional
// and harmless)
while (limit >= 4) {
stbsp__uint32 v = *(stbsp__uint32 *)sn;
// bit hack to find if there's a 0 byte in there
if ((v - 0x01010101) & (~v) & 0x80808080UL)
break;
sn += 4;
limit -= 4;
}
// handle the last few characters to find actual size
while (limit && *sn) {
++sn;
--limit;
}
return (stbsp__uint32)(sn - s);
}
STBSP__PUBLICDEF int m4_vsprintfcb(STBSP_SPRINTFCB *callback, void *user, char *buf, char const *fmt, va_list va)
{
static char hex[] = "0123456789abcdefxp";
static char hexu[] = "0123456789ABCDEFXP";
static char spaces[] =
" "
" "
" "
" ";
char *bf = buf;
char const *f = fmt;
int tlen = 0;
for (;;){
stbsp__int32 field_width;
stbsp__int32 precision;
stbsp__int32 tz;
stbsp__uint32 flags;
// macros for the callback buffer stuff
#define stbsp__chk_cb_bufL(bytes) \
{ \
int len = (int)(bf - buf); \
if ((len + (bytes)) >= STB_SPRINTF_MIN){ \
tlen += len; \
if (0 == (bf = buf = callback(buf, user, len))) goto done; \
} \
}
#define stbsp__chk_cb_buf(bytes) \
{ \
if (callback) { \
stbsp__chk_cb_bufL(bytes); \
} \
}
#define stbsp__flush_cb() \
{ \
stbsp__chk_cb_bufL(STB_SPRINTF_MIN - 1); \
} // flush if there is even one byte in the buffer
#define stbsp__cb_buf_clamp(cl, v) \
cl = v; \
if (callback) { \
int lg = STB_SPRINTF_MIN - (int)(bf - buf); \
if (cl > lg) \
cl = lg; \
}
// fast copy everything up to the next % (or end of string)
for (;;) {
while (((stbsp__uintptr)f) & 3) {
schk1:
if (f[0] == '%') goto scandd;
schk2:
if (f[0] == 0) goto endfmt;
stbsp__chk_cb_buf(1);
*bf++ = f[0];
++f;
}
for (;;) {
// Check if the next 4 bytes contain %(0x25) or end of string.
// Using the 'hasless' trick:
// https://graphics.stanford.edu/~seander/bithacks.html#HasLessInWord
stbsp__uint32 v, c;
v = *(stbsp__uint32 *)f;
c = (~v) & 0x80808080;
if (((v ^ 0x25252525) - 0x01010101) & c)
goto schk1;
if ((v - 0x01010101) & c)
goto schk2;
if (callback)
if ((STB_SPRINTF_MIN - (int)(bf - buf)) < 4)
goto schk1;
#ifdef STB_SPRINTF_NOUNALIGNED
if(((stbsp__uintptr)bf) & 3) {
bf[0] = f[0];
bf[1] = f[1];
bf[2] = f[2];
bf[3] = f[3];
} else
#endif
{
*(stbsp__uint32 *)bf = v;
}
bf += 4;
f += 4;
}
}
scandd:
++f;
// ok, we have a percent, read the modifiers first
field_width = 0;
precision = -1;
flags = 0;
tz = 0;
// flags
for (;;) {
switch (f[0]) {
// if we have left justify
case '-':
flags |= STBSP__LEFTJUST;
++f;
continue;
// if we have leading plus
case '+':
flags |= STBSP__LEADINGPLUS;
++f;
continue;
// if we have leading space
case ' ':
flags |= STBSP__LEADINGSPACE;
++f;
continue;
// if we have leading 0x
case '#':
flags |= STBSP__LEADING_0X;
++f;
continue;
// if we have thousand commas
case '\'':
flags |= STBSP__TRIPLET_COMMA;
++f;
continue;
// if we have memory sizes
case '$':
flags |= STBSP__MEMORY_SIZES;
++f;
continue;
// if we have leading zero
case '0':
flags |= STBSP__LEADINGZERO;
++f;
goto flags_done;
default: goto flags_done;
}
}
flags_done:
// get the field width
if (f[0] == '*'){
field_width = va_arg(va, stbsp__uint32);
++f;
}
else{
while ((f[0] >= '0') && (f[0] <= '9')) {
field_width = field_width*10 + f[0] - '0';
f++;
}
}
// get the precision
if (f[0] == '.'){
++f;
if (f[0] == '*'){
precision = va_arg(va, stbsp__uint32);
++f;
}
else{
precision = 0;
while ((f[0] >= '0') && (f[0] <= '9')){
precision = precision*10 + f[0] - '0';
f++;
}
}
}
// handle integer size overrides
switch (f[0]){
// are we halfwidth?
case 'h':
flags |= STBSP__HALFWIDTH;
++f;
if (f[0] == 'h')
++f; // QUARTERWIDTH
break;
// are we 64-bit (unix style)
case 'l':
flags |= ((sizeof(long) == 8) ? STBSP__INTMAX : 0);
++f;
if (f[0] == 'l') {
flags |= STBSP__INTMAX;
++f;
}
break;
// are we 64-bit on intmax? (c99)
case 'j':
flags |= (sizeof(size_t) == 8) ? STBSP__INTMAX : 0;
++f;
break;
// are we 64-bit on size_t or ptrdiff_t? (c99)
case 'z':
flags |= (sizeof(ptrdiff_t) == 8) ? STBSP__INTMAX : 0;
++f;
break;
case 't':
flags |= (sizeof(ptrdiff_t) == 8) ? STBSP__INTMAX : 0;
++f;
break;
// are we 64-bit (msft style)
case 'I':
if ((f[1] == '6') && (f[2] == '4')) {
flags |= STBSP__INTMAX;
f += 3;
} else if ((f[1] == '3') && (f[2] == '2')) {
f += 3;
} else {
flags |= ((sizeof(void *) == 8) ? STBSP__INTMAX : 0);
++f;
}
break;
default: break;
}
// handle each replacement
switch (f[0]){
#define STBSP__NUMSZ 512 // big enough for e308 (with commas) or e-307
char num[STBSP__NUMSZ];
char lead[8];
char tail[8];
char *s;
char const *h;
stbsp__uint32 l;
stbsp__uint32 n;
stbsp__uint32 cs;
stbsp__uint64 n64;
double fv;
stbsp__int32 dp;
char const *sn;
// NOTE(allen): MODIFICATION
// %S prints str (parameter: String8 str)
case 'S':
{
String8 *str = va_arg(va, String8*);
s = (char*)str->str;
l = (precision >= 0 && precision < str->size) ? precision : (U32)str->size;
lead[0] = 0;
tail[0] = 0;
precision = 0;
dp = 0;
cs = 0;
goto scopy;
}
// NOTE(allen): MODIFICATION
// %N prints n spaces (parameter: int n)
case 'N':
{
// TODO(allen): there's probably a better way to set this
// up so that it doesn't rely on the buffer of spaces -
// perhaps a way to apply the space filling in the left justify path?
l = va_arg(va, int);
l = (sizeof(spaces) - 1 < l) ? (sizeof(spaces) - 1) : l;
l = (precision >= 0 && precision < l) ? precision : l;
s = spaces;
lead[0] = 0;
tail[0] = 0;
precision = 0;
dp = 0;
cs = 0;
goto scopy;
}
case 's':
{
// get the string
s = va_arg(va, char *);
if (s == 0){
s = (char *)"null";
}
// get the length, limited to desired precision
// always limit to ~0u chars since our counts are 32b
l = stbsp__strlen_limited(s, (precision >= 0) ? precision : ~0u);
lead[0] = 0;
tail[0] = 0;
precision = 0;
dp = 0;
cs = 0;
// copy the string in
goto scopy;
}
case 'c': // char
{
// get the character
s = num + STBSP__NUMSZ - 1;
*s = (char)va_arg(va, int);
l = 1;
lead[0] = 0;
tail[0] = 0;
precision = 0;
dp = 0;
cs = 0;
goto scopy;
}
case 'n': // weird write-bytes specifier
{
int *d = va_arg(va, int *);
*d = tlen + (int)(bf - buf);
} break;
case 'A': // hex float
case 'a': // hex float
{
h = (f[0] == 'A') ? hexu : hex;
fv = va_arg(va, double);
if (precision == -1){
precision = 6; // default is 6
}
// read the double into a string
if (stbsp__real_to_parts((stbsp__int64 *)&n64, &dp, fv)){
flags |= STBSP__NEGATIVE;
}
s = num + 64;
stbsp__lead_sign(flags, lead);
if (dp == -1023){
dp = (n64) ? -1022 : 0;
}
else{
n64 |= (((stbsp__uint64)1) << 52);
}
n64 <<= (64 - 56);
if (precision < 15){
n64 += ((((stbsp__uint64)8) << 56) >> (precision*4));
}
// add leading chars
lead[1 + lead[0]] = '0';
lead[2 + lead[0]] = 'x';
lead[0] += 2;
*s++ = h[(n64 >> 60) & 15];
n64 <<= 4;
if (precision){
*s++ = stbsp__period;
}
sn = s;
// print the bits
n = precision;
if (n > 13){
n = 13;
}
if (precision > (stbsp__int32)n){
tz = precision - n;
}
precision = 0;
while (n--) {
*s++ = h[(n64 >> 60) & 15];
n64 <<= 4;
}
// print the expo
tail[1] = h[17];
if (dp < 0){
tail[2] = '-';
dp = -dp;
}
else{
tail[2] = '+';
}
n = (dp >= 1000) ? 6 : ((dp >= 100) ? 5 : ((dp >= 10) ? 4 : 3));
tail[0] = (char)n;
for (;;) {
tail[n] = '0' + dp % 10;
if (n <= 3) break;
--n;
dp /= 10;
}
dp = (int)(s - sn);
l = (int)(s - (num + 64));
s = num + 64;
cs = 1 + (3 << 24);
goto scopy;
}
case 'G': // float
case 'g': // float
{
h = (f[0] == 'G') ? hexu : hex;
fv = va_arg(va, double);
if (precision == -1){
precision = 6;
}
else if (precision == 0){
precision = 1; // default is 6
}
// read the double into a string
if (stbsp__real_to_str(&sn, &l, num, &dp, fv, (precision - 1) | 0x80000000)){
flags |= STBSP__NEGATIVE;
}
// clamp the precision and delete extra zeros after clamp
n = precision;
if (l > (stbsp__uint32)precision){
l = precision;
}
while ((l > 1) && (precision) && (sn[l - 1] == '0')){
--precision;
--l;
}
// should we use %e
if ((dp <= -4) || (dp > (stbsp__int32)n)) {
if (precision > (stbsp__int32)l){
precision = l - 1;
}
else if (precision){
--precision; // when using %e, there is one digit before the decimal
}
goto doexpfromg;
}
// this is the insane action to get the precision to match %g semantics for %f
if (dp > 0){
precision = (dp < (stbsp__int32)l) ? l - dp : 0;
}
else{
precision = -dp + ((precision > (stbsp__int32)l) ? (stbsp__int32) l : precision);
}
goto dofloatfromg;
}
case 'E': // float
case 'e': // float
{
h = (f[0] == 'E') ? hexu : hex;
fv = va_arg(va, double);
if (precision == -1){
precision = 6; // default is 6
}
// read the double into a string
if (stbsp__real_to_str(&sn, &l, num, &dp, fv, precision | 0x80000000)){
flags |= STBSP__NEGATIVE;
}
goto doexpfromg;
}
doexpfromg:
{
tail[0] = 0;
stbsp__lead_sign(flags, lead);
if (dp == STBSP__SPECIAL) {
s = (char *)sn;
cs = 0;
precision = 0;
goto scopy;
}
s = num + 64;
// handle leading chars
*s++ = sn[0];
if (precision){
*s++ = stbsp__period;
}
// handle after decimal
if ((l - 1) > (stbsp__uint32)precision){
l = precision + 1;
}
for (n = 1; n < l; n++){
*s++ = sn[n];
}
// trailing zeros
tz = precision - (l - 1);
precision = 0;
// dump expo
tail[1] = h[0xe];
dp -= 1;
if (dp < 0){
tail[2] = '-';
dp = -dp;
}
else{
tail[2] = '+';
}
n = (dp >= 100) ? 5 : 4;
tail[0] = (char)n;
for (;;) {
tail[n] = '0' + dp % 10;
if (n <= 3)
break;
--n;
dp /= 10;
}
cs = 1 + (3 << 24); // how many tens
goto flt_lead;
}
case 'f': // float
{
fv = va_arg(va, double);
goto doafloat;
}
doafloat:
{
// do kilos
if (flags & STBSP__MEMORY_SIZES) {
double divisor = 1024.f;
while (flags < 0x4000000) {
if ((fv < divisor) && (fv > -divisor))
break;
fv /= divisor;
flags += 0x1000000;
}
}
if (precision == -1){
precision = 6; // default is 6
}
// read the double into a string
if (stbsp__real_to_str(&sn, &l, num, &dp, fv, precision)){
flags |= STBSP__NEGATIVE;
}
}
dofloatfromg:
{
tail[0] = 0;
stbsp__lead_sign(flags, lead);
if (dp == STBSP__SPECIAL) {
s = (char *)sn;
cs = 0;
precision = 0;
goto scopy;
}
s = num + 64;
// handle the three decimal varieties
if (dp <= 0) {
stbsp__int32 i;
// handle 0.000*000xxxx
*s++ = '0';
if (precision){
*s++ = stbsp__period;
}
n = -dp;
if ((stbsp__int32)n > precision){
n = precision;
}
i = n;
while (i) {
if ((((stbsp__uintptr)s) & 3) == 0)
break;
*s++ = '0';
--i;
}
while (i >= 4) {
*(stbsp__uint32 *)s = 0x30303030;
s += 4;
i -= 4;
}
while (i) {
*s++ = '0';
--i;
}
if ((stbsp__int32)(l + n) > precision){
l = precision - n;
}
i = l;
while (i) {
*s++ = *sn++;
--i;
}
tz = precision - (n + l);
cs = 1 + (3 << 24); // how many tens did we write (for commas below)
}
else{
cs = (flags & STBSP__TRIPLET_COMMA) ? ((600 - (stbsp__uint32)dp) % 3) : 0;
if ((stbsp__uint32)dp >= l) {
// handle xxxx000*000.0
n = 0;
for (;;) {
if ((flags & STBSP__TRIPLET_COMMA) && (++cs == 4)) {
cs = 0;
*s++ = stbsp__comma;
} else {
*s++ = sn[n];
++n;
if (n >= l)
break;
}
}
if (n < (stbsp__uint32)dp) {
n = dp - n;
if ((flags & STBSP__TRIPLET_COMMA) == 0) {
while (n) {
if ((((stbsp__uintptr)s) & 3) == 0)
break;
*s++ = '0';
--n;
}
while (n >= 4) {
*(stbsp__uint32 *)s = 0x30303030;
s += 4;
n -= 4;
}
}
while (n) {
if ((flags & STBSP__TRIPLET_COMMA) && (++cs == 4)) {
cs = 0;
*s++ = stbsp__comma;
} else {
*s++ = '0';
--n;
}
}
}
cs = (int)(s - (num + 64)) + (3 << 24); // cs is how many tens
if (precision) {
*s++ = stbsp__period;
tz = precision;
}
} else {
// handle xxxxx.xxxx000*000
n = 0;
for (;;) {
if ((flags & STBSP__TRIPLET_COMMA) && (++cs == 4)) {
cs = 0;
*s++ = stbsp__comma;
} else {
*s++ = sn[n];
++n;
if (n >= (stbsp__uint32)dp)
break;
}
}
cs = (int)(s - (num + 64)) + (3 << 24); // cs is how many tens
if (precision){
*s++ = stbsp__period;
}
if ((l - dp) > (stbsp__uint32)precision){
l = precision + dp;
}
while (n < l) {
*s++ = sn[n];
++n;
}
tz = precision - (l - dp);
}
}
precision = 0;
// handle k,m,g,t
if (flags & STBSP__MEMORY_SIZES) {
tail[0] = 0;
{
char idx = 1;
tail[idx] = ' ';
idx++;
tail[idx] = " KMGT"[flags >> 24];
idx++;
tail[idx] = 'b';
tail[0] = idx;
}
}
goto flt_lead;
}
flt_lead:
{
// get the length that we copied
l = (stbsp__uint32)(s - (num + 64));
s = num + 64;
goto scopy;
}
case 'B': // upper binary
case 'b': // lower binary
{
h = (f[0] == 'B') ? hexu : hex;
lead[0] = 0;
if (flags & STBSP__LEADING_0X) {
lead[0] = 2;
lead[1] = '0';
lead[2] = h[0xb];
}
l = (8 << 4) | (1 << 8);
goto radixnum;
}
case 'o': // octal
{
h = hexu;
lead[0] = 0;
if (flags & STBSP__LEADING_0X) {
lead[0] = 1;
lead[1] = '0';
}
l = (3 << 4) | (3 << 8);
goto radixnum;
}
case 'p': // pointer
{
flags |= (sizeof(void *) == 8) ? STBSP__INTMAX : 0;
precision = sizeof(void *) * 2;
flags &= ~STBSP__LEADINGZERO; // 'p' only prints the pointer with zeros
// fall through - to X
}
case 'X': // upper hex
case 'x': // lower hex
{
h = (f[0] == 'X') ? hexu : hex;
l = (4 << 4) | (4 << 8);
lead[0] = 0;
if (flags & STBSP__LEADING_0X) {
lead[0] = 2;
lead[1] = '0';
lead[2] = h[16];
}
goto radixnum;
}
radixnum:
{
// get the number
if (flags & STBSP__INTMAX){
n64 = va_arg(va, stbsp__uint64);
}
else{
n64 = va_arg(va, stbsp__uint32);
}
s = num + STBSP__NUMSZ;
dp = 0;
// clear tail, and clear leading if value is zero
tail[0] = 0;
if (n64 == 0) {
lead[0] = 0;
if (precision == 0) {
l = 0;
cs = 0;
goto scopy;
}
}
// convert to string
for (;;) {
*--s = h[n64 & ((1 << (l >> 8)) - 1)];
n64 >>= (l >> 8);
if (!((n64) || ((stbsp__int32)((num + STBSP__NUMSZ) - s) < precision))){
break;
}
if (flags & STBSP__TRIPLET_COMMA) {
++l;
if ((l & 15) == ((l >> 4) & 15)) {
l &= ~15;
*--s = stbsp__comma;
}
}
};
// get the tens and the comma pos
cs = (stbsp__uint32)((num + STBSP__NUMSZ) - s) + ((((l >> 4) & 15)) << 24);
// get the length that we copied
l = (stbsp__uint32)((num + STBSP__NUMSZ) - s);
// copy it
goto scopy;
}
case 'u': // unsigned
case 'i':
case 'd': // integer
{
// get the integer and abs it
if (flags & STBSP__INTMAX) {
stbsp__int64 i64 = va_arg(va, stbsp__int64);
n64 = (stbsp__uint64)i64;
if ((f[0] != 'u') && (i64 < 0)) {
n64 = (stbsp__uint64)-i64;
flags |= STBSP__NEGATIVE;
}
} else {
stbsp__int32 i = va_arg(va, stbsp__int32);
n64 = (stbsp__uint32)i;
if ((f[0] != 'u') && (i < 0)) {
n64 = (stbsp__uint32)-i;
flags |= STBSP__NEGATIVE;
}
}
if (flags & STBSP__MEMORY_SIZES) {
if (n64 < 1024){
precision = 0;
}
else if (precision == -1){
precision = 1;
}
fv = (double)(stbsp__int64)n64;
goto doafloat;
}
// convert to string
s = num + STBSP__NUMSZ;
l = 0;
for (;;) {
// do in 32-bit chunks (avoid lots of 64-bit divides even with constant denominators)
char *o = s - 8;
if (n64 >= 100000000) {
n = (stbsp__uint32)(n64 % 100000000);
n64 /= 100000000;
} else {
n = (stbsp__uint32)n64;
n64 = 0;
}
if ((flags & STBSP__TRIPLET_COMMA) == 0) {
do {
s -= 2;
*(stbsp__uint16 *)s = *(stbsp__uint16 *)&stbsp__digitpair.pair[(n % 100) * 2];
n /= 100;
} while (n);
}
while (n) {
if ((flags & STBSP__TRIPLET_COMMA) && (l++ == 3)) {
l = 0;
*--s = stbsp__comma;
--o;
} else {
*--s = (char)(n % 10) + '0';
n /= 10;
}
}
if (n64 == 0) {
if ((s[0] == '0') && (s != (num + STBSP__NUMSZ))){
++s;
}
break;
}
while (s != o){
if ((flags & STBSP__TRIPLET_COMMA) && (l++ == 3)){
l = 0;
*--s = stbsp__comma;
--o;
}
else{
*--s = '0';
}
}
}
tail[0] = 0;
stbsp__lead_sign(flags, lead);
// get the length that we copied
l = (stbsp__uint32)((num + STBSP__NUMSZ) - s);
if (l == 0) {
*--s = '0';
l = 1;
}
cs = l + (3 << 24);
if (precision < 0){
precision = 0;
}
goto scopy;
}
default: // unknown, just copy code
{
s = num + STBSP__NUMSZ - 1;
*s = f[0];
l = 1;
field_width = flags = 0;
lead[0] = 0;
tail[0] = 0;
precision = 0;
dp = 0;
cs = 0;
goto scopy;
}
scopy:
{
// get field_width=leading/trailing space, precision=leading zeros
if (precision < (stbsp__int32)l){
precision = l;
}
n = precision + lead[0] + tail[0] + tz;
if (field_width < (stbsp__int32)n){
field_width = n;
}
field_width -= n;
precision -= l;
// handle right justify and leading zeros
if ((flags & STBSP__LEFTJUST) == 0){
// if leading zeros, everything is in precision
if (flags & STBSP__LEADINGZERO){
precision = (field_width > precision) ? field_width : precision;
field_width = 0;
}
// if no leading zeros, then no commas
else{
flags &= ~STBSP__TRIPLET_COMMA;
}
}
// copy the spaces and/or zeros
if (field_width + precision) {
stbsp__int32 i;
stbsp__uint32 c;
// copy leading spaces (or when doing %8.4d stuff)
if ((flags & STBSP__LEFTJUST) == 0)
while (field_width > 0) {
stbsp__cb_buf_clamp(i, field_width);
field_width -= i;
while (i) {
if ((((stbsp__uintptr)bf) & 3) == 0)
break;
*bf++ = ' ';
--i;
}
while (i >= 4) {
*(stbsp__uint32 *)bf = 0x20202020;
bf += 4;
i -= 4;
}
while (i) {
*bf++ = ' ';
--i;
}
stbsp__chk_cb_buf(1);
}
// copy leader
sn = lead + 1;
while (lead[0]) {
stbsp__cb_buf_clamp(i, lead[0]);
lead[0] -= (char)i;
while (i) {
*bf++ = *sn++;
--i;
}
stbsp__chk_cb_buf(1);
}
// copy leading zeros
c = cs >> 24;
cs &= 0xffffff;
cs = (flags & STBSP__TRIPLET_COMMA) ? ((stbsp__uint32)(c - ((precision + cs) % (c + 1)))) : 0;
while (precision > 0) {
stbsp__cb_buf_clamp(i, precision);
precision -= i;
if ((flags & STBSP__TRIPLET_COMMA) == 0) {
while (i) {
if ((((stbsp__uintptr)bf) & 3) == 0)
break;
*bf++ = '0';
--i;
}
while (i >= 4) {
*(stbsp__uint32 *)bf = 0x30303030;
bf += 4;
i -= 4;
}
}
while (i) {
if ((flags & STBSP__TRIPLET_COMMA) && (cs++ == c)) {
cs = 0;
*bf++ = stbsp__comma;
} else
*bf++ = '0';
--i;
}
stbsp__chk_cb_buf(1);
}
}
// copy leader if there is still one
sn = lead + 1;
while (lead[0]) {
stbsp__int32 i;
stbsp__cb_buf_clamp(i, lead[0]);
lead[0] -= (char)i;
while (i) {
*bf++ = *sn++;
--i;
}
stbsp__chk_cb_buf(1);
}
// copy the string
n = l;
while (n) {
stbsp__int32 i;
stbsp__cb_buf_clamp(i, n);
n -= i;
STBSP__UNALIGNED(while (i >= 4) {
*(stbsp__uint32 volatile *)bf = *(stbsp__uint32 volatile *)s;
bf += 4;
s += 4;
i -= 4;
})
while (i) {
*bf++ = *s++;
--i;
}
stbsp__chk_cb_buf(1);
}
// copy trailing zeros
while (tz) {
stbsp__int32 i;
stbsp__cb_buf_clamp(i, tz);
tz -= i;
while (i) {
if ((((stbsp__uintptr)bf) & 3) == 0)
break;
*bf++ = '0';
--i;
}
while (i >= 4) {
*(stbsp__uint32 *)bf = 0x30303030;
bf += 4;
i -= 4;
}
while (i) {
*bf++ = '0';
--i;
}
stbsp__chk_cb_buf(1);
}
// copy tail if there is one
sn = tail + 1;
while (tail[0]) {
stbsp__int32 i;
stbsp__cb_buf_clamp(i, tail[0]);
tail[0] -= (char)i;
while (i) {
*bf++ = *sn++;
--i;
}
stbsp__chk_cb_buf(1);
}
// handle the left justify
if (flags & STBSP__LEFTJUST){
if (field_width > 0){
while (field_width){
stbsp__int32 i;
stbsp__cb_buf_clamp(i, field_width);
field_width -= i;
while (i){
if ((((stbsp__uintptr)bf) & 3) == 0)
break;
*bf++ = ' ';
--i;
}
while (i >= 4){
*(stbsp__uint32 *)bf = 0x20202020;
bf += 4;
i -= 4;
}
while (i--){
*bf++ = ' ';
}
stbsp__chk_cb_buf(1);
}
}
}
}break;
}
++f;
}
endfmt:
if (!callback)
*bf = 0;
else
stbsp__flush_cb();
done:
return tlen + (int)(bf - buf);
}
// cleanup
#undef STBSP__LEFTJUST
#undef STBSP__LEADINGPLUS
#undef STBSP__LEADINGSPACE
#undef STBSP__LEADING_0X
#undef STBSP__LEADINGZERO
#undef STBSP__INTMAX
#undef STBSP__TRIPLET_COMMA
#undef STBSP__NEGATIVE
#undef STBSP__METRIC_SUFFIX
#undef STBSP__NUMSZ
#undef stbsp__chk_cb_bufL
#undef stbsp__chk_cb_buf
#undef stbsp__flush_cb
#undef stbsp__cb_buf_clamp
// ============================================================================
// wrapper functions
STBSP__PUBLICDEF int m4_sprintf(char *buf, char const *fmt, ...)
{
int result;
va_list va;
va_start(va, fmt);
result = m4_vsprintfcb(0, 0, buf, fmt, va);
va_end(va);
return result;
}
typedef struct stbsp__context {
char *buf;
int count;
int length;
char tmp[STB_SPRINTF_MIN];
} stbsp__context;
static char *stbsp__clamp_callback(const char *buf, void *user, int len)
{
stbsp__context *c = (stbsp__context *)user;
c->length += len;
if (len > c->count)
len = c->count;
if (len) {
if (buf != c->buf) {
const char *s, *se;
char *d;
d = c->buf;
s = buf;
se = buf + len;
do {
*d++ = *s++;
} while (s < se);
}
c->buf += len;
c->count -= len;
}
if (c->count <= 0)
return c->tmp;
return (c->count >= STB_SPRINTF_MIN) ? c->buf : c->tmp; // go direct into buffer if you can
}
static char * stbsp__count_clamp_callback( const char * buf, void * user, int len )
{
stbsp__context * c = (stbsp__context*)user;
(void) sizeof(buf);
c->length += len;
return c->tmp; // go direct into buffer if you can
}
STBSP__PUBLICDEF int m4_vsnprintf( char * buf, int count, char const * fmt, va_list va )
{
stbsp__context c;
if ( (count == 0) && !buf )
{
c.length = 0;
m4_vsprintfcb( stbsp__count_clamp_callback, &c, c.tmp, fmt, va );
}
else
{
int l;
c.buf = buf;
c.count = count;
c.length = 0;
m4_vsprintfcb( stbsp__clamp_callback, &c, stbsp__clamp_callback(0,&c,0), fmt, va );
// zero-terminate
l = (int)( c.buf - buf );
if ( l >= count ) // should never be greater, only equal (or less) than count
l = count - 1;
buf[l] = 0;
}
return c.length;
}
STBSP__PUBLICDEF int m4_snprintf(char *buf, int count, char const *fmt, ...)
{
int result;
va_list va;
va_start(va, fmt);
result = m4_vsnprintf(buf, count, fmt, va);
va_end(va);
return result;
}
STBSP__PUBLICDEF int m4_vsprintf(char *buf, char const *fmt, va_list va)
{
return m4_vsprintfcb(0, 0, buf, fmt, va);
}
// =======================================================================
// low level float utility functions
// copies d to bits w/ strict aliasing (this compiles to nothing on /Ox)
#define STBSP__COPYFP(dest, src) \
{ \
int cn; \
for (cn = 0; cn < 8; cn++) \
((char *)&dest)[cn] = ((char *)&src)[cn]; \
}
// get float info
static stbsp__int32 stbsp__real_to_parts(stbsp__int64 *bits, stbsp__int32 *expo, double value)
{
double d;
stbsp__int64 b = 0;
// load value and round at the frac_digits
d = value;
STBSP__COPYFP(b, d);
*bits = b & ((((stbsp__uint64)1) << 52) - 1);
*expo = (stbsp__int32)(((b >> 52) & 2047) - 1023);
return (stbsp__int32)((stbsp__uint64) b >> 63);
}
static double const stbsp__bot[23] = {
1e+000, 1e+001, 1e+002, 1e+003, 1e+004, 1e+005, 1e+006, 1e+007, 1e+008, 1e+009, 1e+010, 1e+011,
1e+012, 1e+013, 1e+014, 1e+015, 1e+016, 1e+017, 1e+018, 1e+019, 1e+020, 1e+021, 1e+022
};
static double const stbsp__negbot[22] = {
1e-001, 1e-002, 1e-003, 1e-004, 1e-005, 1e-006, 1e-007, 1e-008, 1e-009, 1e-010, 1e-011,
1e-012, 1e-013, 1e-014, 1e-015, 1e-016, 1e-017, 1e-018, 1e-019, 1e-020, 1e-021, 1e-022
};
static double const stbsp__negboterr[22] = {
-5.551115123125783e-018, -2.0816681711721684e-019, -2.0816681711721686e-020, -4.7921736023859299e-021, -8.1803053914031305e-022, 4.5251888174113741e-023,
4.5251888174113739e-024, -2.0922560830128471e-025, -6.2281591457779853e-026, -3.6432197315497743e-027, 6.0503030718060191e-028, 2.0113352370744385e-029,
-3.0373745563400371e-030, 1.1806906454401013e-032, -7.7705399876661076e-032, 2.0902213275965398e-033, -7.1542424054621921e-034, -7.1542424054621926e-035,
2.4754073164739869e-036, 5.4846728545790429e-037, 9.2462547772103625e-038, -4.8596774326570872e-039
};
static double const stbsp__top[13] = {
1e+023, 1e+046, 1e+069, 1e+092, 1e+115, 1e+138, 1e+161, 1e+184, 1e+207, 1e+230, 1e+253, 1e+276, 1e+299
};
static double const stbsp__negtop[13] = {
1e-023, 1e-046, 1e-069, 1e-092, 1e-115, 1e-138, 1e-161, 1e-184, 1e-207, 1e-230, 1e-253, 1e-276, 1e-299
};
static double const stbsp__toperr[13] = {
8388608,
6.8601809640529717e+028,
-7.253143638152921e+052,
-4.3377296974619174e+075,
-1.5559416129466825e+098,
-3.2841562489204913e+121,
-3.7745893248228135e+144,
-1.7356668416969134e+167,
-3.8893577551088374e+190,
-9.9566444326005119e+213,
6.3641293062232429e+236,
-5.2069140800249813e+259,
-5.2504760255204387e+282
};
static double const stbsp__negtoperr[13] = {
3.9565301985100693e-040, -2.299904345391321e-063, 3.6506201437945798e-086, 1.1875228833981544e-109,
-5.0644902316928607e-132, -6.7156837247865426e-155, -2.812077463003139e-178, -5.7778912386589953e-201,
7.4997100559334532e-224, -4.6439668915134491e-247, -6.3691100762962136e-270, -9.436808465446358e-293,
8.0970921678014997e-317
};
#if defined(_MSC_VER) && (_MSC_VER <= 1200)
static stbsp__uint64 const stbsp__powten[20] = {
1,
10,
100,
1000,
10000,
100000,
1000000,
10000000,
100000000,
1000000000,
10000000000,
100000000000,
1000000000000,
10000000000000,
100000000000000,
1000000000000000,
10000000000000000,
100000000000000000,
1000000000000000000,
10000000000000000000U
};
#define stbsp__tento19th ((stbsp__uint64)1000000000000000000)
#else
static stbsp__uint64 const stbsp__powten[20] = {
1,
10,
100,
1000,
10000,
100000,
1000000,
10000000,
100000000,
1000000000,
10000000000ULL,
100000000000ULL,
1000000000000ULL,
10000000000000ULL,
100000000000000ULL,
1000000000000000ULL,
10000000000000000ULL,
100000000000000000ULL,
1000000000000000000ULL,
10000000000000000000ULL
};
#define stbsp__tento19th (1000000000000000000ULL)
#endif
#define stbsp__ddmulthi(oh, ol, xh, yh) \
{ \
double ahi = 0, alo, bhi = 0, blo; \
stbsp__int64 bt; \
oh = xh * yh; \
STBSP__COPYFP(bt, xh); \
bt &= ((~(stbsp__uint64)0) << 27); \
STBSP__COPYFP(ahi, bt); \
alo = xh - ahi; \
STBSP__COPYFP(bt, yh); \
bt &= ((~(stbsp__uint64)0) << 27); \
STBSP__COPYFP(bhi, bt); \
blo = yh - bhi; \
ol = ((ahi * bhi - oh) + ahi * blo + alo * bhi) + alo * blo; \
}
#define stbsp__ddtoS64(ob, xh, xl) \
{ \
double ahi = 0, alo, vh, t; \
ob = (stbsp__int64)xh; \
vh = (double)ob; \
ahi = (xh - vh); \
t = (ahi - xh); \
alo = (xh - (ahi - t)) - (vh + t); \
ob += (stbsp__int64)(ahi + alo + xl); \
}
#define stbsp__ddrenorm(oh, ol) \
{ \
double s; \
s = oh + ol; \
ol = ol - (s - oh); \
oh = s; \
}
#define stbsp__ddmultlo(oh, ol, xh, xl, yh, yl) ol = ol + (xh * yl + xl * yh);
#define stbsp__ddmultlos(oh, ol, xh, yl) ol = ol + (xh * yl);
static void stbsp__raise_to_power10(double *ohi, double *olo, double d, stbsp__int32 power) // power can be -323 to +350
{
double ph, pl;
if ((power >= 0) && (power <= 22)) {
stbsp__ddmulthi(ph, pl, d, stbsp__bot[power]);
} else {
stbsp__int32 e, et, eb;
double p2h, p2l;
e = power;
if (power < 0)
e = -e;
et = (e * 0x2c9) >> 14; /* %23 */
if (et > 13)
et = 13;
eb = e - (et * 23);
ph = d;
pl = 0.0;
if (power < 0) {
if (eb) {
--eb;
stbsp__ddmulthi(ph, pl, d, stbsp__negbot[eb]);
stbsp__ddmultlos(ph, pl, d, stbsp__negboterr[eb]);
}
if (et) {
stbsp__ddrenorm(ph, pl);
--et;
stbsp__ddmulthi(p2h, p2l, ph, stbsp__negtop[et]);
stbsp__ddmultlo(p2h, p2l, ph, pl, stbsp__negtop[et], stbsp__negtoperr[et]);
ph = p2h;
pl = p2l;
}
} else {
if (eb) {
e = eb;
if (eb > 22)
eb = 22;
e -= eb;
stbsp__ddmulthi(ph, pl, d, stbsp__bot[eb]);
if (e) {
stbsp__ddrenorm(ph, pl);
stbsp__ddmulthi(p2h, p2l, ph, stbsp__bot[e]);
stbsp__ddmultlos(p2h, p2l, stbsp__bot[e], pl);
ph = p2h;
pl = p2l;
}
}
if (et) {
stbsp__ddrenorm(ph, pl);
--et;
stbsp__ddmulthi(p2h, p2l, ph, stbsp__top[et]);
stbsp__ddmultlo(p2h, p2l, ph, pl, stbsp__top[et], stbsp__toperr[et]);
ph = p2h;
pl = p2l;
}
}
}
stbsp__ddrenorm(ph, pl);
*ohi = ph;
*olo = pl;
}
// given a float value, returns the significant bits in bits, and the position of the
// decimal point in decimal_pos. +/-INF and NAN are specified by special values
// returned in the decimal_pos parameter.
// frac_digits is absolute normally, but if you want from first significant digits (got %g and %e), or in 0x80000000
static stbsp__int32 stbsp__real_to_str(char const **start, stbsp__uint32 *len, char *out, stbsp__int32 *decimal_pos, double value, stbsp__uint32 frac_digits)
{
double d;
stbsp__int64 bits = 0;
stbsp__int32 expo, e, ng, tens;
d = value;
STBSP__COPYFP(bits, d);
expo = (stbsp__int32)((bits >> 52) & 2047);
ng = (stbsp__int32)((stbsp__uint64) bits >> 63);
if (ng)
d = -d;
if (expo == 2047) // is nan or inf?
{
*start = (bits & ((((stbsp__uint64)1) << 52) - 1)) ? "NaN" : "Inf";
*decimal_pos = STBSP__SPECIAL;
*len = 3;
return ng;
}
if (expo == 0) // is zero or denormal
{
if (((stbsp__uint64) bits << 1) == 0) // do zero
{
*decimal_pos = 1;
*start = out;
out[0] = '0';
*len = 1;
return ng;
}
// find the right expo for denormals
{
stbsp__int64 v = ((stbsp__uint64)1) << 51;
while ((bits & v) == 0) {
--expo;
v >>= 1;
}
}
}
// find the decimal exponent as well as the decimal bits of the value
{
double ph, pl;
// log10 estimate - very specifically tweaked to hit or undershoot by no more than 1 of log10 of all expos 1..2046
tens = expo - 1023;
tens = (tens < 0) ? ((tens * 617) / 2048) : (((tens * 1233) / 4096) + 1);
// move the significant bits into position and stick them into an int
stbsp__raise_to_power10(&ph, &pl, d, 18 - tens);
// get full as much precision from double-double as possible
stbsp__ddtoS64(bits, ph, pl);
// check if we undershot
if (((stbsp__uint64)bits) >= stbsp__tento19th)
++tens;
}
// now do the rounding in integer land
frac_digits = (frac_digits & 0x80000000) ? ((frac_digits & 0x7ffffff) + 1) : (tens + frac_digits);
if ((frac_digits < 24)) {
stbsp__uint32 dg = 1;
if ((stbsp__uint64)bits >= stbsp__powten[9])
dg = 10;
while ((stbsp__uint64)bits >= stbsp__powten[dg]) {
++dg;
if (dg == 20)
goto noround;
}
if (frac_digits < dg) {
stbsp__uint64 r;
// add 0.5 at the right position and round
e = dg - frac_digits;
if ((stbsp__uint32)e >= 24)
goto noround;
r = stbsp__powten[e];
bits = bits + (r / 2);
if ((stbsp__uint64)bits >= stbsp__powten[dg])
++tens;
bits /= r;
}
noround:;
}
// kill long trailing runs of zeros
if (bits) {
stbsp__uint32 n;
for (;;) {
if (bits <= 0xffffffff)
break;
if (bits % 1000)
goto donez;
bits /= 1000;
}
n = (stbsp__uint32)bits;
while ((n % 1000) == 0)
n /= 1000;
bits = n;
donez:;
}
// convert to string
out += 64;
e = 0;
for (;;) {
stbsp__uint32 n;
char *o = out - 8;
// do the conversion in chunks of U32s (avoid most 64-bit divides, worth it, constant denomiators be damned)
if (bits >= 100000000) {
n = (stbsp__uint32)(bits % 100000000);
bits /= 100000000;
} else {
n = (stbsp__uint32)bits;
bits = 0;
}
while (n) {
out -= 2;
*(stbsp__uint16 *)out = *(stbsp__uint16 *)&stbsp__digitpair.pair[(n % 100) * 2];
n /= 100;
e += 2;
}
if (bits == 0) {
if ((e) && (out[0] == '0')) {
++out;
--e;
}
break;
}
while (out != o) {
*--out = '0';
++e;
}
}
*decimal_pos = tens;
*start = out;
*len = e;
return ng;
}
#undef stbsp__ddmulthi
#undef stbsp__ddrenorm
#undef stbsp__ddmultlo
#undef stbsp__ddmultlos
#undef STBSP__SPECIAL
#undef STBSP__COPYFP
// clean up
#undef stbsp__uint16
#undef stbsp__uint32
#undef stbsp__int32
#undef stbsp__uint64
#undef stbsp__int64
#undef STBSP__UNALIGNED
Reference in New Issue View Git Blame Copy Permalink