X-Git-Url: https://pd.if.org/git/?a=blobdiff_plain;f=functions%2F_PDCLIB%2Fprint.c;h=5dacfbf4595e8cfeda6df070fc476ec0a7405077;hb=c5c4350d2beb1ebe93f3f6d45643a64eed2a7c7a;hp=a8c44f6a93d2679a0bcce035ebcb881e7279d999;hpb=d2183e8421f71a0c409e5dca6546569a54403379;p=pdclib diff --git a/functions/_PDCLIB/print.c b/functions/_PDCLIB/print.c index a8c44f6..5dacfbf 100644 --- a/functions/_PDCLIB/print.c +++ b/functions/_PDCLIB/print.c @@ -1,5 +1,3 @@ -/* $Id$ */ - /* _PDCLIB_print( const char *, struct _PDCLIB_status_t * ) This file is part of the Public Domain C Library (PDCLib). @@ -11,27 +9,36 @@ #include #include #include +#include + +#ifndef REGTEST /* Using an integer's bits as flags for both the conversion flags and length modifiers. */ -#define E_minus 1<<0 -#define E_plus 1<<1 -#define E_alt 1<<2 -#define E_space 1<<3 -#define E_zero 1<<4 -#define E_done 1<<5 -#define E_char 1<<6 -#define E_short 1<<7 -#define E_long 1<<8 -#define E_llong 1<<9 -#define E_intmax 1<<10 -#define E_size 1<<11 -#define E_ptrdiff 1<<12 -#define E_intptr 1<<13 -#define E_double 1<<14 -#define E_lower 1<<15 -#define E_unsigned 1<<16 +/* FIXME: one too many flags to work on a 16-bit machine, join some (e.g. the + width flags) into a combined field. +*/ +#define E_minus (1<<0) +#define E_plus (1<<1) +#define E_alt (1<<2) +#define E_space (1<<3) +#define E_zero (1<<4) +#define E_done (1<<5) + +#define E_char (1<<6) +#define E_short (1<<7) +#define E_long (1<<8) +#define E_llong (1<<9) +#define E_intmax (1<<10) +#define E_size (1<<11) +#define E_ptrdiff (1<<12) +#define E_pointer (1<<13) + +#define E_ldouble (1<<14) + +#define E_lower (1<<15) +#define E_unsigned (1<<16) /* This macro delivers a given character to either a memory buffer or a stream, depending on the contents of 'status' (struct _PDCLIB_status_t). @@ -40,146 +47,237 @@ n - pointer to maximum number of characters to be delivered in this call s - the buffer into which the character shall be delivered */ -#define DELIVER( x ) do { if ( status->i < status->n ) { if ( status->stream != NULL ) putc( x, status->stream ); else status->s[status->i] = x; } ++(status->i); } while ( 0 ) +#define PUT( x ) \ +do { \ + int character = x; \ + if ( status->i < status->n ) { \ + if ( status->stream != NULL ) \ + putc( character, status->stream ); \ + else \ + status->s[status->i] = character; \ + } \ + ++(status->i); \ +} while ( 0 ) -/* This function recursively converts a given integer value to a given base - into a character string. Persistent information - like the number of digits - parsed so far - is recorded in a struct _PDCLIB_status_t, which allows to - avoid overwriting snprintf() limits, and enables the function to do the - necessary padding / prefixing of the character string eventually printed. -*/ -static void int2base( intmax_t value, struct _PDCLIB_status_t * status ) + +static void intformat( intmax_t value, struct _PDCLIB_status_t * status ) { - /* Registering the character being printed at the end of the function here - already so it will be taken into account when the deepestmost recursion - does the prefix / padding stuff. - */ - ++(status->this); - if ( ( value / status->base ) != 0 ) + if ( status->prec < 0 ) { - /* More digits to be done - recurse deeper */ - int2base( value / status->base, status ); + status->prec = 1; } - else + /* At worst, we need two prefix characters (hex prefix). */ + char preface[3] = "\0"; + size_t preidx = 0; + if ( ( status->flags & E_alt ) && ( status->base == 16 || status->base == 8 ) && ( value != 0 ) ) { - /* We reached the last digit, the deepest point of our recursion, and - only now know how long the number to be printed actually is. Now we - have to do the sign, prefix, width, and precision padding stuff - before printing the numbers while we resurface from the recursion. - */ - /* At worst, we need two prefix characters (hex prefix). */ - char preface[3] = "\0"; - size_t preidx = 0; - if ( ( status->flags & E_alt ) && ( status->base == 16 || status->base == 8 ) ) + /* Octal / hexadecimal prefix for "%#" conversions */ + preface[ preidx++ ] = '0'; + if ( status->base == 16 ) { - /* Octal / hexadecimal prefix for "%#" conversions */ - preface[ preidx++ ] = '0'; - if ( status->base == 16 ) - { - preface[ preidx++ ] = ( status->flags & E_lower ) ? 'x' : 'X'; - } + preface[ preidx++ ] = ( status->flags & E_lower ) ? 'x' : 'X'; } - if ( value < 0 ) + } + if ( value < 0 ) + { + /* Negative sign for negative values - at all times. */ + preface[ preidx++ ] = '-'; + } + else if ( ! ( status->flags & E_unsigned ) ) + { + /* plus sign / extra space are only for unsigned conversions */ + if ( status->flags & E_plus ) { - /* Negative sign for negative values - at all times. */ - preface[ preidx++ ] = '-'; + preface[ preidx++ ] = '+'; } - else if ( ! ( status->flags & E_unsigned ) ) + else if ( status->flags & E_space ) { - /* plus sign / extra space are only for unsigned conversions */ - if ( status->flags & E_plus ) - { - preface[ preidx++ ] = '+'; - } - else if ( status->flags & E_space ) - { - preface[ preidx++ ] = ' '; - } + preface[ preidx++ ] = ' '; } + } + { + /* At this point, status->current has the number of digits queued up. + Determine if we have a precision requirement to pad those. + */ + size_t prec_pads = ( (_PDCLIB_size_t)status->prec > status->current ) ? ( (_PDCLIB_size_t)status->prec - status->current ) : 0; + if ( ! ( status->flags & ( E_minus | E_zero ) ) ) + { + /* Space padding is only done if no zero padding or left alignment + is requested. Calculate the number of characters that WILL be + printed, including any prefixes determined above. + */ + /* The number of characters to be printed, plus prefixes if any. */ + /* This line contained probably the most stupid, time-wasting bug + I've ever perpetrated. Greetings to Samface, DevL, and all + sceners at Breakpoint 2006. + */ + size_t characters = preidx + ( ( status->current > (_PDCLIB_size_t)status->prec ) ? status->current : (_PDCLIB_size_t)status->prec ); + if ( status->width > characters ) { - size_t prec_pads = ( status->prec > status->this ) ? ( status->prec - status->this ) : 0; - if ( ! ( status->flags & ( E_minus | E_zero ) ) ) - { - /* Space padding is only done if no zero padding or left alignment - is requested. Leave space for any prefixes determined above. - */ - /* The number of characters to be printed, plus prefixes if any. */ - /* This line contained probably the most stupid, time-wasting bug - I've ever perpetrated. Greetings to Samface, DevL, and all - sceners at Breakpoint 2006. - */ - size_t characters = preidx + ( ( status->this > status->prec ) ? status->this : status->prec ); - if ( status->width > characters ) + for ( size_t i = 0; i < status->width - characters; ++i ) { - for ( int i = 0; i < status->width - characters; ++i ) - { - DELIVER( ' ' ); - ++(status->this); - } + PUT( ' ' ); + ++(status->current); } } - /* Now we did the padding, do the prefixes (if any). */ - preidx = 0; - while ( preface[ preidx ] != '\0' ) + } + /* Now we did the padding, do the prefixes (if any). */ + preidx = 0; + while ( preface[ preidx ] != '\0' ) + { + PUT( preface[ preidx++ ] ); + ++(status->current); + } + /* Do the precision padding if necessary. */ + while ( prec_pads-- > 0 ) + { + PUT( '0' ); + ++(status->current); + } + if ( ( ! ( status->flags & E_minus ) ) && ( status->flags & E_zero ) ) + { + /* If field is not left aligned, and zero padding is requested, do + so. + */ + while ( status->current < status->width ) + { + PUT( '0' ); + ++(status->current); + } + } + } +} + + +/* This function recursively converts a given integer value to a character + stream. The conversion is done under the control of a given status struct + and written either to a character string or a stream, depending on that + same status struct. The status struct also keeps the function from exceeding + snprintf() limits, and enables any necessary padding / prefixing of the + output once the number of characters to be printed is known, which happens + at the lowermost recursion level. +*/ +#define INT2BASE() \ +do \ +{ \ + /* Special case: zero value, zero precision -- no output (but padding) */ \ + if ( status->current == 0 && value == 0 && status->prec == 0 ) \ + { \ + intformat( value, status ); \ + } \ + else \ + { \ + /* Registering the character being printed at the end of the function here \ + already so it will be taken into account when the deepestmost recursion \ + does the prefix / padding stuff. \ + */ \ + ++(status->current); \ + if ( ( value / status->base ) != 0 ) \ + { \ + /* More digits to be done - recurse deeper */ \ + int2base( value / status->base, status ); \ + } \ + else \ + { \ + /* We reached the last digit, the deepest point of our recursion, and \ + only now know how long the number to be printed actually is. Now we \ + have to do the sign, prefix, width, and precision padding stuff \ + before printing the numbers while we resurface from the recursion. \ + */ \ + intformat( value, status ); \ + } \ + /* Recursion tail - print the current digit. */ \ + { \ + int digit = value % status->base; \ + if ( digit < 0 ) \ + { \ + digit *= -1; \ + } \ + if ( status->flags & E_lower ) \ + { \ + /* Lowercase letters. Same array used for strto...(). */ \ + PUT( _PDCLIB_digits[ digit ] ); \ + } \ + else \ + { \ + /* Uppercase letters. Array only used here, only 0-F. */ \ + PUT( _PDCLIB_Xdigits[ digit ] ); \ + } \ + } \ + } \ +} while ( 0 ) + + +static void int2base( intmax_t value, struct _PDCLIB_status_t * status ) +{ + INT2BASE(); +} + + +static void stringformat( const char * s, struct _PDCLIB_status_t * status ) +{ + if ( status->flags & E_char ) + { + status->prec = 1; + } + else + { + if ( status->prec < 0 ) { - DELIVER( preface[ preidx++ ] ); - ++(status->this); + status->prec = strlen( s ); } - if ( ( ! ( status->flags & E_minus ) ) && ( status->flags & E_zero ) ) + else { - /* If field is not left aligned, and zero padding is requested, do - so. - */ - while ( status->this < status->width ) + for ( int i = 0; i < status->prec; ++i ) { - DELIVER( '0' ); - ++(status->this); + if ( s[i] == 0 ) + { + status->prec = i; + break; + } } } - /* Do the precision padding if necessary. */ - for ( int i = 0; i < prec_pads; ++i ) - { - DELIVER( '0' ); - } - } } - /* Recursion tail - print the current digit. */ - { - int digit = value % status->base; - if ( digit < 0 ) + if ( ! ( status->flags & E_minus ) && ( status->width > (_PDCLIB_size_t)status->prec ) ) { - digit *= -1; + while ( status->current < ( status->width - status->prec ) ) + { + PUT( ' ' ); + ++(status->current); + } } - if ( status->flags & E_lower ) + while ( status->prec > 0 ) { - /* Lowercase letters. Same array used for strto...(). */ - DELIVER( _PDCLIB_digits[ digit ] ); + PUT( *(s++) ); + --(status->prec); + ++(status->current); } - else + if ( status->flags & E_minus ) { - /* Uppercase letters. Array only used here, only 0-F. */ - DELIVER( _PDCLIB_Xdigits[ digit ] ); - } + while ( status->width > status->current ) + { + PUT( ' ' ); + ++(status->current); + } } } -/* This function is to be called with spec pointing to the leading '%' of a - printf() conversion specifier. -*/ + const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status ) { const char * orig_spec = spec; if ( *(++spec) == '%' ) { - DELIVER( *spec ); + /* %% -> print single '%' */ + PUT( *spec ); return ++spec; } /* Initializing status structure */ status->flags = 0; status->base = 0; - status->this = 0; + status->current = 0; status->width = 0; - status->prec = 0; + status->prec = EOF; /* First come 0..n flags */ do @@ -187,26 +285,32 @@ const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status switch ( *spec ) { case '-': + /* left-aligned output */ status->flags |= E_minus; ++spec; break; case '+': + /* positive numbers prefixed with '+' */ status->flags |= E_plus; ++spec; break; case '#': + /* alternative format (leading 0x for hex, 0 for octal) */ status->flags |= E_alt; ++spec; break; case ' ': + /* positive numbers prefixed with ' ' */ status->flags |= E_space; ++spec; break; case '0': + /* right-aligned padding done with '0' instead of ' ' */ status->flags |= E_zero; ++spec; break; default: + /* not a flag, exit flag parsing */ status->flags |= E_done; break; } @@ -216,11 +320,15 @@ const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status if ( *spec == '*' ) { /* Retrieve width value from argument stack */ - if ( ( status->width = va_arg( status->arg, int ) ) < 0 ) + int width = va_arg( status->arg, int ); + if ( width < 0 ) { - /* Negative value is '-' flag plus absolute value */ status->flags |= E_minus; - status->width *= -1; + status->width = abs( width ); + } + else + { + status->width = width; } ++spec; } @@ -244,6 +352,7 @@ const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status EOF (negative), there is no need for testing for negative here. */ status->prec = va_arg( status->arg, int ); + ++spec; } else { @@ -251,13 +360,13 @@ const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status status->prec = (int)strtol( spec, &endptr, 10 ); if ( spec == endptr ) { - /* Decimal point but no number - bad conversion specifier. */ - return orig_spec; + /* Decimal point but no number - equals zero */ + status->prec = 0; } spec = endptr; } /* Having a precision cancels out any zero flag. */ - status->flags ^= E_zero; + status->flags &= ~E_zero; } /* Optional length modifier @@ -270,36 +379,44 @@ const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status case 'h': if ( *spec == 'h' ) { + /* hh -> char */ status->flags |= E_char; ++spec; } else { + /* h -> short */ status->flags |= E_short; } break; case 'l': if ( *spec == 'l' ) { + /* ll -> long long */ status->flags |= E_llong; ++spec; } else { + /* k -> long */ status->flags |= E_long; } break; case 'j': + /* j -> intmax_t, which might or might not be long long */ status->flags |= E_intmax; break; case 'z': + /* z -> size_t, which might or might not be unsigned int */ status->flags |= E_size; break; case 't': + /* t -> ptrdiff_t, which might or might not be long */ status->flags |= E_ptrdiff; break; case 'L': - status->flags |= E_double; + /* L -> long double */ + status->flags |= E_ldouble; break; default: --spec; @@ -341,23 +458,21 @@ const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status case 'A': break; case 'c': - /* TODO: Flags, wide chars. */ - DELIVER( va_arg( status->arg, int ) ); - return ++spec; - case 's': - /* TODO: Flags, wide chars. */ + /* TODO: wide chars. */ { - char * s = va_arg( status->arg, char * ); - while ( *s != '\0' ) - { - DELIVER( *(s++) ); - } + char c[1]; + c[0] = (char)va_arg( status->arg, int ); + status->flags |= E_char; + stringformat( c, status ); return ++spec; } + case 's': + /* TODO: wide chars. */ + stringformat( va_arg( status->arg, char * ), status ); + return ++spec; case 'p': - /* TODO: E_long -> E_intptr */ status->base = 16; - status->flags |= ( E_lower | E_unsigned | E_alt | E_long ); + status->flags |= ( E_lower | E_unsigned | E_alt | E_pointer ); break; case 'n': { @@ -378,7 +493,7 @@ const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status if ( status->flags & E_unsigned ) { uintmax_t value; - switch ( status->flags & ( E_char | E_short | E_long | E_llong | E_size ) ) + switch ( status->flags & ( E_char | E_short | E_long | E_llong | E_size | E_pointer ) ) { case E_char: value = (uintmax_t)(unsigned char)va_arg( status->arg, int ); @@ -398,62 +513,56 @@ const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status case E_size: value = (uintmax_t)va_arg( status->arg, size_t ); break; + case E_pointer: + value = (uintmax_t)(uintptr_t)va_arg( status->arg, void * ); + break; + default: + puts( "UNSUPPORTED PRINTF FLAG COMBINATION" ); + return NULL; } - ++(status->this); - if ( ( value / status->base ) != 0 ) - { - int2base( (intmax_t)(value / status->base), status ); - } - int digit = value % status->base; - if ( digit < 0 ) - { - digit *= -1; - } - if ( status->flags & E_lower ) - { - DELIVER( _PDCLIB_digits[ digit ] ); - } - else - { - DELIVER( _PDCLIB_Xdigits[ digit ] ); - } + INT2BASE(); } else { + intmax_t value; switch ( status->flags & ( E_char | E_short | E_long | E_llong | E_intmax ) ) { case E_char: - int2base( (intmax_t)(char)va_arg( status->arg, int ), status ); + value = (intmax_t)(char)va_arg( status->arg, int ); break; case E_short: - int2base( (intmax_t)(short)va_arg( status->arg, int ), status ); + value = (intmax_t)(short)va_arg( status->arg, int ); break; case 0: - int2base( (intmax_t)va_arg( status->arg, int ), status ); + value = (intmax_t)va_arg( status->arg, int ); break; case E_long: - int2base( (intmax_t)va_arg( status->arg, long ), status ); + value = (intmax_t)va_arg( status->arg, long ); break; case E_llong: - int2base( (intmax_t)va_arg( status->arg, long long ), status ); + value = (intmax_t)va_arg( status->arg, long long ); break; case E_ptrdiff: - int2base( (intmax_t)va_arg( status->arg, ptrdiff_t ), status ); + value = (intmax_t)va_arg( status->arg, ptrdiff_t ); break; case E_intmax: - int2base( va_arg( status->arg, intmax_t ), status ); + value = va_arg( status->arg, intmax_t ); break; + default: + puts( "UNSUPPORTED PRINTF FLAG COMBINATION" ); + return NULL; } + INT2BASE(); } if ( status->flags & E_minus ) { - while ( status->this < status->width ) + while ( status->current < status->width ) { - DELIVER( ' ' ); - ++(status->this); + PUT( ' ' ); + ++(status->current); } } - if ( status->i >= status->n ) + if ( status->i >= status->n && status->n > 0 ) { status->s[status->n - 1] = '\0'; } @@ -461,12 +570,50 @@ const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status return ++spec; } +#endif + #ifdef TEST -#include <_PDCLIB_test.h> +#define _PDCLIB_FILEID "_PDCLIB/print.c" +#define _PDCLIB_STRINGIO + +#include "_PDCLIB_test.h" + +#ifndef REGTEST + +static int testprintf( char * buffer, const char * format, ... ) +{ + /* Members: base, flags, n, i, current, s, width, prec, stream, arg */ + struct _PDCLIB_status_t status; + status.base = 0; + status.flags = 0; + status.n = 100; + status.i = 0; + status.current = 0; + status.s = buffer; + status.width = 0; + status.prec = EOF; + status.stream = NULL; + va_start( status.arg, format ); + memset( buffer, '\0', 100 ); + if ( *(_PDCLIB_print( format, &status )) != '\0' ) + { + printf( "_PDCLIB_print() did not return end-of-specifier on '%s'.\n", format ); + ++TEST_RESULTS; + } + va_end( status.arg ); + return status.i; +} + +#endif + +#define TEST_CONVERSION_ONLY int main( void ) { - TESTCASE( NO_TESTDRIVER ); +#ifndef REGTEST + char target[100]; +#include "printf_testcases.h" +#endif return TEST_RESULTS; }