diff --git a/stb.h b/stb.h index 6831476..4b2933c 100644 --- a/stb.h +++ b/stb.h @@ -730,6 +730,7 @@ STB_EXTERN int stb_snprintf(char *s, size_t n, const char *fmt, ...); STB_EXTERN int stb_vsnprintf(char *s, size_t n, const char *fmt, va_list v); #ifdef STB_DEFINE + int stb_vsnprintf(char *s, size_t n, const char *fmt, va_list v) { int res; diff --git a/stb_sprintf.h b/stb_sprintf.h index 62962e3..8fdc70e 100644 --- a/stb_sprintf.h +++ b/stb_sprintf.h @@ -1,5 +1,14 @@ -#ifndef RR_SPRINTF_H_INCLUDE -#define RR_SPRINTF_H_INCLUDE +// stb_sprintf - v1.00 - public domain snprintf() implementation +// originally by Jeff Roberts / RAD Game Tools, 2015/10/20 +// http://github.com/nothings/stb +// +// allowed types: sc uidBboXx p AaGgEef n +// lengths : h ll j z t I64 I32 I + + + +#ifndef STB_SPRINTF_H_INCLUDE +#define STB_SPRINTF_H_INCLUDE /* Single file sprintf replacement. @@ -22,7 +31,7 @@ the same format strings in cross platform code. It uses the standard single file trick of being both the header file and the source itself. If you just include it normally, you just get the header file function definitions. To get the code, you include -it from a C or C++ file and define RR_SPRINTF_IMPLEMENTATION first. +it from a C or C++ file and define STB_SPRINTF_IMPLEMENTATION first. It only uses va_args macros from the C runtime to do it's work. It does cast doubles to S64s and shifts and divides U64s, which does @@ -34,25 +43,25 @@ in 16K. API: ==== -int rrsprintf( char * buf, char const * fmt, ... ) -int rrsnprintf( char * buf, int count, char const * fmt, ... ) +int stbsp_sprintf( char * buf, char const * fmt, ... ) +int stbsp_snprintf( char * buf, int count, char const * fmt, ... ) Convert an arg list into a buffer. rrsnprintf always returns a zero-terminated string (unlike regular snprintf). -int rrvsprintf( char * buf, char const * fmt, va_list va ) -int rrvsnprintf( char * buf, int count, char const * fmt, va_list va ) +int stbsp_vsprintf( char * buf, char const * fmt, va_list va ) +int stbsp_vsnprintf( char * buf, int count, char const * fmt, va_list va ) Convert a va_list arg list into a buffer. rrvsnprintf always returns a zero-terminated string (unlike regular snprintf). -int rrvsprintfcb( RRSPRINTFCB * callback, void * user, char * buf, char const * fmt, va_list va ) - typedef char * RRSPRINTFCB( char const * buf, void * user, int len ); - Convert into a buffer, calling back every RR_SPRINTF_MIN chars. +int stbsp_vsprintfcb( STBSP_SPRINTFCB * callback, void * user, char * buf, char const * fmt, va_list va ) + typedef char * STBSP_SPRINTFCB( char const * buf, void * user, int len ); + Convert into a buffer, calling back every STB_SPRINTF_MIN chars. Your callback can then copy the chars out, print them or whatever. This function is actually the workhorse for everything else. - The buffer you pass in must hold at least RR_SPRINTF_MIN characters. + The buffer you pass in must hold at least STB_SPRINTF_MIN characters. // you return the next buffer to use or 0 to stop converting -void rrsetseparators( char comma, char period ) +void stbsp_set_seperators( char comma, char period ) Set the comma and period characters to use. FLOATS/DOUBLES: @@ -67,10 +76,10 @@ with MSVC or GCC (but they don't match each other either). We also don't attempt to find the minimum length matching float (pre-MSVC15 doesn't either). -If you don't need float or doubles at all, define RR_SPRINTF_NOFLOAT +If you don't need float or doubles at all, define STB_SPRINTF_NOFLOAT and you'll save 4K of code space. -64-BIT INTS: +64-STBSP__INTMAXT INTS: ============ This library also supports 64-bit integers and you can use MSVC style or GCC style indicators (%I64d or %lld). It supports the C99 specifiers @@ -111,94 +120,94 @@ PERFORMANCE vs MSVC 2008 32-/64-bit (GCC is even slower than MSVC): "...512 char string..." ( 35.0x/32.5x faster!) */ -#ifdef RR_SPRINTF_STATIC -#define RRPUBLIC_DEC static -#define RRPUBLIC_DEF static +#ifdef STB_SPRINTF_STATIC +#define STBSP__PUBLICDEC static +#define STBSP__PUBLICDEF static #else #ifdef __cplusplus -#define RRPUBLIC_DEC extern "C" -#define RRPUBLIC_DEF extern "C" +#define STBSP__PUBLICDEC extern "C" +#define STBSP__PUBLICDEF extern "C" #else -#define RRPUBLIC_DEC extern -#define RRPUBLIC_DEF +#define STBSP__PUBLICDEC extern +#define STBSP__PUBLICDEF #endif #endif #include // for va_list() -#ifndef RR_SPRINTF_MIN -#define RR_SPRINTF_MIN 512 // how many characters per callback +#ifndef STB_SPRINTF_MIN +#define STB_SPRINTF_MIN 512 // how many characters per callback #endif -typedef char * RRSPRINTFCB( char * buf, void * user, int len ); +typedef char * STBSP_SPRINTFCB( char * buf, void * user, int len ); -#ifndef RR_SPRINTF_DECORATE -#define RR_SPRINTF_DECORATE(name) rr##name // define this before including if you want to change the names +#ifndef STB_SPRINTF_DECORATE +#define STB_SPRINTF_DECORATE(name) stbsp_##name // define this before including if you want to change the names #endif -#ifndef RR_SPRINTF_IMPLEMENTATION +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE( vsprintf )( char * buf, char const * fmt, va_list va ); +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE( vsnprintf )( char * buf, int count, char const * fmt, va_list va ); +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE( sprintf ) ( char * buf, char const * fmt, ... ); +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE( snprintf )( char * buf, int count, char const * fmt, ... ); -RRPUBLIC_DEF int RR_SPRINTF_DECORATE( vsprintf )( char * buf, char const * fmt, va_list va ); -RRPUBLIC_DEF int RR_SPRINTF_DECORATE( vsnprintf )( char * buf, int count, char const * fmt, va_list va ); -RRPUBLIC_DEF int RR_SPRINTF_DECORATE( sprintf ) ( char * buf, char const * fmt, ... ); -RRPUBLIC_DEF int RR_SPRINTF_DECORATE( snprintf )( char * buf, int count, char const * fmt, ... ); +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE( vsprintfcb )( STBSP_SPRINTFCB * callback, void * user, char * buf, char const * fmt, va_list va ); +STBSP__PUBLICDEF void STB_SPRINTF_DECORATE( set_separators )( char comma, char period ); -RRPUBLIC_DEF int RR_SPRINTF_DECORATE( vsprintfcb )( RRSPRINTFCB * callback, void * user, char * buf, char const * fmt, va_list va ); -RRPUBLIC_DEF void RR_SPRINTF_DECORATE( setseparators )( char comma, char period ); +#endif // STB_SPRINTF_H_INCLUDE -#else +#ifndef STB_SPRINTF_IMPLEMENTATION #include // for va_arg() -#define rU32 unsigned int -#define rS32 signed int +#define stbsp__uint32 unsigned int +#define stbsp__int32 signed int #ifdef _MSC_VER -#define rU64 unsigned __int64 -#define rS64 signed __int64 +#define stbsp__uint64 unsigned __int64 +#define stbsp__int64 signed __int64 #else -#define rU64 unsigned long long -#define rS64 signed long long +#define stbsp__uint64 unsigned long long +#define stbsp__int64 signed long long #endif -#define rU16 unsigned short +#define stbsp__uint16 unsigned short -#ifndef rUINTa +#ifndef stbsp__uintptr #if defined(__ppc64__) || defined(__aarch64__) || defined(_M_X64) || defined(__x86_64__) || defined(__x86_64) -#define rUINTa rU64 +#define stbsp__uintptr stbsp__uint64 #else -#define rUINTa rU32 +#define stbsp__uintptr stbsp__uint32 #endif #endif -#ifndef RR_SPRINTF_MSVC_MODE // used for MSVC2013 and earlier (MSVC2015 matches GCC) +#ifndef STB_SPRINTF_MSVC_MODE // used for MSVC2013 and earlier (MSVC2015 matches GCC) #if defined(_MSC_VER) && (_MSC_VER<1900) -#define RR_SPRINTF_MSVC_MODE +#define STB_SPRINTF_MSVC_MODE #endif #endif -#ifdef RR_SPRINTF_NOUNALIGNED // define this before inclusion to force rrsprint to always use aligned accesses -#define RR_UNALIGNED(code) +#ifdef STB_SPRINTF_NOUNALIGNED // define this before inclusion to force rrsprint to always use aligned accesses +#define STBSP__UNALIGNED(code) #else -#define RR_UNALIGNED(code) code +#define STBSP__UNALIGNED(code) code #endif -#ifndef RR_SPRINTF_NOFLOAT +#ifndef STB_SPRINTF_NOFLOAT // internal float utility functions -static rS32 rrreal_to_str( char const * * start, rU32 * len, char *out, rS32 * decimal_pos, double value, rU32 frac_digits ); -static rS32 rrreal_to_parts( rS64 * bits, rS32 * expo, double value ); -#define RRSPECIAL 0x7000 +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 #endif -static char RRperiod='.'; -static char RRcomma=','; -static char rrdiglookup[201]="00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899"; +static char stbsp__period='.'; +static char stbsp__comma=','; +static char stbsp__digitpair[201]="00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899"; -RRPUBLIC_DEF void RR_SPRINTF_DECORATE( setseparators )( char pcomma, char pperiod ) +STBSP__PUBLICDEF void STB_SPRINTF_DECORATE( set_separators )( char pcomma, char pperiod ) { - RRperiod=pperiod; - RRcomma=pcomma; + stbsp__period=pperiod; + stbsp__comma=pcomma; } -RRPUBLIC_DEF int RR_SPRINTF_DECORATE( vsprintfcb )( RRSPRINTFCB * callback, void * user, char * buf, char const * fmt, va_list va ) +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE( vsprintfcb )( STBSP_SPRINTFCB * callback, void * user, char * buf, char const * fmt, va_list va ) { static char hex[]="0123456789abcdefxp"; static char hexu[]="0123456789ABCDEFXP"; @@ -210,42 +219,42 @@ RRPUBLIC_DEF int RR_SPRINTF_DECORATE( vsprintfcb )( RRSPRINTFCB * callback, void f = fmt; for(;;) { - rS32 fw,pr,tz; rU32 fl; + stbsp__int32 fw,pr,tz; stbsp__uint32 fl; - #define LJ 1 - #define LP 2 - #define LS 4 - #define LX 8 - #define LZ 16 - #define BI 32 - #define CS 64 - #define NG 128 - #define KI 256 - #define HW 512 + #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__METRIC_SUFFIX 256 + #define STBSP__HALFWIDTH 512 // macros for the callback buffer stuff - #define chk_cb_bufL(bytes) { int len = (int)(bf-buf); if ((len+(bytes))>=RR_SPRINTF_MIN) { tlen+=len; if (0==(bf=buf=callback(buf,user,len))) goto done; } } - #define chk_cb_buf(bytes) { if ( callback ) { chk_cb_bufL(bytes); } } - #define flush_cb() { chk_cb_bufL(RR_SPRINTF_MIN-1); } //flush if there is even one byte in the buffer - #define cb_buf_clamp(cl,v) cl = v; if ( callback ) { int lg = RR_SPRINTF_MIN-(int)(bf-buf); if (cl>lg) cl=lg; } + #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 (((rUINTa)f)&3) + while (((stbsp__uintptr)f)&3) { schk1: if (f[0]=='%') goto scandd; schk2: if (f[0]==0) goto endfmt; - chk_cb_buf(1); *bf++=f[0]; ++f; + stbsp__chk_cb_buf(1); *bf++=f[0]; ++f; } for(;;) { - rU32 v,c; - v=*(rU32*)f; c=(~v)&0x80808080; + stbsp__uint32 v,c; + v=*(stbsp__uint32*)f; c=(~v)&0x80808080; if ((v-0x26262626)&c) goto schk1; if ((v-0x01010101)&c) goto schk2; - if (callback) if ((RR_SPRINTF_MIN-(int)(bf-buf))<4) goto schk1; - *(rU32*)bf=v; bf+=4; f+=4; + if (callback) if ((STB_SPRINTF_MIN-(int)(bf-buf))<4) goto schk1; + *(stbsp__uint32*)bf=v; bf+=4; f+=4; } } scandd: @@ -259,61 +268,63 @@ RRPUBLIC_DEF int RR_SPRINTF_DECORATE( vsprintfcb )( RRSPRINTFCB * callback, void { switch(f[0]) { - // if we have left just - case '-': fl|=LJ; ++f; continue; + // if we have left justify + case '-': fl|=STBSP__LEFTJUST; ++f; continue; // if we have leading plus - case '+': fl|=LP; ++f; continue; + case '+': fl|=STBSP__LEADINGPLUS; ++f; continue; // if we have leading space - case ' ': fl|=LS; ++f; continue; + case ' ': fl|=STBSP__LEADINGSPACE; ++f; continue; // if we have leading 0x - case '#': fl|=LX; ++f; continue; + case '#': fl|=STBSP__LEADING_0X; ++f; continue; // if we have thousand commas - case '\'': fl|=CS; ++f; continue; + case '\'': fl|=STBSP__TRIPLET_COMMA; ++f; continue; // if we have kilo marker - case '$': fl|=KI; ++f; continue; + case '$': fl|=STBSP__METRIC_SUFFIX; ++f; continue; // if we have leading zero - case '0': fl|=LZ; ++f; goto flags_done; + case '0': fl|=STBSP__LEADINGZERO; ++f; goto flags_done; default: goto flags_done; } } flags_done: // get the field width - if ( f[0] == '*' ) {fw = va_arg(va,rU32); ++f;} else { while (( f[0] >= '0' ) && ( f[0] <= '9' )) { fw = fw * 10 + f[0] - '0'; f++; } } + if ( f[0] == '*' ) {fw = va_arg(va,stbsp__uint32); ++f;} else { while (( f[0] >= '0' ) && ( f[0] <= '9' )) { fw = fw * 10 + f[0] - '0'; f++; } } // get the precision - if ( f[0]=='.' ) { ++f; if ( f[0] == '*' ) {pr = va_arg(va,rU32); ++f;} else { pr = 0; while (( f[0] >= '0' ) && ( f[0] <= '9' )) { pr = pr * 10 + f[0] - '0'; f++; } } } + if ( f[0]=='.' ) { ++f; if ( f[0] == '*' ) {pr = va_arg(va,stbsp__uint32); ++f;} else { pr = 0; while (( f[0] >= '0' ) && ( f[0] <= '9' )) { pr = pr * 10 + f[0] - '0'; f++; } } } // handle integer size overrides switch(f[0]) { // are we halfwidth? - case 'h': fl|=HW; ++f; break; + case 'h': fl|=STBSP__HALFWIDTH; ++f; break; // are we 64-bit (unix style) - case 'l': ++f; if ( f[0]=='l') { fl|=BI; ++f; } break; + case 'l': ++f; if ( f[0]=='l') { fl|=STBSP__INTMAX; ++f; } break; // are we 64-bit on intmax? (c99) - case 'j': fl|=BI; ++f; break; + case 'j': fl|=STBSP__INTMAX; ++f; break; // are we 64-bit on size_t or ptrdiff_t? (c99) - case 'z': case 't': fl|=((sizeof(char*)==8)?BI:0); ++f; break; + case 'z': case 't': fl|=((sizeof(char*)==8)?STBSP__INTMAX:0); ++f; break; // are we 64-bit (msft style) - case 'I': if ( ( f[1]=='6') && ( f[2]=='4') ) { fl|=BI; f+=3; } else if ( ( f[1]=='3') && ( f[2]=='2') ) { f+=3; } else { fl|=((sizeof(void*)==8)?BI:0); ++f; } break; + case 'I': if ( ( f[1]=='6') && ( f[2]=='4') ) { fl|=STBSP__INTMAX; f+=3; } + else if ( ( f[1]=='3') && ( f[2]=='2') ) { f+=3; } + else { fl|=((sizeof(void*)==8)?STBSP__INTMAX:0); ++f; } break; default: break; } // handle each replacement switch( f[0] ) { - #define NUMSZ 512 // big enough for e308 (with commas) or e-307 - char num[NUMSZ]; + #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; - rU32 l,n,cs; - rU64 n64; - #ifndef RR_SPRINTF_NOFLOAT + stbsp__uint32 l,n,cs; + stbsp__uint64 n64; + #ifndef STB_SPRINTF_NOFLOAT double fv; #endif - rS32 dp; char const * sn; + stbsp__int32 dp; char const * sn; case 's': // get the string @@ -322,16 +333,16 @@ RRPUBLIC_DEF int RR_SPRINTF_DECORATE( vsprintfcb )( RRSPRINTFCB * callback, void sn = s; for(;;) { - if ((((rUINTa)sn)&3)==0) break; + if ((((stbsp__uintptr)sn)&3)==0) break; lchk: if (sn[0]==0) goto ld; ++sn; } n = 0xffffffff; - if (pr>=0) { n=(rU32)(sn-s); if (n>=(rU32)pr) goto ld; n=((rU32)(pr-n))>>2; } + if (pr>=0) { n=(stbsp__uint32)(sn-s); if (n>=(stbsp__uint32)pr) goto ld; n=((stbsp__uint32)(pr-n))>>2; } while(n) { - rU32 v=*(rU32*)sn; + stbsp__uint32 v=*(stbsp__uint32*)sn; if ((v-0x01010101)&(~v)&0x80808080UL) goto lchk; sn+=4; --n; @@ -339,16 +350,16 @@ RRPUBLIC_DEF int RR_SPRINTF_DECORATE( vsprintfcb )( RRSPRINTFCB * callback, void goto lchk; ld: - l = (rU32) ( sn - s ); + l = (stbsp__uint32) ( sn - s ); // clamp to precision - if ( l > (rU32)pr ) l = pr; + if ( l > (stbsp__uint32)pr ) l = pr; lead[0]=0; tail[0]=0; pr = 0; dp = 0; cs = 0; // copy the string in goto scopy; case 'c': // char // get the character - s = num + NUMSZ -1; *s = (char)va_arg(va,int); + s = num + STBSP__NUMSZ -1; *s = (char)va_arg(va,int); l = 1; lead[0]=0; tail[0]=0; pr = 0; dp = 0; cs = 0; goto scopy; @@ -358,7 +369,7 @@ RRPUBLIC_DEF int RR_SPRINTF_DECORATE( vsprintfcb )( RRSPRINTFCB * callback, void *d = tlen + (int)( bf - buf ); } break; -#ifdef RR_SPRINTF_NOFLOAT +#ifdef STB_SPRINTF_NOFLOAT case 'A': // float case 'a': // hex float case 'G': // float @@ -382,30 +393,30 @@ RRPUBLIC_DEF int RR_SPRINTF_DECORATE( vsprintfcb )( RRSPRINTFCB * callback, void fv = va_arg(va,double); if (pr==-1) pr=6; // default is 6 // read the double into a string - if ( rrreal_to_parts( (rS64*)&n64, &dp, fv ) ) - fl |= NG; + if ( stbsp__real_to_parts( (stbsp__int64*)&n64, &dp, fv ) ) + fl |= STBSP__NEGATIVE; s = num+64; // sign - lead[0]=0; if (fl&NG) { lead[0]=1; lead[1]='-'; } else if (fl&LS) { lead[0]=1; lead[1]=' '; } else if (fl&LP) { lead[0]=1; lead[1]='+'; }; + lead[0]=0; if (fl&STBSP__NEGATIVE) { lead[0]=1; lead[1]='-'; } else if (fl&STBSP__LEADINGSPACE) { lead[0]=1; lead[1]=' '; } else if (fl&STBSP__LEADINGPLUS) { lead[0]=1; lead[1]='+'; }; - if (dp==-1023) dp=(n64)?-1022:0; else n64|=(((rU64)1)<<52); + if (dp==-1023) dp=(n64)?-1022:0; else n64|=(((stbsp__uint64)1)<<52); n64<<=(64-56); - if (pr<15) n64+=((((rU64)8)<<56)>>(pr*4)); + if (pr<15) n64+=((((stbsp__uint64)8)<<56)>>(pr*4)); // add leading chars - #ifdef RR_SPRINTF_MSVC_MODE + #ifdef STB_SPRINTF_MSVC_MODE *s++='0';*s++='x'; #else lead[1+lead[0]]='0'; lead[2+lead[0]]='x'; lead[0]+=2; #endif *s++=h[(n64>>60)&15]; n64<<=4; - if ( pr ) *s++=RRperiod; + if ( pr ) *s++=stbsp__period; sn = s; // print the bits - n = pr; if (n>13) n = 13; if (pr>(rS32)n) tz=pr-n; pr = 0; + n = pr; if (n>13) n = 13; if (pr>(stbsp__int32)n) tz=pr-n; pr = 0; while(n--) { *s++=h[(n64>>60)&15]; n64<<=4; } // print the expo @@ -431,21 +442,21 @@ RRPUBLIC_DEF int RR_SPRINTF_DECORATE( vsprintfcb )( RRSPRINTFCB * callback, void fv = va_arg(va,double); if (pr==-1) pr=6; else if (pr==0) pr = 1; // default is 6 // read the double into a string - if ( rrreal_to_str( &sn, &l, num, &dp, fv, (pr-1)|0x80000000 ) ) - fl |= NG; + if ( stbsp__real_to_str( &sn, &l, num, &dp, fv, (pr-1)|0x80000000 ) ) + fl |= STBSP__NEGATIVE; // clamp the precision and delete extra zeros after clamp n = pr; - if ( l > (rU32)pr ) l = pr; while ((l>1)&&(pr)&&(sn[l-1]=='0')) { --pr; --l; } + if ( l > (stbsp__uint32)pr ) l = pr; while ((l>1)&&(pr)&&(sn[l-1]=='0')) { --pr; --l; } // should we use %e - if ((dp<=-4)||(dp>(rS32)n)) + if ((dp<=-4)||(dp>(stbsp__int32)n)) { - if ( pr > (rS32)l ) pr = l-1; else if ( pr ) --pr; // when using %e, there is one digit before the decimal + if ( pr > (stbsp__int32)l ) pr = l-1; else if ( pr ) --pr; // when using %e, there is one digit before the decimal goto doexpfromg; } // this is the insane action to get the pr to match %g sematics for %f - if(dp>0) { pr=(dp<(rS32)l)?l-dp:0; } else { pr = -dp+((pr>(rS32)l)?l:pr); } + if(dp>0) { pr=(dp<(stbsp__int32)l)?l-dp:0; } else { pr = -dp+((pr>(stbsp__int32)l)?l:pr); } goto dofloatfromg; case 'E': // float @@ -458,20 +469,20 @@ RRPUBLIC_DEF int RR_SPRINTF_DECORATE( vsprintfcb )( RRSPRINTFCB * callback, void fv = va_arg(va,double); if (pr==-1) pr=6; // default is 6 // read the double into a string - if ( rrreal_to_str( &sn, &l, num, &dp, fv, pr|0x80000000 ) ) - fl |= NG; + if ( stbsp__real_to_str( &sn, &l, num, &dp, fv, pr|0x80000000 ) ) + fl |= STBSP__NEGATIVE; doexpfromg: tail[0]=0; - lead[0]=0; if (fl&NG) { lead[0]=1; lead[1]='-'; } else if (fl&LS) { lead[0]=1; lead[1]=' '; } else if (fl&LP) { lead[0]=1; lead[1]='+'; }; - if ( dp == RRSPECIAL ) { s=(char*)sn; cs=0; pr=0; goto scopy; } + lead[0]=0; if (fl&STBSP__NEGATIVE) { lead[0]=1; lead[1]='-'; } else if (fl&STBSP__LEADINGSPACE) { lead[0]=1; lead[1]=' '; } else if (fl&STBSP__LEADINGPLUS) { lead[0]=1; lead[1]='+'; }; + if ( dp == STBSP__SPECIAL ) { s=(char*)sn; cs=0; pr=0; goto scopy; } s=num+64; // handle leading chars *s++=sn[0]; - if (pr) *s++=RRperiod; + if (pr) *s++=stbsp__period; // handle after decimal - if ((l-1)>(rU32)pr) l=pr+1; + if ((l-1)>(stbsp__uint32)pr) l=pr+1; for(n=1;n=100)?5:4; @@ -493,52 +504,52 @@ RRPUBLIC_DEF int RR_SPRINTF_DECORATE( vsprintfcb )( RRSPRINTFCB * callback, void fv = va_arg(va,double); doafloat: // do kilos - if (fl&KI) {while(fl<0x4000000) { if ((fv<1024.0) && (fv>-1024.0)) break; fv/=1024.0; fl+=0x1000000; }} + if (fl&STBSP__METRIC_SUFFIX) {while(fl<0x4000000) { if ((fv<1024.0) && (fv>-1024.0)) break; fv/=1024.0; fl+=0x1000000; }} if (pr==-1) pr=6; // default is 6 // read the double into a string - if ( rrreal_to_str( &sn, &l, num, &dp, fv, pr ) ) - fl |= NG; + if ( stbsp__real_to_str( &sn, &l, num, &dp, fv, pr ) ) + fl |= STBSP__NEGATIVE; dofloatfromg: tail[0]=0; // sign - lead[0]=0; if (fl&NG) { lead[0]=1; lead[1]='-'; } else if (fl&LS) { lead[0]=1; lead[1]=' '; } else if (fl&LP) { lead[0]=1; lead[1]='+'; }; - if ( dp == RRSPECIAL ) { s=(char*)sn; cs=0; pr=0; goto scopy; } + lead[0]=0; if (fl&STBSP__NEGATIVE) { lead[0]=1; lead[1]='-'; } else if (fl&STBSP__LEADINGSPACE) { lead[0]=1; lead[1]=' '; } else if (fl&STBSP__LEADINGPLUS) { lead[0]=1; lead[1]='+'; }; + if ( dp == STBSP__SPECIAL ) { s=(char*)sn; cs=0; pr=0; goto scopy; } s=num+64; // handle the three decimal varieties if (dp<=0) { - rS32 i; + stbsp__int32 i; // handle 0.000*000xxxx - *s++='0'; if (pr) *s++=RRperiod; - n=-dp; if((rS32)n>pr) n=pr; i=n; while(i) { if ((((rUINTa)s)&3)==0) break; *s++='0'; --i; } while(i>=4) { *(rU32*)s=0x30303030; s+=4; i-=4; } while(i) { *s++='0'; --i; } - if ((rS32)(l+n)>pr) l=pr-n; i=l; while(i) { *s++=*sn++; --i; } + *s++='0'; if (pr) *s++=stbsp__period; + n=-dp; if((stbsp__int32)n>pr) n=pr; 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)>pr) l=pr-n; i=l; while(i) { *s++=*sn++; --i; } tz = pr-(n+l); cs = 1 + (3<<24); // how many tens did we write (for commas below) } else { - cs = (fl&CS)?((600-(rU32)dp)%3):0; - if ((rU32)dp>=l) + cs = (fl&STBSP__TRIPLET_COMMA)?((600-(stbsp__uint32)dp)%3):0; + if ((stbsp__uint32)dp>=l) { // handle xxxx000*000.0 - n=0; for(;;) { if ((fl&CS) && (++cs==4)) { cs = 0; *s++=RRcomma; } else { *s++=sn[n]; ++n; if (n>=l) break; } } - if (n<(rU32)dp) + n=0; for(;;) { if ((fl&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 ((fl&CS)==0) { while(n) { if ((((rUINTa)s)&3)==0) break; *s++='0'; --n; } while(n>=4) { *(rU32*)s=0x30303030; s+=4; n-=4; } } - while(n) { if ((fl&CS) && (++cs==4)) { cs = 0; *s++=RRcomma; } else { *s++='0'; --n; } } + if ((fl&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 ((fl&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 (pr) { *s++=RRperiod; tz=pr;} + if (pr) { *s++=stbsp__period; tz=pr;} } else { // handle xxxxx.xxxx000*000 - n=0; for(;;) { if ((fl&CS) && (++cs==4)) { cs = 0; *s++=RRcomma; } else { *s++=sn[n]; ++n; if (n>=(rU32)dp) break; } } + n=0; for(;;) { if ((fl&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 (pr) *s++=RRperiod; - if ((l-dp)>(rU32)pr) l=pr+dp; + if (pr) *s++=stbsp__period; + if ((l-dp)>(stbsp__uint32)pr) l=pr+dp; while(n>24) { tail[2]="_kmgt"[fl>>24]; tail[0]=2; } } }; + if (fl&STBSP__METRIC_SUFFIX) { tail[0]=1; tail[1]=' '; { if (fl>>24) { tail[2]="_kmgt"[fl>>24]; tail[0]=2; } } }; flt_lead: // get the length that we copied - l = (rU32) ( s-(num+64) ); + l = (stbsp__uint32) ( s-(num+64) ); s=num+64; goto scopy; #endif @@ -563,21 +574,21 @@ RRPUBLIC_DEF int RR_SPRINTF_DECORATE( vsprintfcb )( RRSPRINTFCB * callback, void h = hex; binary: lead[0]=0; - if (fl&LX) { lead[0]=2;lead[1]='0';lead[2]=h[0xb]; } + if (fl&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 (fl&LX) { lead[0]=1;lead[1]='0'; } + if (fl&STBSP__LEADING_0X) { lead[0]=1;lead[1]='0'; } l=(3<<4)|(3<<8); goto radixnum; case 'p': // pointer - fl |= (sizeof(void*)==8)?BI:0; + fl |= (sizeof(void*)==8)?STBSP__INTMAX:0; pr = sizeof(void*)*2; - fl &= ~LZ; // 'p' only prints the pointer with zeros + fl &= ~STBSP__LEADINGZERO; // 'p' only prints the pointer with zeros // drop through to X case 'X': // upper binary @@ -588,23 +599,23 @@ RRPUBLIC_DEF int RR_SPRINTF_DECORATE( vsprintfcb )( RRSPRINTFCB * callback, void h = hex; dohexb: l=(4<<4)|(4<<8); lead[0]=0; - if (fl&LX) { lead[0]=2;lead[1]='0';lead[2]=h[16]; } + if (fl&STBSP__LEADING_0X) { lead[0]=2;lead[1]='0';lead[2]=h[16]; } radixnum: // get the number - if ( fl&BI ) - n64 = va_arg(va,rU64); + if ( fl&STBSP__INTMAX ) + n64 = va_arg(va,stbsp__uint64); else - n64 = va_arg(va,rU32); + n64 = va_arg(va,stbsp__uint32); - s = num + NUMSZ; dp = 0; + 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 (pr==0) { l=0; cs = ( ((l>>4)&15)) << 24; goto scopy; } } // convert to string - for(;;) { *--s = h[n64&((1<<(l>>8))-1)]; n64>>=(l>>8); if ( ! ( (n64) || ((rS32) ( (num+NUMSZ) - s ) < pr ) ) ) break; if ( fl&CS) { ++l; if ((l&15)==((l>>4)&15)) { l&=~15; *--s=RRcomma; } } }; + for(;;) { *--s = h[n64&((1<<(l>>8))-1)]; n64>>=(l>>8); if ( ! ( (n64) || ((stbsp__int32) ( (num+STBSP__NUMSZ) - s ) < pr ) ) ) break; if ( fl&STBSP__TRIPLET_COMMA) { ++l; if ((l&15)==((l>>4)&15)) { l&=~15; *--s=stbsp__comma; } } }; // get the tens and the comma pos - cs = (rU32) ( (num+NUMSZ) - s ) + ( ( ((l>>4)&15)) << 24 ); + cs = (stbsp__uint32) ( (num+STBSP__NUMSZ) - s ) + ( ( ((l>>4)&15)) << 24 ); // get the length that we copied - l = (rU32) ( (num+NUMSZ) - s ); + l = (stbsp__uint32) ( (num+STBSP__NUMSZ) - s ); // copy it goto scopy; @@ -612,99 +623,99 @@ RRPUBLIC_DEF int RR_SPRINTF_DECORATE( vsprintfcb )( RRSPRINTFCB * callback, void case 'i': case 'd': // integer // get the integer and abs it - if ( fl&BI ) + if ( fl&STBSP__INTMAX ) { - rS64 i64 = va_arg(va,rS64); n64 = (rU64)i64; if ((f[0]!='u') && (i64<0)) { n64=(rU64)-i64; fl|=NG; } + stbsp__int64 i64 = va_arg(va,stbsp__int64); n64 = (stbsp__uint64)i64; if ((f[0]!='u') && (i64<0)) { n64=(stbsp__uint64)-i64; fl|=STBSP__NEGATIVE; } } else { - rS32 i = va_arg(va,rS32); n64 = (rU32)i; if ((f[0]!='u') && (i<0)) { n64=(rU32)-i; fl|=NG; } + stbsp__int32 i = va_arg(va,stbsp__int32); n64 = (stbsp__uint32)i; if ((f[0]!='u') && (i<0)) { n64=(stbsp__uint32)-i; fl|=STBSP__NEGATIVE; } } - #ifndef RR_SPRINTF_NOFLOAT - if (fl&KI) { if (n64<1024) pr=0; else if (pr==-1) pr=1; fv=(double)(rS64)n64; goto doafloat; } + #ifndef STB_SPRINTF_NOFLOAT + if (fl&STBSP__METRIC_SUFFIX) { if (n64<1024) pr=0; else if (pr==-1) pr=1; fv=(double)(stbsp__int64)n64; goto doafloat; } #endif // convert to string - s = num+NUMSZ; l=0; + 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 = (rU32)( n64 % 100000000); n64 /= 100000000; } else {n = (rU32)n64; n64 = 0; } - if((fl&CS)==0) { while(n) { s-=2; *(rU16*)s=*(rU16*)&rrdiglookup[(n%100)*2]; n/=100; } } - while (n) { if ( ( fl&CS) && (l++==3) ) { l=0; *--s=RRcomma; --o; } else { *--s=(char)(n%10)+'0'; n/=10; } } - if (n64==0) { if ((s[0]=='0') && (s!=(num+NUMSZ))) ++s; break; } - while (s!=o) if ( ( fl&CS) && (l++==3) ) { l=0; *--s=RRcomma; --o; } else { *--s='0'; } + if (n64>=100000000) { n = (stbsp__uint32)( n64 % 100000000); n64 /= 100000000; } else {n = (stbsp__uint32)n64; n64 = 0; } + if((fl&STBSP__TRIPLET_COMMA)==0) { while(n) { s-=2; *(stbsp__uint16*)s=*(stbsp__uint16*)&stbsp__digitpair[(n%100)*2]; n/=100; } } + while (n) { if ( ( fl&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 ( ( fl&STBSP__TRIPLET_COMMA) && (l++==3) ) { l=0; *--s=stbsp__comma; --o; } else { *--s='0'; } } tail[0]=0; // sign - lead[0]=0; if (fl&NG) { lead[0]=1; lead[1]='-'; } else if (fl&LS) { lead[0]=1; lead[1]=' '; } else if (fl&LP) { lead[0]=1; lead[1]='+'; }; + lead[0]=0; if (fl&STBSP__NEGATIVE) { lead[0]=1; lead[1]='-'; } else if (fl&STBSP__LEADINGSPACE) { lead[0]=1; lead[1]=' '; } else if (fl&STBSP__LEADINGPLUS) { lead[0]=1; lead[1]='+'; }; // get the length that we copied - l = (rU32) ( (num+NUMSZ) - s ); if ( l == 0 ) { *--s='0'; l = 1; } + l = (stbsp__uint32) ( (num+STBSP__NUMSZ) - s ); if ( l == 0 ) { *--s='0'; l = 1; } cs = l + (3<<24); if (pr<0) pr = 0; scopy: // get fw=leading/trailing space, pr=leading zeros - if (pr<(rS32)l) pr = l; + if (pr<(stbsp__int32)l) pr = l; n = pr + lead[0] + tail[0] + tz; - if (fw<(rS32)n) fw = n; + if (fw<(stbsp__int32)n) fw = n; fw -= n; pr -= l; // handle right justify and leading zeros - if ( (fl&LJ)==0 ) + if ( (fl&STBSP__LEFTJUST)==0 ) { - if (fl&LZ) // if leading zeros, everything is in pr + if (fl&STBSP__LEADINGZERO) // if leading zeros, everything is in pr { pr = (fw>pr)?fw:pr; fw = 0; } else { - fl &= ~CS; // if no leading zeros, then no commas + fl &= ~STBSP__TRIPLET_COMMA; // if no leading zeros, then no commas } } // copy the spaces and/or zeros if (fw+pr) { - rS32 i; rU32 c; + stbsp__int32 i; stbsp__uint32 c; // copy leading spaces (or when doing %8.4d stuff) - if ( (fl&LJ)==0 ) while(fw>0) { cb_buf_clamp(i,fw); fw -= i; while(i) { if ((((rUINTa)bf)&3)==0) break; *bf++=' '; --i; } while(i>=4) { *(rU32*)bf=0x20202020; bf+=4; i-=4; } while (i) {*bf++=' '; --i;} chk_cb_buf(1); } + if ( (fl&STBSP__LEFTJUST)==0 ) while(fw>0) { stbsp__cb_buf_clamp(i,fw); fw -= 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]) { cb_buf_clamp(i,lead[0]); lead[0] -= (char)i; while (i) {*bf++=*sn++; --i;} chk_cb_buf(1); } + 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 = (fl&CS)?((rU32)(c-((pr+cs)%(c+1)))):0; - while(pr>0) { cb_buf_clamp(i,pr); pr -= i; if((fl&CS)==0) { while(i) { if ((((rUINTa)bf)&3)==0) break; *bf++='0'; --i; } while(i>=4) { *(rU32*)bf=0x30303030; bf+=4; i-=4; } } while (i) { if((fl&CS) && (cs++==c)) { cs = 0; *bf++=RRcomma; } else *bf++='0'; --i; } chk_cb_buf(1); } + cs = (fl&STBSP__TRIPLET_COMMA)?((stbsp__uint32)(c-((pr+cs)%(c+1)))):0; + while(pr>0) { stbsp__cb_buf_clamp(i,pr); pr -= i; if((fl&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((fl&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]) { rS32 i; cb_buf_clamp(i,lead[0]); lead[0] -= (char)i; while (i) {*bf++=*sn++; --i;} chk_cb_buf(1); } + 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) { rS32 i; cb_buf_clamp(i,n); n-=i; RR_UNALIGNED( while(i>=4) { *(rU32*)bf=*(rU32*)s; bf+=4; s+=4; i-=4; } ) while (i) {*bf++=*s++; --i;} chk_cb_buf(1); } + n = l; while (n) { stbsp__int32 i; stbsp__cb_buf_clamp(i,n); n-=i; STBSP__UNALIGNED( while(i>=4) { *(stbsp__uint32*)bf=*(stbsp__uint32*)s; bf+=4; s+=4; i-=4; } ) while (i) {*bf++=*s++; --i;} stbsp__chk_cb_buf(1); } // copy trailing zeros - while(tz) { rS32 i; cb_buf_clamp(i,tz); tz -= i; while(i) { if ((((rUINTa)bf)&3)==0) break; *bf++='0'; --i; } while(i>=4) { *(rU32*)bf=0x30303030; bf+=4; i-=4; } while (i) {*bf++='0'; --i;} chk_cb_buf(1); } + 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]) { rS32 i; cb_buf_clamp(i,tail[0]); tail[0] -= (char)i; while (i) {*bf++=*sn++; --i;} chk_cb_buf(1); } + 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 (fl&LJ) if (fw>0) { while (fw) { rS32 i; cb_buf_clamp(i,fw); fw-=i; while(i) { if ((((rUINTa)bf)&3)==0) break; *bf++=' '; --i; } while(i>=4) { *(rU32*)bf=0x20202020; bf+=4; i-=4; } while (i--) *bf++=' '; chk_cb_buf(1); } } + if (fl&STBSP__LEFTJUST) if (fw>0) { while (fw) { stbsp__int32 i; stbsp__cb_buf_clamp(i,fw); fw-=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; default: // unknown, just copy code - s = num + NUMSZ -1; *s = f[0]; + s = num + STBSP__NUMSZ -1; *s = f[0]; l = 1; fw=pr=fl=0; lead[0]=0; tail[0]=0; pr = 0; dp = 0; cs = 0; @@ -717,48 +728,48 @@ RRPUBLIC_DEF int RR_SPRINTF_DECORATE( vsprintfcb )( RRSPRINTFCB * callback, void if (!callback) *bf = 0; else - flush_cb(); + stbsp__flush_cb(); done: return tlen + (int)(bf-buf); } // cleanup -#undef LJ -#undef LP -#undef LS -#undef LX -#undef LZ -#undef BI -#undef CS -#undef NG -#undef KI -#undef NUMSZ -#undef chk_cb_bufL -#undef chk_cb_buf -#undef flush_cb -#undef cb_buf_clamp +#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 -RRPUBLIC_DEF int RR_SPRINTF_DECORATE( sprintf )( char * buf, char const * fmt, ... ) +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE( sprintf )( char * buf, char const * fmt, ... ) { va_list va; va_start( va, fmt ); - return RR_SPRINTF_DECORATE( vsprintfcb )( 0, 0, buf, fmt, va ); + return STB_SPRINTF_DECORATE( vsprintfcb )( 0, 0, buf, fmt, va ); } -typedef struct RRCCS +typedef struct stbsp__context { char * buf; int count; - char tmp[ RR_SPRINTF_MIN ]; -} RRCCS; + char tmp[ STB_SPRINTF_MIN ]; +} stbsp__context; -static char * rrclampcallback( char * buf, void * user, int len ) +static char * stbsp__clamp_callback( char * buf, void * user, int len ) { - RRCCS * c = (RRCCS*)user; + stbsp__context * c = (stbsp__context*)user; if ( len > c->count ) len = c->count; @@ -775,12 +786,12 @@ static char * rrclampcallback( char * buf, void * user, int len ) } if ( c->count <= 0 ) return 0; - return ( c->count >= RR_SPRINTF_MIN ) ? c->buf : c->tmp; // go direct into buffer if you can + return ( c->count >= STB_SPRINTF_MIN ) ? c->buf : c->tmp; // go direct into buffer if you can } -RRPUBLIC_DEF int RR_SPRINTF_DECORATE( vsnprintf )( char * buf, int count, char const * fmt, va_list va ) +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE( vsnprintf )( char * buf, int count, char const * fmt, va_list va ) { - RRCCS c; + stbsp__context c; int l; if ( count == 0 ) @@ -789,7 +800,7 @@ RRPUBLIC_DEF int RR_SPRINTF_DECORATE( vsnprintf )( char * buf, int count, char c c.buf = buf; c.count = count; - RR_SPRINTF_DECORATE( vsprintfcb )( rrclampcallback, &c, rrclampcallback(0,&c,0), fmt, va ); + STB_SPRINTF_DECORATE( vsprintfcb )( stbsp__clamp_callback, &c, stbsp__clamp_callback(0,&c,0), fmt, va ); // zero-terminate l = (int)( c.buf - buf ); @@ -800,100 +811,100 @@ RRPUBLIC_DEF int RR_SPRINTF_DECORATE( vsnprintf )( char * buf, int count, char c return l; } -RRPUBLIC_DEF int RR_SPRINTF_DECORATE( snprintf )( char * buf, int count, char const * fmt, ... ) +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE( snprintf )( char * buf, int count, char const * fmt, ... ) { va_list va; va_start( va, fmt ); - return RR_SPRINTF_DECORATE( vsnprintf )( buf, count, fmt, va ); + return STB_SPRINTF_DECORATE( vsnprintf )( buf, count, fmt, va ); } -RRPUBLIC_DEF int RR_SPRINTF_DECORATE( vsprintf )( char * buf, char const * fmt, va_list va ) +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE( vsprintf )( char * buf, char const * fmt, va_list va ) { - return RR_SPRINTF_DECORATE( vsprintfcb )( 0, 0, buf, fmt, va ); + return STB_SPRINTF_DECORATE( vsprintfcb )( 0, 0, buf, fmt, va ); } // ======================================================================= // low level float utility functions -#ifndef RR_SPRINTF_NOFLOAT +#ifndef STB_SPRINTF_NOFLOAT - // copies d to bits w/ strict aliasing (this compiles to nothing on /Ox) - #define RRCOPYFP(dest,src) { int cn; for(cn=0;cn<8;cn++) ((char*)&dest)[cn]=((char*)&src)[cn]; } +// 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 rS32 rrreal_to_parts( rS64 * bits, rS32 * expo, double value ) +static stbsp__int32 stbsp__real_to_parts( stbsp__int64 * bits, stbsp__int32 * expo, double value ) { double d; - rS64 b = 0; + stbsp__int64 b = 0; // load value and round at the frac_digits d = value; - RRCOPYFP( b, d ); + STBSP__COPYFP( b, d ); - *bits = b & ((((rU64)1)<<52)-1); - *expo = ((b >> 52) & 2047)-1023; + *bits = b & ((((stbsp__uint64)1)<<52)-1); + *expo = (stbsp__int32) (((b >> 52) & 2047)-1023); - return (rS32)(b >> 63); + return (stbsp__int32)(b >> 63); } -static double const rrbot[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 rrnegbot[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 rrnegboterr[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 rrtop[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 rrnegtop[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 rrtoperr[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 rrnegtoperr[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}; +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 rU64 const rrpot[20]={1,10,100,1000, 10000,100000,1000000,10000000, 100000000,1000000000,10000000000,100000000000, 1000000000000,10000000000000,100000000000000,1000000000000000, 10000000000000000,100000000000000000,1000000000000000000,10000000000000000000U }; -#define rrtento19th ((rU64)1000000000000000000) +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 rU64 const rrpot[20]={1,10,100,1000, 10000,100000,1000000,10000000, 100000000,1000000000,10000000000ULL,100000000000ULL, 1000000000000ULL,10000000000000ULL,100000000000000ULL,1000000000000000ULL, 10000000000000000ULL,100000000000000000ULL,1000000000000000000ULL,10000000000000000000ULL }; -#define rrtento19th (1000000000000000000ULL) +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 rrddmulthi(oh,ol,xh,yh) \ +#define stbsp__ddmulthi(oh,ol,xh,yh) \ { \ double ahi=0,alo,bhi=0,blo; \ - rS64 bt; \ + stbsp__int64 bt; \ oh = xh * yh; \ - RRCOPYFP(bt,xh); bt&=((~(rU64)0)<<27); RRCOPYFP(ahi,bt); alo = xh-ahi; \ - RRCOPYFP(bt,yh); bt&=((~(rU64)0)<<27); RRCOPYFP(bhi,bt); blo = yh-bhi; \ + 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 rrddtoS64(ob,xh,xl) \ +#define stbsp__ddtoS64(ob,xh,xl) \ { \ double ahi=0,alo,vh,t;\ - ob = (rS64)ph;\ + ob = (stbsp__int64)ph;\ vh=(double)ob;\ ahi = ( xh - vh );\ t = ( ahi - xh );\ alo = (xh-(ahi-t))-(vh+t);\ - ob += (rS64)(ahi+alo+xl);\ + ob += (stbsp__int64)(ahi+alo+xl);\ } -#define rrddrenorm(oh,ol) { double s; s=oh+ol; ol=ol-(s-oh); oh=s; } +#define stbsp__ddrenorm(oh,ol) { double s; s=oh+ol; ol=ol-(s-oh); oh=s; } -#define rrddmultlo(oh,ol,xh,xl,yh,yl) \ +#define stbsp__ddmultlo(oh,ol,xh,xl,yh,yl) \ ol = ol + ( xh*yl + xl*yh ); \ -#define rrddmultlos(oh,ol,xh,yl) \ +#define stbsp__ddmultlos(oh,ol,xh,yl) \ ol = ol + ( xh*yl ); \ -static void rrraise_to_power10( double *ohi, double *olo, double d, rS32 power ) // power can be -323 to +350 +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)) { - rrddmulthi(ph,pl,d,rrbot[power]); + stbsp__ddmulthi(ph,pl,d,stbsp__bot[power]); } else { - rS32 e,et,eb; + stbsp__int32 e,et,eb; double p2h,p2l; e=power; if (power<0) e=-e; @@ -902,11 +913,11 @@ static void rrraise_to_power10( double *ohi, double *olo, double d, rS32 power ) ph = d; pl = 0.0; if (power<0) { - if (eb) { --eb; rrddmulthi(ph,pl,d,rrnegbot[eb]); rrddmultlos(ph,pl,d,rrnegboterr[eb]); } + if (eb) { --eb; stbsp__ddmulthi(ph,pl,d,stbsp__negbot[eb]); stbsp__ddmultlos(ph,pl,d,stbsp__negboterr[eb]); } if (et) { - rrddrenorm(ph,pl); - --et; rrddmulthi(p2h,p2l,ph,rrnegtop[et]); rrddmultlo(p2h,p2l,ph,pl,rrnegtop[et],rrnegtoperr[et]); ph=p2h;pl=p2l; + 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 @@ -914,17 +925,17 @@ static void rrraise_to_power10( double *ohi, double *olo, double d, rS32 power ) if (eb) { e = eb; if (eb>22) eb=22; e -= eb; - rrddmulthi(ph,pl,d,rrbot[eb]); - if ( e ) { rrddrenorm(ph,pl); rrddmulthi(p2h,p2l,ph,rrbot[e]); rrddmultlos(p2h,p2l,rrbot[e],pl); ph=p2h;pl=p2l; } + 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) { - rrddrenorm(ph,pl); - --et; rrddmulthi(p2h,p2l,ph,rrtop[et]); rrddmultlo(p2h,p2l,ph,pl,rrtop[et],rrtoperr[et]); ph=p2h;pl=p2l; + 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; } } } - rrddrenorm(ph,pl); + stbsp__ddrenorm(ph,pl); *ohi = ph; *olo = pl; } @@ -932,22 +943,22 @@ static void rrraise_to_power10( double *ohi, double *olo, double d, rS32 power ) // 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 rS32 rrreal_to_str( char const * * start, rU32 * len, char *out, rS32 * decimal_pos, double value, rU32 frac_digits ) +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; - rS64 bits = 0; - rS32 expo, e, ng, tens; + stbsp__int64 bits = 0; + stbsp__int32 expo, e, ng, tens; d = value; - RRCOPYFP(bits,d); - expo = (bits >> 52) & 2047; - ng = (rS32)(bits >> 63); + STBSP__COPYFP(bits,d); + expo = (stbsp__int32) ((bits >> 52) & 2047); + ng = (stbsp__int32)(bits >> 63); if (ng) d=-d; if ( expo == 2047 ) // is nan or inf? { - *start = (bits&((((rU64)1)<<52)-1)) ? "NaN" : "Inf"; - *decimal_pos = RRSPECIAL; + *start = (bits&((((stbsp__uint64)1)<<52)-1)) ? "NaN" : "Inf"; + *decimal_pos = STBSP__SPECIAL; *len = 3; return ng; } @@ -963,7 +974,7 @@ static rS32 rrreal_to_str( char const * * start, rU32 * len, char *out, rS32 * d } // find the right expo for denormals { - rS64 v = ((rU64)1)<<51; + stbsp__int64 v = ((stbsp__uint64)1)<<51; while ((bits&v)==0) { --expo; v >>= 1; } } } @@ -976,29 +987,29 @@ static rS32 rrreal_to_str( char const * * start, rU32 * len, char *out, rS32 * d 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 - rrraise_to_power10( &ph, &pl, d, 18-tens ); + stbsp__raise_to_power10( &ph, &pl, d, 18-tens ); // get full as much precision from double-double as possible - rrddtoS64( bits, ph,pl ); + stbsp__ddtoS64( bits, ph,pl ); // check if we undershot - if ( ((rU64)bits) >= rrtento19th ) ++tens; + 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 ) ) { - rU32 dg = 1; if ((rU64)bits >= rrpot[9] ) dg=10; while( (rU64)bits >= rrpot[dg] ) { ++dg; if (dg==20) goto noround; } + 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 ) { - rU64 r; + stbsp__uint64 r; // add 0.5 at the right position and round e = dg - frac_digits; - if ( (rU32)e >= 24 ) goto noround; - r = rrpot[e]; + if ( (stbsp__uint32)e >= 24 ) goto noround; + r = stbsp__powten[e]; bits = bits + (r/2); - if ( (rU64)bits >= rrpot[dg] ) ++tens; + if ( (stbsp__uint64)bits >= stbsp__powten[dg] ) ++tens; bits /= r; } noround:; @@ -1007,7 +1018,12 @@ static rS32 rrreal_to_str( char const * * start, rU32 * len, char *out, rS32 * d // kill long trailing runs of zeros if ( bits ) { - rU32 n; for(;;) { if ( bits<=0xffffffff ) break; if (bits%1000) goto donez; bits/=1000; } n = (rU32)bits; while ((n%1000)==0) n/=1000; bits=n; donez:; + 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 @@ -1015,11 +1031,11 @@ static rS32 rrreal_to_str( char const * * start, rU32 * len, char *out, rS32 * d e = 0; for(;;) { - rU32 n; + 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 = (rU32)( bits % 100000000); bits /= 100000000; } else {n = (rU32)bits; bits = 0; } - while(n) { out-=2; *(rU16*)out=*(rU16*)&rrdiglookup[(n%100)*2]; n/=100; e+=2; } + 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[(n%100)*2]; n/=100; e+=2; } if (bits==0) { if ((e) && (out[0]=='0')) { ++out; --e; } break; } while( out!=o ) { *--out ='0'; ++e; } } @@ -1030,26 +1046,21 @@ static rS32 rrreal_to_str( char const * * start, rU32 * len, char *out, rS32 * d return ng; } -#undef rrddmulthi -#undef rrddrenorm -#undef rrddmultlo -#undef rrddmultlos -#undef RRSPECIAL -#undef RRCOPYFP +#undef stbsp__ddmulthi +#undef stbsp__ddrenorm +#undef stbsp__ddmultlo +#undef stbsp__ddmultlos +#undef STBSP__SPECIAL +#undef STBSP__COPYFP -#endif +#endif // STB_SPRINTF_NOFLOAT // clean up -#undef rU16 -#undef rU32 -#undef rS32 -#undef rU64 -#undef rS64 -#undef RRPUBLIC_DEC -#undef RRPUBLIC_DEF -#undef RR_SPRINTF_DECORATE -#undef RR_UNALIGNED +#undef stbsp__uint16 +#undef stbsp__uint32 +#undef stbsp__int32 +#undef stbsp__uint64 +#undef stbsp__int64 +#undef STBSP__UNALIGNED -#endif - -#endif +#endif // STB_SPRINTF_IMPLEMENTATION diff --git a/tests/grid_reachability.c b/tests/grid_reachability.c index 2bb1cd8..905f2c2 100644 --- a/tests/grid_reachability.c +++ b/tests/grid_reachability.c @@ -143,6 +143,8 @@ void end_timer(void) printf("%6.4lf ms: %s\n", tm * 1000, message); } +extern void quicktest(void); + int loc[5000][2]; int main(int argc, char **argv) { @@ -152,6 +154,7 @@ int main(int argc, char **argv) uint8 *map = stbi_load("data/map_03.png", &w, &h, 0, 1); assert(map); + quicktest(); for (j=0; j < h; ++j) for (i=0; i < w; ++i) diff --git a/tests/stb.dsp b/tests/stb.dsp index 5b32abb..05f0a7f 100644 --- a/tests/stb.dsp +++ b/tests/stb.dsp @@ -154,6 +154,10 @@ SOURCE=..\stb_rect_pack.h # End Source File # Begin Source File +SOURCE=..\stb_sprintf.h +# End Source File +# Begin Source File + SOURCE=..\stb_textedit.h # End Source File # Begin Source File diff --git a/tests/test_c_compilation.c b/tests/test_c_compilation.c index de25330..2a54df5 100644 --- a/tests/test_c_compilation.c +++ b/tests/test_c_compilation.c @@ -1,3 +1,7 @@ +#include "stb_sprintf.h" +#define STB_SPRINTF_IMPLEMENTATION +#include "stb_sprintf.h" + #define STB_PERLIN_IMPLEMENTATION #define STB_IMAGE_WRITE_IMPLEMENTATION #define STB_DXT_IMPLEMENATION @@ -28,3 +32,11 @@ #define STBTE_DRAW_TILE(x,y,id,highlight,data) 0 #define STB_TILEMAP_EDITOR_IMPLEMENTATION #include "stb_tilemap_editor.h" + + +int quicktest(void) +{ + char buffer[999]; + stbsp_sprintf(buffer, "test%%test"); + return 0; +} \ No newline at end of file diff --git a/tests/test_cpp_compilation.cpp b/tests/test_cpp_compilation.cpp index 4e77da5..138948b 100644 --- a/tests/test_cpp_compilation.cpp +++ b/tests/test_cpp_compilation.cpp @@ -1,3 +1,7 @@ +#include "stb_sprintf.h" +#define STB_SPRINTF_IMPLEMENTATION +#include "stb_sprintf.h" + #define STB_TRUETYPE_IMPLEMENTATION #define STB_PERLIN_IMPLEMENTATION #define STB_IMAGE_WRITE_IMPLEMENTATION