X-Git-Url: https://pd.if.org/git/?a=blobdiff_plain;f=functions%2F_PDCLIB%2Fprint.c;h=439098d69bc604331de9b5e832178fb431c4c32a;hb=3ea605404733209c32d8e43915fa3790adbcb1c9;hp=28cd4bc0ae1b0a2c65e9db96995fba196767c703;hpb=42e018009a78cdddd97fd18d2b6bb02d8e0fe16e;p=pdclib.old

diff --git a/functions/_PDCLIB/print.c b/functions/_PDCLIB/print.c
index 28cd4bc..439098d 100644
--- a/functions/_PDCLIB/print.c
+++ b/functions/_PDCLIB/print.c
@@ -8,10 +8,20 @@
 
 #include <stdio.h>
 #include <stdint.h>
+#include <stdarg.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.
 */
+/* 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
@@ -26,7 +36,7 @@
 #define E_size     1<<11
 #define E_ptrdiff  1<<12
 #define E_intptr   1<<13
-#define E_double   1<<14
+#define E_ldouble  1<<14
 #define E_lower    1<<15
 #define E_unsigned 1<<16
 
@@ -37,146 +47,138 @@
    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 )
+/* 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 int2base( uintmax_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 )
+    char sign = 0;
+    if ( ! ( status->flags & E_unsigned ) ) 
     {
-        /* 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.
-        */
-        /* 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 )
-            {
-                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 )
-            {
-                preface[ preidx++ ] = '+';
-            }
-            else if ( status->flags & E_space )
-            {
-                preface[ preidx++ ] = ' ';
-            }
-        }
-        {
-        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 ( int i = 0; i < status->width - characters; ++i )
-                {
-                    DELIVER( ' ' );
-                    ++(status->this);
-                }
-            }
-        }
-        /* Now we did the padding, do the prefixes (if any). */
-        preidx = 0;
-        while ( preface[ preidx ] != '\0' )
+        intmax_t signval = (intmax_t) value;
+        bool negative = signval < 0;
+        value = signval < 0 ? -signval : signval;
+
+        if ( negative ) 
         {
-            DELIVER( preface[ preidx++ ] );
-            ++(status->this);
-        }
-        if ( ( ! ( status->flags & E_minus ) ) && ( status->flags & E_zero ) )
+            sign = '-';
+        } 
+        else if ( status->flags & E_plus ) 
         {
-            /* If field is not left aligned, and zero padding is requested, do
-               so.
-            */
-            while ( status->this < status->width )
-            {
-                DELIVER( '0' );
-                ++(status->this);
-            }
+            sign = '+';
         }
-        /* Do the precision padding if necessary. */
-        for ( int i = 0; i < prec_pads; ++i )
+        else if (status->flags & E_space )
         {
-            DELIVER( '0' );
-        }
+            sign = ' ';
         }
     }
-    /* Recursion tail - print the current digit. */
+
+    // 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;
+    unsigned written = 0;
+
+    // Build up our output string - backwards
     {
-    int digit = value % status->base;
-    if ( digit < 0 )
+        const char * digits = (status->flags & E_lower) ? 
+                                _PDCLIB_digits : _PDCLIB_Xdigits;
+        uintmax_t remaining = value;
+        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 ) )    
     {
-        digit *= -1;
+        while( written < status->width ) 
+        {
+            outend[-++written] = '0';
+            padding++;
+        }
     }
-    if ( status->flags & E_lower )
+
+    // Prefixes
+    if ( sign != 0 )
     {
-        /* Lowercase letters. Same array used for strto...(). */
-        DELIVER( _PDCLIB_digits[ digit ] );
+        if ( padding == 0 ) written++;
+        outend[-written] = sign;
     }
-    else
+    else if ( status->flags & E_alt )
     {
-        /* Uppercase letters. Array only used here, only 0-F. */
-        DELIVER( _PDCLIB_Xdigits[ digit ] );
+        switch ( status->base )
+        {
+            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;
+        }
     }
+
+    // Space padding to field width
+    if ( ! ( status->flags & ( E_minus | E_zero ) ) )
+    {
+        while( written < status->width ) outend[-++written] = ' ';
     }
+
+    // Write output
+    status->current = written;
+    while ( written )
+        PUT( outend[-written--] );
 }
 
-/* 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
@@ -184,26 +186,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;
         }
@@ -213,11 +221,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;
     }
@@ -267,36 +279,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;
@@ -339,7 +359,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. */
@@ -347,7 +367,7 @@ 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;
             }
@@ -396,24 +416,7 @@ const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status
                     value = (uintmax_t)va_arg( status->arg, size_t );
                     break;
             }
-            ++(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( value, status );
         }
         else
         {
@@ -444,16 +447,63 @@ const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status
         }
         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';
         }
     }
     return ++spec;
 }
+
+#endif
+
+#ifdef TEST
+#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 = 0;
+    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 )
+{
+#ifndef REGTEST
+    char target[100];
+#include "printf_testcases.h"
+#endif
+    return TEST_RESULTS;
+}
+
+#endif