chiark - git - mdw - disorder/blob - lib/printf.c

   1 /*
   2  * This file is part of DisOrder
   3  * Copyright (C) 2004, 2007 Richard Kettlewell
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  18  * USA
  19  */
  20
  21 #define NO_MEMORY_ALLOCATION
  22 /* because byte_snprintf used from log.c */
  23
  24 #include <config.h>
  25 #include "types.h"
  26
  27 #include <stdio.h>
  28 #include <stdarg.h>
  29 #include <string.h>
  30 #include <errno.h>
  31 #include <stdlib.h>
  32 #include <stddef.h>
  33
  34 #include "printf.h"
  35 #include "sink.h"
  36 #include "vacopy.h"
  37
  38 enum flags {
  39   f_thousands = 1,
  40   f_left = 2,
  41   f_sign = 4,
  42   f_space = 8,
  43   f_hash = 16,
  44   f_zero = 32,
  45   f_width = 256,
  46   f_precision = 512
  47 };
  48
  49 enum lengths {
  50   l_char = 1,
  51   l_short,
  52   l_long,
  53   l_longlong,
  54   l_size_t,
  55   l_intmax_t,
  56   l_ptrdiff_t,
  57   l_longdouble
  58 };
  59
  60 struct conversion;
  61
  62 struct state {
  63   struct sink *output;
  64   int bytes;
  65   va_list ap;
  66 };
  67
  68 struct specifier {
  69   int ch;
  70   int (*check)(const struct conversion *c);
  71   int (*output)(struct state *s, struct conversion *c);
  72   int base;
  73   const char *digits;
  74   const char *xform;
  75 };
  76
  77 struct conversion {
  78   unsigned flags;
  79   int width;
  80   int precision;
  81   int length;
  82   const struct specifier *specifier;
  83 };
  84
  85 static const char flags[] = "'-+ #0";
  86
  87 /* write @nbytes@ to the output.  Return -1 on error, 0 on success.
  88  * Keeps track of the number of bytes written. */
  89 static int do_write(struct state *s,
  90                     const void *buffer,
  91                     int nbytes) {
  92   if(s->bytes > INT_MAX - nbytes) {
  93 #ifdef EOVERFLOW
  94     errno = EOVERFLOW;
  95 #endif
  96     return -1;
  97   }
  98   if(s->output->write(s->output, buffer, nbytes) < 0) return -1;
  99   s->bytes += nbytes;
 100   return 0;
 101 }
 102
 103 /* write character @ch@ @n@ times, reasonably efficiently */
 104 static int do_pad(struct state *s, int ch, unsigned n) {
 105   unsigned t;
 106   const char *padding;
 107
 108   switch(ch) {
 109   case ' ': padding = "                                "; break;
 110   case '0': padding = "00000000000000000000000000000000"; break;
 111   default: abort();
 112   }
 113   t = n / 32;
 114   n %= 32;
 115   while(t-- > 0)
 116     if(do_write(s, padding, 32) < 0) return -1;
 117   if(n > 0)
 118     if(do_write(s, padding, n) < 0) return -1;
 119   return 0;
 120 }
 121
 122 /* pick up the integer at @ptr@, returning it via @intp@.  Return the
 123  * number of characters consumed.  Return 0 if there is no integer
 124  * there and -1 if an error occurred (e.g. too big) */
 125 static int get_integer(int *intp, const char *ptr) {
 126   long n;
 127   char *e;
 128
 129   errno = 0;
 130   n = strtol(ptr, &e, 10);
 131   if(errno || n > INT_MAX || n < INT_MIN || e == ptr) return -1;
 132   *intp = n;
 133   return e - ptr;
 134 }
 135
 136 /* consistency checks for various conversion specifications */
 137
 138 static int check_integer(const struct conversion *c) {
 139   switch(c->length) {
 140   case 0:
 141   case l_char:
 142   case l_short:
 143   case l_long:
 144   case l_longlong:
 145   case l_intmax_t:
 146   case l_size_t:
 147   case l_longdouble:
 148     return 0;
 149   default:
 150     return -1;
 151   }
 152 }
 153
 154 static int check_string(const struct conversion *c) {
 155   switch(c->length) {
 156   case 0:
 157     /* XXX don't support %ls, %lc */
 158     return 0;
 159   default:
 160     return -1;
 161   }
 162 }
 163
 164 static int check_pointer(const struct conversion *c) {
 165   if(c->length) return -1;
 166   return 0;
 167 }
 168
 169 static int check_percent(const struct conversion *c) {
 170   if(c->flags || c->width || c->precision || c->length) return -1;
 171   return 0;
 172 }
 173
 174 /* output functions for various conversion specifications */
 175
 176 static int output_percent(struct state *s,
 177                           struct conversion attribute((unused)) *c) {
 178   return do_write(s, "%", 1);
 179 }
 180
 181 static int output_integer(struct state *s, struct conversion *c) {
 182   uintmax_t u;
 183   intmax_t l;
 184   char sign;
 185   int base, dp, iszero, ndigits, prec, xform, sign_bytes, pad;
 186   char digits[CHAR_BIT * sizeof (uintmax_t)]; /* overestimate */
 187
 188   switch(c->specifier->ch) {
 189   default:
 190     if(c->specifier->base < 0) {
 191       switch(c->length) {
 192       case 0: l = va_arg(s->ap, int); break;
 193       case l_char: l = (signed char)va_arg(s->ap, int); break;
 194       case l_short: l = (short)va_arg(s->ap, int); break;
 195       case l_long: l = va_arg(s->ap, long); break;
 196       case l_longlong: l = va_arg(s->ap, long_long); break;
 197       case l_intmax_t: l = va_arg(s->ap, intmax_t); break;
 198       case l_size_t: l = va_arg(s->ap, ssize_t); break;
 199       case l_ptrdiff_t: l = va_arg(s->ap, ptrdiff_t); break;
 200       default: abort();
 201       }
 202       base = -c->specifier->base;
 203       if(l < 0) {
 204         u = -l;
 205         sign = '-';
 206       } else {
 207         u = l;
 208         sign = 0;
 209       }
 210     } else {
 211       switch(c->length) {
 212       case 0: u = va_arg(s->ap, unsigned int); break;
 213       case l_char: u = (unsigned char)va_arg(s->ap, unsigned int); break;
 214       case l_short: u = (unsigned short)va_arg(s->ap, unsigned int); break;
 215       case l_long: u = va_arg(s->ap, unsigned long); break;
 216       case l_longlong: u = va_arg(s->ap, u_long_long); break;
 217       case l_intmax_t: u = va_arg(s->ap, uintmax_t); break;
 218       case l_size_t: u = va_arg(s->ap, size_t); break;
 219       case l_ptrdiff_t: u = va_arg(s->ap, ptrdiff_t); break;
 220       default: abort();
 221       }
 222       base = c->specifier->base;
 223       sign = 0;
 224     }
 225     break;
 226   case 'p':
 227     u = (uintptr_t)va_arg(s->ap, void *);
 228     c->flags |= f_hash;
 229     base = c->specifier->base;
 230     sign = 0;
 231     break;
 232   }
 233   /* default precision */
 234   if(!(c->flags & f_precision))
 235     c->precision = 1;
 236   /* enforce sign */
 237   if((c->flags & f_sign) && !sign) sign = '+';
 238   /* compute the digits */
 239   iszero = (u == 0);
 240   dp = sizeof digits;
 241   while(u) {
 242     digits[--dp] = c->specifier->digits[u % base];
 243     u /= base;
 244   }
 245   ndigits = sizeof digits - dp;
 246   /* alternative form */
 247   if(c->flags & f_hash) {
 248     switch(base) {
 249     case 8:
 250       if((dp == sizeof digits || digits[dp] != '0')
 251          && c->precision <= ndigits)
 252         c->precision = ndigits + 1;
 253       break;
 254     }
 255     if(!iszero && c->specifier->xform)
 256       xform = strlen(c->specifier->xform);
 257     else
 258       xform = 0;
 259   } else
 260     xform = 0;
 261   /* calculate number of 0s to add for precision */
 262   if(ndigits < c->precision)
 263     prec = c->precision - ndigits;
 264   else
 265     prec = 0;
 266   /* bytes occupied by the sign */
 267   if(sign)
 268     sign_bytes = 1;
 269   else
 270     sign_bytes = 0;
 271   /* XXX implement the ' ' flag */
 272   /* calculate number of bytes of padding */
 273   if(c->flags & f_width) {
 274     if((pad = c->width - (ndigits + prec + xform + sign_bytes)) < 0)
 275       pad = 0;
 276   } else
 277     pad = 0;
 278   /* now we are ready to output.  Possibilities are:
 279    * [space pad][sign][xform][0 prec]digits
 280    * [sign][xform][0 pad][0 prec]digits
 281    * [sign][xform][0 prec]digits[space pad]
 282    *
 283    * '-' beats '0'.
 284    */
 285   if(c->flags & f_left) {
 286     if(pad && do_pad(s, ' ', pad) < 0) return -1;
 287     if(sign && do_write(s, &sign, 1)) return -1;
 288     if(xform && do_write(s, c->specifier->xform, xform)) return -1;
 289     if(prec && do_pad(s, '0', prec) < 0) return -1;
 290     if(ndigits && do_write(s, digits + dp, ndigits)) return -1;
 291   } else if(c->flags & f_zero) {
 292     if(sign && do_write(s, &sign, 1)) return -1;
 293     if(xform && do_write(s, c->specifier->xform, xform)) return -1;
 294     if(pad && do_pad(s, '0', pad) < 0) return -1;
 295     if(prec && do_pad(s, '0', prec) < 0) return -1;
 296     if(ndigits && do_write(s, digits + dp, ndigits)) return -1;
 297   } else {
 298     if(sign && do_write(s, &sign, 1)) return -1;
 299     if(xform && do_write(s, c->specifier->xform, xform)) return -1;
 300     if(prec && do_pad(s, '0', prec) < 0) return -1;
 301     if(ndigits && do_write(s, digits + dp, ndigits)) return -1;
 302     if(pad && do_pad(s, ' ', pad) < 0) return -1;
 303   }
 304   return 0;
 305 }
 306
 307 static int output_string(struct state *s, struct conversion *c) {
 308   const char *str, *n;
 309   int pad, len;
 310
 311   str = va_arg(s->ap, const char *);
 312   if(c->flags & f_precision) {
 313     if((n = memchr(str, 0, c->precision)))
 314       len = n - str;
 315     else
 316       len = c->precision;
 317   } else
 318     len = strlen(str);
 319   if(c->flags & f_width) {
 320     if((pad = c->width - len) < 0)
 321       pad = 0;
 322   } else
 323     pad = 0;
 324   if(c->flags & f_left) {
 325     if(pad && do_pad(s, ' ', pad) < 0) return -1;
 326     if(do_write(s, str, len) < 0) return -1;
 327   } else {
 328     if(do_write(s, str, len) < 0) return -1;
 329     if(pad && do_pad(s, ' ', pad) < 0) return -1;
 330   }
 331   return 0;
 332
 333 }
 334
 335 static int output_char(struct state *s, struct conversion *c) {
 336   int pad;
 337   char ch;
 338
 339   ch = va_arg(s->ap, int);
 340   if(c->flags & f_width) {
 341     if((pad = c->width - 1) < 0)
 342       pad = 0;
 343   } else
 344     pad = 0;
 345   if(c->flags & f_left) {
 346     if(pad && do_pad(s, ' ', pad) < 0) return -1;
 347     if(do_write(s, &ch, 1) < 0) return -1;
 348   } else {
 349     if(do_write(s, &ch, 1) < 0) return -1;
 350     if(pad && do_pad(s, ' ', pad) < 0) return -1;
 351   }
 352   return 0;
 353 }
 354
 355 static int output_count(struct state *s, struct conversion *c) {
 356   switch(c->length) {
 357   case 0: *va_arg(s->ap, int *) = s->bytes; break;
 358   case l_char: *va_arg(s->ap, signed char *) = s->bytes; break;
 359   case l_short: *va_arg(s->ap, short *) = s->bytes; break;
 360   case l_long: *va_arg(s->ap, long *) = s->bytes; break;
 361   case l_longlong: *va_arg(s->ap, long_long *) = s->bytes; break;
 362   case l_intmax_t: *va_arg(s->ap, intmax_t *) = s->bytes; break;
 363   case l_size_t: *va_arg(s->ap, ssize_t *) = s->bytes; break;
 364   case l_ptrdiff_t: *va_arg(s->ap, ptrdiff_t *) = s->bytes; break;
 365   default: abort();
 366   }
 367   return 0;
 368 }
 369
 370 /* table of conversion specifiers */
 371 static const struct specifier specifiers[] = {
 372   /* XXX don't support floating point conversions */
 373   { '%', check_percent, output_percent,  0,  0,                  0    },
 374   { 'X', check_integer, output_integer,  16, "0123456789ABCDEF", "0X" },
 375   { 'c', check_string,  output_char,     0,  0,                  0    },
 376   { 'd', check_integer, output_integer, -10, "0123456789",       0    },
 377   { 'i', check_integer, output_integer, -10, "0123456789",       0    },
 378   { 'n', check_integer, output_count,    0,  0,                  0    },
 379   { 'o', check_integer, output_integer,  8,  "01234567",         0    },
 380   { 'p', check_pointer, output_integer,  16, "0123456789abcdef", "0x" },
 381   { 's', check_string,  output_string,   0,  0,                  0    },
 382   { 'u', check_integer, output_integer,  10, "0123456789",       0    },
 383   { 'x', check_integer, output_integer,  16, "0123456789abcdef", "0x" },
 384 };
 385
 386 /* collect and check information about a conversion specification */
 387 static int parse_conversion(struct conversion *c, const char *ptr) {
 388   int n, ch, l, r, m;
 389   const char *q, *start = ptr;
 390
 391   memset(c, 0, sizeof *c);
 392   /* flags */
 393   while(*ptr && (q = strchr(flags, *ptr))) {
 394     c->flags |= (1 << (q - flags));
 395     ++ptr;
 396   }
 397   /* minimum field width */
 398   if(*ptr >= '0' && *ptr <= '9') {
 399     if((n = get_integer(&c->width, ptr)) < 0) return -1;
 400     ptr += n;
 401     c->flags |= f_width;
 402   } else if(*ptr == '*') {
 403     ++ptr;
 404     c->width = -1;
 405     c->flags |= f_width;
 406   }
 407   /* precision */
 408   if(*ptr == '.') {
 409     ++ptr;
 410     if(*ptr >= '0' && *ptr <= '9') {
 411       if((n = get_integer(&c->precision, ptr)) < 0) return -1;
 412       ptr += n;
 413     } else if(*ptr == '*') {
 414       ++ptr;
 415       c->precision = -1;
 416     } else
 417       return -1;
 418     c->flags |= f_precision;
 419   }
 420   /* length modifier */
 421   switch(ch = *ptr++) {
 422   case 'h':
 423     if((ch = *ptr++) == 'h') { c->length = l_char; ch = *ptr++; }
 424     else c->length = l_short;
 425     break;
 426   case 'l':
 427     if((ch = *ptr++) == 'l') { c->length = l_longlong; ch = *ptr++; }
 428     else c->length = l_long;
 429     break;
 430   case 'q': c->length = l_longlong; ch = *ptr++; break;
 431   case 'j': c->length = l_intmax_t; ch = *ptr++; break;
 432   case 'z': c->length = l_size_t; ch = *ptr++; break;
 433   case 't': c->length = l_ptrdiff_t; ch = *ptr++; break;
 434   case 'L': c->length = l_longdouble; ch = *ptr++; break;
 435   }
 436   /* conversion specifier */
 437   l = 0;
 438   r = sizeof specifiers / sizeof *specifiers;
 439   while(l <= r && (specifiers[m = (l + r) / 2].ch != ch))
 440     if(ch < specifiers[m].ch) r = m - 1;
 441     else l = m + 1;
 442   if(specifiers[m].ch != ch) return -1;
 443   if(specifiers[m].check(c)) return -1;
 444   c->specifier = &specifiers[m];
 445   return ptr - start;
 446 }
 447
 448 /* ISO/IEC 9899:1999 7.19.6.1 */
 449 /* http://www.opengroup.org/onlinepubs/009695399/functions/fprintf.html */
 450
 451 int byte_vsinkprintf(struct sink *output,
 452                      const char *fmt,
 453                      va_list ap) {
 454   int n;
 455   const char *ptr;
 456   struct state s;
 457   struct conversion c;
 458
 459   memset(&s, 0, sizeof s);
 460   s.output = output;
 461   va_copy(s.ap,ap);
 462   while(*fmt) {
 463     /* output text up to next conversion specification */
 464     for(ptr = fmt; *fmt && *fmt != '%'; ++fmt)
 465       ;
 466     if((n = fmt - ptr))
 467       if(do_write(&s, ptr, n) < 0) goto error;
 468     if(!*fmt)
 469       break;
 470     ++fmt;
 471     /* parse conversion */
 472     if((n = parse_conversion(&c, fmt)) < 0) goto error;
 473     fmt += n;
 474     /* fill in width and precision */
 475     if((c.flags & f_width) && c.width == -1)
 476       if((c.width = va_arg(s.ap, int)) < 0) {
 477         c.width = -c.width;
 478         c.flags |= f_left;
 479       }
 480     if((c.flags & f_precision) && c.precision == -1)
 481       if((c.precision = va_arg(s.ap, int)) < 0)
 482         c.flags ^= f_precision;
 483     /* generate the output */
 484     if(c.specifier->output(&s, &c) < 0) goto error;
 485   }
 486   va_end(s.ap);
 487   return s.bytes;
 488 error:
 489   va_end(s.ap);
 490   return -1;
 491 }
 492
 493 /*
 494 Local Variables:
 495 c-basic-offset:2
 496 comment-column:40
 497 End:
 498 */