?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
.
[glibc/history.git] / stdio-common / vfprintf.c
blobebe6220b2468ede89c70aa1ca214cb77e2986634
1 /* Copyright (C) 1991, 92, 93, 94, 95, 96 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Library General Public License as
6 published by the Free Software Foundation; either version 2 of the
7 License, or (at your option) any later version.
8
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Library General Public License for more details.
13
14 You should have received a copy of the GNU Library General Public
15 License along with the GNU C Library; see the file COPYING.LIB. If
16 not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 Boston, MA 02111-1307, USA. */
18
19 #include <ctype.h>
20 #include <limits.h>
21 #include <printf.h>
22 #include <stdarg.h>
23 #include <stdlib.h>
24 #include <errno.h>
25 #include <wchar.h>
26 #include "_itoa.h"
27 #include "../locale/localeinfo.h"
28
29 /* This code is shared between the standard stdio implementation found
30 in GNU C library and the libio implementation originally found in
31 GNU libg++.
32
33 Beside this it is also shared between the normal and wide character
34 implementation as defined in ISO/IEC 9899:1990/Amendment 1:1995. */
35
36 #ifndef COMPILE_WPRINTF
37 # define CHAR_T char
38 # define UCHAR_T unsigned char
39 # define INT_T int
40 # define L_(Str) Str
41 # define ISDIGIT(Ch) isdigit (Ch)
42
43 # ifdef USE_IN_LIBIO
44 # define PUT(F, S, N) _IO_sputn (F, S, N)
45 # define PAD(Padchar) \
46 if (width > 0) \
47 done += _IO_padn (s, Padchar, width)
48 # else
49 # define PUTC(C, F) putc (C, F)
50 ssize_t __printf_pad __P ((FILE *, char pad, size_t n));
51 # define PAD(Padchar) \
52 if (width > 0) \
53 { if (__printf_pad (s, Padchar, width) == -1) \
54 return -1; else done += width; }
55 # endif
56 #else
57 # define vfprintf vfwprintf
58 # define CHAR_T wchar_t
59 # define UCHAR_T uwchar_t
60 # define INT_T wint_t
61 # define L_(Str) L##Str
62 # define ISDIGIT(Ch) iswdigit (Ch)
63
64 # ifdef USE_IN_LIBIO
65 # define PUT(F, S, N) _IO_sputn (F, S, N)
66 # define PAD(Padchar) \
67 if (width > 0) \
68 done += _IO_wpadn (s, Padchar, width)
69 # else
70 # define PUTC(C, F) wputc (C, F)
71 ssize_t __wprintf_pad __P ((FILE *, wchar_t pad, size_t n));
72 # define PAD(Padchar) \
73 if (width > 0) \
74 { if (__wprintf_pad (s, Padchar, width) == -1) \
75 return -1; else done += width; }
76 # endif
77 #endif
78
79 /* Include the shared code for parsing the format string. */
80 #include "printf-parse.h"
81
82
83 #ifdef USE_IN_LIBIO
84 /* This code is for use in libio. */
85 # include <libioP.h>
86 # define PUTC(C, F) _IO_putc_unlocked (C, F)
87 # define vfprintf _IO_vfprintf
88 # define FILE _IO_FILE
89 # define va_list _IO_va_list
90 # undef BUFSIZ
91 # define BUFSIZ _IO_BUFSIZ
92 # define ARGCHECK(S, Format) \
93 do \
94 { \
95 /* Check file argument for consistence. */ \
96 CHECK_FILE (S, -1); \
97 if (S->_flags & _IO_NO_WRITES || Format == NULL) \
98 { \
99 MAYBE_SET_EINVAL; \
100 return -1; \
101 } \
102 } while (0)
103 # define UNBUFFERED_P(S) ((S)->_IO_file_flags & _IO_UNBUFFERED)
104 #else /* ! USE_IN_LIBIO */
105 /* This code is for use in the GNU C library. */
106 # include <stdio.h>
107 # define PUT(F, S, N) fwrite (S, 1, N, F)
108 # define ARGCHECK(S, Format) \
109 do \
110 { \
111 /* Check file argument for consistence. */ \
112 if (!__validfp(S) || !S->__mode.__write || Format == NULL) \
113 { \
114 errno = EINVAL; \
115 return -1; \
116 } \
117 if (!S->__seen) \
118 { \
119 if (__flshfp (S, EOF) == EOF) \
120 return -1; \
121 } \
122 } \
123 while (0)
124 # define UNBUFFERED_P(s) ((s)->__buffer == NULL)
125 # define flockfile(S) /* nothing */
126 # define funlockfile(S) /* nothing */
127 #endif /* USE_IN_LIBIO */
128
129
130 #define outchar(Ch) \
131 do \
132 { \
133 register const int outc = (Ch); \
134 if (PUTC (outc, s) == EOF) \
135 return -1; \
136 else \
137 ++done; \
138 } \
139 while (0)
140
141 #define outstring(String, Len) \
142 do \
143 { \
144 if (PUT (s, String, Len) != Len) \
145 return -1; \
146 done += Len; \
147 } \
148 while (0)
149
150 /* For handling long_double and longlong we use the same flag. */
151 #ifndef is_longlong
152 # define is_longlong is_long_double
153 #endif
154
155
156 /* Global variables. */
157 static const char null[] = "(null)";
158
159
160 /* Helper function to provide temporary buffering for unbuffered streams. */
161 static int buffered_vfprintf __P ((FILE *stream, const CHAR_T *fmt, va_list));
162
163 /* Handle unknown format specifier. */
164 static int printf_unknown __P ((FILE *, const struct printf_info *,
165 const void *const *));
166
167 /* Group digits of number string. */
168 static char *group_number __P ((CHAR_T *, CHAR_T *, const CHAR_T *, wchar_t));
169
170
171 /* The function itself. */
172 int
173 vfprintf (FILE *s, const CHAR_T *format, va_list ap)
174 {
175 /* The character used as thousands separator. */
176 wchar_t thousands_sep;
177
178 /* The string describing the size of groups of digits. */
179 const char *grouping;
180
181 /* Place to accumulate the result. */
182 int done;
183
184 /* Current character in format string. */
185 const UCHAR_T *f;
186
187 /* End of leading constant string. */
188 const UCHAR_T *lead_str_end;
189
190 /* Points to next format specifier. */
191 const UCHAR_T *end_of_spec;
192
193 /* Buffer intermediate results. */
194 char work_buffer[1000];
195 #define workend (&work_buffer[sizeof (work_buffer) - 1])
196
197 /* State for restartable multibyte character handling functions. */
198 mbstate_t mbstate;
199
200 /* We have to save the original argument pointer. */
201 va_list ap_save;
202
203 /* Count number of specifiers we already processed. */
204 int nspecs_done;
205
206
207 /* This table maps a character into a number representing a
208 class. In each step there is a destination label for each
209 class. */
210 static const int jump_table[] =
211 {
212 /* ' ' */ 1, 0, 0, /* '#' */ 4,
213 0, /* '%' */ 14, 0, /* '\''*/ 6,
214 0, 0, /* '*' */ 7, /* '+' */ 2,
215 0, /* '-' */ 3, /* '.' */ 9, 0,
216 /* '0' */ 5, /* '1' */ 8, /* '2' */ 8, /* '3' */ 8,
217 /* '4' */ 8, /* '5' */ 8, /* '6' */ 8, /* '7' */ 8,
218 /* '8' */ 8, /* '9' */ 8, 0, 0,
219 0, 0, 0, 0,
220 0, 0, 0, 0,
221 0, /* 'E' */ 19, 0, /* 'G' */ 19,
222 0, 0, 0, 0,
223 /* 'L' */ 12, 0, 0, 0,
224 0, 0, 0, 0,
225 0, 0, 0, 0,
226 /* 'X' */ 18, 0, /* 'Z' */ 13, 0,
227 0, 0, 0, 0,
228 0, 0, 0, /* 'c' */ 20,
229 /* 'd' */ 15, /* 'e' */ 19, /* 'f' */ 19, /* 'g' */ 19,
230 /* 'h' */ 10, /* 'i' */ 15, 0, 0,
231 /* 'l' */ 11, /* 'm' */ 24, /* 'n' */ 23, /* 'o' */ 17,
232 /* 'p' */ 22, /* 'q' */ 12, 0, /* 's' */ 21,
233 0, /* 'u' */ 16, 0, 0,
234 /* 'x' */ 18
235 };
236
237 #define NOT_IN_JUMP_RANGE(Ch) ((Ch) < ' ' || (Ch) > 'x')
238 #define CHAR_CLASS(Ch) (jump_table[(int) (Ch) - ' '])
239 #define JUMP(ChExpr, table) \
240 do \
241 { \
242 const void *ptr; \
243 spec = (ChExpr); \
244 ptr = NOT_IN_JUMP_RANGE (spec) ? REF (form_unknown) \
245 : table[CHAR_CLASS (spec)]; \
246 goto *ptr; \
247 } \
248 while (0)
249
250 #define STEP0_3_TABLE \
251 /* Step 0: at the beginning. */ \
252 static const void *step0_jumps[25] = \
253 { \
254 REF (form_unknown), \
255 REF (flag_space), /* for ' ' */ \
256 REF (flag_plus), /* for '+' */ \
257 REF (flag_minus), /* for '-' */ \
258 REF (flag_hash), /* for '<hash>' */ \
259 REF (flag_zero), /* for '0' */ \
260 REF (flag_quote), /* for '\'' */ \
261 REF (width_asterics), /* for '*' */ \
262 REF (width), /* for '1'...'9' */ \
263 REF (precision), /* for '.' */ \
264 REF (mod_half), /* for 'h' */ \
265 REF (mod_long), /* for 'l' */ \
266 REF (mod_longlong), /* for 'L', 'q' */ \
267 REF (mod_size_t), /* for 'Z' */ \
268 REF (form_percent), /* for '%' */ \
269 REF (form_integer), /* for 'd', 'i' */ \
270 REF (form_unsigned), /* for 'u' */ \
271 REF (form_octal), /* for 'o' */ \
272 REF (form_hexa), /* for 'X', 'x' */ \
273 REF (form_float), /* for 'E', 'e', 'f', 'G', 'g' */ \
274 REF (form_character), /* for 'c' */ \
275 REF (form_string), /* for 's' */ \
276 REF (form_pointer), /* for 'p' */ \
277 REF (form_number), /* for 'n' */ \
278 REF (form_strerror) /* for 'm' */ \
279 }; \
280 /* Step 1: after processing width. */ \
281 static const void *step1_jumps[25] = \
282 { \
283 REF (form_unknown), \
284 REF (form_unknown), /* for ' ' */ \
285 REF (form_unknown), /* for '+' */ \
286 REF (form_unknown), /* for '-' */ \
287 REF (form_unknown), /* for '<hash>' */ \
288 REF (form_unknown), /* for '0' */ \
289 REF (form_unknown), /* for '\'' */ \
290 REF (form_unknown), /* for '*' */ \
291 REF (form_unknown), /* for '1'...'9' */ \
292 REF (precision), /* for '.' */ \
293 REF (mod_half), /* for 'h' */ \
294 REF (mod_long), /* for 'l' */ \
295 REF (mod_longlong), /* for 'L', 'q' */ \
296 REF (mod_size_t), /* for 'Z' */ \
297 REF (form_percent), /* for '%' */ \
298 REF (form_integer), /* for 'd', 'i' */ \
299 REF (form_unsigned), /* for 'u' */ \
300 REF (form_octal), /* for 'o' */ \
301 REF (form_hexa), /* for 'X', 'x' */ \
302 REF (form_float), /* for 'E', 'e', 'f', 'G', 'g' */ \
303 REF (form_character), /* for 'c' */ \
304 REF (form_string), /* for 's' */ \
305 REF (form_pointer), /* for 'p' */ \
306 REF (form_number), /* for 'n' */ \
307 REF (form_strerror) /* for 'm' */ \
308 }; \
309 /* Step 2: after processing precision. */ \
310 static const void *step2_jumps[25] = \
311 { \
312 REF (form_unknown), \
313 REF (form_unknown), /* for ' ' */ \
314 REF (form_unknown), /* for '+' */ \
315 REF (form_unknown), /* for '-' */ \
316 REF (form_unknown), /* for '<hash>' */ \
317 REF (form_unknown), /* for '0' */ \
318 REF (form_unknown), /* for '\'' */ \
319 REF (form_unknown), /* for '*' */ \
320 REF (form_unknown), /* for '1'...'9' */ \
321 REF (form_unknown), /* for '.' */ \
322 REF (mod_half), /* for 'h' */ \
323 REF (mod_long), /* for 'l' */ \
324 REF (mod_longlong), /* for 'L', 'q' */ \
325 REF (mod_size_t), /* for 'Z' */ \
326 REF (form_percent), /* for '%' */ \
327 REF (form_integer), /* for 'd', 'i' */ \
328 REF (form_unsigned), /* for 'u' */ \
329 REF (form_octal), /* for 'o' */ \
330 REF (form_hexa), /* for 'X', 'x' */ \
331 REF (form_float), /* for 'E', 'e', 'f', 'G', 'g' */ \
332 REF (form_character), /* for 'c' */ \
333 REF (form_string), /* for 's' */ \
334 REF (form_pointer), /* for 'p' */ \
335 REF (form_number), /* for 'n' */ \
336 REF (form_strerror) /* for 'm' */ \
337 }; \
338 /* Step 3: after processing first 'l' modifier. */ \
339 static const void *step3_jumps[25] = \
340 { \
341 REF (form_unknown), \
342 REF (form_unknown), /* for ' ' */ \
343 REF (form_unknown), /* for '+' */ \
344 REF (form_unknown), /* for '-' */ \
345 REF (form_unknown), /* for '<hash>' */ \
346 REF (form_unknown), /* for '0' */ \
347 REF (form_unknown), /* for '\'' */ \
348 REF (form_unknown), /* for '*' */ \
349 REF (form_unknown), /* for '1'...'9' */ \
350 REF (form_unknown), /* for '.' */ \
351 REF (form_unknown), /* for 'h' */ \
352 REF (mod_longlong), /* for 'l' */ \
353 REF (form_unknown), /* for 'L', 'q' */ \
354 REF (form_unknown), /* for 'Z' */ \
355 REF (form_percent), /* for '%' */ \
356 REF (form_integer), /* for 'd', 'i' */ \
357 REF (form_unsigned), /* for 'u' */ \
358 REF (form_octal), /* for 'o' */ \
359 REF (form_hexa), /* for 'X', 'x' */ \
360 REF (form_float), /* for 'E', 'e', 'f', 'G', 'g' */ \
361 REF (form_character), /* for 'c' */ \
362 REF (form_string), /* for 's' */ \
363 REF (form_pointer), /* for 'p' */ \
364 REF (form_number), /* for 'n' */ \
365 REF (form_strerror) /* for 'm' */ \
366 }
367
368 #define STEP4_TABLE \
369 /* Step 4: processing format specifier. */ \
370 static const void *step4_jumps[25] = \
371 { \
372 REF (form_unknown), \
373 REF (form_unknown), /* for ' ' */ \
374 REF (form_unknown), /* for '+' */ \
375 REF (form_unknown), /* for '-' */ \
376 REF (form_unknown), /* for '<hash>' */ \
377 REF (form_unknown), /* for '0' */ \
378 REF (form_unknown), /* for '\'' */ \
379 REF (form_unknown), /* for '*' */ \
380 REF (form_unknown), /* for '1'...'9' */ \
381 REF (form_unknown), /* for '.' */ \
382 REF (form_unknown), /* for 'h' */ \
383 REF (form_unknown), /* for 'l' */ \
384 REF (form_unknown), /* for 'L', 'q' */ \
385 REF (form_unknown), /* for 'Z' */ \
386 REF (form_percent), /* for '%' */ \
387 REF (form_integer), /* for 'd', 'i' */ \
388 REF (form_unsigned), /* for 'u' */ \
389 REF (form_octal), /* for 'o' */ \
390 REF (form_hexa), /* for 'X', 'x' */ \
391 REF (form_float), /* for 'E', 'e', 'f', 'G', 'g' */ \
392 REF (form_character), /* for 'c' */ \
393 REF (form_string), /* for 's' */ \
394 REF (form_pointer), /* for 'p' */ \
395 REF (form_number), /* for 'n' */ \
396 REF (form_strerror) /* for 'm' */ \
397 }
398
399
400 #define process_arg(fspec) \
401 /* Start real work. We know about all flag and modifiers and \
402 now process the wanted format specifier. */ \
403 LABEL (form_percent): \
404 /* Write a literal "%". */ \
405 outchar ('%'); \
406 break; \
407 \
408 LABEL (form_integer): \
409 /* Signed decimal integer. */ \
410 base = 10; \
411 \
412 if (is_longlong) \
413 { \
414 long long int signed_number; \
415 \
416 if (fspec == NULL) \
417 signed_number = va_arg (ap, long long int); \
418 else \
419 signed_number = args_value[fspec->data_arg].pa_long_long_int; \
420 \
421 is_negative = signed_number < 0; \
422 number.longlong = is_negative ? (- signed_number) : signed_number; \
423 \
424 goto LABEL (longlong_number); \
425 } \
426 else \
427 { \
428 long int signed_number; \
429 \
430 if (fspec == NULL) \
431 if (is_long) \
432 signed_number = va_arg (ap, long int); \
433 else /* `short int' will be promoted to `int'. */ \
434 signed_number = va_arg (ap, int); \
435 else \
436 if (is_long) \
437 signed_number = args_value[fspec->data_arg].pa_long_int; \
438 else \
439 signed_number = args_value[fspec->data_arg].pa_int; \
440 \
441 is_negative = signed_number < 0; \
442 number.word = is_negative ? (- signed_number) : signed_number; \
443 \
444 goto LABEL (number); \
445 } \
446 /* NOTREACHED */ \
447 \
448 LABEL (form_unsigned): \
449 /* Unsigned decimal integer. */ \
450 base = 10; \
451 goto LABEL (unsigned_number); \
452 /* NOTREACHED */ \
453 \
454 LABEL (form_octal): \
455 /* Unsigned octal integer. */ \
456 base = 8; \
457 goto LABEL (unsigned_number); \
458 /* NOTREACHED */ \
459 \
460 LABEL (form_hexa): \
461 /* Unsigned hexadecimal integer. */ \
462 base = 16; \
463 \
464 LABEL (unsigned_number): /* Unsigned number of base BASE. */ \
465 \
466 /* ANSI specifies the `+' and ` ' flags only for signed \
467 conversions. */ \
468 is_negative = 0; \
469 showsign = 0; \
470 space = 0; \
471 \
472 if (is_longlong) \
473 { \
474 if (fspec == NULL) \
475 number.longlong = va_arg (ap, unsigned long long int); \
476 else \
477 number.longlong = args_value[fspec->data_arg].pa_u_long_long_int; \
478 \
479 LABEL (longlong_number): \
480 if (prec < 0) \
481 /* Supply a default precision if none was given. */ \
482 prec = 1; \
483 else \
484 /* We have to take care for the '0' flag. If a precision \
485 is given it must be ignored. */ \
486 pad = ' '; \
487 \
488 /* If the precision is 0 and the number is 0 nothing has to \
489 be written for the number. */ \
490 if (prec == 0 && number.longlong == 0) \
491 string = workend; \
492 else \
493 { \
494 /* Put the number in WORK. */ \
495 string = _itoa (number.longlong, workend + 1, base, \
496 spec == 'X'); \
497 string -= 1; \
498 if (group && grouping) \
499 string = group_number (string, workend, grouping, \
500 thousands_sep); \
501 } \
502 /* Simply further test for num != 0. */ \
503 number.word = number.longlong != 0; \
504 } \
505 else \
506 { \
507 if (fspec == NULL) \
508 if (is_long) \
509 number.word = va_arg (ap, unsigned long int); \
510 else if (!is_short) \
511 number.word = va_arg (ap, unsigned int); \
512 else \
513 number.word = (unsigned short int) va_arg (ap, unsigned int); \
514 else \
515 if (is_long) \
516 number.word = args_value[fspec->data_arg].pa_u_long_int; \
517 else if (!is_short) \
518 number.word = args_value[fspec->data_arg].pa_u_int; \
519 else \
520 number.word = (unsigned short int) \
521 args_value[fspec->data_arg].pa_u_short_int; \
522 \
523 LABEL (number): \
524 if (prec < 0) \
525 /* Supply a default precision if none was given. */ \
526 prec = 1; \
527 else \
528 /* We have to take care for the '0' flag. If a precision \
529 is given it must be ignored. */ \
530 pad = ' '; \
531 \
532 /* If the precision is 0 and the number is 0 nothing has to \
533 be written for the number. */ \
534 if (prec == 0 && number.word == 0) \
535 string = workend; \
536 else \
537 { \
538 /* Put the number in WORK. */ \
539 string = _itoa_word (number.word, workend + 1, base, \
540 spec == 'X'); \
541 string -= 1; \
542 if (group && grouping) \
543 string = group_number (string, workend, grouping, \
544 thousands_sep); \
545 } \
546 } \
547 \
548 prec -= workend - string; \
549 \
550 if (prec > 0) \
551 /* Add zeros to the precision. */ \
552 while (prec-- > 0) \
553 *string-- = '0'; \
554 else if (number.word != 0 && alt && base == 8) \
555 /* Add octal marker. */ \
556 *string-- = '0'; \
557 \
558 if (!left) \
559 { \
560 width -= workend - string; \
561 \
562 if (number.word != 0 && alt && base == 16) \
563 /* Account for 0X hex marker. */ \
564 width -= 2; \
565 \
566 if (is_negative || showsign || space) \
567 --width; \
568 \
569 if (pad == '0') \
570 { \
571 while (width-- > 0) \
572 *string-- = '0'; \
573 \
574 if (number.word != 0 && alt && base == 16) \
575 { \
576 *string-- = spec; \
577 *string-- = '0'; \
578 } \
579 \
580 if (is_negative) \
581 *string-- = '-'; \
582 else if (showsign) \
583 *string-- = '+'; \
584 else if (space) \
585 *string-- = ' '; \
586 } \
587 else \
588 { \
589 if (number.word != 0 && alt && base == 16) \
590 { \
591 *string-- = spec; \
592 *string-- = '0'; \
593 } \
594 \
595 if (is_negative) \
596 *string-- = '-'; \
597 else if (showsign) \
598 *string-- = '+'; \
599 else if (space) \
600 *string-- = ' '; \
601 \
602 while (width-- > 0) \
603 *string-- = ' '; \
604 } \
605 \
606 outstring (string + 1, workend - string); \
607 \
608 break; \
609 } \
610 else \
611 { \
612 if (number.word != 0 && alt && base == 16) \
613 { \
614 *string-- = spec; \
615 *string-- = '0'; \
616 } \
617 \
618 if (is_negative) \
619 *string-- = '-'; \
620 else if (showsign) \
621 *string-- = '+'; \
622 else if (space) \
623 *string-- = ' '; \
624 \
625 width -= workend - string; \
626 outstring (string + 1, workend - string); \
627 \
628 PAD (' '); \
629 break; \
630 } \
631 \
632 LABEL (form_float): \
633 { \
634 /* Floating-point number. This is handled by printf_fp.c. */ \
635 extern int __printf_fp __P ((FILE *, const struct printf_info *, \
636 const void **const)); \
637 const void *ptr; \
638 int function_done; \
639 \
640 if (fspec == NULL) \
641 { \
642 struct printf_info info = { prec: prec, \
643 width: width, \
644 spec: spec, \
645 is_long_double: is_long_double, \
646 is_short: is_short, \
647 is_long: is_long, \
648 alt: alt, \
649 space: space, \
650 left: left, \
651 showsign: showsign, \
652 group: group, \
653 pad: pad, \
654 extra: 0 }; \
655 \
656 if (is_long_double) \
657 the_arg.pa_long_double = va_arg (ap, long double); \
658 else \
659 the_arg.pa_double = va_arg (ap, double); \
660 ptr = (const void *) &the_arg; \
661 \
662 function_done = __printf_fp (s, &info, &ptr); \
663 } \
664 else \
665 { \
666 ptr = (const void *) &args_value[fspec->data_arg]; \
667 \
668 function_done = __printf_fp (s, &fspec->info, &ptr); \
669 } \
670 \
671 if (function_done < 0) \
672 /* Error in print handler. */ \
673 return -1; \
674 \
675 done += function_done; \
676 } \
677 break; \
678 \
679 LABEL (form_character): \
680 /* Character. */ \
681 --width; /* Account for the character itself. */ \
682 if (!left) \
683 PAD (' '); \
684 if (fspec == NULL) \
685 outchar ((unsigned char) va_arg (ap, int)); /* Promoted. */ \
686 else \
687 outchar ((unsigned char) args_value[fspec->data_arg].pa_char); \
688 if (left) \
689 PAD (' '); \
690 break; \
691 \
692 LABEL (form_string): \
693 { \
694 size_t len; \
695 \
696 /* The string argument could in fact be `char *' or `wchar_t *'. \
697 But this should not make a difference here. */ \
698 if (fspec == NULL) \
699 string = (char *) va_arg (ap, const char *); \
700 else \
701 string = (char *) args_value[fspec->data_arg].pa_string; \
702 \
703 /* Entry point for printing other strings. */ \
704 LABEL (print_string): \
705 \
706 if (string == NULL) \
707 { \
708 /* Write "(null)" if there's space. */ \
709 if (prec == -1 || prec >= (int) sizeof (null) - 1) \
710 { \
711 string = (char *) null; \
712 len = sizeof (null) - 1; \
713 } \
714 else \
715 { \
716 string = (char *) ""; \
717 len = 0; \
718 } \
719 } \
720 else if (!is_long) \
721 { \
722 if (prec != -1) \
723 { \
724 /* Search for the end of the string, but don't search past \
725 the length specified by the precision. */ \
726 const char *end = memchr (string, '\0', prec); \
727 if (end) \
728 len = end - string; \
729 else \
730 len = prec; \
731 } \
732 else \
733 len = strlen (string); \
734 } \
735 else \
736 { \
737 const wchar_t *s2 = (const wchar_t *) string; \
738 mbstate_t mbstate; \
739 \
740 len = wcsrtombs (NULL, &s2, 0, &mbstate); \
741 if (len == (size_t) -1) \
742 /* Illegal wide-character string. */ \
743 return -1; \
744 \
745 s2 = (const wchar_t *) string; \
746 string = alloca (len + 1); \
747 (void) wcsrtombs (string, &s2, prec != -1 ? prec : UINT_MAX, \
748 &mbstate); \
749 } \
750 \
751 if ((width -= len) < 0) \
752 { \
753 outstring (string, len); \
754 break; \
755 } \
756 \
757 if (!left) \
758 PAD (' '); \
759 outstring (string, len); \
760 if (left) \
761 PAD (' '); \
762 } \
763 break; \
764 \
765 LABEL (form_pointer): \
766 /* Generic pointer. */ \
767 { \
768 const void *ptr; \
769 if (fspec == NULL) \
770 ptr = va_arg (ap, void *); \
771 else \
772 ptr = args_value[fspec->data_arg].pa_pointer; \
773 if (ptr != NULL) \
774 { \
775 /* If the pointer is not NULL, write it as a %#x spec. */ \
776 base = 16; \
777 number.word = (unsigned long int) ptr; \
778 is_negative = 0; \
779 alt = 1; \
780 group = 0; \
781 spec = 'x'; \
782 goto LABEL (number); \
783 } \
784 else \
785 { \
786 /* Write "(nil)" for a nil pointer. */ \
787 string = (char *) "(nil)"; \
788 /* Make sure the full string "(nil)" is printed. */ \
789 if (prec < 5) \
790 prec = 5; \
791 is_long = 0; /* This is no wide-char string. */ \
792 goto LABEL (print_string); \
793 } \
794 } \
795 /* NOTREACHED */ \
796 \
797 LABEL (form_number): \
798 /* Answer the count of characters written. */ \
799 if (fspec == NULL) \
800 if (is_longlong) \
801 *(long long int *) va_arg (ap, void *) = done; \
802 else if (is_long) \
803 *(long int *) va_arg (ap, void *) = done; \
804 else if (!is_short) \
805 *(int *) va_arg (ap, void *) = done; \
806 else \
807 *(short int *) va_arg (ap, void *) = done; \
808 else \
809 if (is_longlong) \
810 *(long long int *) args_value[fspec->data_arg].pa_pointer = done; \
811 else if (is_long) \
812 *(long int *) args_value[fspec->data_arg].pa_pointer = done; \
813 else if (!is_short) \
814 *(int *) args_value[fspec->data_arg].pa_pointer = done; \
815 else \
816 *(short int *) args_value[fspec->data_arg].pa_pointer = done; \
817 break; \
818 \
819 LABEL (form_strerror): \
820 /* Print description of error ERRNO. */ \
821 { \
822 extern char *_strerror_internal __P ((int, char *buf, size_t)); \
823 \
824 string = (char *) \
825 _strerror_internal (errno, work_buffer, sizeof work_buffer); \
826 } \
827 is_long = 0; /* This is no wide-char string. */ \
828 goto LABEL (print_string)
829
830
831 /* Sanity check of arguments. */
832 ARGCHECK (s, format);
833
834 if (UNBUFFERED_P (s))
835 /* Use a helper function which will allocate a local temporary buffer
836 for the stream and then call us again. */
837 return buffered_vfprintf (s, format, ap);
838
839 /* Initialize local variables. */
840 done = 0;
841 grouping = (const char *) -1;
842 ap_save = ap;
843 nspecs_done = 0;
844
845 /* Find the first format specifier. */
846 f = lead_str_end = find_spec (format, &mbstate);
847
848 /* Lock stream. */
849 flockfile (s);
850
851 /* Write the literal text before the first format. */
852 outstring ((const UCHAR_T *) format,
853 lead_str_end - (const UCHAR_T *) format);
854
855 /* If we only have to print a simple string, return now. */
856 if (*f == L_('\0'))
857 {
858 funlockfile (s);
859 return done;
860 }
861
862 /* Process whole format string. */
863 do
864 {
865 #define REF(Name) &&do_##Name
866 #define LABEL(Name) do_##Name
867 STEP0_3_TABLE;
868 STEP4_TABLE;
869
870 union printf_arg *args_value; /* This is not used here but ... */
871 int is_negative; /* Flag for negative number. */
872 union
873 {
874 unsigned long long int longlong;
875 unsigned long int word;
876 } number;
877 int base;
878 union printf_arg the_arg;
879 char *string; /* Pointer to argument string. */
880 int alt = 0; /* Alternate format. */
881 int space = 0; /* Use space prefix if no sign is needed. */
882 int left = 0; /* Left-justify output. */
883 int showsign = 0; /* Always begin with plus or minus sign. */
884 int group = 0; /* Print numbers according grouping rules. */
885 int is_long_double = 0; /* Argument is long double/ long long int. */
886 int is_short = 0; /* Argument is long int. */
887 int is_long = 0; /* Argument is short int. */
888 int width = 0; /* Width of output; 0 means none specified. */
889 int prec = -1; /* Precision of output; -1 means none specified. */
890 char pad = ' '; /* Padding character. */
891 CHAR_T spec;
892
893 /* Get current character in format string. */
894 JUMP (*++f, step0_jumps);
895
896 /* ' ' flag. */
897 LABEL (flag_space):
898 space = 1;
899 JUMP (*++f, step0_jumps);
900
901 /* '+' flag. */
902 LABEL (flag_plus):
903 showsign = 1;
904 JUMP (*++f, step0_jumps);
905
906 /* The '-' flag. */
907 LABEL (flag_minus):
908 left = 1;
909 pad = L_(' ');
910 JUMP (*++f, step0_jumps);
911
912 /* The '#' flag. */
913 LABEL (flag_hash):
914 alt = 1;
915 JUMP (*++f, step0_jumps);
916
917 /* The '0' flag. */
918 LABEL (flag_zero):
919 if (!left)
920 pad = L_('0');
921 JUMP (*++f, step0_jumps);
922
923 /* The '\'' flag. */
924 LABEL (flag_quote):
925 group = 1;
926
927 /* XXX Completely wrong. Use wctob. */
928 if (grouping == (const char *) -1)
929 {
930 /* Figure out the thousands separator character. */
931 if (mbtowc (&thousands_sep,
932 _NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP),
933 strlen (_NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP))) <= 0)
934 thousands_sep = (wchar_t)
935 *_NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP);
936 grouping = _NL_CURRENT (LC_NUMERIC, GROUPING);
937 if (*grouping == '\0' || *grouping == CHAR_MAX
938 || thousands_sep == L'\0')
939 grouping = NULL;
940 }
941 JUMP (*++f, step0_jumps);
942
943 /* Get width from argument. */
944 LABEL (width_asterics):
945 {
946 const UCHAR_T *tmp; /* Temporary value. */
947
948 tmp = ++f;
949 if (ISDIGIT (*tmp) && read_int (&tmp) && *tmp == L_('$'))
950 /* The width comes from a positional parameter. */
951 goto do_positional;
952
953 width = va_arg (ap, int);
954
955 /* Negative width means left justified. */
956 if (width < 0)
957 {
958 width = -width;
959 pad = L_(' ');
960 left = 1;
961 }
962 }
963 JUMP (*f, step1_jumps);
964
965 /* Given width in format string. */
966 LABEL (width):
967 width = read_int (&f);
968 if (*f == L_('$'))
969 /* Oh, oh. The argument comes from a positional parameter. */
970 goto do_positional;
971 JUMP (*f, step1_jumps);
972
973 LABEL (precision):
974 ++f;
975 if (*f == L_('*'))
976 {
977 const UCHAR_T *tmp; /* Temporary value. */
978
979 tmp = ++f;
980 if (ISDIGIT (*tmp) && read_int (&tmp) > 0 && *tmp == L_('$'))
981 /* The precision comes from a positional parameter. */
982 goto do_positional;
983
984 prec = va_arg (ap, int);
985
986 /* If the precision is negative the precision is omitted. */
987 if (prec < 0)
988 prec = -1;
989 }
990 else if (ISDIGIT (*f))
991 prec = read_int (&f);
992 else
993 prec = 0;
994 JUMP (*f, step2_jumps);
995
996 /* Process 'h' modifier. No other modifier is allowed to
997 follow. */
998 LABEL (mod_half):
999 is_short = 1;
1000 JUMP (*++f, step4_jumps);
1001
1002 /* Process 'l' modifier. There might another 'l' follow. */
1003 LABEL (mod_long):
1004 is_long = 1;
1005 JUMP (*++f, step3_jumps);
1006
1007 /* Process 'L', 'q', or 'll' modifier. No other modifier is
1008 allowed to follow. */
1009 LABEL (mod_longlong):
1010 is_long_double = 1;
1011 JUMP (*++f, step4_jumps);
1012
1013 LABEL (mod_size_t):
1014 is_longlong = sizeof (size_t) > sizeof (unsigned long int);
1015 is_long = sizeof (size_t) > sizeof (unsigned int);
1016 JUMP (*++f, step4_jumps);
1017
1018
1019 /* Process current format. */
1020 while (1)
1021 {
1022 process_arg (((struct printf_spec *) NULL));
1023
1024 LABEL (form_unknown):
1025 if (spec == L_('\0'))
1026 {
1027 /* The format string ended before the specifier is complete. */
1028 funlockfile (s);
1029 return -1;
1030 }
1031
1032 /* If we are in the fast loop force entering the complicated
1033 one. */
1034 goto do_positional;
1035 }
1036
1037 /* Look for next format specifier. */
1038 f = find_spec ((end_of_spec = ++f), &mbstate);
1039
1040 /* Write the following constant string. */
1041 outstring (end_of_spec, f - end_of_spec);
1042 }
1043 while (*f != L_('\0'));
1044
1045 /* Unlock stream. */
1046 funlockfile (s);
1047
1048 /* We processed the whole format without any positional parameters. */
1049 return done;
1050
1051 /* Here starts the more complex loop to handle positional parameters. */
1052 do_positional:
1053 {
1054 /* Array with information about the needed arguments. This has to
1055 be dynamically extendable. */
1056 size_t nspecs = 0;
1057 size_t nspecs_max = 32; /* A more or less arbitrary start value. */
1058 struct printf_spec *specs
1059 = alloca (nspecs_max * sizeof (struct printf_spec));
1060
1061 /* The number of arguments the format string requests. This will
1062 determine the size of the array needed to store the argument
1063 attributes. */
1064 size_t nargs = 0;
1065 int *args_type;
1066 union printf_arg *args_value;
1067
1068 /* Positional parameters refer to arguments directly. This could
1069 also determine the maximum number of arguments. Track the
1070 maximum number. */
1071 size_t max_ref_arg = 0;
1072
1073 /* Just a counter. */
1074 int cnt;
1075
1076
1077 if (grouping == (const char *) -1)
1078 {
1079 /* XXX Use wctob. But this is incompatible for now. */
1080 /* Figure out the thousands separator character. */
1081 if (mbtowc (&thousands_sep,
1082 _NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP),
1083 strlen (_NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP))) <= 0)
1084 thousands_sep = (wchar_t) *_NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP);
1085 grouping = _NL_CURRENT (LC_NUMERIC, GROUPING);
1086 if (*grouping == '\0' || *grouping == CHAR_MAX
1087 || thousands_sep == L'\0')
1088 grouping = NULL;
1089 }
1090
1091 for (f = lead_str_end; *f != '\0'; f = specs[nspecs++].next_fmt)
1092 {
1093 if (nspecs >= nspecs_max)
1094 {
1095 /* Extend the array of format specifiers. */
1096 struct printf_spec *old = specs;
1097
1098 nspecs_max *= 2;
1099 specs = alloca (nspecs_max * sizeof (struct printf_spec));
1100
1101 if (specs == &old[nspecs])
1102 /* Stack grows up, OLD was the last thing allocated;
1103 extend it. */
1104 nspecs_max += nspecs_max / 2;
1105 else
1106 {
1107 /* Copy the old array's elements to the new space. */
1108 memcpy (specs, old, nspecs * sizeof (struct printf_spec));
1109 if (old == &specs[nspecs])
1110 /* Stack grows down, OLD was just below the new
1111 SPECS. We can use that space when the new space
1112 runs out. */
1113 nspecs_max += nspecs_max / 2;
1114 }
1115 }
1116
1117 /* Parse the format specifier. */
1118 nargs += parse_one_spec (f, nargs, &specs[nspecs], &max_ref_arg,
1119 &mbstate);
1120 }
1121
1122 /* Determine the number of arguments the format string consumes. */
1123 nargs = MAX (nargs, max_ref_arg);
1124
1125 /* Allocate memory for the argument descriptions. */
1126 args_type = alloca (nargs * sizeof (int));
1127 memset (args_type, 0, nargs * sizeof (int));
1128 args_value = alloca (nargs * sizeof (union printf_arg));
1129
1130 /* XXX Could do sanity check here: If any element in ARGS_TYPE is
1131 still zero after this loop, format is invalid. For now we
1132 simply use 0 as the value. */
1133
1134 /* Fill in the types of all the arguments. */
1135 for (cnt = 0; cnt < nspecs; ++cnt)
1136 {
1137 /* If the width is determined by an argument this is an int. */
1138 if (specs[cnt].width_arg != -1)
1139 args_type[specs[cnt].width_arg] = PA_INT;
1140
1141 /* If the precision is determined by an argument this is an int. */
1142 if (specs[cnt].prec_arg != -1)
1143 args_type[specs[cnt].prec_arg] = PA_INT;
1144
1145 switch (specs[cnt].ndata_args)
1146 {
1147 case 0: /* No arguments. */
1148 break;
1149 case 1: /* One argument; we already have the type. */
1150 args_type[specs[cnt].data_arg] = specs[cnt].data_arg_type;
1151 break;
1152 default:
1153 /* We have more than one argument for this format spec.
1154 We must call the arginfo function again to determine
1155 all the types. */
1156 (void) (*__printf_arginfo_table[specs[cnt].info.spec])
1157 (&specs[cnt].info,
1158 specs[cnt].ndata_args, &args_type[specs[cnt].data_arg]);
1159 break;
1160 }
1161 }
1162
1163 /* Now we know all the types and the order. Fill in the argument
1164 values. */
1165 for (cnt = 0, ap = ap_save; cnt < nargs; ++cnt)
1166 switch (args_type[cnt])
1167 {
1168 #define T(tag, mem, type) \
1169 case tag: \
1170 args_value[cnt].mem = va_arg (ap, type); \
1171 break
1172
1173 T (PA_CHAR, pa_char, int); /* Promoted. */
1174 T (PA_INT|PA_FLAG_SHORT, pa_short_int, int); /* Promoted. */
1175 T (PA_INT, pa_int, int);
1176 T (PA_INT|PA_FLAG_LONG, pa_long_int, long int);
1177 T (PA_INT|PA_FLAG_LONG_LONG, pa_long_long_int, long long int);
1178 T (PA_FLOAT, pa_float, double); /* Promoted. */
1179 T (PA_DOUBLE, pa_double, double);
1180 T (PA_DOUBLE|PA_FLAG_LONG_DOUBLE, pa_long_double, long double);
1181 T (PA_STRING, pa_string, const char *);
1182 T (PA_POINTER, pa_pointer, void *);
1183 #undef T
1184 default:
1185 if ((args_type[cnt] & PA_FLAG_PTR) != 0)
1186 args_value[cnt].pa_pointer = va_arg (ap, void *);
1187 else
1188 args_value[cnt].pa_long_double = 0.0;
1189 break;
1190 }
1191
1192 /* Now walk through all format specifiers and process them. */
1193 for (; nspecs_done < nspecs; ++nspecs_done)
1194 {
1195 #undef REF
1196 #define REF(Name) &&do2_##Name
1197 #undef LABEL
1198 #define LABEL(Name) do2_##Name
1199 STEP4_TABLE;
1200
1201 int is_negative;
1202 union
1203 {
1204 unsigned long long int longlong;
1205 unsigned long int word;
1206 } number;
1207 int base;
1208 union printf_arg the_arg;
1209 char *string; /* Pointer to argument string. */
1210
1211 /* Fill variables from values in struct. */
1212 int alt = specs[nspecs_done].info.alt;
1213 int space = specs[nspecs_done].info.space;
1214 int left = specs[nspecs_done].info.left;
1215 int showsign = specs[nspecs_done].info.showsign;
1216 int group = specs[nspecs_done].info.group;
1217 int is_long_double = specs[nspecs_done].info.is_long_double;
1218 int is_short = specs[nspecs_done].info.is_short;
1219 int is_long = specs[nspecs_done].info.is_long;
1220 int width = specs[nspecs_done].info.width;
1221 int prec = specs[nspecs_done].info.prec;
1222 char pad = specs[nspecs_done].info.pad;
1223 CHAR_T spec = specs[nspecs_done].info.spec;
1224
1225 /* Fill in last information. */
1226 if (specs[nspecs_done].width_arg != -1)
1227 {
1228 /* Extract the field width from an argument. */
1229 specs[nspecs_done].info.width =
1230 args_value[specs[nspecs_done].width_arg].pa_int;
1231
1232 if (specs[nspecs_done].info.width < 0)
1233 /* If the width value is negative left justification is
1234 selected and the value is taken as being positive. */
1235 {
1236 specs[nspecs_done].info.width *= -1;
1237 left = specs[nspecs_done].info.left = 1;
1238 }
1239 width = specs[nspecs_done].info.width;
1240 }
1241
1242 if (specs[nspecs_done].prec_arg != -1)
1243 {
1244 /* Extract the precision from an argument. */
1245 specs[nspecs_done].info.prec =
1246 args_value[specs[nspecs_done].prec_arg].pa_int;
1247
1248 if (specs[nspecs_done].info.prec < 0)
1249 /* If the precision is negative the precision is
1250 omitted. */
1251 specs[nspecs_done].info.prec = -1;
1252
1253 prec = specs[nspecs_done].info.prec;
1254 }
1255
1256 /* Process format specifiers. */
1257 while (1)
1258 {
1259 JUMP (spec, step4_jumps);
1260
1261 process_arg ((&specs[nspecs_done]));
1262
1263 LABEL (form_unknown):
1264 {
1265 extern printf_function **__printf_function_table;
1266 int function_done;
1267 printf_function *function;
1268 unsigned int i;
1269 const void **ptr;
1270
1271 function =
1272 (__printf_function_table == NULL ? NULL :
1273 __printf_function_table[specs[nspecs_done].info.spec]);
1274
1275 if (function == NULL)
1276 function = &printf_unknown;
1277
1278 ptr = alloca (specs[nspecs_done].ndata_args
1279 * sizeof (const void *));
1280
1281 /* Fill in an array of pointers to the argument values. */
1282 for (i = 0; i < specs[nspecs_done].ndata_args; ++i)
1283 ptr[i] = &args_value[specs[nspecs_done].data_arg + i];
1284
1285 /* Call the function. */
1286 function_done = (*function) (s, &specs[nspecs_done].info, ptr);
1287
1288 /* If an error occured we don't have information about #
1289 of chars. */
1290 if (function_done < 0)
1291 {
1292 funlockfile (s);
1293 return -1;
1294 }
1295
1296 done += function_done;
1297 }
1298 break;
1299 }
1300
1301 /* Write the following constant string. */
1302 outstring (specs[nspecs_done].end_of_fmt,
1303 specs[nspecs_done].next_fmt
1304 - specs[nspecs_done].end_of_fmt);
1305 }
1306 }
1307
1308 /* Unlock the stream. */
1309 funlockfile (s);
1310
1311 return done;
1312 }
1313
1314 #ifdef USE_IN_LIBIO
1315 # undef vfprintf
1316 # ifdef strong_alias
1317 /* This is for glibc. */
1318 strong_alias (_IO_vfprintf, vfprintf);
1319 # else
1320 # if defined __ELF__ || defined __GNU_LIBRARY__
1321 # include <gnu-stabs.h>
1322 # ifdef weak_alias
1323 weak_alias (_IO_vfprintf, vfprintf);
1324 # endif
1325 # endif
1326 # endif
1327 #endif
1328 \f
1329 /* Handle an unknown format specifier. This prints out a canonicalized
1330 representation of the format spec itself. */
1331 static int
1332 printf_unknown (FILE *s, const struct printf_info *info,
1333 const void *const *args)
1334
1335 {
1336 int done = 0;
1337 char work_buffer[BUFSIZ];
1338 register char *w;
1339
1340 outchar ('%');
1341
1342 if (info->alt)
1343 outchar ('#');
1344 if (info->group)
1345 outchar ('\'');
1346 if (info->showsign)
1347 outchar ('+');
1348 else if (info->space)
1349 outchar (' ');
1350 if (info->left)
1351 outchar ('-');
1352 if (info->pad == '0')
1353 outchar ('0');
1354
1355 if (info->width != 0)
1356 {
1357 w = _itoa_word (info->width, workend + 1, 10, 0);
1358 while (++w <= workend)
1359 outchar (*w);
1360 }
1361
1362 if (info->prec != -1)
1363 {
1364 outchar ('.');
1365 w = _itoa_word (info->prec, workend + 1, 10, 0);
1366 while (++w <= workend)
1367 outchar (*w);
1368 }
1369
1370 if (info->spec != '\0')
1371 outchar (info->spec);
1372
1373 return done;
1374 }
1375 \f
1376 /* Group the digits according to the grouping rules of the current locale.
1377 The interpretation of GROUPING is as in `struct lconv' from <locale.h>. */
1378 static char *
1379 group_number (CHAR_T *w, CHAR_T *rear_ptr, const CHAR_T *grouping,
1380 wchar_t thousands_sep)
1381 {
1382 int len;
1383 char *src, *s;
1384
1385 /* We treat all negative values like CHAR_MAX. */
1386
1387 if (*grouping == CHAR_MAX || *grouping < 0)
1388 /* No grouping should be done. */
1389 return w;
1390
1391 len = *grouping;
1392
1393 /* Copy existing string so that nothing gets overwritten. */
1394 src = (char *) alloca (rear_ptr - w);
1395 memcpy (src, w + 1, rear_ptr - w);
1396 s = &src[rear_ptr - w - 1];
1397 w = rear_ptr;
1398
1399 /* Process all characters in the string. */
1400 while (s >= src)
1401 {
1402 *w-- = *s--;
1403
1404 if (--len == 0 && s >= src)
1405 {
1406 /* A new group begins. */
1407 *w-- = thousands_sep;
1408
1409 len = *grouping++;
1410 if (*grouping == '\0')
1411 /* The previous grouping repeats ad infinitum. */
1412 --grouping;
1413 else if (*grouping == CHAR_MAX || *grouping < 0)
1414 {
1415 /* No further grouping to be done.
1416 Copy the rest of the number. */
1417 do
1418 *w-- = *s--;
1419 while (s >= src);
1420 break;
1421 }
1422 }
1423 }
1424 return w;
1425 }
1426 \f
1427 #ifdef USE_IN_LIBIO
1428 /* Helper "class" for `fprintf to unbuffered': creates a temporary buffer. */
1429 struct helper_file
1430 {
1431 struct _IO_FILE_plus _f;
1432 _IO_FILE *_put_stream;
1433 };
1434
1435 static int
1436 _IO_helper_overflow (_IO_FILE *s, int c)
1437 {
1438 _IO_FILE *target = ((struct helper_file*) s)->_put_stream;
1439 int used = s->_IO_write_ptr - s->_IO_write_base;
1440 if (used)
1441 {
1442 _IO_size_t written = _IO_sputn (target, s->_IO_write_base, used);
1443 s->_IO_write_ptr -= written;
1444 }
1445 return PUTC (c, s);
1446 }
1447
1448 static const struct _IO_jump_t _IO_helper_jumps =
1449 {
1450 JUMP_INIT_DUMMY,
1451 JUMP_INIT (finish, _IO_default_finish),
1452 JUMP_INIT (overflow, _IO_helper_overflow),
1453 JUMP_INIT (underflow, _IO_default_underflow),
1454 JUMP_INIT (uflow, _IO_default_uflow),
1455 JUMP_INIT (pbackfail, _IO_default_pbackfail),
1456 JUMP_INIT (xsputn, _IO_default_xsputn),
1457 JUMP_INIT (xsgetn, _IO_default_xsgetn),
1458 JUMP_INIT (seekoff, _IO_default_seekoff),
1459 JUMP_INIT (seekpos, _IO_default_seekpos),
1460 JUMP_INIT (setbuf, _IO_default_setbuf),
1461 JUMP_INIT (sync, _IO_default_sync),
1462 JUMP_INIT (doallocate, _IO_default_doallocate),
1463 JUMP_INIT (read, _IO_default_read),
1464 JUMP_INIT (write, _IO_default_write),
1465 JUMP_INIT (seek, _IO_default_seek),
1466 JUMP_INIT (close, _IO_default_close),
1467 JUMP_INIT (stat, _IO_default_stat)
1468 };
1469
1470 static int
1471 buffered_vfprintf (register _IO_FILE *s, const CHAR_T *format,
1472 _IO_va_list args)
1473 {
1474 char buf[_IO_BUFSIZ];
1475 struct helper_file helper;
1476 register _IO_FILE *hp = (_IO_FILE *) &helper;
1477 int result, to_flush;
1478
1479 /* Initialize helper. */
1480 helper._put_stream = s;
1481 hp->_IO_write_base = buf;
1482 hp->_IO_write_ptr = buf;
1483 hp->_IO_write_end = buf + sizeof buf;
1484 hp->_IO_file_flags = _IO_MAGIC|_IO_NO_READS;
1485 _IO_JUMPS (hp) = (struct _IO_jump_t *) &_IO_helper_jumps;
1486
1487 /* Now print to helper instead. */
1488 result = _IO_vfprintf (hp, format, args);
1489
1490 /* Now flush anything from the helper to the S. */
1491 if ((to_flush = hp->_IO_write_ptr - hp->_IO_write_base) > 0)
1492 {
1493 if (_IO_sputn (s, hp->_IO_write_base, to_flush) != to_flush)
1494 return -1;
1495 }
1496
1497 return result;
1498 }
1499
1500 #else /* !USE_IN_LIBIO */
1501
1502 static int
1503 buffered_vfprintf (register FILE *s, const CHAR_T *format, va_list args)
1504 {
1505 char buf[BUFSIZ];
1506 int result;
1507
1508 s->__bufp = s->__buffer = buf;
1509 s->__bufsize = sizeof buf;
1510 s->__put_limit = s->__buffer + s->__bufsize;
1511 s->__get_limit = s->__buffer;
1512
1513 /* Now use buffer to print. */
1514 result = vfprintf (s, format, args);
1515
1516 if (fflush (s) == EOF)
1517 result = -1;
1518 s->__buffer = s->__bufp = s->__get_limit = s->__put_limit = NULL;
1519 s->__bufsize = 0;
1520
1521 return result;
1522 }
1523 \f
1524 /* Pads string with given number of a specified character.
1525 This code is taken from iopadn.c of the GNU I/O library. */
1526 #define PADSIZE 16
1527 static const CHAR_T blanks[PADSIZE] =
1528 { L_(' '), L_(' '), L_(' '), L_(' '), L_(' '), L_(' '), L_(' '), L_(' '),
1529 L_(' '), L_(' '), L_(' '), L_(' '), L_(' '), L_(' '), L_(' '), L_(' ') };
1530 static const CHAR_T zeroes[PADSIZE] =
1531 { L_('0'), L_('0'), L_('0'), L_('0'), L_('0'), L_('0'), L_('0'), L_('0'),
1532 L_('0'), L_('0'), L_('0'), L_('0'), L_('0'), L_('0'), L_('0'), L_('0') };
1533
1534 ssize_t
1535 #ifndef COMPILE_WPRINTF
1536 __printf_pad (FILE *s, char pad, size_t count)
1537 #else
1538 __wprintf_pad (FILE *s, wchar_t pad, size_t count)
1539 #endif
1540 {
1541 const CHAR_T *padptr;
1542 register size_t i;
1543
1544 padptr = pad == L_(' ') ? blanks : zeroes;
1545
1546 for (i = count; i >= PADSIZE; i -= PADSIZE)
1547 if (PUT (s, padptr, PADSIZE) != PADSIZE)
1548 return -1;
1549 if (i > 0)
1550 if (PUT (s, padptr, i) != i)
1551 return -1;
1552
1553 return count;
1554 }
1555 #undef PADSIZE
1556 #endif /* USE_IN_LIBIO */
Unaltered CVS history