pd.if.org Git - pdclib.old/blob - functions/stdio/_PDCLIB_print.c

   1 /* $Id$ */
   2
   3 /* _PDCLIB_print( const char *, struct _PDCLIB_status_t * )
   4
   5    This file is part of the Public Domain C Library (PDCLib).
   6    Permission is granted to use, modify, and / or redistribute at will.
   7 */
   8
   9 #include <stdio.h>
  10 #include <stdint.h>
  11 #include <stdarg.h>
  12 #include <string.h>
  13 #include <stdlib.h>
  14 #include <stddef.h>
  15 #include <stdbool.h>
  16 #include <limits.h>
  17
  18 #ifndef REGTEST
  19
  20 /* Using an integer's bits as flags for both the conversion flags and length
  21    modifiers.
  22 */
  23 /* FIXME: one too many flags to work on a 16-bit machine, join some (e.g. the
  24           width flags) into a combined field.
  25 */
  26 #define E_minus    (1<<0)
  27 #define E_plus     (1<<1)
  28 #define E_alt      (1<<2)
  29 #define E_space    (1<<3)
  30 #define E_zero     (1<<4)
  31 #define E_done     (1<<5)
  32 #define E_char     (1<<6)
  33 #define E_short    (1<<7)
  34 #define E_long     (1<<8)
  35 #define E_llong    (1<<9)
  36 #define E_intmax   (1<<10)
  37 #define E_size     (1<<11)
  38 #define E_ptrdiff  (1<<12)
  39 #define E_intptr   (1<<13)
  40 #define E_ldouble  (1<<14)
  41 #define E_lower    (1<<15)
  42 #define E_unsigned (1<<16)
  43
  44 /* This macro delivers a given character to either a memory buffer or a stream,
  45    depending on the contents of 'status' (struct _PDCLIB_status_t).
  46    x - the character to be delivered
  47    i - pointer to number of characters already delivered in this call
  48    n - pointer to maximum number of characters to be delivered in this call
  49    s - the buffer into which the character shall be delivered
  50 */
  51 #define PUT( x ) \
  52 do { \
  53     int character = x; \
  54     if ( status->i < status->n ) { \
  55         if ( status->stream != NULL ) \
  56             putc_unlocked( character, status->stream ); \
  57         else \
  58             status->s[status->i] = character; \
  59     } \
  60     ++(status->i); \
  61 } while ( 0 )
  62
  63 /* Maximum number of output characters =
  64  *   number of bits in (u)intmax_t / number of bits per character in smallest
  65  *   base. Smallest base is octal, 3 bits/char.
  66  *
  67  * Additionally require 2 extra characters for prefixes
  68  */
  69 static const size_t maxIntLen = sizeof(intmax_t) * CHAR_BIT / 3 + 1;
  70
  71 static void int2base( uintmax_t value, struct _PDCLIB_status_t * status )
  72 {
  73     char sign = 0;
  74     if ( ! ( status->flags & E_unsigned ) )
  75     {
  76         intmax_t signval = (intmax_t) value;
  77         bool negative = signval < 0;
  78         value = signval < 0 ? -signval : signval;
  79
  80         if ( negative )
  81         {
  82             sign = '-';
  83         }
  84         else if ( status->flags & E_plus )
  85         {
  86             sign = '+';
  87         }
  88         else if (status->flags & E_space )
  89         {
  90             sign = ' ';
  91         }
  92     }
  93
  94     // The user could theoretically ask for a silly buffer length here.
  95     // Perhaps after a certain size we should malloc? Or do we refuse to protect
  96     // them from their own stupidity?
  97     size_t bufLen = (status->width > maxIntLen ? status->width : maxIntLen) + 2;
  98     char outbuf[bufLen];
  99     char * outend = outbuf + bufLen;
 100     int written = 0;
 101
 102     // Build up our output string - backwards
 103     {
 104         const char * digits = (status->flags & E_lower) ?
 105                                 _PDCLIB_digits : _PDCLIB_Xdigits;
 106         uintmax_t remaining = value;
 107         if(status->prec != 0 || remaining != 0) do {
 108             uintmax_t digit = remaining % status->base;
 109             remaining /= status->base;
 110
 111             outend[-++written] = digits[digit];
 112         } while(remaining != 0);
 113     }
 114
 115     // Pad field out to the precision specification
 116     while( (long) written < status->prec ) outend[-++written] = '0';
 117
 118     // If a field width specified, and zero padding was requested, then pad to
 119     // the field width
 120     unsigned padding = 0;
 121     if ( ( ! ( status->flags & E_minus ) ) && ( status->flags & E_zero ) )
 122     {
 123         while( written < (int) status->width )
 124         {
 125             outend[-++written] = '0';
 126             padding++;
 127         }
 128     }
 129
 130     // Prefixes
 131     if ( sign != 0 )
 132     {
 133         if ( padding == 0 ) written++;
 134         outend[-written] = sign;
 135     }
 136     else if ( status->flags & E_alt )
 137     {
 138         switch ( status->base )
 139         {
 140             case 8:
 141                 if ( outend[-written] != '0' ) outend[-++written] = '0';
 142                 break;
 143             case 16:
 144                 // No prefix if zero
 145                 if ( value == 0 ) break;
 146
 147                 written += padding < 2 ? 2 - padding : 0;
 148                 outend[-written    ] = '0';
 149                 outend[-written + 1] = (status->flags & E_lower) ? 'x' : 'X';
 150                 break;
 151             default:
 152                 break;
 153         }
 154     }
 155
 156     // Space padding to field width
 157     if ( ! ( status->flags & ( E_minus | E_zero ) ) )
 158     {
 159         while( written < (int) status->width ) outend[-++written] = ' ';
 160     }
 161
 162     // Write output
 163     status->current = written;
 164     while ( written )
 165         PUT( outend[-written--] );
 166 }
 167
 168 static void printstr( const char * str, struct _PDCLIB_status_t * status )
 169 {
 170     if ( status->width == 0 || status->flags & E_minus )
 171     {
 172         // Simple case or left justification
 173         while ( str[status->current] &&
 174             ( status->prec < 0 || (long)status->current < status->prec ) )
 175         {
 176             PUT( str[status->current++] );
 177         }
 178
 179         while( status->current < status->width )
 180         {
 181             PUT( ' ' );
 182             status->current++;
 183         }
 184     } else {
 185         // Right justification
 186         size_t len = status->prec >= 0 ? strnlen( str, status->prec )
 187                                        :  strlen( str );
 188         int padding = status->width - len;
 189         while((long)status->current < padding)
 190         {
 191             PUT( ' ' );
 192             status->current++;
 193         }
 194
 195         for( size_t i = 0; i != len; i++ )
 196         {
 197             PUT( str[i] );
 198             status->current++;
 199         }
 200     }
 201 }
 202
 203 static void printchar( char chr, struct _PDCLIB_status_t * status )
 204 {
 205     if( ! ( status->flags & E_minus ) )
 206     {
 207         // Right justification
 208         for( ; status->current + 1 < status->width; status->current++)
 209         {
 210             PUT( ' ' );
 211         }
 212         PUT( chr );
 213         status->current++;
 214     } else {
 215         // Left justification
 216         PUT( chr );
 217         status->current++;
 218
 219         for( ; status->current < status->width; status->current++)
 220         {
 221             PUT( ' ' );
 222         }
 223     }
 224 }
 225
 226 const char * _PDCLIB_print( const char * spec, struct _PDCLIB_status_t * status )
 227 {
 228     const char * orig_spec = spec;
 229     if ( *(++spec) == '%' )
 230     {
 231         /* %% -> print single '%' */
 232         PUT( *spec );
 233         return ++spec;
 234     }
 235     /* Initializing status structure */
 236     status->flags = 0;
 237     status->base  = 0;
 238     status->current  = 0;
 239     status->width = 0;
 240     status->prec  = EOF;
 241
 242     /* First come 0..n flags */
 243     do
 244     {
 245         switch ( *spec )
 246         {
 247             case '-':
 248                 /* left-aligned output */
 249                 status->flags |= E_minus;
 250                 ++spec;
 251                 break;
 252             case '+':
 253                 /* positive numbers prefixed with '+' */
 254                 status->flags |= E_plus;
 255                 ++spec;
 256                 break;
 257             case '#':
 258                 /* alternative format (leading 0x for hex, 0 for octal) */
 259                 status->flags |= E_alt;
 260                 ++spec;
 261                 break;
 262             case ' ':
 263                 /* positive numbers prefixed with ' ' */
 264                 status->flags |= E_space;
 265                 ++spec;
 266                 break;
 267             case '0':
 268                 /* right-aligned padding done with '0' instead of ' ' */
 269                 status->flags |= E_zero;
 270                 ++spec;
 271                 break;
 272             default:
 273                 /* not a flag, exit flag parsing */
 274                 status->flags |= E_done;
 275                 break;
 276         }
 277     } while ( ! ( status->flags & E_done ) );
 278
 279     /* Optional field width */
 280     if ( *spec == '*' )
 281     {
 282         /* Retrieve width value from argument stack */
 283         int width = va_arg( status->arg, int );
 284         if ( width < 0 )
 285         {
 286             status->flags |= E_minus;
 287             status->width = abs( width );
 288         }
 289         else
 290         {
 291             status->width = width;
 292         }
 293         ++spec;
 294     }
 295     else
 296     {
 297         /* If a width is given, strtol() will return its value. If not given,
 298            strtol() will return zero. In both cases, endptr will point to the
 299            rest of the conversion specifier - just what we need.
 300         */
 301         status->width = (int)strtol( spec, (char**)&spec, 10 );
 302     }
 303
 304     /* Optional precision */
 305     if ( *spec == '.' )
 306     {
 307         ++spec;
 308         if ( *spec == '*' )
 309         {
 310             /* Retrieve precision value from argument stack. A negative value
 311                is as if no precision is given - as precision is initalized to
 312                EOF (negative), there is no need for testing for negative here.
 313             */
 314             status->prec = va_arg( status->arg, int );
 315             ++spec;
 316         }
 317         else
 318         {
 319             status->prec = (int)strtol( spec, (char**) &spec, 10 );
 320         }
 321         /* Having a precision cancels out any zero flag. */
 322         status->flags &= ~E_zero;
 323     }
 324
 325     /* Optional length modifier
 326        We step one character ahead in any case, and step back only if we find
 327        there has been no length modifier (or step ahead another character if it
 328        has been "hh" or "ll").
 329     */
 330     switch ( *(spec++) )
 331     {
 332         case 'h':
 333             if ( *spec == 'h' )
 334             {
 335                 /* hh -> char */
 336                 status->flags |= E_char;
 337                 ++spec;
 338             }
 339             else
 340             {
 341                 /* h -> short */
 342                 status->flags |= E_short;
 343             }
 344             break;
 345         case 'l':
 346             if ( *spec == 'l' )
 347             {
 348                 /* ll -> long long */
 349                 status->flags |= E_llong;
 350                 ++spec;
 351             }
 352             else
 353             {
 354                 /* k -> long */
 355                 status->flags |= E_long;
 356             }
 357             break;
 358         case 'j':
 359             /* j -> intmax_t, which might or might not be long long */
 360             status->flags |= E_intmax;
 361             break;
 362         case 'z':
 363             /* z -> size_t, which might or might not be unsigned int */
 364             status->flags |= E_size;
 365             break;
 366         case 't':
 367             /* t -> ptrdiff_t, which might or might not be long */
 368             status->flags |= E_ptrdiff;
 369             break;
 370         case 'L':
 371             /* L -> long double */
 372             status->flags |= E_ldouble;
 373             break;
 374         default:
 375             --spec;
 376             break;
 377     }
 378
 379     /* Conversion specifier */
 380     switch ( *spec )
 381     {
 382         case 'd':
 383             /* FALLTHROUGH */
 384         case 'i':
 385             status->base = 10;
 386             break;
 387         case 'o':
 388             status->base = 8;
 389             status->flags |= E_unsigned;
 390             break;
 391         case 'u':
 392             status->base = 10;
 393             status->flags |= E_unsigned;
 394             break;
 395         case 'x':
 396             status->base = 16;
 397             status->flags |= ( E_lower | E_unsigned );
 398             break;
 399         case 'X':
 400             status->base = 16;
 401             status->flags |= E_unsigned;
 402             break;
 403         case 'f':
 404         case 'F':
 405         case 'e':
 406         case 'E':
 407         case 'g':
 408         case 'G':
 409             break;
 410         case 'a':
 411         case 'A':
 412             break;
 413         case 'c':
 414             /* TODO: wide chars. */
 415             printchar( va_arg( status->arg, int ), status );
 416             return ++spec;
 417         case 's':
 418             /* TODO: wide chars. */
 419             {
 420                 char * s = va_arg( status->arg, char * );
 421                 printstr( s, status );
 422                 return ++spec;
 423             }
 424         case 'p':
 425             /* TODO: E_long -> E_intptr */
 426             status->base = 16;
 427             status->flags |= ( E_lower | E_unsigned | E_alt | E_long );
 428             break;
 429         case 'n':
 430            {
 431                int * val = va_arg( status->arg, int * );
 432                *val = status->i;
 433                return ++spec;
 434            }
 435         default:
 436             /* No conversion specifier. Bad conversion. */
 437             return orig_spec;
 438     }
 439
 440     /* Do the actual output based on our findings */
 441     if ( status->base != 0 )
 442     {
 443         /* Integer conversions */
 444         /* TODO: Check for invalid flag combinations. */
 445         if ( status->flags & E_unsigned )
 446         {
 447             uintmax_t value;
 448             switch ( status->flags & ( E_char | E_short | E_long | E_llong | E_size ) )
 449             {
 450                 case E_char:
 451                     value = (uintmax_t)(unsigned char)va_arg( status->arg, int );
 452                     break;
 453                 case E_short:
 454                     value = (uintmax_t)(unsigned short)va_arg( status->arg, int );
 455                     break;
 456                 case 0:
 457                     value = (uintmax_t)va_arg( status->arg, unsigned int );
 458                     break;
 459                 case E_long:
 460                     value = (uintmax_t)va_arg( status->arg, unsigned long );
 461                     break;
 462                 case E_llong:
 463                     value = (uintmax_t)va_arg( status->arg, unsigned long long );
 464                     break;
 465                 case E_size:
 466                     value = (uintmax_t)va_arg( status->arg, size_t );
 467                     break;
 468             }
 469             int2base( value, status );
 470         }
 471         else
 472         {
 473             switch ( status->flags & ( E_char | E_short | E_long | E_llong | E_intmax ) )
 474             {
 475                 case E_char:
 476                     int2base( (intmax_t)(char)va_arg( status->arg, int ), status );
 477                     break;
 478                 case E_short:
 479                     int2base( (intmax_t)(short)va_arg( status->arg, int ), status );
 480                     break;
 481                 case 0:
 482                     int2base( (intmax_t)va_arg( status->arg, int ), status );
 483                     break;
 484                 case E_long:
 485                     int2base( (intmax_t)va_arg( status->arg, long ), status );
 486                     break;
 487                 case E_llong:
 488                     int2base( (intmax_t)va_arg( status->arg, long long ), status );
 489                     break;
 490                 case E_ptrdiff:
 491                     int2base( (intmax_t)va_arg( status->arg, ptrdiff_t ), status );
 492                     break;
 493                 case E_intmax:
 494                     int2base( va_arg( status->arg, intmax_t ), status );
 495                     break;
 496             }
 497         }
 498         if ( status->flags & E_minus )
 499         {
 500             while ( status->current < status->width )
 501             {
 502                 PUT( ' ' );
 503                 ++(status->current);
 504             }
 505         }
 506         if ( status->i >= status->n && status->n > 0 )
 507         {
 508             status->s[status->n - 1] = '\0';
 509         }
 510     }
 511     return ++spec;
 512 }
 513
 514 #endif
 515
 516 #ifdef TEST
 517 #define _PDCLIB_FILEID "_PDCLIB/print.c"
 518 #define _PDCLIB_STRINGIO
 519
 520 #include <_PDCLIB_test.h>
 521
 522 #ifndef REGTEST
 523 static int testprintf( char * buffer, const char * format, ... )
 524 {
 525     /* Members: base, flags, n, i, current, s, width, prec, stream, arg      */
 526     struct _PDCLIB_status_t status;
 527     status.base = 0;
 528     status.flags = 0;
 529     status.n = 100;
 530     status.i = 0;
 531     status.current = 0;
 532     status.s = buffer;
 533     status.width = 0;
 534     status.prec = 0;
 535     status.stream = NULL;
 536     va_start( status.arg, format );
 537     memset( buffer, '\0', 100 );
 538     if ( *(_PDCLIB_print( format, &status )) != '\0' )
 539     {
 540         printf( "_PDCLIB_print() did not return end-of-specifier on '%s'.\n", format );
 541         ++TEST_RESULTS;
 542     }
 543     va_end( status.arg );
 544     return status.i;
 545 }
 546 #endif
 547
 548 #define TEST_CONVERSION_ONLY
 549
 550 int main( void )
 551 {
 552 #ifndef REGTEST
 553     char target[100];
 554 #include "printf_testcases.h"
 555 #endif
 556     return TEST_RESULTS;
 557 }
 558
 559 #endif