Merge branch 'vendor/TEXINFO'
[dragonfly.git] / 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 */