?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
netinet/in.h: add IPPROTO_MH
[uclibc-ng.git] / libc / stdio / old_vfprintf.c
blob75bf3413e73de6aef5174ef3f0a4ecb72108d72e
1 /*
2 * This file based on printf.c from 'Dlibs' on the atari ST (RdeBath)
3 *
4 *
5 * Dale Schumacher 399 Beacon Ave.
6 * (alias: Dalnefre') St. Paul, MN 55104
7 * dal@syntel.UUCP United States of America
8 * "It's not reality that's important, but how you perceive things."
9 */
10
11 /* Altered to use stdarg, made the core function vfnprintf.
12 * Hooked into the stdio package using 'inside information'
13 * Altered sizeof() assumptions, now assumes all integers except chars
14 * will be either
15 * sizeof(xxx) == sizeof(long) or sizeof(xxx) == sizeof(short)
16 *
17 * -RDB
18 */
19
20 /*
21 * Manuel Novoa III Dec 2000
22 *
23 * The previous vfnprintf routine was almost completely rewritten with the
24 * goal of fixing some shortcomings and reducing object size.
25 *
26 * The summary of changes:
27 *
28 * Converted print conversion specification parsing from one big switch
29 * to a method using string tables. This new method verifies that the
30 * conversion flags, field width, precision, qualifier, and specifier
31 * appear in the correct order. Many questionable specifications were
32 * accepted by the previous code. This new method also resulted in a
33 * substantial reduction in object size of about 330 bytes (20%) from
34 * the old version (1627 bytes) on i386, even with the following
35 * improvements.
36 *
37 * Implemented %n specifier as required by the standards.
38 * Implemented proper handling of precision for int types.
39 * Implemented # for hex and pointer, fixed error for octal rep of 0.
40 * Implemented return of -1 on stream error.
41 *
42 * Added optional support for the GNU extension %m which prints the string
43 * corresponding the errno.
44 *
45 * Added optional support for long long ints and unsigned long long ints
46 * using the conversion qualifiers "ll", "L", or "q" (like glibc).
47 *
48 * Added optional support for doubles in a very limited form. None of
49 * the formating options are obeyed. The string returned by __dtostr
50 * is printed directly.
51 *
52 * Converted to use my (un)signed long (long) to string routines, which are
53 * smaller than the previous functions and don't require static buffers.
54 *
55 * Other Modifications:
56 * Modified sprintf, snprintf, vsprintf, vsnprintf to share on fake-file.
57 */
58
59 /*
60 * Manuel Novoa III Jan 2001
61 *
62 * Removed fake file from *s*printf functions because of possible problems
63 * if called recursively. Instead, have sprintf, snprintf, and vsprintf
64 * call vsnprintf which allocates a fake file on the stack.
65 * Removed WANT_FPUTC option. Always use standard putc macro to avoid
66 * problems with the fake file used by the *s*printf functions.
67 * Fixed bug parsing flags -- did not restart scan.
68 * Added function asprintf.
69 * Fixed 0-pad prefixing bug.
70 * Converted sizeof(int) == sizeof(long) tests to compile time vs run time.
71 * This saves 112 bytes of code on i386.
72 * Fixed precision bug -- when negative set to default.
73 * Added function fnprintf to support __dtostr.
74 * Added floating point support for doubles. Yeah!
75 *
76 *
77 * May 2001 Fixes from Johan Adolfsson (johan.adolfsson@axis.com)
78 * 1) printf("%c",0) returned 0 instead of 1.
79 * 2) unrolled loop in asprintf to reduce size and remove compile warning.
80 *
81 *
82 * June 2001
83 * 1) fix %p so that "0x" is prepended to outputed hex val
84 * 2) fix %p so that "(nil)" is output for (void *)0 to match glibc
85 *
86 * Sep 5, 2003
87 * Convert to new floating point conversion routine.
88 * Fix qualifier handling on integer and %n conversions.
89 * Add support for vsnprintf when in non-buffered/no-wchar configuration.
90 *
91 */
92
93 /*****************************************************************************/
94 /* OPTIONS */
95 /*****************************************************************************/
96 /* The optional support for long longs and doubles comes in two forms.
97 *
98 * 1) Normal (or partial for doubles) output support. Set to 1 to turn on.
99 * Adds about 130 bytes for doubles, about 220 bytes for long longs,
100 * and about 275 for both to the base code size of 1163 on i386.
101 */
102
103 /* These are now set in uClibc_config.h based on Config. */
104 /*
105 #define __UCLIBC_HAS_FLOATS__ 1
106 */
107
108 /* 2) An error message is inserted into the stream, an arg of the
109 * appropriate size is removed from the arglist, and processing
110 * continues. This is adds less code and may be useful in some
111 * cases. Set to 1 to turn on. Adds about 50 bytes for doubles,
112 * about 140 bytes for long longs, and about 175 bytes for both
113 * to the base code size of 1163 on i386.
114 */
115
116 #define WANT_FLOAT_ERROR 0
117
118 /*
119 * Set to support GNU extension of %m to print string corresponding to errno.
120 *
121 * Warning: This adds about 50 bytes (i386) to the code but it also pulls in
122 * strerror and the corresponding string table which together are about 3.8k.
123 */
124
125 /* Now controlled by uClibc_stdio.h and set below. */
126 /* #define WANT_GNU_ERRNO 0 */
127
128 /**************************************************************************/
129
130 #include "_stdio.h"
131 #include <stdarg.h>
132 #include <limits.h>
133 #include <stdint.h>
134 #include <string.h>
135 #include <errno.h>
136 #include <ctype.h>
137 #include <bits/uClibc_uintmaxtostr.h>
138
139 #include "_fpmaxtostr.h"
140
141 /* #undef WANT_FLOAT_ERROR */
142 /* #define WANT_FLOAT_ERROR 1 */
143
144 /* #define __isdigit(c) (((unsigned int)(c - '0')) < 10) */
145
146 #ifdef __UCLIBC_HAS_PRINTF_M_SPEC__
147 #define WANT_GNU_ERRNO 1
148 #else
149 #define WANT_GNU_ERRNO 0
150 #endif
151
152 #undef PUTC
153 #undef OUTNSTR
154 #undef _outnstr
155
156 #ifdef __STDIO_BUFFERS
157
158 #define PUTC(C,F) putc_unlocked((C),(F))
159 #define OUTNSTR _outnstr
160 #define _outnstr(stream, string, len) __stdio_fwrite(string, len, stream)
161
162 #else /* __STDIO_BUFFERS */
163
164 typedef struct {
165 FILE f;
166 unsigned char *bufend; /* pointer to 1 past end of buffer */
167 unsigned char *bufpos;
168 } __FILE_vsnprintf;
169
170 #ifdef __UCLIBC_HAS_FLOATS__
171 static void _outnstr(FILE *stream, const unsigned char *s, size_t n)
172 {
173 __FILE_vsnprintf *f = (__FILE_vsnprintf *) stream;
174
175 if (!__STDIO_STREAM_IS_FAKE_VSNPRINTF_NB(&f->f)) {
176 __stdio_fwrite(s, n, &f->f);
177 } else if (f->bufend > f->bufpos) {
178 size_t r = f->bufend - f->bufpos;
179 if (r > n) {
180 r = n;
181 }
182 memcpy(f->bufpos, s, r);
183 f->bufpos += r;
184 }
185 }
186 #endif
187
188 static void putc_unlocked_sprintf(int c, __FILE_vsnprintf *f)
189 {
190 if (!__STDIO_STREAM_IS_FAKE_VSNPRINTF_NB(&f->f)) {
191 putc_unlocked(c, &f->f);
192 } else if (f->bufpos < f->bufend) {
193 *f->bufpos++ = c;
194 }
195 }
196
197
198 #define PUTC(C,F) putc_unlocked_sprintf((C),(__FILE_vsnprintf *)(F))
199 #define OUTNSTR _outnstr
200
201 #endif /* __STDIO_BUFFERS */
202
203 #ifdef __UCLIBC_HAS_FLOATS__
204
205 static void _charpad(FILE * __restrict stream, int padchar, size_t numpad)
206 {
207 /* TODO -- Use a buffer to cut down on function calls... */
208 char pad[1];
209
210 *pad = padchar;
211 while (numpad) {
212 OUTNSTR(stream, pad, 1);
213 --numpad;
214 }
215 }
216
217 static void _fp_out_narrow(FILE *fp, intptr_t type, intptr_t len, intptr_t buf)
218 {
219 if (type & 0x80) { /* Some type of padding needed. */
220 int buflen = strlen((const char *) buf);
221 if ((len -= buflen) > 0) {
222 _charpad(fp, (type & 0x7f), len);
223 }
224 len = buflen;
225 }
226 if (len) {
227 OUTNSTR(fp, (const char *) buf, len);
228 }
229 }
230
231 #endif
232
233
234 enum {
235 FLAG_PLUS = 0,
236 FLAG_MINUS_LJUSTIFY,
237 FLAG_HASH,
238 FLAG_0_PAD,
239 FLAG_SPACE,
240 };
241
242 /* layout 01234 */
243 static const char spec[] = "+-#0 ";
244
245 /**********************************************************************/
246
247 /*
248 * In order to ease translation to what arginfo and _print_info._flags expect,
249 * we map: 0:int 1:char 2:longlong 4:long 8:short
250 * and then _flags |= (((q << 7) + q) & 0x701) and argtype |= (_flags & 0x701)
251 */
252
253 #ifdef PDS
254 #error PDS already defined!
255 #endif
256 #ifdef SS
257 #error SS already defined!
258 #endif
259 #ifdef IMS
260 #error IMS already defined!
261 #endif
262
263 #if PTRDIFF_MAX == INT_MAX
264 #define PDS 0
265 #elif PTRDIFF_MAX == LONG_MAX
266 #define PDS 4
267 #elif defined(LLONG_MAX) && (PTRDIFF_MAX == LLONG_MAX)
268 #define PDS 8
269 #else
270 #error fix QUAL_CHARS ptrdiff_t entry 't'!
271 #endif
272
273 #if SIZE_MAX == UINT_MAX
274 #define SS 0
275 #elif SIZE_MAX == ULONG_MAX
276 #define SS 4
277 #elif defined(LLONG_MAX) && (SIZE_MAX == ULLONG_MAX)
278 #define SS 8
279 #else
280 #error fix QUAL_CHARS size_t entries 'z', 'Z'!
281 #endif
282
283 #if INTMAX_MAX == INT_MAX
284 #define IMS 0
285 #elif INTMAX_MAX == LONG_MAX
286 #define IMS 4
287 #elif defined(LLONG_MAX) && (INTMAX_MAX == LLONG_MAX)
288 #define IMS 8
289 #else
290 #error fix QUAL_CHARS intmax_t entry 'j'!
291 #endif
292
293 #define QUAL_CHARS { \
294 /* j:(u)intmax_t z:(s)size_t t:ptrdiff_t \0:int */ \
295 /* q:long_long Z:(s)size_t */ \
296 'h', 'l', 'L', 'j', 'z', 't', 'q', 'Z', 0, \
297 2, 4, 8, IMS, SS, PDS, 8, SS, 0, /* TODO -- fix!!! */\
298 1, 8 \
299 }
300
301 static const char qual_chars[] = QUAL_CHARS;
302
303 /* static const char qual[] = "hlLq"; */
304 /**********************************************************************/
305
306 #if !defined(__UCLIBC_HAS_FLOATS__) && WANT_FLOAT_ERROR
307 static const char dbl_err[] = "<DOUBLE>";
308 #endif
309
310 #if defined(__UCLIBC_HAS_FLOATS__) || WANT_FLOAT_ERROR
311 /* layout 012345678901234567 */
312 static const char u_spec[] = "%nbopxXudicsfgGeEaA";
313 #else
314 /* layout 0123456789012 */
315 static const char u_spec[] = "%nbopxXudics";
316 #endif
317
318 /* WARNING: u_spec and u_radix need to stay in agreement!!! */
319 /* u_radix[i] <-> u_spec[i+2] for unsigned entries only */
320 static const char u_radix[] = "\x02\x08\x10\x10\x10\x0a";
321
322 int vfprintf(FILE * __restrict op, register const char * __restrict fmt,
323 va_list ap)
324 {
325 union {
326 #ifdef LLONG_MAX
327 long long ll;
328 #endif
329 #if LONG_MAX != INT_MAX
330 long l;
331 #endif
332 int i;
333 } intarg;
334 int i, cnt, dataargtype, len;
335 const void *argptr = argptr; /* ok to be initialized. */
336 register char *p;
337 const char *fmt0;
338 int preci, width;
339 #define upcase i
340 int radix, dpoint /*, upcase*/;
341 char tmp[65]; /* TODO - determine needed size from headers */
342 char flag[sizeof(spec)];
343 __STDIO_AUTO_THREADLOCK_VAR;
344
345 __STDIO_AUTO_THREADLOCK(op);
346
347 __STDIO_STREAM_VALIDATE(op);
348
349 cnt = 0;
350
351 if (__STDIO_STREAM_IS_NARROW_WRITING(op)
352 || !__STDIO_STREAM_TRANS_TO_WRITE(op, __FLAG_NARROW)
353 ) {
354
355 while (*fmt) {
356 if (*fmt == '%') {
357 fmt0 = fmt; /* save our position in case of bad format */
358 ++fmt;
359 width = -1; /* min field width */
360 preci = -5; /* max string width or mininum digits */
361 radix = 10; /* number base */
362 dpoint = 0; /* found decimal point */
363
364 /* init flags */
365 for (p =(char *) spec ; *p ; p++) {
366 flag[p-spec] = '\0';
367 }
368 flag[FLAG_0_PAD] = ' ';
369
370 /* process optional flags */
371 for (p = (char *)spec ; *p ; ) {
372 if (*fmt == *p) {
373 flag[p-spec] = *fmt++;
374 p = (char *)spec; /* restart scan */
375 } else {
376 p++;
377 }
378 }
379
380 if (!flag[FLAG_PLUS]) {
381 flag[FLAG_PLUS] = flag[FLAG_SPACE];
382 }
383
384 /* process optional width and precision */
385 do {
386 if (*fmt == '.') {
387 ++fmt;
388 dpoint = 1;
389 }
390 if (*fmt == '*') { /* parameter width value */
391 ++fmt;
392 i = va_arg(ap, int);
393 } else {
394 for ( i = 0 ; (*fmt >= '0') && (*fmt <= '9') ; ++fmt ) {
395 i = (i * 10) + (*fmt - '0');
396 }
397 }
398
399 if (dpoint) {
400 preci = i;
401 if (i<0) {
402 preci = -5;
403 }
404 } else {
405 width = i;
406 if (i<0) {
407 width = -i;
408 flag[FLAG_MINUS_LJUSTIFY] = 1;
409 }
410 }
411 } while ((*fmt == '.') && !dpoint );
412
413 /* process optional qualifier */
414 p = (char *) qual_chars;
415 do {
416 if (*fmt == *p) {
417 ++fmt;
418 break;
419 }
420 } while (*++p);
421 if ((p - qual_chars < 2) && (*fmt == *p)) {
422 p += ((sizeof(qual_chars)-2) / 2);
423 ++fmt;
424 }
425 dataargtype = ((int)(p[(sizeof(qual_chars)-2) / 2])) << 8;
426
427 #if WANT_GNU_ERRNO
428 if (*fmt == 'm') {
429 flag[FLAG_PLUS] = '\0';
430 flag[FLAG_0_PAD] = ' ';
431 p = __glibc_strerror_r(errno, tmp, sizeof(tmp));
432 goto print;
433 }
434 #endif
435
436 /* process format specifier */
437 for (p = (char *) u_spec ; *p ; p++) {
438 if (*fmt != *p) continue;
439 if (p-u_spec < 1) { /* print a % */
440 goto charout;
441 }
442 if (p-u_spec < 2) { /* store output count in int ptr */
443 _store_inttype(va_arg(ap, void *),
444 dataargtype,
445 (intmax_t) (cnt));
446 goto nextfmt;
447 }
448
449 if (p-u_spec < 10) {
450 if (*p == 'p') {
451 #if INTPTR_MAX == INT_MAX
452 dataargtype = 0;
453 #else
454 #error Fix dataargtype for pointers!
455 #endif
456 }
457
458 switch(dataargtype) {
459 case (PA_INT|PA_FLAG_LONG_LONG):
460 #ifdef LLONG_MAX
461 intarg.ll = va_arg(ap, long long);
462 argptr = &intarg.ll;
463 break;
464 #endif
465 case (PA_INT|PA_FLAG_LONG):
466 #if LONG_MAX != INT_MAX
467 intarg.l = va_arg(ap, long);
468 argptr = &intarg.l;
469 break;
470 #endif
471 default:
472 intarg.i = va_arg(ap, int);
473 argptr = &intarg.i;
474 break;
475 }
476 }
477
478 if (p-u_spec < 8) { /* unsigned conversion */
479 radix = u_radix[p-u_spec-2];
480 upcase = ((*p == 'x') ? __UIM_LOWER : __UIM_UPPER);
481 if (*p == 'p') {
482 upcase = __UIM_LOWER;
483 flag[FLAG_HASH] = 'p';
484 }
485 p = _uintmaxtostr(tmp + sizeof(tmp) - 1,
486 (uintmax_t)
487 _load_inttype(dataargtype, argptr, radix),
488 radix, upcase);
489
490 flag[FLAG_PLUS] = '\0'; /* meaningless for unsigned */
491 if (*p != '0') { /* non-zero */
492 if (flag[FLAG_HASH]) {
493 if (radix == 8) {
494 *--p = '0'; /* add leadding zero */
495 } else if (radix != 10) { /* either 2 or 16 */
496 flag[FLAG_PLUS] = '0';
497 *--p = 'b';
498 if (radix == 16) {
499 *p = 'x';
500 if (*fmt == 'X') {
501 *p = 'X';
502 }
503 }
504 }
505 }
506 } else if (flag[FLAG_HASH] == 'p') { /* null pointer */
507 p = "(nil)";
508 }
509 } else if (p-u_spec < 10) { /* signed conversion */
510 p = _uintmaxtostr(tmp + sizeof(tmp) - 1,
511 (uintmax_t)
512 _load_inttype(dataargtype, argptr, -radix),
513 -radix, upcase);
514
515 } else if (p-u_spec < 12) { /* character or string */
516 flag[FLAG_PLUS] = '\0';
517 flag[FLAG_0_PAD] = ' ';
518 if (*p == 'c') { /* character */
519 p = tmp;
520 *p = va_arg(ap, int);
521 /* This takes care of the "%c",0 case */
522 len = 1;
523 goto print_len_set;
524 } else { /* string */
525 p = va_arg(ap, char *);
526 if (!p) {
527 p = "(null)";
528 preci = 6;
529 } else {
530 if (preci < 0) {
531 preci = INT_MAX;
532 }
533 }
534 len = strnlen(p, preci);
535 goto print_len_set;
536 }
537 #if defined(__UCLIBC_HAS_FLOATS__) || WANT_FLOAT_ERROR
538 } else if (p-u_spec < 27) { /* floating point */
539 #endif /* defined(__UCLIBC_HAS_FLOATS__) || WANT_FLOAT_ERROR */
540 #if defined(__UCLIBC_HAS_FLOATS__)
541 struct printf_info info;
542 if (preci < 0) {
543 preci = 6;
544 }
545 info.width = width;
546 info.prec = preci;
547 info.spec = *fmt;
548 info.pad = flag[FLAG_0_PAD];
549 info._flags = 0;
550 if (flag[FLAG_PLUS] == '+') {
551 PRINT_INFO_SET_FLAG(&info,showsign);
552 } else if (flag[FLAG_PLUS] == ' ') {
553 PRINT_INFO_SET_FLAG(&info,space);
554 }
555 if (flag[FLAG_HASH]) {
556 PRINT_INFO_SET_FLAG(&info,alt);
557 }
558 if (flag[FLAG_MINUS_LJUSTIFY]) {
559 PRINT_INFO_SET_FLAG(&info,left);
560 }
561 #if 1
562 cnt += _fpmaxtostr(op,
563 (__fpmax_t)
564 ((dataargtype == (8 << 8))
565 ? va_arg(ap, long double)
566 : (long double) va_arg(ap, double)),
567 &info, _fp_out_narrow);
568 #else
569 cnt += _fpmaxtostr(op,
570 (__fpmax_t)
571 ((lval > 1)
572 ? va_arg(ap, long double)
573 : (long double) va_arg(ap, double)),
574 &info, _fp_out_narrow);
575 #endif
576 goto nextfmt;
577 #elif WANT_FLOAT_ERROR
578 (void) ((lval > 1) ? va_arg(ap, long double)
579 : va_arg(ap, double)); /* carry on */
580 p = (char *) dbl_err;
581 #endif /* defined(__UCLIBC_HAS_FLOATS__) */
582 }
583
584 #if WANT_GNU_ERRNO
585 print:
586 #endif
587 { /* this used to be printfield */
588 /* cheaper than strlen call */
589 /* for ( len = 0 ; p[len] ; len++ ) { } */
590 len = strnlen(p, SIZE_MAX);
591 print_len_set:
592 if ((*p == '-')
593 #if WANT_GNU_ERRNO
594 && (*fmt != 'm')
595 #endif
596 && (*fmt != 's')) {
597 flag[FLAG_PLUS] = *p++;
598 --len;
599 }
600 if (flag[FLAG_PLUS]) {
601 ++len;
602 ++preci;
603 if (flag[FLAG_PLUS] == '0') { /* base 16 */
604 ++preci; /* account for x or X */
605 }
606 }
607
608 if (preci >= 0) {
609 if ((*fmt == 's')
610 #if WANT_GNU_ERRNO
611 || (*fmt == 'm')
612 #endif
613 ) {
614 if (len > preci) {
615 len = preci;
616 } else {
617 preci = len;
618 }
619 }
620 preci -= len;
621 if (preci < 0) {
622 preci = 0;
623 }
624 width -= preci;
625 }
626
627 width -= len;
628 if (width < 0) {
629 width = 0;
630 }
631
632 if (preci < 0) {
633 preci = 0;
634 if (!flag[FLAG_MINUS_LJUSTIFY]
635 /* && flag[FLAG_PLUS] */
636 && (flag[FLAG_0_PAD] == '0')) {
637 preci = width;
638 width = 0;
639 }
640 }
641
642 while (width + len + preci) {
643 unsigned char ch;
644 /* right padding || left padding */
645 if ((!len && !preci)
646 || (width && !flag[FLAG_MINUS_LJUSTIFY])) {
647 ch = ' ';
648 --width;
649 } else if (flag[FLAG_PLUS]) {
650 ch = flag[FLAG_PLUS]; /* sign */
651 if (flag[FLAG_PLUS]=='0') { /* base 16 case */
652 flag[FLAG_PLUS] = *p++; /* get the x|X */
653 } else {
654 flag[FLAG_PLUS] = '\0';
655 }
656 --len;
657 } else if (preci) {
658 ch = '0';
659 --preci;
660 } else {
661 ch = *p++; /* main field */
662 --len;
663 }
664 ++cnt;
665 PUTC(ch, op);
666 }
667 }
668 goto nextfmt;
669 }
670
671 fmt = fmt0; /* this was an illegal format */
672 }
673
674 charout:
675 ++cnt;
676 PUTC(*fmt, op); /* normal char out */
677
678 nextfmt:
679 ++fmt;
680 }
681
682 }
683
684 i = (__FERROR_UNLOCKED(op)) ? -1 : cnt;
685
686 __STDIO_STREAM_VALIDATE(op);
687
688 __STDIO_AUTO_THREADUNLOCK(op);
689
690 return i;
691 }
692 libc_hidden_def(vfprintf)
embedded C library