X-Git-Url: https://pd.if.org/git/?a=blobdiff_plain;f=functions%2F_PDCLIB%2Fprint.c;h=95fbe9c752e62acd964b2f5c981e3c6e2d7d56da;hb=29387e76cd5cd340fe7d811dc9830931d3d0ec9b;hp=46c00d9eeb60e2ea88e392d12423eeb7bff49fe6;hpb=45cef7ce4ce521d28771a69c6dbde30ca8905e83;p=pdclib

diff --git a/functions/_PDCLIB/print.c b/functions/_PDCLIB/print.c
index 46c00d9..95fbe9c 100644
--- a/functions/_PDCLIB/print.c
+++ b/functions/_PDCLIB/print.c
@@ -9,8 +9,13 @@
 #include <stdio.h>
 #include <stdint.h>
 #include <stdarg.h>
+#include <string.h>
 #include <stdlib.h>
 #include <stddef.h>
+#include <stdbool.h>
+#include <limits.h>
+
+#ifndef REGTEST
 
 /* Using an integer's bits as flags for both the conversion flags and length
    modifiers.
@@ -18,23 +23,23 @@
 /* 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_intptr   (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,158 +47,189 @@
    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 ) { \
         if ( status->stream != NULL ) \
-            putc( character, status->stream ); \
+            putc_unlocked( character, status->stream ); \
         else \
             status->s[status->i] = character; \
     } \
     ++(status->i); \
 } while ( 0 )
 
+/* Maximum number of output characters = 
+ *   number of bits in (u)intmax_t / number of bits per character in smallest 
+ *   base. Smallest base is octal, 3 bits/char.
+ *
+ * Additionally require 2 extra characters for prefixes
+ */
+static const size_t maxIntLen = sizeof(intmax_t) * CHAR_BIT / 3 + 1;
 
-static void intformat( intmax_t value, struct _PDCLIB_status_t * status )
+static void int2base( uintmax_t value, struct _PDCLIB_status_t * status )
 {
-    /* 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 ) )
+    char sign = 0;
+    if ( ! ( status->flags & E_unsigned ) ) 
     {
-        /* Octal / hexadecimal prefix for "%#" conversions */
-        preface[ preidx++ ] = '0';
-        if ( status->base == 16 )
+        intmax_t signval = (intmax_t) value;
+        bool negative = signval < 0;
+        value = signval < 0 ? -signval : signval;
+
+        if ( negative ) 
         {
-            preface[ preidx++ ] = ( status->flags & E_lower ) ? 'x' : 'X';
-        }
-    }
-    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 )
+            sign = '-';
+        } 
+        else if ( status->flags & E_plus ) 
         {
-            preface[ preidx++ ] = '+';
+            sign = '+';
         }
-        else if ( status->flags & E_space )
+        else if (status->flags & E_space )
         {
-            preface[ preidx++ ] = ' ';
+            sign = ' ';
         }
     }
+
+    // The user could theoretically ask for a silly buffer length here. 
+    // Perhaps after a certain size we should malloc? Or do we refuse to protect
+    // them from their own stupidity?
+    size_t bufLen = (status->width > maxIntLen ? status->width : maxIntLen) + 2;
+    char outbuf[bufLen];
+    char * outend = outbuf + bufLen;
+    int written = 0;
+
+    // Build up our output string - backwards
     {
-    size_t prec_pads = ( status->prec > status->current ) ? ( status->prec - status->current ) : 0;
-    if ( ! ( status->flags & ( E_minus | E_zero ) ) )
+        const char * digits = (status->flags & E_lower) ? 
+                                _PDCLIB_digits : _PDCLIB_Xdigits;
+        uintmax_t remaining = value;
+        if(status->prec != 0 || remaining != 0) do {
+            uintmax_t digit = remaining % status->base;
+            remaining /= status->base;
+
+            outend[-++written] = digits[digit];
+        } while(remaining != 0);
+    }
+
+    // Pad field out to the precision specification
+    while( (long) written < status->prec ) outend[-++written] = '0';
+
+    // If a field width specified, and zero padding was requested, then pad to
+    // the field width
+    unsigned padding = 0;
+    if ( ( ! ( status->flags & E_minus ) ) && ( status->flags & 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->current > status->prec ) ? status->current : status->prec );
-        if ( status->width > characters )
+        while( written < (int) status->width ) 
         {
-            for ( size_t i = 0; i < status->width - characters; ++i )
-            {
-                DELIVER( ' ' );
-                ++(status->current);
-            }
+            outend[-++written] = '0';
+            padding++;
         }
     }
-    /* Now we did the padding, do the prefixes (if any). */
-    preidx = 0;
-    while ( preface[ preidx ] != '\0' )
+
+    // Prefixes
+    if ( sign != 0 )
     {
-        DELIVER( preface[ preidx++ ] );
-        ++(status->current);
+        if ( padding == 0 ) written++;
+        outend[-written] = sign;
     }
-    if ( ( ! ( status->flags & E_minus ) ) && ( status->flags & E_zero ) )
+    else if ( status->flags & E_alt )
     {
-        /* If field is not left aligned, and zero padding is requested, do
-           so.
-        */
-        while ( status->current < status->width )
+        switch ( status->base )
         {
-            DELIVER( '0' );
-            ++(status->current);
+            case 8:
+                if ( outend[-written] != '0' ) outend[-++written] = '0';
+                break;
+            case 16:
+                // No prefix if zero
+                if ( value == 0 ) break;
+
+                written += padding < 2 ? 2 - padding : 0;
+                outend[-written    ] = '0';
+                outend[-written + 1] = (status->flags & E_lower) ? 'x' : 'X';
+                break;
+            default:
+                break;
         }
     }
