medfall

ggformat.cc (6756B)

---

 #include <ctype.h>
 
 #include "intrinsics.h"
 #include "ggformat.h"
 #include "strtonum.h"
 #include "strlcat.h"
 #include "platform_io.h"
 
 struct ShortString {
 	char buf[ 16 ];
 
 	ShortString() {
 		buf[ 0 ] = '\0';
 	}
 
 	void operator+=( int x ) {
 		char num[ 16 ];
 		snprintf( num, sizeof( num ), "%d", x );
 		*this += num;
 	}
 
 	void operator+=( const char * str ) {
 		strlcat( buf, str, sizeof( buf ) );
 	}
 };
 
 template< typename T >
 static void format_helper( FormatBuffer * fb, const ShortString & fmt, const T & x ) {
 	char * dst = fb->buf + fb->len;
 	size_t len = fb->capacity - fb->len;
 
 	if( fb->len >= fb->capacity ) {
 		dst = NULL;
 		len = 0;
 	}
 
 #if PLATFORM_WINDOWS
 	int printed = _snprintf( NULL, 0, fmt.buf, x );
 	_snprintf( dst, len, fmt.buf, x );
 #else
 	int printed = snprintf( dst, len, fmt.buf, x );
 #endif
 	fb->len += checked_cast< size_t >( printed );
 }
 
 void format( FormatBuffer * fb, double x, const FormatOpts & opts ) {
 	ShortString fmt;
 	fmt += "%";
 	int precision = opts.precision != -1 ? opts.precision : 5;
 	if( opts.plus_sign ) fmt += "+";
 	if( opts.left_align ) fmt += "-";
 	if( opts.zero_pad ) fmt += "0";
 	if( opts.width != -1 ) fmt += opts.width + 1 + precision;
 	fmt += ".";
 	fmt += precision;
 	fmt += "f";
 	format_helper( fb, fmt, x );
 }
 
 void format( FormatBuffer * fb, char x, const FormatOpts & opts ) {
 	ShortString fmt;
 	fmt += "%";
 	if( opts.left_align ) fmt += "-";
 	if( opts.width != -1 ) fmt += opts.width;
 	fmt += "c";
 	format_helper( fb, fmt, x );
 }
 
 void format( FormatBuffer * fb, const char * x, const FormatOpts & opts ) {
 	ShortString fmt;
 	fmt += "%";
 	if( opts.left_align ) fmt += "-";
 	if( opts.width != -1 ) fmt += opts.width;
 	fmt += "s";
 	format_helper( fb, fmt, x );
 }
 
 void format( FormatBuffer * fb, bool x, const FormatOpts & opts ) {
 	format( fb, x ? "true" : "false", opts );
 }
 
 template< typename T >
 static void int_helper( FormatBuffer * fb, const char * fmt_length, const char * fmt_decimal, const T & x, const FormatOpts & opts ) {
 	ShortString fmt;
 	fmt += "%";
 	if( opts.plus_sign ) fmt += "+";
 	if( opts.left_align ) fmt += "-";
 	if( opts.zero_pad ) fmt += "0";
 	if( opts.width != -1 ) fmt += opts.width;
 	if( opts.number_format == FormatOpts::DECIMAL ) {
 		fmt += fmt_length;
 		fmt += fmt_decimal;
 	}
 	else if( opts.number_format == FormatOpts::HEX ) {
 		fmt += fmt_length;
 		fmt += "x";
 	}
 	else if( opts.number_format == FormatOpts::BINARY ) {
 		fmt += "s";
 		char binary[ sizeof( x ) * 8 + 1 ];
 		binary[ sizeof( x ) * 8 ] = '\0';
 
 		for( size_t i = 0; i < sizeof( x ) * 8; i++ ) {
 			// this is UB for signed types, but who cares?
 			T bit = x & ( T( 1 ) << ( sizeof( x ) * 8 - i - 1 ) );
 			binary[ i ] = bit == 0 ? '0' : '1';
 		}
 
 		format_helper( fb, fmt, binary );
 		return;
 	}
 	format_helper( fb, fmt, x );
 }
 
 #define INT_OVERLOADS( T, fmt_length ) \
 	void format( FormatBuffer * fb, signed T x, const FormatOpts & opts ) { \
 		int_helper( fb, fmt_length, "d", x, opts ); \
 	} \
 	void format( FormatBuffer * fb, unsigned T x, const FormatOpts & opts ) { \
 		int_helper( fb, fmt_length, "u", x, opts ); \
 	}
 
 INT_OVERLOADS( char, "hh" )
 INT_OVERLOADS( short, "h" )
 INT_OVERLOADS( int, "" )
 INT_OVERLOADS( long, "l" )
 INT_OVERLOADS( long long, "ll" )
 
 #undef INT_OVERLOADS
 
 static const char * parse_format_bool( const char * p, const char * one_past_end, char x, bool * out ) {
 	if( p >= one_past_end ) return p;
 	if( *p != x ) return p;
 	*out = true;
 	return p + 1;
 }
 
 static const char * parse_format_int( const char * p, const char * one_past_end, int * out ) {
 	char num[ 16 ];
 	size_t num_len = 0;
 
 	while( p + num_len < one_past_end && isdigit( p[ num_len ] ) ) {
 		num[ num_len ] = p[ num_len ];
 		num_len++;
 	}
 	num[ num_len ] = '\0';
 
 	if( num_len == 0 ) return p;
 
 	*out = int( strtonum( num, 1, 1024, NULL ) );
 	ASSERT( *out != 0 );
 
 	return p + num_len;
 }
 
 static const char * parse_format_precision( const char * p, const char * one_past_end, int * precision ) {
 	bool has_a_dot = false;
 	const char * after_dot = parse_format_bool( p, one_past_end, '.', &has_a_dot );
 	if( !has_a_dot ) return p;
 	return parse_format_int( after_dot, one_past_end, precision );
 }
 
 static const char * parse_format_number_format( const char * p, const char * one_past_end, FormatOpts::NumberFormat * number_format ) {
 	bool hex = false;
 	const char * after_hex = parse_format_bool( p, one_past_end, 'x', &hex );
 
 	if( hex ) {
 		*number_format = FormatOpts::HEX;
 		return after_hex;
 	}
 
 	bool bin = false;
 	const char * after_bin = parse_format_bool( p, one_past_end, 'b', &bin );
 
 	if( bin ) {
 		*number_format = FormatOpts::BINARY;
 		return after_bin;
 	}
 
 	return p;
 }
 
 
 FormatOpts parse_formatopts( const char * fmt, size_t len ) {
 	FormatOpts opts;
 
 	const char * start = fmt;
 	const char * one_past_end = start + len;
 
 	start = parse_format_bool( start, one_past_end, '+', &opts.plus_sign );
 	start = parse_format_bool( start, one_past_end, '-', &opts.left_align );
 	start = parse_format_bool( start, one_past_end, '0', &opts.zero_pad );
 	start = parse_format_int( start, one_past_end, &opts.width );
 	start = parse_format_precision( start, one_past_end, &opts.precision );
 	start = parse_format_number_format( start, one_past_end, &opts.number_format );
 
 	ASSERT( start == one_past_end );
 
 	return opts;
 }
 
 static bool strchridx( const char * haystack, char needle, size_t * idx, size_t skip = 0 ) {
 	*idx = skip;
 	while( haystack[ *idx ] != '\0' ) {
 		if( haystack[ *idx ] == needle ) {
 			return true;
 		}
 		( *idx )++;
 	}
 	return false;
 }
 
 bool ggformat_find( const char * str, size_t * start, size_t * one_past_end ) {
 	size_t open_idx;
 	bool has_open = strchridx( str, '{', &open_idx );
 	if( has_open && str[ open_idx + 1 ] == '{' ) {
 		has_open = false;
 	}
 	if( !has_open ) open_idx = 0;
 
 	size_t close_idx;
 	bool has_close = strchridx( str, '}', &close_idx, open_idx );
 	if( has_close && str[ close_idx + 1 ] == '}' ) {
 		has_close = false;
 	}
 
 	if( has_open ) {
 		ASSERT( has_close );
 		ASSERT( open_idx < close_idx );
 
 		*start = open_idx;
 		*one_past_end = close_idx;
 
 		return true;
 	}
 
 	ASSERT( !has_close );
 	return false;
 }
 
 void ggformat_literals( FormatBuffer * fb, const char * literals, size_t len ) {
 	size_t copied_len = 0;
 	for( size_t i = 0; i < len; i++ ) {
 		if( literals[ i ] == '{' || literals[ i ] == '}' ) {
 			i++;
 		}
 		if( fb->len + copied_len < fb->capacity ) {
 			fb->buf[ fb->len + copied_len ] = literals[ i ];
 		}
 		copied_len++;
 	}
 	fb->len += copied_len;
 	if( fb->capacity > 0 ) {
 		fb->buf[ fb->len < fb->capacity - 1 ? fb->len : fb->capacity - 1 ] = '\0';
 	}
 }
 
 void ggformat_impl( FormatBuffer * fb, const char * fmt ) {
 	size_t ignored;
 	ASSERT( !ggformat_find( fmt, &ignored, &ignored ) );
 	ggformat_literals( fb, fmt, strlen( fmt ) );
 }