]> pd.if.org Git - pdclib/blobdiff - functions/_PDCLIB/print.c
Allowed precision to be negative / ignored.
[pdclib] / functions / _PDCLIB / print.c
index 46c00d9eeb60e2ea88e392d12423eeb7bff49fe6..d2b5dbddc41c29dc895d4e3d17621df31c37fd05 100644 (file)
@@ -1,5 +1,3 @@
-/* $Id$ */
-
 /* _PDCLIB_print( const char *, struct _PDCLIB_status_t * )
 
    This file is part of the Public Domain C Library (PDCLib).
 #include <stdlib.h>
 #include <stddef.h>
 
+#ifndef REGTEST
+
 /* Using an integer's bits as flags for both the conversion flags and length
    modifiers.
 */
 /* 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_intptr   1<<13
-#define E_ldouble  1<<14
-#define E_lower    1<<15
-#define E_unsigned 1<<16
+#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).
@@ -42,9 +45,8 @@
    i - pointer to number of characters already delivered in this call
    n - pointer to maximum number of characters to be delivered in this call
    s - the buffer into which the character shall be delivered
-   TODO: ref. fputs() for a better way to buffer handling
 */
-#define DELIVER( x ) \
+#define PUT( x ) \
 do { \
     int character = x; \
     if ( status->i < status->n ) { \
@@ -59,10 +61,14 @@ do { \
 
 static void intformat( intmax_t value, struct _PDCLIB_status_t * status )
 {
+    if ( status->prec < 0 )
+    {
+        status->prec = 1;
+    }
     /* 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 ) )
+    if ( ( status->flags & E_alt ) && ( status->base == 16 || status->base == 8 ) && ( value != 0 ) )
     {
         /* Octal / hexadecimal prefix for "%#" conversions */
         preface[ preidx++ ] = '0';
@@ -89,23 +95,27 @@ static void intformat( intmax_t value, struct _PDCLIB_status_t * status )
         }
     }
     {
-    size_t prec_pads = ( status->prec > status->current ) ? ( status->prec - status->current ) : 0;
+    /* 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. Leave space for any prefixes determined above.
+           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 > status->prec ) ? status->current : status->prec );
+        size_t characters = preidx + ( ( status->current > (_PDCLIB_size_t)status->prec ) ? status->current : (_PDCLIB_size_t)status->prec );
         if ( status->width > characters )
         {
             for ( size_t i = 0; i < status->width - characters; ++i )
             {
-                DELIVER( ' ' );
+                PUT( ' ' );
                 ++(status->current);
             }
         }
@@ -114,7 +124,13 @@ static void intformat( intmax_t value, struct _PDCLIB_status_t * status )
     preidx = 0;
     while ( preface[ preidx ] != '\0' )
     {
-        DELIVER( preface[ preidx++ ] );
+        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 ) )
@@ -124,15 +140,10 @@ static void intformat( intmax_t value, struct _PDCLIB_status_t * status )
         */
         while ( status->current < status->width )
         {
-            DELIVER( '0' );
+            PUT( '0' );
             ++(status->current);
         }
     }
-    /* Do the precision padding if necessary. */
-    for ( size_t i = 0; i < prec_pads; ++i )
-    {
-        DELIVER( '0' );
-    }
     }
 }
 
@@ -176,12 +187,12 @@ static void int2base( intmax_t value, struct _PDCLIB_status_t * status )
     if ( status->flags & E_lower )
     {
         /* Lowercase letters. Same array used for strto...(). */
-        DELIVER( _PDCLIB_digits[ digit ] );
+        PUT( _PDCLIB_digits[ digit ] );
     }
     else
     {
         /* Uppercase letters. Array only used here, only 0-F. */
-        DELIVER( _PDCLIB_Xdigits[ digit ] );
+        PUT( _PDCLIB_Xdigits[ digit ] );
     }
     }
 }
@@ -193,7 +204,7 @@ const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status
     if ( *(++spec) == '%' )
     {
         /* %% -> print single '%' */
-        DELIVER( *spec );
+        PUT( *spec );
         return ++spec;
     }
     /* Initializing status structure */
@@ -201,7 +212,7 @@ const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status
     status->base  = 0;
     status->current  = 0;
     status->width = 0;
-    status->prec  = 0;
+    status->prec  = EOF;
 
     /* First come 0..n flags */
     do
@@ -276,6 +287,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
         {
@@ -283,13 +295,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
@@ -382,7 +394,7 @@ const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status
             break;
         case 'c':
             /* TODO: Flags, wide chars. */
-            DELIVER( va_arg( status->arg, int ) );
+            PUT( va_arg( status->arg, int ) );
             return ++spec;
         case 's':
             /* TODO: Flags, wide chars. */
@@ -390,14 +402,14 @@ const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status
                 char * s = va_arg( status->arg, char * );
                 while ( *s != '\0' )
                 {
-                    DELIVER( *(s++) );
+                    PUT( *(s++) );
                 }
                 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':
            {
@@ -418,7 +430,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 );
@@ -438,12 +450,17 @@ 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->current);
-            /* FIXME: The if clause means one-digit values do not get formatted */
-            /* Was introduced originally to get value to "safe" levels re. uintmax_t. */
             if ( ( value / status->base ) != 0 )
             {
+                /* Get value to "safe" levels re. uintmax_t. */
                 int2base( (intmax_t)(value / status->base), status );
             }
             else
@@ -457,11 +474,11 @@ const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status
             }
             if ( status->flags & E_lower )
             {
-                DELIVER( _PDCLIB_digits[ digit ] );
+                PUT( _PDCLIB_digits[ digit ] );
             }
             else
             {
-                DELIVER( _PDCLIB_Xdigits[ digit ] );
+                PUT( _PDCLIB_Xdigits[ digit ] );
             }
         }
         else
@@ -489,13 +506,16 @@ const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status
                 case E_intmax:
                     int2base( va_arg( status->arg, intmax_t ), status );
                     break;
+                default:
+                    puts( "UNSUPPORTED PRINTF FLAG COMBINATION" );
+                    return NULL;
             }
         }
         if ( status->flags & E_minus )
         {
             while ( status->current < status->width )
             {
-                DELIVER( ' ' );
+                PUT( ' ' );
                 ++(status->current);
             }
         }
@@ -507,11 +527,15 @@ 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 <limits.h>
-#include <string.h>
+#include "_PDCLIB_test.h"
+
+#ifndef REGTEST
 
 static int testprintf( char * buffer, const char * format, ... )
 {
@@ -537,15 +561,16 @@ static int testprintf( char * buffer, const char * format, ... )
     return status.i;
 }
 
-#define TEST_CONVERSION_ONLY
+#endif
 
-#define TESTCASE_SPRINTF( x ) if ( strcmp( target, x ) == 0 ) {} \
-                              else { TEST_RESULTS += 1; printf( "FAILED: " __FILE__ ", line %d - \"%s\" != %s\n", __LINE__, target, #x ); }
+#define TEST_CONVERSION_ONLY
 
 int main( void )
 {
+#ifndef REGTEST
     char target[100];
-#include "printf_testcases.incl"
+#include "printf_testcases.h"
+#endif
     return TEST_RESULTS;
 }