1 /* $Header: /src/pub/tcsh/tc.printf.c,v 3.27 2005/01/05 16:06:15 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("$Id: tc.printf.c,v 3.27 2005/01/05 16:06:15 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 32766 /* should be bigger than any field to print */ 45 46 static char buf[128]; 47 static char snil[] = "(nil)"; 48 49 static void xaddchar __P((int)); 50 static void doprnt __P((void (*) __P((int)), const char *, va_list)); 51 52 static void 53 doprnt(addchar, sfmt, ap) 54 void (*addchar) __P((int)); 55 const char *sfmt; 56 va_list ap; 57 { 58 char *bp; 59 const char *f; 60 #ifdef SHORT_STRINGS 61 Char *Bp; 62 #endif /* SHORT_STRINGS */ 63 #ifdef HAVE_LONG_LONG 64 long long l; 65 unsigned long long u; 66 #else 67 long l; 68 unsigned long u; 69 #endif 70 int i; 71 int fmt; 72 unsigned char pad = ' '; 73 int flush_left = 0, f_width = 0, prec = INF, hash = 0, do_long = 0; 74 int sign = 0; 75 int attributes = 0; 76 77 78 f = sfmt; 79 for (; *f; f++) { 80 if (*f != '%') { /* then just out the char */ 81 (*addchar) ((int) (((unsigned char)*f) | attributes)); 82 } 83 else { 84 f++; /* skip the % */ 85 86 if (*f == '-') { /* minus: flush left */ 87 flush_left = 1; 88 f++; 89 } 90 91 if (*f == '0' || *f == '.') { 92 /* padding with 0 rather than blank */ 93 pad = '0'; 94 f++; 95 } 96 if (*f == '*') { /* field width */ 97 f_width = va_arg(ap, int); 98 f++; 99 } 100 else if (isdigit((unsigned char) *f)) { 101 f_width = atoi(f); 102 while (isdigit((unsigned char) *f)) 103 f++; /* skip the digits */ 104 } 105 106 if (*f == '.') { /* precision */ 107 f++; 108 if (*f == '*') { 109 prec = va_arg(ap, int); 110 f++; 111 } 112 else if (isdigit((unsigned char) *f)) { 113 prec = atoi(f); 114 while (isdigit((unsigned char) *f)) 115 f++; /* skip the digits */ 116 } 117 } 118 119 if (*f == '#') { /* alternate form */ 120 hash = 1; 121 f++; 122 } 123 124 if (*f == 'l') { /* long format */ 125 do_long++; 126 f++; 127 if (*f == 'l') { 128 do_long++; 129 f++; 130 } 131 } 132 133 fmt = (unsigned char) *f; 134 if (fmt != 'S' && fmt != 'Q' && isupper(fmt)) { 135 do_long = 1; 136 fmt = tolower(fmt); 137 } 138 bp = buf; 139 switch (fmt) { /* do the format */ 140 case 'd': 141 switch (do_long) { 142 case 0: 143 l = (long) (va_arg(ap, int)); 144 break; 145 case 1: 146 #ifndef HAVE_LONG_LONG 147 default: 148 #endif 149 l = va_arg(ap, long); 150 break; 151 #ifdef HAVE_LONG_LONG 152 default: 153 l = va_arg(ap, long long); 154 break; 155 #endif 156 } 157 158 if (l < 0) { 159 sign = 1; 160 l = -l; 161 } 162 do { 163 *bp++ = (char) (l % 10) + '0'; 164 } while ((l /= 10) > 0); 165 if (sign) 166 *bp++ = '-'; 167 f_width = f_width - (int) (bp - buf); 168 if (!flush_left) 169 while (f_width-- > 0) 170 (*addchar) ((int) (pad | attributes)); 171 for (bp--; bp >= buf; bp--) 172 (*addchar) ((int) (((unsigned char) *bp) | attributes)); 173 if (flush_left) 174 while (f_width-- > 0) 175 (*addchar) ((int) (' ' | attributes)); 176 break; 177 178 case 'p': 179 do_long = 1; 180 hash = 1; 181 fmt = 'x'; 182 /*FALLTHROUGH*/ 183 case 'o': 184 case 'x': 185 case 'u': 186 switch (do_long) { 187 case 0: 188 u = (unsigned long) (va_arg(ap, unsigned int)); 189 break; 190 case 1: 191 #ifndef HAVE_LONG_LONG 192 default: 193 #endif 194 u = va_arg(ap, unsigned long); 195 break; 196 #ifdef HAVE_LONG_LONG 197 default: 198 u = va_arg(ap, unsigned long long); 199 break; 200 #endif 201 } 202 if (fmt == 'u') { /* unsigned decimal */ 203 do { 204 *bp++ = (char) (u % 10) + '0'; 205 } while ((u /= 10) > 0); 206 } 207 else if (fmt == 'o') { /* octal */ 208 do { 209 *bp++ = (char) (u % 8) + '0'; 210 } while ((u /= 8) > 0); 211 if (hash) 212 *bp++ = '0'; 213 } 214 else if (fmt == 'x') { /* hex */ 215 do { 216 i = (int) (u % 16); 217 if (i < 10) 218 *bp++ = i + '0'; 219 else 220 *bp++ = i - 10 + 'a'; 221 } while ((u /= 16) > 0); 222 if (hash) { 223 *bp++ = 'x'; 224 *bp++ = '0'; 225 } 226 } 227 i = f_width - (int) (bp - buf); 228 if (!flush_left) 229 while (i-- > 0) 230 (*addchar) ((int) (pad | attributes)); 231 for (bp--; bp >= buf; bp--) 232 (*addchar) ((int) (((unsigned char) *bp) | attributes)); 233 if (flush_left) 234 while (i-- > 0) 235 (*addchar) ((int) (' ' | attributes)); 236 break; 237 238 239 case 'c': 240 i = va_arg(ap, int); 241 (*addchar) ((int) (i | attributes)); 242 break; 243 244 case 'S': 245 case 'Q': 246 #ifdef SHORT_STRINGS 247 Bp = va_arg(ap, Char *); 248 if (!Bp) { 249 bp = NULL; 250 goto lcase_s; 251 } 252 f_width = f_width - Strlen(Bp); 253 if (!flush_left) 254 while (f_width-- > 0) 255 (*addchar) ((int) (pad | attributes)); 256 for (i = 0; *Bp && i < prec; i++) { 257 char cbuf[MB_LEN_MAX]; 258 size_t pos, len; 259 260 if (fmt == 'Q' && *Bp & QUOTE) 261 (*addchar) ((int) ('\\' | attributes)); 262 len = one_wctomb(cbuf, *Bp & CHAR); 263 for (pos = 0; pos < len; pos++) 264 (*addchar) ((int) ((unsigned char)cbuf[pos] 265 | attributes | (*Bp & ATTRIBUTES))); 266 Bp++; 267 } 268 if (flush_left) 269 while (f_width-- > 0) 270 (*addchar) ((int) (' ' | attributes)); 271 break; 272 #endif /* SHORT_STRINGS */ 273 274 case 's': 275 case 'q': 276 bp = va_arg(ap, char *); 277 lcase_s: 278 if (!bp) 279 bp = snil; 280 f_width = f_width - strlen((char *) bp); 281 if (!flush_left) 282 while (f_width-- > 0) 283 (*addchar) ((int) (pad | attributes)); 284 for (i = 0; *bp && i < prec; i++) { 285 if (fmt == 'q' && *bp & QUOTE) 286 (*addchar) ((int) ('\\' | attributes)); 287 (*addchar) ((int) (((unsigned char) *bp & TRIM) | 288 attributes)); 289 bp++; 290 } 291 if (flush_left) 292 while (f_width-- > 0) 293 (*addchar) ((int) (' ' | attributes)); 294 break; 295 296 case 'a': 297 attributes = va_arg(ap, int); 298 break; 299 300 case '%': 301 (*addchar) ((int) ('%' | attributes)); 302 break; 303 304 default: 305 break; 306 } 307 flush_left = 0, f_width = 0, prec = INF, hash = 0, do_long = 0; 308 sign = 0; 309 pad = ' '; 310 } 311 } 312 } 313 314 315 static char *xstring, *xestring; 316 static void 317 xaddchar(c) 318 int c; 319 { 320 if (xestring == xstring) 321 *xstring = '\0'; 322 else 323 *xstring++ = (char) c; 324 } 325 326 327 pret_t 328 /*VARARGS*/ 329 #ifdef PROTOTYPES 330 xsnprintf(char *str, size_t size, const char *fmt, ...) 331 #else 332 xsnprintf(va_alist) 333 va_dcl 334 #endif 335 { 336 va_list va; 337 #ifdef PROTOTYPES 338 va_start(va, fmt); 339 #else 340 char *str, *fmt; 341 size_t size; 342 343 va_start(va); 344 str = va_arg(va, char *); 345 size = va_arg(va, size_t); 346 fmt = va_arg(va, char *); 347 #endif 348 349 xstring = str; 350 xestring = str + size - 1; 351 doprnt(xaddchar, fmt, va); 352 va_end(va); 353 *xstring++ = '\0'; 354 #ifdef PURIFY 355 return 1; 356 #endif 357 } 358 359 pret_t 360 /*VARARGS*/ 361 #ifdef PROTOTYPES 362 xprintf(const char *fmt, ...) 363 #else 364 xprintf(va_alist) 365 va_dcl 366 #endif 367 { 368 va_list va; 369 #ifdef PROTOTYPES 370 va_start(va, fmt); 371 #else 372 char *fmt; 373 374 va_start(va); 375 fmt = va_arg(va, char *); 376 #endif 377 doprnt(xputchar, fmt, va); 378 va_end(va); 379 #ifdef PURIFY 380 return 1; 381 #endif 382 } 383 384 385 pret_t 386 xvprintf(fmt, va) 387 const char *fmt; 388 va_list va; 389 { 390 doprnt(xputchar, fmt, va); 391 #ifdef PURIFY 392 return 1; 393 #endif 394 } 395 396 pret_t 397 xvsnprintf(str, size, fmt, va) 398 char *str; 399 size_t size; 400 const char *fmt; 401 va_list va; 402 { 403 xstring = str; 404 xestring = str + size - 1; 405 doprnt(xaddchar, fmt, va); 406 *xstring++ = '\0'; 407 #ifdef PURIFY 408 return 1; 409 #endif 410 } 411 412 413 414 #ifdef PURIFY 415 /* Purify uses (some of..) the following functions to output memory-use 416 * debugging info. Given all the messing with file descriptors that 417 * tcsh does, the easiest way I could think of to get it (Purify) to 418 * print anything was by replacing some standard functions with 419 * ones that do tcsh output directly - see dumb hook in doreaddirs() 420 * (sh.dir.c) -sg 421 */ 422 #ifndef FILE 423 #define FILE int 424 #endif 425 int 426 #ifdef PROTOTYPES 427 fprintf(FILE *fp, const char* fmt, ...) 428 #else 429 fprintf(va_alist) 430 va_dcl 431 #endif 432 { 433 va_list va; 434 #ifdef PROTOTYPES 435 va_start(va, fmt); 436 #else 437 FILE *fp; 438 const char *fmt; 439 440 va_start(va); 441 fp = va_arg(va, FILE *); 442 fmt = va_arg(va, const char *); 443 #endif 444 doprnt(xputchar, fmt, va); 445 va_end(va); 446 return 1; 447 } 448 449 int 450 vfprintf(fp, fmt, va) 451 FILE *fp; 452 const char *fmt; 453 va_list va; 454 { 455 doprnt(xputchar, fmt, va); 456 return 1; 457 } 458 459 #endif /* PURIFY */ 460