?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update from main archive 961001
[glibc.git] / stdio-common / vfprintf.c
blob7714c0e67f63431e1390b484b287fc9c7ec6faba
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 <libc-lock.h>
27 #include "_itoa.h"
28 #include "../locale/localeinfo.h"
29
30 /* This code is shared between the standard stdio implementation found
31 in GNU C library and the libio implementation originally found in
32 GNU libg++.
33
34 Beside this it is also shared between the normal and wide character
35 implementation as defined in ISO/IEC 9899:1990/Amendment 1:1995. */
36
37 #ifndef COMPILE_WPRINTF
38 # define CHAR_T char
39 # define UCHAR_T unsigned char
40 # define INT_T int
41 # define L_(Str) Str
42 # define ISDIGIT(Ch) isdigit (Ch)
43
44 # ifdef USE_IN_LIBIO
45 # define PUT(F, S, N) _IO_sputn (F, S, N)
46 # define PAD(Padchar) \
47 if (width > 0) \
48 done += _IO_padn (s, Padchar, width)
49 # else
50 # define PUTC(C, F) putc (C, F)
51 ssize_t __printf_pad __P ((FILE *, char pad, size_t n));
52 # define PAD(Padchar) \
53 if (width > 0) \
54 { if (__printf_pad (s, Padchar, width) == -1) \
55 return -1; else done += width; }
56 # endif
57 #else
58 # define vfprintf vfwprintf
59 # define CHAR_T wchar_t
60 # define UCHAR_T uwchar_t
61 # define INT_T wint_t
62 # define L_(Str) L##Str
63 # define ISDIGIT(Ch) iswdigit (Ch)
64
65 # ifdef USE_IN_LIBIO
66 # define PUT(F, S, N) _IO_sputn (F, S, N)
67 # define PAD(Padchar) \
68 if (width > 0) \
69 done += _IO_wpadn (s, Padchar, width)
70 # else
71 # define PUTC(C, F) wputc (C, F)
72 ssize_t __wprintf_pad __P ((FILE *, wchar_t pad, size_t n));
73 # define PAD(Padchar) \
74 if (width > 0) \
75 { if (__wprintf_pad (s, Padchar, width) == -1) \
76 return -1; else done += width; }
77 # endif
78 #endif
79
80 /* Include the shared code for parsing the format string. */
81 #include "printf-parse.h"
82
83
84 #ifdef USE_IN_LIBIO
85 /* This code is for use in libio. */
86 # include <libioP.h>
87 # define PUTC(C, F) _IO_putc_unlocked (C, F)
88 # define vfprintf _IO_vfprintf
89 # define FILE _IO_FILE
90 # undef va_list
91 # define va_list _IO_va_list
92 # undef BUFSIZ
93 # define BUFSIZ _IO_BUFSIZ
94 # define ARGCHECK(S, Format) \
95 do \
96 { \
97 /* Check file argument for consistence. */ \
98 CHECK_FILE (S, -1); \
99 if (S->_flags & _IO_NO_WRITES || Format == NULL) \
100 { \
101 MAYBE_SET_EINVAL; \
102 return -1; \
103 } \
104 } while (0)
105 # define UNBUFFERED_P(S) ((S)->_IO_file_flags & _IO_UNBUFFERED)
106 #else /* ! USE_IN_LIBIO */
107 /* This code is for use in the GNU C library. */
108 # include <stdio.h>
109 # define PUT(F, S, N) fwrite (S, 1, N, F)
110 # define ARGCHECK(S, Format) \
111 do \
112 { \
113 /* Check file argument for consistence. */ \
114 if (!__validfp(S) || !S->__mode.__write || Format == NULL) \
115 { \
116 __set_errno (EINVAL); \
117 return -1; \
118 } \
119 if (!S->__seen) \
120 { \
121 if (__flshfp (S, EOF) == EOF) \
122 return -1; \
123 } \
124 } \
125 while (0)
126 # define UNBUFFERED_P(s) ((s)->__buffer == NULL)
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 extern void __flockfile (FILE *);
156 weak_extern (__flockfile);
157 extern void __funlockfile (FILE *);
158
159 /* Global variables. */
160 static const char null[] = "(null)";
161
162
163 /* Helper function to provide temporary buffering for unbuffered streams. */
164 static int buffered_vfprintf __P ((FILE *stream, const CHAR_T *fmt, va_list));
165
166 /* Handle unknown format specifier. */
167 static int printf_unknown __P ((FILE *, const struct printf_info *,
168 const void *const *));
169
170 /* Group digits of number string. */
171 static char *group_number __P ((CHAR_T *, CHAR_T *, const CHAR_T *, wchar_t));
172
173
174 /* The function itself. */
175 int
176 vfprintf (FILE *s, const CHAR_T *format, va_list ap)
177 {
178 /* The character used as thousands separator. */
179 wchar_t thousands_sep;
180
181 /* The string describing the size of groups of digits. */
182 const char *grouping;
183
184 /* Place to accumulate the result. */
185 int done;
186
187 /* Current character in format string. */
188 const UCHAR_T *f;
189
190 /* End of leading constant string. */
191 const UCHAR_T *lead_str_end;
192
193 /* Points to next format specifier. */
194 const UCHAR_T *end_of_spec;
195
196 /* Buffer intermediate results. */
197 char work_buffer[1000];
198 #define workend (&work_buffer[sizeof (work_buffer) - 1])
199
200 /* State for restartable multibyte character handling functions. */
201 mbstate_t mbstate;
202
203 /* We have to save the original argument pointer. */
204 va_list ap_save;
205
206 /* Count number of specifiers we already processed. */
207 int nspecs_done;
208
209
210 /* This table maps a character into a number representing a
211 class. In each step there is a destination label for each
212 class. */
213 static const int jump_table[] =
214 {
215 /* ' ' */ 1, 0, 0, /* '#' */ 4,
216 0, /* '%' */ 14, 0, /* '\''*/ 6,
217 0, 0, /* '*' */ 7, /* '+' */ 2,
218 0, /* '-' */ 3, /* '.' */ 9, 0,
219 /* '0' */ 5, /* '1' */ 8, /* '2' */ 8, /* '3' */ 8,
220 /* '4' */ 8, /* '5' */ 8, /* '6' */ 8, /* '7' */ 8,
221 /* '8' */ 8, /* '9' */ 8, 0, 0,
222 0, 0, 0, 0,
223 0, 0, 0, 0,
224 0, /* 'E' */ 19, 0, /* 'G' */ 19,
225 0, 0, 0, 0,
226 /* 'L' */ 12, 0, 0, 0,
227 0, 0, 0, 0,
228 0, 0, 0, 0,
229 /* 'X' */ 18, 0, /* 'Z' */ 13, 0,
230 0, 0, 0, 0,
231 0, 0, 0, /* 'c' */ 20,
232 /* 'd' */ 15, /* 'e' */ 19, /* 'f' */ 19, /* 'g' */ 19,
233 /* 'h' */ 10, /* 'i' */ 15, 0, 0,
234 /* 'l' */ 11, /* 'm' */ 24, /* 'n' */ 23, /* 'o' */ 17,
235 /* 'p' */ 22, /* 'q' */ 12, 0, /* 's' */ 21,
236 0, /* 'u' */ 16, 0, 0,
237 /* 'x' */ 18
238 };
239
240 #define NOT_IN_JUMP_RANGE(Ch) ((Ch) < ' ' || (Ch) > 'x')
241 #define CHAR_CLASS(Ch) (jump_table[(int) (Ch) - ' '])
242 #define JUMP(ChExpr, table) \
243 do \
244 { \
245 const void *ptr; \
246 spec = (ChExpr); \
247 ptr = NOT_IN_JUMP_RANGE (spec) ? REF (form_unknown) \
248 : table[CHAR_CLASS (spec)]; \
249 goto *ptr; \
250 } \
251 while (0)
252
253 #define STEP0_3_TABLE \
254 /* Step 0: at the beginning. */ \
255 static const void *step0_jumps[25] = \
256 { \
257 REF (form_unknown), \
258 REF (flag_space), /* for ' ' */ \
259 REF (flag_plus), /* for '+' */ \
260 REF (flag_minus), /* for '-' */ \
261 REF (flag_hash), /* for '<hash>' */ \
262 REF (flag_zero), /* for '0' */ \
263 REF (flag_quote), /* for '\'' */ \
264 REF (width_asterics), /* for '*' */ \
265 REF (width), /* for '1'...'9' */ \
266 REF (precision), /* for '.' */ \
267 REF (mod_half), /* for 'h' */ \
268 REF (mod_long), /* for 'l' */ \
269 REF (mod_longlong), /* for 'L', 'q' */ \
270 REF (mod_size_t), /* for 'Z' */ \
271 REF (form_percent), /* for '%' */ \
272 REF (form_integer), /* for 'd', 'i' */ \
273 REF (form_unsigned), /* for 'u' */ \
274 REF (form_octal), /* for 'o' */ \
275 REF (form_hexa), /* for 'X', 'x' */ \
276 REF (form_float), /* for 'E', 'e', 'f', 'G', 'g' */ \
277 REF (form_character), /* for 'c' */ \
278 REF (form_string), /* for 's' */ \
279 REF (form_pointer), /* for 'p' */ \
280 REF (form_number), /* for 'n' */ \
281 REF (form_strerror) /* for 'm' */ \
282 }; \
283 /* Step 1: after processing width. */ \
284 static const void *step1_jumps[25] = \
285 { \
286 REF (form_unknown), \
287 REF (form_unknown), /* for ' ' */ \
288 REF (form_unknown), /* for '+' */ \
289 REF (form_unknown), /* for '-' */ \
290 REF (form_unknown), /* for '<hash>' */ \
291 REF (form_unknown), /* for '0' */ \
292 REF (form_unknown), /* for '\'' */ \
293 REF (form_unknown), /* for '*' */ \
294 REF (form_unknown), /* for '1'...'9' */ \
295 REF (precision), /* for '.' */ \
296 REF (mod_half), /* for 'h' */ \
297 REF (mod_long), /* for 'l' */ \
298 REF (mod_longlong), /* for 'L', 'q' */ \
299 REF (mod_size_t), /* for 'Z' */ \
300 REF (form_percent), /* for '%' */ \
301 REF (form_integer), /* for 'd', 'i' */ \
302 REF (form_unsigned), /* for 'u' */ \
303 REF (form_octal), /* for 'o' */ \
304 REF (form_hexa), /* for 'X', 'x' */ \
305 REF (form_float), /* for 'E', 'e', 'f', 'G', 'g' */ \
306 REF (form_character), /* for 'c' */ \
307 REF (form_string), /* for 's' */ \
308 REF (form_pointer), /* for 'p' */ \
309 REF (form_number), /* for 'n' */ \
310 REF (form_strerror) /* for 'm' */ \
311 }; \
312 /* Step 2: after processing precision. */ \
313 static const void *step2_jumps[25] = \
314 { \
315 REF (form_unknown), \
316 REF (form_unknown), /* for ' ' */ \
317 REF (form_unknown), /* for '+' */ \
318 REF (form_unknown), /* for '-' */ \
319 REF (form_unknown), /* for '<hash>' */ \
320 REF (form_unknown), /* for '0' */ \
321 REF (form_unknown), /* for '\'' */ \
322 REF (form_unknown), /* for '*' */ \
323 REF (form_unknown), /* for '1'...'9' */ \
324 REF (form_unknown), /* for '.' */ \
325 REF (mod_half), /* for 'h' */ \
326 REF (mod_long), /* for 'l' */ \
327 REF (mod_longlong), /* for 'L', 'q' */ \
328 REF (mod_size_t), /* for 'Z' */ \
329 REF (form_percent), /* for '%' */ \
330 REF (form_integer), /* for 'd', 'i' */ \
331 REF (form_unsigned), /* for 'u' */ \
332 REF (form_octal), /* for 'o' */ \
333 REF (form_hexa), /* for 'X', 'x' */ \
334 REF (form_float), /* for 'E', 'e', 'f', 'G', 'g' */ \
335 REF (form_character), /* for 'c' */ \
336 REF (form_string), /* for 's' */ \
337 REF (form_pointer), /* for 'p' */ \
338 REF (form_number), /* for 'n' */ \
339 REF (form_strerror) /* for 'm' */ \
340 }; \
341 /* Step 3: after processing first 'l' modifier. */ \
342 static const void *step3_jumps[25] = \
343 { \
344 REF (form_unknown), \
345 REF (form_unknown), /* for ' ' */ \
346 REF (form_unknown), /* for '+' */ \
347 REF (form_unknown), /* for '-' */ \
348 REF (form_unknown), /* for '<hash>' */ \
349 REF (form_unknown), /* for '0' */ \
350 REF (form_unknown), /* for '\'' */ \
351 REF (form_unknown), /* for '*' */ \
352 REF (form_unknown), /* for '1'...'9' */ \
353 REF (form_unknown), /* for '.' */ \
354 REF (form_unknown), /* for 'h' */ \
355 REF (mod_longlong), /* for 'l' */ \
356 REF (form_unknown), /* for 'L', 'q' */ \
357 REF (form_unknown), /* for 'Z' */ \
358 REF (form_percent), /* for '%' */ \
359 REF (form_integer), /* for 'd', 'i' */ \
360 REF (form_unsigned), /* for 'u' */ \
361 REF (form_octal), /* for 'o' */ \
362 REF (form_hexa), /* for 'X', 'x' */ \
363 REF (form_float), /* for 'E', 'e', 'f', 'G', 'g' */ \
364 REF (form_character), /* for 'c' */ \
365 REF (form_string), /* for 's' */ \
366 REF (form_pointer), /* for 'p' */ \
367 REF (form_number), /* for 'n' */ \
368 REF (form_strerror) /* for 'm' */ \
369 }
370
371 #define STEP4_TABLE \
372 /* Step 4: processing format specifier. */ \
373 static const void *step4_jumps[25] = \
374 { \
375 REF (form_unknown), \
376 REF (form_unknown), /* for ' ' */ \
377 REF (form_unknown), /* for '+' */ \
378 REF (form_unknown), /* for '-' */ \
379 REF (form_unknown), /* for '<hash>' */ \
380 REF (form_unknown), /* for '0' */ \
381 REF (form_unknown), /* for '\'' */ \
382 REF (form_unknown), /* for '*' */ \
383 REF (form_unknown), /* for '1'...'9' */ \
384 REF (form_unknown), /* for '.' */ \
385 REF (form_unknown), /* for 'h' */ \
386 REF (form_unknown), /* for 'l' */ \
387 REF (form_unknown), /* for 'L', 'q' */ \
388 REF (form_unknown), /* for 'Z' */ \
389 REF (form_percent), /* for '%' */ \
390 REF (form_integer), /* for 'd', 'i' */ \
391 REF (form_unsigned), /* for 'u' */ \
392 REF (form_octal), /* for 'o' */ \
393 REF (form_hexa), /* for 'X', 'x' */ \
394 REF (form_float), /* for 'E', 'e', 'f', 'G', 'g' */ \
395 REF (form_character), /* for 'c' */ \
396 REF (form_string), /* for 's' */ \
397 REF (form_pointer), /* for 'p' */ \
398 REF (form_number), /* for 'n' */ \
399 REF (form_strerror) /* for 'm' */ \
400 }
401
402
403 #define process_arg(fspec) \
404 /* Start real work. We know about all flags and modifiers and \
405 now process the wanted format specifier. */ \
406 LABEL (form_percent): \
407 /* Write a literal "%". */ \
408 outchar ('%'); \
409 break; \
410 \
411 LABEL (form_integer): \
412 /* Signed decimal integer. */ \
413 base = 10; \
414 \
415 if (is_longlong) \
416 { \
417 long long int signed_number; \
418 \
419 if (fspec == NULL) \
420 signed_number = va_arg (ap, long long int); \
421 else \
422 signed_number = args_value[fspec->data_arg].pa_long_long_int; \
423 \
424 is_negative = signed_number < 0; \
425 number.longlong = is_negative ? (- signed_number) : signed_number; \
426 \
427 goto LABEL (longlong_number); \
428 } \
429 else \
430 { \
431 long int signed_number; \
432 \
433 if (fspec == NULL) \
434 if (is_long) \
435 signed_number = va_arg (ap, long int); \
436 else /* `short int' will be promoted to `int'. */ \
437 signed_number = va_arg (ap, int); \
438 else \
439 if (is_long) \
440 signed_number = args_value[fspec->data_arg].pa_long_int; \
441 else \
442 signed_number = args_value[fspec->data_arg].pa_int; \
443 \
444 is_negative = signed_number < 0; \
445 number.word = is_negative ? (- signed_number) : signed_number; \
446 \
447 goto LABEL (number); \
448 } \
449 /* NOTREACHED */ \
450 \
451 LABEL (form_unsigned): \
452 /* Unsigned decimal integer. */ \
453 base = 10; \
454 goto LABEL (unsigned_number); \
455 /* NOTREACHED */ \
456 \
457 LABEL (form_octal): \
458 /* Unsigned octal integer. */ \
459 base = 8; \
460 goto LABEL (unsigned_number); \
461 /* NOTREACHED */ \
462 \
463 LABEL (form_hexa): \
464 /* Unsigned hexadecimal integer. */ \
465 base = 16; \
466 \
467 LABEL (unsigned_number): /* Unsigned number of base BASE. */ \
468 \
469 /* ANSI specifies the `+' and ` ' flags only for signed \
470 conversions. */ \
471 is_negative = 0; \
472 showsign = 0; \
473 space = 0; \
474 \
475 if (is_longlong) \
476 { \
477 if (fspec == NULL) \
478 number.longlong = va_arg (ap, unsigned long long int); \
479 else \
480 number.longlong = args_value[fspec->data_arg].pa_u_long_long_int; \
481 \
482 LABEL (longlong_number): \
483 if (prec < 0) \
484 /* Supply a default precision if none was given. */ \
485 prec = 1; \
486 else \
487 /* We have to take care for the '0' flag. If a precision \
488 is given it must be ignored. */ \
489 pad = ' '; \
490 \
491 /* If the precision is 0 and the number is 0 nothing has to \
492 be written for the number. */ \
493 if (prec == 0 && number.longlong == 0) \
494 string = workend; \
495 else \
496 { \
497 /* Put the number in WORK. */ \
498 string = _itoa (number.longlong, workend + 1, base, \
499 spec == 'X'); \
500 string -= 1; \
501 if (group && grouping) \
502 string = group_number (string, workend, grouping, \
503 thousands_sep); \
504 } \
505 /* Simply further test for num != 0. */ \
506 number.word = number.longlong != 0; \
507 } \
508 else \
509 { \
510 if (fspec == NULL) \
511 if (is_long) \
512 number.word = va_arg (ap, unsigned long int); \
513 else if (!is_short) \
514 number.word = va_arg (ap, unsigned int); \
515 else \
516 number.word = (unsigned short int) va_arg (ap, unsigned int); \
517 else \
518 if (is_long) \
519 number.word = args_value[fspec->data_arg].pa_u_long_int; \
520 else if (!is_short) \
521 number.word = args_value[fspec->data_arg].pa_u_int; \
522 else \
523 number.word = (unsigned short int) \
524 args_value[fspec->data_arg].pa_u_short_int; \
525 \
526 LABEL (number): \
527 if (prec < 0) \
528 /* Supply a default precision if none was given. */ \
529 prec = 1; \
530 else \
531 /* We have to take care for the '0' flag. If a precision \
532 is given it must be ignored. */ \
533 pad = ' '; \
534 \
535 /* If the precision is 0 and the number is 0 nothing has to \
536 be written for the number. */ \
537 if (prec == 0 && number.word == 0) \
538 string = workend; \
539 else \
540 { \
541 /* Put the number in WORK. */ \
542 string = _itoa_word (number.word, workend + 1, base, \
543 spec == 'X'); \
544 string -= 1; \
545 if (group && grouping) \
546 string = group_number (string, workend, grouping, \
547 thousands_sep); \
548 } \
549 } \
550 \
551 prec -= workend - string; \
552 \
553 if (prec > 0) \
554 /* Add zeros to the precision. */ \
555 while (prec-- > 0) \
556 *string-- = '0'; \
557 else if (number.word != 0 && alt && base == 8) \
558 /* Add octal marker. */ \
559 *string-- = '0'; \
560 \
561 if (!left) \
562 { \
563 width -= workend - string; \
564 \
565 if (number.word != 0 && alt && base == 16) \
566 /* Account for 0X hex marker. */ \
567 width -= 2; \
568 \
569 if (is_negative || showsign || space) \
570 --width; \
571 \
572 if (pad == '0') \
573 { \
574 while (width-- > 0) \
575 *string-- = '0'; \
576 \
577 if (number.word != 0 && alt && base == 16) \
578 { \
579 *string-- = spec; \
580 *string-- = '0'; \
581 } \
582 \
583 if (is_negative) \
584 *string-- = '-'; \
585 else if (showsign) \
586 *string-- = '+'; \
587 else if (space) \
588 *string-- = ' '; \
589 } \
590 else \
591 { \
592 if (number.word != 0 && alt && base == 16) \
593 { \
594 *string-- = spec; \
595 *string-- = '0'; \
596 } \
597 \
598 if (is_negative) \
599 *string-- = '-'; \
600 else if (showsign) \
601 *string-- = '+'; \
602 else if (space) \
603 *string-- = ' '; \
604 \
605 while (width-- > 0) \
606 *string-- = ' '; \
607 } \
608 \
609 outstring (string + 1, workend - string); \
610 \
611 break; \
612 } \
613 else \
614 { \
615 if (number.word != 0 && alt && base == 16) \
616 { \
617 *string-- = spec; \
618 *string-- = '0'; \
619 } \
620 \
621 if (is_negative) \
622 *string-- = '-'; \
623 else if (showsign) \
624 *string-- = '+'; \
625 else if (space) \
626 *string-- = ' '; \
627 \
628 width -= workend - string; \
629 outstring (string + 1, workend - string); \
630 \
631 PAD (' '); \
632 break; \
633 } \
634 \
635 LABEL (form_float): \
636 { \
637 /* Floating-point number. This is handled by printf_fp.c. */ \
638 extern int __printf_fp __P ((FILE *, const struct printf_info *, \
639 const void **const)); \
640 const void *ptr; \
641 int function_done; \
642 \
643 if (fspec == NULL) \
644 { \
645 struct printf_info info = { prec: prec, \
646 width: width, \
647 spec: spec, \
648 is_long_double: is_long_double, \
649 is_short: is_short, \
650 is_long: is_long, \
651 alt: alt, \
652 space: space, \
653 left: left, \
654 showsign: showsign, \
655 group: group, \
656 pad: pad, \
657 extra: 0 }; \
658 \
659 if (is_long_double) \
660 the_arg.pa_long_double = va_arg (ap, long double); \
661 else \
662 the_arg.pa_double = va_arg (ap, double); \
663 ptr = (const void *) &the_arg; \
664 \
665 function_done = __printf_fp (s, &info, &ptr); \
666 } \
667 else \
668 { \
669 ptr = (const void *) &args_value[fspec->data_arg]; \
670 \
671 function_done = __printf_fp (s, &fspec->info, &ptr); \
672 } \
673 \
674 if (function_done < 0) \
675 /* Error in print handler. */ \
676 return -1; \
677 \
678 done += function_done; \
679 } \
680 break; \
681 \
682 LABEL (form_character): \
683 /* Character. */ \
684 --width; /* Account for the character itself. */ \
685 if (!left) \
686 PAD (' '); \
687 if (fspec == NULL) \
688 outchar ((unsigned char) va_arg (ap, int)); /* Promoted. */ \
689 else \
690 outchar ((unsigned char) args_value[fspec->data_arg].pa_char); \
691 if (left) \
692 PAD (' '); \
693 break; \
694 \
695 LABEL (form_string): \
696 { \
697 size_t len; \
698 \
699 /* The string argument could in fact be `char *' or `wchar_t *'. \
700 But this should not make a difference here. */ \
701 if (fspec == NULL) \
702 string = (char *) va_arg (ap, const char *); \
703 else \
704 string = (char *) args_value[fspec->data_arg].pa_string; \
705 \
706 /* Entry point for printing other strings. */ \
707 LABEL (print_string): \
708 \
709 if (string == NULL) \
710 { \
711 /* Write "(null)" if there's space. */ \
712 if (prec == -1 || prec >= (int) sizeof (null) - 1) \
713 { \
714 string = (char *) null; \
715 len = sizeof (null) - 1; \
716 } \
717 else \
718 { \
719 string = (char *) ""; \
720 len = 0; \
721 } \
722 } \
723 else if (!is_long) \
724 { \
725 if (prec != -1) \
726 { \
727 /* Search for the end of the string, but don't search past \
728 the length specified by the precision. */ \
729 const char *end = memchr (string, '\0', prec); \
730 if (end) \
731 len = end - string; \
732 else \
733 len = prec; \
734 } \
735 else \
736 len = strlen (string); \
737 } \
738 else \
739 { \
740 const wchar_t *s2 = (const wchar_t *) string; \
741 mbstate_t mbstate; \
742 \
743 len = __wcsrtombs (NULL, &s2, 0, &mbstate); \
744 if (len == (size_t) -1) \
745 /* Illegal wide-character string. */ \
746 return -1; \
747 \
748 s2 = (const wchar_t *) string; \
749 string = alloca (len + 1); \
750 (void) __wcsrtombs (string, &s2, prec != -1 ? prec : UINT_MAX, \
751 &mbstate); \
752 } \
753 \
754 if ((width -= len) < 0) \
755 { \
756 outstring (string, len); \
757 break; \
758 } \
759 \
760 if (!left) \
761 PAD (' '); \
762 outstring (string, len); \
763 if (left) \
764 PAD (' '); \
765 } \
766 break; \
767 \
768 LABEL (form_pointer): \
769 /* Generic pointer. */ \
770 { \
771 const void *ptr; \
772 if (fspec == NULL) \
773 ptr = va_arg (ap, void *); \
774 else \
775 ptr = args_value[fspec->data_arg].pa_pointer; \
776 if (ptr != NULL) \
777 { \
778 /* If the pointer is not NULL, write it as a %#x spec. */ \
779 base = 16; \
780 number.word = (unsigned long int) ptr; \
781 is_negative = 0; \
782 alt = 1; \
783 group = 0; \
784 spec = 'x'; \
785 goto LABEL (number); \
786 } \
787 else \
788 { \
789 /* Write "(nil)" for a nil pointer. */ \
790 string = (char *) "(nil)"; \
791 /* Make sure the full string "(nil)" is printed. */ \
792 if (prec < 5) \
793 prec = 5; \
794 is_long = 0; /* This is no wide-char string. */ \
795 goto LABEL (print_string); \
796 } \
797 } \
798 /* NOTREACHED */ \
799 \
800 LABEL (form_number): \
801 /* Answer the count of characters written. */ \
802 if (fspec == NULL) \
803 if (is_longlong) \
804 *(long long int *) va_arg (ap, void *) = done; \
805 else if (is_long) \
806 *(long int *) va_arg (ap, void *) = done; \
807 else if (!is_short) \
808 *(int *) va_arg (ap, void *) = done; \
809 else \
810 *(short int *) va_arg (ap, void *) = done; \
811 else \
812 if (is_longlong) \
813 *(long long int *) args_value[fspec->data_arg].pa_pointer = done; \
814 else if (is_long) \
815 *(long int *) args_value[fspec->data_arg].pa_pointer = done; \
816 else if (!is_short) \
817 *(int *) args_value[fspec->data_arg].pa_pointer = done; \
818 else \
819 *(short int *) args_value[fspec->data_arg].pa_pointer = done; \
820 break; \
821 \
822 LABEL (form_strerror): \
823 /* Print description of error ERRNO. */ \
824 { \
825 extern char *_strerror_internal __P ((int, char *buf, size_t)); \
826 \
827 string = (char *) \
828 _strerror_internal (errno, work_buffer, sizeof work_buffer); \
829 } \
830 is_long = 0; /* This is no wide-char string. */ \
831 goto LABEL (print_string)
832
833
834 /* Sanity check of arguments. */
835 ARGCHECK (s, format);
836
837 if (UNBUFFERED_P (s))
838 /* Use a helper function which will allocate a local temporary buffer
839 for the stream and then call us again. */
840 return buffered_vfprintf (s, format, ap);
841
842 /* Initialize local variables. */
843 done = 0;
844 grouping = (const char *) -1;
845 ap_save = ap;
846 nspecs_done = 0;
847
848 /* Find the first format specifier. */
849 f = lead_str_end = find_spec (format, &mbstate);
850
851 /* Lock stream. */
852 __libc_cleanup_region_start ((void (*) (void *)) &__funlockfile, s);
853
854 if (__flockfile != NULL)
855 __flockfile (s);
856
857 /* Write the literal text before the first format. */
858 outstring ((const UCHAR_T *) format,
859 lead_str_end - (const UCHAR_T *) format);
860
861 /* If we only have to print a simple string, return now. */
862 if (*f == L_('\0'))
863 goto all_done;
864
865 /* Process whole format string. */
866 do
867 {
868 #define REF(Name) &&do_##Name
869 #define LABEL(Name) do_##Name
870 STEP0_3_TABLE;
871 STEP4_TABLE;
872
873 union printf_arg *args_value; /* This is not used here but ... */
874 int is_negative; /* Flag for negative number. */
875 union
876 {
877 unsigned long long int longlong;
878 unsigned long int word;
879 } number;
880 int base;
881 union printf_arg the_arg;
882 char *string; /* Pointer to argument string. */
883 int alt = 0; /* Alternate format. */
884 int space = 0; /* Use space prefix if no sign is needed. */
885 int left = 0; /* Left-justify output. */
886 int showsign = 0; /* Always begin with plus or minus sign. */
887 int group = 0; /* Print numbers according grouping rules. */
888 int is_long_double = 0; /* Argument is long double/ long long int. */
889 int is_short = 0; /* Argument is long int. */
890 int is_long = 0; /* Argument is short int. */
891 int width = 0; /* Width of output; 0 means none specified. */
892 int prec = -1; /* Precision of output; -1 means none specified. */
893 char pad = ' '; /* Padding character. */
894 CHAR_T spec;
895
896 /* Get current character in format string. */
897 JUMP (*++f, step0_jumps);
898
899 /* ' ' flag. */
900 LABEL (flag_space):
901 space = 1;
902 JUMP (*++f, step0_jumps);
903
904 /* '+' flag. */
905 LABEL (flag_plus):
906 showsign = 1;
907 JUMP (*++f, step0_jumps);
908
909 /* The '-' flag. */
910 LABEL (flag_minus):
911 left = 1;
912 pad = L_(' ');
913 JUMP (*++f, step0_jumps);
914
915 /* The '#' flag. */
916 LABEL (flag_hash):
917 alt = 1;
918 JUMP (*++f, step0_jumps);
919
920 /* The '0' flag. */
921 LABEL (flag_zero):
922 if (!left)
923 pad = L_('0');
924 JUMP (*++f, step0_jumps);
925
926 /* The '\'' flag. */
927 LABEL (flag_quote):
928 group = 1;
929
930 /* XXX Completely wrong. Use wctob. */
931 if (grouping == (const char *) -1)
932 {
933 /* Figure out the thousands separator character. */
934 if (mbtowc (&thousands_sep,
935 _NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP),
936 strlen (_NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP))) <= 0)
937 thousands_sep = (wchar_t)
938 *_NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP);
939 grouping = _NL_CURRENT (LC_NUMERIC, GROUPING);
940 if (*grouping == '\0' || *grouping == CHAR_MAX
941 || thousands_sep == L'\0')
942 grouping = NULL;
943 }
944 JUMP (*++f, step0_jumps);
945
946 /* Get width from argument. */
947 LABEL (width_asterics):
948 {
949 const UCHAR_T *tmp; /* Temporary value. */
950
951 tmp = ++f;
952 if (ISDIGIT (*tmp) && read_int (&tmp) && *tmp == L_('$'))
953 /* The width comes from a positional parameter. */
954 goto do_positional;
955
956 width = va_arg (ap, int);
957
958 /* Negative width means left justified. */
959 if (width < 0)
960 {
961 width = -width;
962 pad = L_(' ');
963 left = 1;
964 }
965 }
966 JUMP (*f, step1_jumps);
967
968 /* Given width in format string. */
969 LABEL (width):
970 width = read_int (&f);
971 if (*f == L_('$'))
972 /* Oh, oh. The argument comes from a positional parameter. */
973 goto do_positional;
974 JUMP (*f, step1_jumps);
975
976 LABEL (precision):
977 ++f;
978 if (*f == L_('*'))
979 {
980 const UCHAR_T *tmp; /* Temporary value. */
981
982 tmp = ++f;
983 if (ISDIGIT (*tmp) && read_int (&tmp) > 0 && *tmp == L_('$'))
984 /* The precision comes from a positional parameter. */
985 goto do_positional;
986
987 prec = va_arg (ap, int);
988
989 /* If the precision is negative the precision is omitted. */
990 if (prec < 0)
991 prec = -1;
992 }
993 else if (ISDIGIT (*f))
994 prec = read_int (&f);
995 else
996 prec = 0;
997 JUMP (*f, step2_jumps);
998
999 /* Process 'h' modifier. No other modifier is allowed to
1000 follow. */
1001 LABEL (mod_half):
1002 is_short = 1;
1003 JUMP (*++f, step4_jumps);
1004
1005 /* Process 'l' modifier. There might another 'l' follow. */
1006 LABEL (mod_long):
1007 is_long = 1;
1008 JUMP (*++f, step3_jumps);
1009
1010 /* Process 'L', 'q', or 'll' modifier. No other modifier is
1011 allowed to follow. */
1012 LABEL (mod_longlong):
1013 is_long_double = 1;
1014 JUMP (*++f, step4_jumps);
1015
1016 LABEL (mod_size_t):
1017 is_longlong = sizeof (size_t) > sizeof (unsigned long int);
1018 is_long = sizeof (size_t) > sizeof (unsigned int);
1019 JUMP (*++f, step4_jumps);
1020
1021
1022 /* Process current format. */
1023 while (1)
1024 {
1025 process_arg (((struct printf_spec *) NULL));
1026
1027 LABEL (form_unknown):
1028 if (spec == L_('\0'))
1029 {
1030 /* The format string ended before the specifier is complete. */
1031 done = -1;
1032 goto all_done;
1033 }
1034
1035 /* If we are in the fast loop force entering the complicated
1036 one. */
1037 goto do_positional;
1038 }
1039
1040 /* Look for next format specifier. */
1041 f = find_spec ((end_of_spec = ++f), &mbstate);
1042
1043 /* Write the following constant string. */
1044 outstring (end_of_spec, f - end_of_spec);
1045 }
1046 while (*f != L_('\0'));
1047
1048 /* Unlock stream and return. */
1049 goto all_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 done = -1;
1293 goto all_done;
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 all_done:
1309 /* Unlock the stream. */
1310 __libc_cleanup_region_end (1);
1311
1312 return done;
1313 }
1314
1315 #ifdef USE_IN_LIBIO
1316 # undef vfprintf
1317 # ifdef strong_alias
1318 /* This is for glibc. */
1319 strong_alias (_IO_vfprintf, vfprintf);
1320 # else
1321 # if defined __ELF__ || defined __GNU_LIBRARY__
1322 # include <gnu-stabs.h>
1323 # ifdef weak_alias
1324 weak_alias (_IO_vfprintf, vfprintf);
1325 # endif
1326 # endif
1327 # endif
1328 #endif
1329 \f
1330 /* Handle an unknown format specifier. This prints out a canonicalized
1331 representation of the format spec itself. */
1332 static int
1333 printf_unknown (FILE *s, const struct printf_info *info,
1334 const void *const *args)
1335
1336 {
1337 int done = 0;
1338 char work_buffer[BUFSIZ];
1339 register char *w;
1340
1341 outchar ('%');
1342
1343 if (info->alt)
1344 outchar ('#');
1345 if (info->group)
1346 outchar ('\'');
1347 if (info->showsign)
1348 outchar ('+');
1349 else if (info->space)
1350 outchar (' ');
1351 if (info->left)
1352 outchar ('-');
1353 if (info->pad == '0')
1354 outchar ('0');
1355
1356 if (info->width != 0)
1357 {
1358 w = _itoa_word (info->width, workend + 1, 10, 0);
1359 while (++w <= workend)
1360 outchar (*w);
1361 }
1362
1363 if (info->prec != -1)
1364 {
1365 outchar ('.');
1366 w = _itoa_word (info->prec, workend + 1, 10, 0);
1367 while (++w <= workend)
1368 outchar (*w);
1369 }
1370
1371 if (info->spec != '\0')
1372 outchar (info->spec);
1373
1374 return done;
1375 }
1376 \f
1377 /* Group the digits according to the grouping rules of the current locale.
1378 The interpretation of GROUPING is as in `struct lconv' from <locale.h>. */
1379 static char *
1380 group_number (CHAR_T *w, CHAR_T *rear_ptr, const CHAR_T *grouping,
1381 wchar_t thousands_sep)
1382 {
1383 int len;
1384 char *src, *s;
1385
1386 /* We treat all negative values like CHAR_MAX. */
1387
1388 if (*grouping == CHAR_MAX || *grouping < 0)
1389 /* No grouping should be done. */
1390 return w;
1391
1392 len = *grouping;
1393
1394 /* Copy existing string so that nothing gets overwritten. */
1395 src = (char *) alloca (rear_ptr - w);
1396 memcpy (src, w + 1, rear_ptr - w);
1397 s = &src[rear_ptr - w - 1];
1398 w = rear_ptr;
1399
1400 /* Process all characters in the string. */
1401 while (s >= src)
1402 {
1403 *w-- = *s--;
1404
1405 if (--len == 0 && s >= src)
1406 {
1407 /* A new group begins. */
1408 *w-- = thousands_sep;
1409
1410 len = *grouping++;
1411 if (*grouping == '\0')
1412 /* The previous grouping repeats ad infinitum. */
1413 --grouping;
1414 else if (*grouping == CHAR_MAX || *grouping < 0)
1415 {
1416 /* No further grouping to be done.
1417 Copy the rest of the number. */
1418 do
1419 *w-- = *s--;
1420 while (s >= src);
1421 break;
1422 }
1423 }
1424 }
1425 return w;
1426 }
1427 \f
1428 #ifdef USE_IN_LIBIO
1429 /* Helper "class" for `fprintf to unbuffered': creates a temporary buffer. */
1430 struct helper_file
1431 {
1432 struct _IO_FILE_plus _f;
1433 _IO_FILE *_put_stream;
1434 #ifdef _IO_MTSAFE_IO
1435 _IO_lock_t lock;
1436 #endif
1437 };
1438
1439 static int
1440 _IO_helper_overflow (_IO_FILE *s, int c)
1441 {
1442 _IO_FILE *target = ((struct helper_file*) s)->_put_stream;
1443 int used = s->_IO_write_ptr - s->_IO_write_base;
1444 if (used)
1445 {
1446 _IO_size_t written = _IO_sputn (target, s->_IO_write_base, used);
1447 s->_IO_write_ptr -= written;
1448 }
1449 return PUTC (c, s);
1450 }
1451
1452 static const struct _IO_jump_t _IO_helper_jumps =
1453 {
1454 JUMP_INIT_DUMMY,
1455 JUMP_INIT (finish, _IO_default_finish),
1456 JUMP_INIT (overflow, _IO_helper_overflow),
1457 JUMP_INIT (underflow, _IO_default_underflow),
1458 JUMP_INIT (uflow, _IO_default_uflow),
1459 JUMP_INIT (pbackfail, _IO_default_pbackfail),
1460 JUMP_INIT (xsputn, _IO_default_xsputn),
1461 JUMP_INIT (xsgetn, _IO_default_xsgetn),
1462 JUMP_INIT (seekoff, _IO_default_seekoff),
1463 JUMP_INIT (seekpos, _IO_default_seekpos),
1464 JUMP_INIT (setbuf, _IO_default_setbuf),
1465 JUMP_INIT (sync, _IO_default_sync),
1466 JUMP_INIT (doallocate, _IO_default_doallocate),
1467 JUMP_INIT (read, _IO_default_read),
1468 JUMP_INIT (write, _IO_default_write),
1469 JUMP_INIT (seek, _IO_default_seek),
1470 JUMP_INIT (close, _IO_default_close),
1471 JUMP_INIT (stat, _IO_default_stat)
1472 };
1473
1474 static int
1475 buffered_vfprintf (register _IO_FILE *s, const CHAR_T *format,
1476 _IO_va_list args)
1477 {
1478 char buf[_IO_BUFSIZ];
1479 struct helper_file helper;
1480 register _IO_FILE *hp = (_IO_FILE *) &helper;
1481 int result, to_flush;
1482
1483 /* Initialize helper. */
1484 helper._put_stream = s;
1485 hp->_IO_write_base = buf;
1486 hp->_IO_write_ptr = buf;
1487 hp->_IO_write_end = buf + sizeof buf;
1488 hp->_IO_file_flags = _IO_MAGIC|_IO_NO_READS;
1489 #ifdef _IO_MTSAFE_IO
1490 hp->_lock = &helper.lock;
1491 #endif
1492 _IO_JUMPS (hp) = (struct _IO_jump_t *) &_IO_helper_jumps;
1493
1494 /* Now print to helper instead. */
1495 result = _IO_vfprintf (hp, format, args);
1496
1497 /* Now flush anything from the helper to the S. */
1498 if ((to_flush = hp->_IO_write_ptr - hp->_IO_write_base) > 0)
1499 {
1500 if (_IO_sputn (s, hp->_IO_write_base, to_flush) != to_flush)
1501 return -1;
1502 }
1503
1504 return result;
1505 }
1506
1507 #else /* !USE_IN_LIBIO */
1508
1509 static int
1510 buffered_vfprintf (register FILE *s, const CHAR_T *format, va_list args)
1511 {
1512 char buf[BUFSIZ];
1513 int result;
1514
1515 s->__bufp = s->__buffer = buf;
1516 s->__bufsize = sizeof buf;
1517 s->__put_limit = s->__buffer + s->__bufsize;
1518 s->__get_limit = s->__buffer;
1519
1520 /* Now use buffer to print. */
1521 result = vfprintf (s, format, args);
1522
1523 if (fflush (s) == EOF)
1524 result = -1;
1525 s->__buffer = s->__bufp = s->__get_limit = s->__put_limit = NULL;
1526 s->__bufsize = 0;
1527
1528 return result;
1529 }
1530 \f
1531 /* Pads string with given number of a specified character.
1532 This code is taken from iopadn.c of the GNU I/O library. */
1533 #define PADSIZE 16
1534 static const CHAR_T blanks[PADSIZE] =
1535 { L_(' '), L_(' '), L_(' '), L_(' '), L_(' '), L_(' '), L_(' '), L_(' '),
1536 L_(' '), L_(' '), L_(' '), L_(' '), L_(' '), L_(' '), L_(' '), L_(' ') };
1537 static const CHAR_T zeroes[PADSIZE] =
1538 { L_('0'), L_('0'), L_('0'), L_('0'), L_('0'), L_('0'), L_('0'), L_('0'),
1539 L_('0'), L_('0'), L_('0'), L_('0'), L_('0'), L_('0'), L_('0'), L_('0') };
1540
1541 ssize_t
1542 #ifndef COMPILE_WPRINTF
1543 __printf_pad (FILE *s, char pad, size_t count)
1544 #else
1545 __wprintf_pad (FILE *s, wchar_t pad, size_t count)
1546 #endif
1547 {
1548 const CHAR_T *padptr;
1549 register size_t i;
1550
1551 padptr = pad == L_(' ') ? blanks : zeroes;
1552
1553 for (i = count; i >= PADSIZE; i -= PADSIZE)
1554 if (PUT (s, padptr, PADSIZE) != PADSIZE)
1555 return -1;
1556 if (i > 0)
1557 if (PUT (s, padptr, i) != i)
1558 return -1;
1559
1560 return count;
1561 }
1562 #undef PADSIZE
1563 #endif /* USE_IN_LIBIO */
sources.redhat.com git mirror of glibc CVS