-    /* Do the precision padding if necessary. */
-    for ( size_t i = 0; i < prec_pads; ++i )
+
+    // Space padding to field width
+    if ( ! ( status->flags & ( E_minus | E_zero ) ) )
     {
-        DELIVER( '0' );
-    }
+        while( written < (int) status->width ) outend[-++written] = ' ';
     }
-}
 
+    // Write output
+    status->current = written;
+    while ( written )
+        PUT( outend[-written--] );
+}
 
-/* 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.
-*/
-static void int2base( intmax_t value, struct _PDCLIB_status_t * status )
+static void printstr( const char * str, 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->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 )
+    if ( status->width == 0 || status->flags & E_minus )
     {
-        /* Lowercase letters. Same array used for strto...(). */
-        DELIVER( _PDCLIB_digits[ digit ] );
+        // Simple case or left justification
+        while ( str[status->current] && 
+            ( status->prec < 0 || (long)status->current < status->prec ) )
+        {
+            PUT( str[status->current++] );
+        }
+
+        while( status->current < status->width ) 
+        {
+            PUT( ' ' );
+            status->current++;
+        }
+    } else {
+        // Right justification
+        size_t len = status->prec >= 0 ? strnlen( str, status->prec ) 
+                                       :  strlen( str );
+        int padding = status->width - len;
+        while((long)status->current < padding)
+        {
+            PUT( ' ' );
+            status->current++;
+        }
+
+        for( size_t i = 0; i != len; i++ )
+        {
+            PUT( str[i] );
+            status->current++;
+        }
     }
-    else
+}
+
+static void printchar( char chr, struct _PDCLIB_status_t * status )
+{
+    if( ! ( status->flags & E_minus ) )
     {
-        /* Uppercase letters. Array only used here, only 0-F. */
-        DELIVER( _PDCLIB_Xdigits[ digit ] );
-    }
+        // Right justification
+        for( ; status->current + 1 < status->width; status->current++)
+        {
+            PUT( ' ' );
+        }
+        PUT( chr );
+        status->current++;
+    } else {
+        // Left justification
+        PUT( chr );
+        status->current++;
+
+        for( ; status->current < status->width; status->current++)
+        {
+            PUT( ' ' );
+        }
     }
 }
 
-
 const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status )
 {
     const char * orig_spec = spec;
     if ( *(++spec) == '%' )
     {
         /* %% -> print single '%' */
-        DELIVER( *spec );
+        PUT( *spec );
         return ++spec;
     }
     /* Initializing status structure */
@@ -201,7 +237,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,20 +312,14 @@ 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
         {
-            char * endptr;
-            status->prec = (int)strtol( spec, &endptr, 10 );
-            if ( spec == endptr )
-            {
-                /* Decimal point but no number - bad conversion specifier. */
-                return orig_spec;
-            }
-            spec = endptr;
+            status->prec = (int)strtol( spec, (char**) &spec, 10 );
         }
         /* Having a precision cancels out any zero flag. */
-        status->flags ^= E_zero;
+        status->flags &= ~E_zero;
     }
 
     /* Optional length modifier
@@ -381,17 +411,14 @@ 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 ) );
+            /* TODO: wide chars. */
+            printchar( va_arg( status->arg, int ), status );
             return ++spec;
         case 's':
-            /* TODO: Flags, wide chars. */
+            /* TODO: wide chars. */
             {
                 char * s = va_arg( status->arg, char * );
-                while ( *s != '\0' )
-                {
-                    DELIVER( *(s++) );
-                }
+                printstr( s, status );
                 return ++spec;
             }
         case 'p':
@@ -439,30 +466,7 @@ const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status
                     value = (uintmax_t)va_arg( status->arg, size_t );
                     break;
             }
-            ++(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 )
-            {
-                int2base( (intmax_t)(value / status->base), status );
-            }
-            else
-            {
-                intformat( (intmax_t)value, 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( value, status );
         }
         else
         {
@@ -495,7 +499,7 @@ const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status
         {
             while ( status->current < status->width )
             {
-                DELIVER( ' ' );
+                PUT( ' ' );
                 ++(status->current);
             }
         }
@@ -507,12 +511,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, ... )
 {
     /* Members: base, flags, n, i, current, s, width, prec, stream, arg      */
@@ -536,16 +543,16 @@ static int testprintf( char * buffer, const char * format, ... )
     va_end( status.arg );
     return status.i;
 }
+#endif
 
 #define TEST_CONVERSION_ONLY
 
-#define TESTCASE_SPRINTF( x ) if ( strcmp( target, x ) == 0 ) {} \
-                              else { TEST_RESULTS += 1; printf( "FAILED: " __FILE__ ", line %d - \"%s\" != %s\n", __LINE__, target, #x ); }
-
 int main( void )
 {
+#ifndef REGTEST
     char target[100];
-#include "printf_testcases.incl"
+#include "printf_testcases.h"
+#endif
     return TEST_RESULTS;
 }