contrib/tcsh-6/tc.printf.c

   1 /* $Header: /p/tcsh/cvsroot/tcsh/tc.printf.c,v 3.35 2006/03/02 18:46:45 christos Exp $ */
   2 /*
   3  * tc.printf.c: A public-domain, minimal printf/sprintf routine that prints
   4  *             through the putchar() routine.  Feel free to use for
   5  *             anything...  -- 7/17/87 Paul Placeway
   6  */
   7 /*-
   8  * Copyright (c) 1980, 1991 The Regents of the University of California.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35 #include "sh.h"
  36
  37 RCSID("$tcsh: tc.printf.c,v 3.35 2006/03/02 18:46:45 christos Exp $")
  38
  39 #ifdef lint
  40 #undef va_arg
  41 #define va_arg(a, b) (a ? (b) 0 : (b) 0)
  42 #endif
  43
  44 #define INF     INT_MAX         /* should be bigger than any field to print */
  45
  46 static char snil[] = "(nil)";
  47
  48 static  void    xaddchar        (int);
  49 static  void    doprnt          (void (*) (int), const char *, va_list);
  50
  51 static void
  52 doprnt(void (*addchar) (int), const char *sfmt, va_list ap)
  53 {
  54     char *bp;
  55     const char *f;
  56 #ifdef SHORT_STRINGS
  57     const Char *Bp;
  58 #endif /* SHORT_STRINGS */
  59 #ifdef HAVE_LONG_LONG
  60     long long l;
  61     unsigned long long u;
  62 #else
  63     long l;
  64     unsigned long u;
  65 #endif
  66     char buf[(CHAR_BIT * sizeof (l) + 2) / 3 + 1]; /* Octal: 3 bits per char */
  67     int i;
  68     int fmt;
  69     unsigned char pad = ' ';
  70     int     flush_left = 0, f_width = 0, prec = INF, hash = 0;
  71     int     do_long = 0, do_size_t = 0;
  72     int     sign = 0;
  73     int     attributes = 0;
  74
  75
  76     f = sfmt;
  77     for (; *f; f++) {
  78         if (*f != '%') {        /* then just out the char */
  79             (*addchar) (((unsigned char)*f) | attributes);
  80         }
  81         else {
  82             f++;                /* skip the % */
  83
  84             if (*f == '-') {    /* minus: flush left */
  85                 flush_left = 1;
  86                 f++;
  87             }
  88
  89             if (*f == '0' || *f == '.') {
  90                 /* padding with 0 rather than blank */
  91                 pad = '0';
  92                 f++;
  93             }
  94             if (*f == '*') {    /* field width */
  95                 f_width = va_arg(ap, int);
  96                 f++;
  97             }
  98             else if (isdigit((unsigned char) *f)) {
  99                 f_width = atoi(f);
 100                 while (isdigit((unsigned char) *f))
 101                     f++;        /* skip the digits */
 102             }
 103
 104             if (*f == '.') {    /* precision */
 105                 f++;
 106                 if (*f == '*') {
 107                     prec = va_arg(ap, int);
 108                     f++;
 109                 }
 110                 else if (isdigit((unsigned char) *f)) {
 111                     prec = atoi(f);
 112                     while (isdigit((unsigned char) *f))
 113                         f++;    /* skip the digits */
 114                 }
 115             }
 116
 117             if (*f == '#') {    /* alternate form */
 118                 hash = 1;
 119                 f++;
 120             }
 121
 122             if (*f == 'l') {    /* long format */
 123                 do_long++;
 124                 f++;
 125                 if (*f == 'l') {
 126                     do_long++;
 127                     f++;
 128                 }
 129             }
 130             if (*f == 'z') {    /* size_t format */
 131                 do_size_t++;
 132                 f++;
 133             }
 134
 135             fmt = (unsigned char) *f;
 136             if (fmt != 'S' && fmt != 'Q' && isupper(fmt)) {
 137                 do_long = 1;
 138                 fmt = tolower(fmt);
 139             }
 140             bp = buf;
 141             switch (fmt) {      /* do the format */
 142             case 'd':
 143                 switch (do_long) {
 144                 case 0:
 145                     if (do_size_t)
 146                         l = (long) (va_arg(ap, size_t));
 147                     else
 148                         l = (long) (va_arg(ap, int));
 149                     break;
 150                 case 1:
 151 #ifndef HAVE_LONG_LONG
 152                 default:
 153 #endif
 154                     l = va_arg(ap, long);
 155                     break;
 156 #ifdef HAVE_LONG_LONG
 157                 default:
 158                     l = va_arg(ap, long long);
 159                     break;
 160 #endif
 161                 }
 162
 163                 if (l < 0) {
 164                     sign = 1;
 165                     l = -l;
 166                 }
 167                 do {
 168                     *bp++ = (char) (l % 10) + '0';
 169                 } while ((l /= 10) > 0);
 170                 if (sign)
 171                     *bp++ = '-';
 172                 f_width = f_width - (int) (bp - buf);
 173                 if (!flush_left)
 174                     while (f_width-- > 0)
 175                         (*addchar) (pad | attributes);
 176                 for (bp--; bp >= buf; bp--)
 177                     (*addchar) (((unsigned char) *bp) | attributes);
 178                 if (flush_left)
 179                     while (f_width-- > 0)
 180                         (*addchar) (' ' | attributes);
 181                 break;
 182
 183             case 'p':
 184                 do_long = 1;
 185                 hash = 1;
 186                 fmt = 'x';
 187                 /*FALLTHROUGH*/
 188             case 'o':
 189             case 'x':
 190             case 'u':
 191                 switch (do_long) {
 192                 case 0:
 193                     if (do_size_t)
 194                         u = va_arg(ap, size_t);
 195                     else
 196                         u = va_arg(ap, unsigned int);
 197                     break;
 198                 case 1:
 199 #ifndef HAVE_LONG_LONG
 200                 default:
 201 #endif
 202                     u = va_arg(ap, unsigned long);
 203                     break;
 204 #ifdef HAVE_LONG_LONG
 205                 default:
 206                     u = va_arg(ap, unsigned long long);
 207                     break;
 208 #endif
 209                 }
 210                 if (fmt == 'u') {       /* unsigned decimal */
 211                     do {
 212                         *bp++ = (char) (u % 10) + '0';
 213                     } while ((u /= 10) > 0);
 214                 }
 215                 else if (fmt == 'o') {  /* octal */
 216                     do {
 217                         *bp++ = (char) (u % 8) + '0';
 218                     } while ((u /= 8) > 0);
 219                     if (hash)
 220                         *bp++ = '0';
 221                 }
 222                 else if (fmt == 'x') {  /* hex */
 223                     do {
 224                         i = (int) (u % 16);
 225                         if (i < 10)
 226                             *bp++ = i + '0';
 227                         else
 228                             *bp++ = i - 10 + 'a';
 229                     } while ((u /= 16) > 0);
 230                     if (hash) {
 231                         *bp++ = 'x';
 232                         *bp++ = '0';
 233                     }
 234                 }
 235                 i = f_width - (int) (bp - buf);
 236                 if (!flush_left)
 237                     while (i-- > 0)
 238                         (*addchar) (pad | attributes);
 239                 for (bp--; bp >= buf; bp--)
 240                     (*addchar) (((unsigned char) *bp) | attributes);
 241                 if (flush_left)
 242                     while (i-- > 0)
 243                         (*addchar) (' ' | attributes);
 244                 break;
 245
 246
 247             case 'c':
 248                 i = va_arg(ap, int);
 249                 (*addchar) (i | attributes);
 250                 break;
 251
 252             case 'S':
 253             case 'Q':
 254 #ifdef SHORT_STRINGS
 255                 Bp = va_arg(ap, Char *);
 256                 if (!Bp) {
 257                     bp = NULL;
 258                     goto lcase_s;
 259                 }
 260                 f_width = f_width - Strlen(Bp);
 261                 if (!flush_left)
 262                     while (f_width-- > 0)
 263                         (*addchar) ((int) (pad | attributes));
 264                 for (i = 0; *Bp && i < prec; i++) {
 265                     char cbuf[MB_LEN_MAX];
 266                     size_t pos, len;
 267
 268                     if (fmt == 'Q' && *Bp & QUOTE)
 269                         (*addchar) ('\\' | attributes);
 270                     len = one_wctomb(cbuf, *Bp & CHAR);
 271                     for (pos = 0; pos < len; pos++)
 272                         (*addchar) ((unsigned char)cbuf[pos] | attributes
 273                                     | (*Bp & ATTRIBUTES));
 274                     Bp++;
 275                 }
 276                 if (flush_left)
 277                     while (f_width-- > 0)
 278                         (*addchar) (' ' | attributes);
 279                 break;
 280 #endif /* SHORT_STRINGS */
 281
 282             case 's':
 283             case 'q':
 284                 bp = va_arg(ap, char *);
 285 lcase_s:
 286                 if (!bp)
 287                     bp = snil;
 288                 f_width = f_width - strlen(bp);
 289                 if (!flush_left)
 290                     while (f_width-- > 0)
 291                         (*addchar) (pad | attributes);
 292                 for (i = 0; *bp && i < prec; i++) {
 293                     if (fmt == 'q' && *bp & QUOTE)
 294                         (*addchar) ('\\' | attributes);
 295                     (*addchar) (((unsigned char) *bp & TRIM) | attributes);
 296                     bp++;
 297                 }
 298                 if (flush_left)
 299                     while (f_width-- > 0)
 300                         (*addchar) (' ' | attributes);
 301                 break;
 302
 303             case 'a':
 304                 attributes = va_arg(ap, int);
 305                 break;
 306
 307             case '%':
 308                 (*addchar) ('%' | attributes);
 309                 break;
 310
 311             default:
 312                 break;
 313             }
 314             flush_left = 0, f_width = 0, prec = INF, hash = 0;
 315             do_size_t = 0, do_long = 0;
 316             sign = 0;
 317             pad = ' ';
 318         }
 319     }
 320 }
 321
 322
 323 static char *xstring, *xestring;
 324 static void
 325 xaddchar(int c)
 326 {
 327     if (xestring == xstring)
 328         *xstring = '\0';
 329     else
 330         *xstring++ = (char) c;
 331 }
 332
 333
 334 pret_t
 335 /*VARARGS*/
 336 xsnprintf(char *str, size_t size, const char *fmt, ...)
 337 {
 338     va_list va;
 339     va_start(va, fmt);
 340
 341     xstring = str;
 342     xestring = str + size - 1;
 343     doprnt(xaddchar, fmt, va);
 344     va_end(va);
 345     *xstring++ = '\0';
 346 #ifdef PURIFY
 347     return 1;
 348 #endif
 349 }
 350
 351 pret_t
 352 /*VARARGS*/
 353 xprintf(const char *fmt, ...)
 354 {
 355     va_list va;
 356     va_start(va, fmt);
 357     doprnt(xputchar, fmt, va);
 358     va_end(va);
 359 #ifdef PURIFY
 360     return 1;
 361 #endif
 362 }
 363
 364
 365 pret_t
 366 xvprintf(const char *fmt, va_list va)
 367 {
 368     doprnt(xputchar, fmt, va);
 369 #ifdef PURIFY
 370     return 1;
 371 #endif
 372 }
 373
 374 pret_t
 375 xvsnprintf(char *str, size_t size, const char *fmt, va_list va)
 376 {
 377     xstring = str;
 378     xestring = str + size - 1;
 379     doprnt(xaddchar, fmt, va);
 380     *xstring++ = '\0';
 381 #ifdef PURIFY
 382     return 1;
 383 #endif
 384 }
 385
 386 char *
 387 xvasprintf(const char *fmt, va_list va)
 388 {
 389     size_t size;
 390     char *buf;
 391
 392     buf = NULL;
 393     size = 2048; /* Arbitrary */
 394     for (;;) {
 395         va_list copy;
 396
 397         buf = xrealloc(buf, size);
 398         xstring = buf;
 399         xestring = buf + size - 1;
 400         va_copy(copy, va);
 401         doprnt(xaddchar, fmt, copy);
 402         va_end(copy);
 403         if (xstring < xestring)
 404             break;
 405         size *= 2;
 406     }
 407     *xstring++ = '\0';
 408     return xrealloc(buf, xstring - buf);
 409 }
 410
 411 char *
 412 xasprintf(const char *fmt, ...)
 413 {
 414     va_list va;
 415     char *ret;
 416
 417     va_start (va, fmt);
 418     ret = xvasprintf(fmt, va);
 419     va_end(va);
 420     return ret;
 421 }
 422
 423
 424 #ifdef PURIFY
 425 /* Purify uses (some of..) the following functions to output memory-use
 426  * debugging info.  Given all the messing with file descriptors that
 427  * tcsh does, the easiest way I could think of to get it (Purify) to
 428  * print anything was by replacing some standard functions with
 429  * ones that do tcsh output directly - see dumb hook in doreaddirs()
 430  * (sh.dir.c) -sg
 431  */
 432 #ifndef FILE
 433 #define FILE int
 434 #endif
 435 int
 436 fprintf(FILE *fp, const char* fmt, ...)
 437 {
 438     va_list va;
 439     va_start(va, fmt);
 440     doprnt(xputchar, fmt, va);
 441     va_end(va);
 442     return 1;
 443 }
 444
 445 int
 446 vfprintf(FILE *fp, const char *fmt, va_list va)
 447 {
 448     doprnt(xputchar, fmt, va);
 449     return 1;
 450 }
 451
 452 #endif  /* PURIFY */