Thu Jan 18 00:32:43 1996 Roland McGrath <roland@churchy.gnu.ai.mit.edu>
[kopensolaris-gnu/glibc.git] / stdio-common / vfprintf.c
1 /* Copyright (C) 1991, 1992, 1993, 1994, 1995 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., 675 Mass Ave,
17 Cambridge, MA 02139, USA.  */
18
19 #include <ctype.h>
20 #include <errno.h>
21 #include <float.h>
22 #include <limits.h>
23 #include <math.h>
24 #include <printf.h>
25 #include <stdarg.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <printf.h>
29 #include <stddef.h>
30 #include "_itoa.h"
31 #include "../locale/localeinfo.h"
32
33 /* Include the shared code for parsing the format string.  */
34 #include "printf-parse.h"
35
36
37 /* This function from the GNU C library is also used in libio.
38    To compile for use in libio, compile with -DUSE_IN_LIBIO.  */
39
40 #ifdef USE_IN_LIBIO
41 /* This code is for use in libio.  */
42 #include <libioP.h>
43 #define PUT(f, s, n)    _IO_sputn (f, s, n)
44 #define PAD(padchar)                                                          \
45   if (specs[cnt].info.width > 0)                                              \
46     done += _IO_padn (s, padchar, specs[cnt].info.width)
47 #define PUTC(c, f)      _IO_putc (c, f)
48 #define vfprintf        _IO_vfprintf
49 #define size_t          _IO_size_t
50 #define FILE            _IO_FILE
51 #define va_list         _IO_va_list
52 #undef  BUFSIZ
53 #define BUFSIZ          _IO_BUFSIZ
54 #define ARGCHECK(s, format)                                                   \
55   do                                                                          \
56     {                                                                         \
57       /* Check file argument for consistence.  */                             \
58       CHECK_FILE (s, -1);                                                     \
59       if (s->_flags & _IO_NO_WRITES || format == NULL)                        \
60         {                                                                     \
61           MAYBE_SET_EINVAL;                                                   \
62           return -1;                                                          \
63         }                                                                     \
64     } while (0)
65 #define UNBUFFERED_P(s) ((s)->_IO_file_flags & _IO_UNBUFFERED)
66 #else /* ! USE_IN_LIBIO */
67 /* This code is for use in the GNU C library.  */
68 #include <stdio.h>
69 #define PUTC(c, f)      putc (c, f)
70 #define PUT(f, s, n)    fwrite (s, 1, n, f)
71 ssize_t __printf_pad __P ((FILE *, char pad, size_t n));
72 #define PAD(padchar)                                                          \
73   if (specs[cnt].info.width > 0)                                              \
74     { if (__printf_pad (s, padchar, specs[cnt].info.width) == -1)             \
75         return -1; else done += specs[cnt].info.width; }
76 #define ARGCHECK(s, format) \
77   do                                                                          \
78     {                                                                         \
79       /* Check file argument for consistence.  */                             \
80       if (!__validfp(s) || !s->__mode.__write || format == NULL)              \
81         {                                                                     \
82           errno = EINVAL;                                                     \
83           return -1;                                                          \
84         }                                                                     \
85       if (!s->__seen)                                                         \
86         {                                                                     \
87           if (__flshfp (s, EOF) == EOF)                                       \
88             return -1;                                                        \
89         }                                                                     \
90     } while (0)
91 #define UNBUFFERED_P(s) ((s)->__buffer == NULL)
92 #endif /* USE_IN_LIBIO */
93
94
95 #define outchar(x)                                                            \
96   do                                                                          \
97     {                                                                         \
98       register const int outc = (x);                                          \
99       if (PUTC (outc, s) == EOF)                                              \
100         return -1;                                                            \
101       else                                                                    \
102         ++done;                                                               \
103     } while (0)
104
105 #define outstring(string, len)                                                \
106   do                                                                          \
107     {                                                                         \
108       if (len > 20)                                                           \
109         {                                                                     \
110           if (PUT (s, string, len) != len)                                    \
111             return -1;                                                        \
112           done += len;                                                        \
113         }                                                                     \
114       else                                                                    \
115         {                                                                     \
116           register const char *cp = string;                                   \
117           register int l = len;                                               \
118           while (l-- > 0)                                                     \
119             outchar (*cp++);                                                  \
120         }                                                                     \
121     } while (0)
122
123 /* Helper function to provide temporary buffering for unbuffered streams.  */
124 static int buffered_vfprintf __P ((FILE *stream, const char *fmt, va_list));
125
126 static printf_function printf_unknown;
127
128 extern printf_function **__printf_function_table;
129
130 static char *group_number __P ((char *, char *, const char *, wchar_t));
131
132
133 int
134 vfprintf (s, format, ap)
135     register FILE *s;
136     const char *format;
137     va_list ap;
138 {
139   /* The character used as thousands separator.  */
140   wchar_t thousands_sep;
141
142   /* The string describing the size of groups of digits.  */
143   const char *grouping;
144
145   /* Array with information about the needed arguments.  This has to be
146      dynamically extendable.  */
147   size_t nspecs;
148   size_t nspecs_max;
149   struct printf_spec *specs;
150
151   /* The number of arguments the format string requests.  This will
152      determine the size of the array needed to store the argument
153      attributes.  */
154   size_t nargs;
155   int *args_type;
156   union printf_arg *args_value;
157
158   /* Positional parameters refer to arguments directly.  This could also
159      determine the maximum number of arguments.  Track the maximum number.  */
160   size_t max_ref_arg;
161
162   /* End of leading constant string.  */
163   const char *lead_str_end;
164
165   /* Number of characters written.  */
166   register size_t done = 0;
167
168   /* Running pointer through format string.  */
169   const char *f;
170
171   /* Just a counter.  */
172   int cnt;
173
174   ARGCHECK (s, format);
175
176   if (UNBUFFERED_P (s))
177     /* Use a helper function which will allocate a local temporary buffer
178        for the stream and then call us again.  */
179     return buffered_vfprintf (s, format, ap);
180
181   /* Reset multibyte characters to their initial state.  */
182   (void) mblen ((char *) NULL, 0);
183
184   /* Figure out the thousands separator character.  */
185   if (mbtowc (&thousands_sep, _NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP),
186               strlen (_NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP))) <= 0)
187     thousands_sep = (wchar_t) *_NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP);
188   grouping = _NL_CURRENT (LC_NUMERIC, GROUPING);
189   if (*grouping == '\0' || *grouping == CHAR_MAX || thousands_sep == L'\0')
190     grouping = NULL;
191
192   nspecs_max = 32;              /* A more or less arbitrary start value.  */
193   specs = alloca (nspecs_max * sizeof (struct printf_spec));
194   nspecs = 0;
195   nargs = 0;
196   max_ref_arg = 0;
197
198   /* Find the first format specifier.  */
199   lead_str_end = find_spec (format);
200
201   for (f = lead_str_end; *f != '\0'; f = specs[nspecs++].next_fmt)
202     {
203       if (nspecs >= nspecs_max)
204         {
205           /* Extend the array of format specifiers.  */
206           struct printf_spec *old = specs;
207
208           nspecs_max *= 2;
209           specs = alloca (nspecs_max * sizeof (struct printf_spec));
210           if (specs == &old[nspecs])
211             /* Stack grows up, OLD was the last thing allocated; extend it.  */
212             nspecs_max += nspecs_max / 2;
213           else
214             {
215               /* Copy the old array's elements to the new space.  */
216               memcpy (specs, old, nspecs * sizeof (struct printf_spec));
217               if (old == &specs[nspecs])
218                 /* Stack grows down, OLD was just below the new SPECS.
219                    We can use that space when the new space runs out.  */
220                 nspecs_max += nspecs_max / 2;
221             }
222         }
223
224       /* Parse the format specifier.  */
225       nargs += parse_one_spec (f, nargs, &specs[nspecs], &max_ref_arg);
226     }
227
228   /* Determine the number of arguments the format string consumes.  */
229   nargs = MAX (nargs, max_ref_arg);
230
231   /* Allocate memory for the argument descriptions.  */
232   args_type = alloca (nargs * sizeof (int));
233   memset (args_type, 0, nargs * sizeof (int));
234   args_value = alloca (nargs * sizeof (union printf_arg));
235
236   /* XXX Could do sanity check here: If any element in ARGS_TYPE is
237      still zero after this loop, format is invalid.  For now we simply
238      use 0 as the value.  */
239
240   /* Fill in the types of all the arguments.  */
241   for (cnt = 0; cnt < nspecs; ++cnt)
242     {
243       /* If the width is determined by an argument this is an int.  */
244       if (specs[cnt].width_arg != -1)
245         args_type[specs[cnt].width_arg] = PA_INT;
246
247       /* If the precision is determined by an argument this is an int.  */
248       if (specs[cnt].prec_arg != -1)
249         args_type[specs[cnt].prec_arg] = PA_INT;
250
251       switch (specs[cnt].ndata_args)
252         {
253         case 0:                 /* No arguments.  */
254           break;
255         case 1:                 /* One argument; we already have the type.  */
256           args_type[specs[cnt].data_arg] = specs[cnt].data_arg_type;
257           break;
258         default:
259           /* We have more than one argument for this format spec.  We must
260              call the arginfo function again to determine all the types.  */
261           (void) (*__printf_arginfo_table[specs[cnt].info.spec])
262             (&specs[cnt].info,
263              specs[cnt].ndata_args, &args_type[specs[cnt].data_arg]);
264           break;
265         }
266     }
267
268   /* Now we know all the types and the order.  Fill in the argument values.  */
269   for (cnt = 0; cnt < nargs; ++cnt)
270     switch (args_type[cnt])
271       {
272 #define T(tag, mem, type)                                                     \
273       case tag:                                                               \
274         args_value[cnt].mem = va_arg (ap, type);                              \
275         break
276
277         T (PA_CHAR, pa_char, int); /* Promoted.  */
278         T (PA_INT|PA_FLAG_SHORT, pa_short_int, int); /* Promoted.  */
279         T (PA_INT, pa_int, int);
280         T (PA_INT|PA_FLAG_LONG, pa_long_int, long int);
281         T (PA_INT|PA_FLAG_LONG_LONG, pa_long_long_int, long long int);
282         T (PA_FLOAT, pa_float, double); /* Promoted.  */
283         T (PA_DOUBLE, pa_double, double);
284         T (PA_DOUBLE|PA_FLAG_LONG_DOUBLE, pa_long_double, long double);
285         T (PA_STRING, pa_string, const char *);
286         T (PA_POINTER, pa_pointer, void *);
287 #undef T
288       default:
289         if ((args_type[cnt] & PA_FLAG_PTR) != 0)
290           args_value[cnt].pa_pointer = va_arg (ap, void *);
291         else
292           args_value[cnt].pa_long_double = 0.0;
293         break;
294       }
295
296   /* Write the literal text before the first format.  */
297   outstring (format, lead_str_end - format);
298
299   /* Now walk through all format specifiers and process them.  */
300   for (cnt = 0; cnt < nspecs; ++cnt)
301     {
302       printf_function *function; /* Auxiliary function to do output.  */
303       int is_neg;               /* Decimal integer is negative.  */
304       int base;                 /* Base of a number to be written.  */
305       unsigned long long int num; /* Integral number to be written.  */
306       const char *str;          /* String to be written.  */
307       char errorbuf[1024];      /* Buffer sometimes used by %m.  */
308
309       if (specs[cnt].width_arg != -1)
310         {
311           /* Extract the field width from an argument.  */
312           specs[cnt].info.width = args_value[specs[cnt].width_arg].pa_int;
313
314           if (specs[cnt].info.width < 0)
315             /* If the width value is negative left justification is selected
316                and the value is taken as being positive.  */
317             {
318               specs[cnt].info.width = -specs[cnt].info.width;
319               specs[cnt].info.left = 1;
320             }
321         }
322
323       if (specs[cnt].prec_arg != -1)
324         {
325           /* Extract the precision from an argument.  */
326           specs[cnt].info.prec = args_value[specs[cnt].prec_arg].pa_int;
327
328           if (specs[cnt].info.prec < 0)
329             /* If the precision is negative the precision is omitted.  */
330             specs[cnt].info.prec = -1;
331         }
332
333       /* Check for a user-defined handler for this spec.  */
334       function = (__printf_function_table == NULL ? NULL :
335                   __printf_function_table[specs[cnt].info.spec]);
336
337       if (function != NULL)
338       use_function:             /* Built-in formats with helpers use this.  */
339         {
340           int function_done;
341           unsigned int i;
342           const void *ptr[specs[cnt].ndata_args];
343
344           /* Fill in an array of pointers to the argument values.  */
345           for (i = 0; i < specs[cnt].ndata_args; ++i)
346             ptr[i] = &args_value[specs[cnt].data_arg + i];
347
348           /* Call the function.  */
349           function_done = (*function) (s, &specs[cnt].info, ptr);
350
351           /* If an error occured don't do any further work.  */
352           if (function_done < 0)
353             return -1;
354
355           done += function_done;
356         }
357       else
358         switch (specs[cnt].info.spec)
359           {
360           case '%':
361             /* Write a literal "%".  */
362             outchar ('%');
363             break;
364           case 'i':
365           case 'd':
366             {
367               long long int signed_num;
368
369               /* Decimal integer.  */
370               base = 10;
371               if (specs[cnt].info.is_longlong)
372                 signed_num = args_value[specs[cnt].data_arg].pa_long_long_int;
373               else if (specs[cnt].info.is_long)
374                 signed_num = args_value[specs[cnt].data_arg].pa_long_int;
375               else if (!specs[cnt].info.is_short)
376                 signed_num = args_value[specs[cnt].data_arg].pa_int;
377               else
378                 signed_num = args_value[specs[cnt].data_arg].pa_short_int;
379
380               is_neg = signed_num < 0;
381               num = is_neg ? (- signed_num) : signed_num;
382               goto number;
383             }
384
385           case 'u':
386             /* Decimal unsigned integer.  */
387             base = 10;
388             goto unsigned_number;
389
390           case 'o':
391             /* Octal unsigned integer.  */
392             base = 8;
393             goto unsigned_number;
394
395           case 'X':
396             /* Hexadecimal unsigned integer.  */
397           case 'x':
398             /* Hex with lower-case digits.  */
399             base = 16;
400
401           unsigned_number:
402             /* Unsigned number of base BASE.  */
403
404             if (specs[cnt].info.is_longlong)
405               num = args_value[specs[cnt].data_arg].pa_u_long_long_int;
406             else if (specs[cnt].info.is_long)
407               num = args_value[specs[cnt].data_arg].pa_u_long_int;
408             else if (!specs[cnt].info.is_short)
409               num = args_value[specs[cnt].data_arg].pa_u_int;
410             else
411               num = args_value[specs[cnt].data_arg].pa_u_short_int;
412
413             /* ANSI only specifies the `+' and
414                ` ' flags for signed conversions.  */
415             is_neg = 0;
416             specs[cnt].info.showsign = 0;
417             specs[cnt].info.space = 0;
418
419           number:
420             /* Number of base BASE.  */
421             {
422               char work[BUFSIZ];
423               char *const workend = &work[sizeof(work) - 1];
424               register char *w;
425
426               if (specs[cnt].info.prec == -1)
427                   /* Supply a default precision if none was given.  */
428                   specs[cnt].info.prec = 1;
429               else
430                 /* We have to take care for the '0' flag.  If a
431                    precision is given it must be ignored.  */
432                 specs[cnt].info.pad = ' ';
433
434               /* If the precision is 0 and the number is 0 nothing has
435                  to be written for the number.  */
436               if (specs[cnt].info.prec == 0 && num == 0)
437                 w = workend;
438               else
439                 {
440                   /* Put the number in WORK.  */
441                   w = _itoa (num, workend + 1, base,
442                              specs[cnt].info.spec == 'X');
443                   w -= 1;
444                   if (specs[cnt].info.group && grouping)
445                     w = group_number (w, workend, grouping, thousands_sep);
446                 }
447               specs[cnt].info.width -= workend - w;
448               specs[cnt].info.prec -= workend - w;
449
450               if (num != 0 && specs[cnt].info.alt && base == 8
451                   && specs[cnt].info.prec <= 0)
452                 {
453                   /* Add octal marker.  */
454                   *w-- = '0';
455                   --specs[cnt].info.width;
456                 }
457
458               if (specs[cnt].info.prec > 0)
459                 {
460                   /* Add zeros to the precision.  */
461                   specs[cnt].info.width -= specs[cnt].info.prec;
462                   while (specs[cnt].info.prec-- > 0)
463                     *w-- = '0';
464                 }
465
466               if (num != 0 && specs[cnt].info.alt && base == 16)
467                 /* Account for 0X hex marker.  */
468                 specs[cnt].info.width -= 2;
469
470               if (is_neg || specs[cnt].info.showsign || specs[cnt].info.space)
471                 --specs[cnt].info.width;
472
473               if (!specs[cnt].info.left && specs[cnt].info.pad == ' ')
474                 PAD (' ');
475
476               if (is_neg)
477                 outchar ('-');
478               else if (specs[cnt].info.showsign)
479                 outchar ('+');
480               else if (specs[cnt].info.space)
481                 outchar (' ');
482
483               if (num != 0 && specs[cnt].info.alt && base == 16)
484                 {
485                   outchar ('0');
486                   outchar (specs[cnt].info.spec);
487                 }
488
489               if (!specs[cnt].info.left && specs[cnt].info.pad == '0')
490                 PAD ('0');
491
492               /* Write the number.  */
493               while (++w <= workend)
494                 outchar (*w);
495
496               if (specs[cnt].info.left)
497                 PAD (' ');
498             }
499             break;
500
501           case 'e':
502           case 'E':
503           case 'f':
504           case 'g':
505           case 'G':
506             {
507               /* Floating-point number.  This is handled by printf_fp.c.  */
508               extern printf_function __printf_fp;
509               function = __printf_fp;
510               goto use_function;
511             }
512
513           case 'c':
514             /* Character.  */
515             --specs[cnt].info.width;/* Account for the character itself.  */
516             if (!specs[cnt].info.left)
517               PAD (' ');
518             outchar ((unsigned char) args_value[specs[cnt].data_arg].pa_char);
519             if (specs[cnt].info.left)
520               PAD (' ');
521             break;
522
523           case 's':
524             {
525               static const char null[] = "(null)";
526               size_t len;
527
528               str = args_value[specs[cnt].data_arg].pa_string;
529
530             string:
531
532               if (str == NULL)
533                 {
534                   /* Write "(null)" if there's space.  */
535                   if (specs[cnt].info.prec == -1
536                       || specs[cnt].info.prec >= (int) sizeof (null) - 1)
537                     {
538                       str = null;
539                       len = sizeof (null) - 1;
540                     }
541                   else
542                     {
543                       str = "";
544                       len = 0;
545                     }
546                 }
547               else if (specs[cnt].info.prec != -1)
548                 {
549                   /* Search for the end of the string, but don't search
550                      past the length specified by the precision.  */
551                   const char *end = memchr (str, '\0', specs[cnt].info.prec);
552                   if (end)
553                     len = end - str;
554                   else
555                     len = specs[cnt].info.prec;
556                 }
557               else
558                 len = strlen (str);
559
560               specs[cnt].info.width -= len;
561
562               if (!specs[cnt].info.left)
563                 PAD (' ');
564               outstring (str, len);
565               if (specs[cnt].info.left)
566                 PAD (' ');
567             }
568             break;
569
570           case 'p':
571             /* Generic pointer.  */
572             {
573               const void *ptr;
574               ptr = args_value[specs[cnt].data_arg].pa_pointer;
575               if (ptr != NULL)
576                 {
577                   /* If the pointer is not NULL, write it as a %#x spec.  */
578                   base = 16;
579                   num = (unsigned long long int) (unsigned long int) ptr;
580                   is_neg = 0;
581                   specs[cnt].info.alt = 1;
582                   specs[cnt].info.spec = 'x';
583                   specs[cnt].info.group = 0;
584                   goto number;
585                 }
586               else
587                 {
588                   /* Write "(nil)" for a nil pointer.  */
589                   str = "(nil)";
590                   /* Make sure the full string "(nil)" is printed.  */
591                   if (specs[cnt].info.prec < 5)
592                     specs[cnt].info.prec = 5;
593                   goto string;
594                 }
595             }
596             break;
597
598           case 'n':
599             /* Answer the count of characters written.  */
600             if (specs[cnt].info.is_longlong)
601               *(long long int *)
602                 args_value[specs[cnt].data_arg].pa_pointer = done;
603             else if (specs[cnt].info.is_long)
604               *(long int *)
605                 args_value[specs[cnt].data_arg].pa_pointer = done;
606             else if (!specs[cnt].info.is_short)
607               *(int *)
608                 args_value[specs[cnt].data_arg].pa_pointer = done;
609             else
610               *(short int *)
611                 args_value[specs[cnt].data_arg].pa_pointer = done;
612             break;
613
614           case 'm':
615             {
616               extern char *_strerror_internal __P ((int, char *buf, size_t));
617               str = _strerror_internal (errno, errorbuf, sizeof errorbuf);
618               goto string;
619             }
620
621           default:
622             /* Unrecognized format specifier.  */
623             function = printf_unknown;
624             goto use_function;
625           }
626
627       /* Write the following constant string.  */
628       outstring (specs[cnt].end_of_fmt,
629                  specs[cnt].next_fmt - specs[cnt].end_of_fmt);
630     }
631
632   return done;
633 }
634
635 #ifdef USE_IN_LIBIO
636 # undef vfprintf
637 # ifdef strong_alias
638 /* This is for glibc.  */
639 strong_alias (_IO_vfprintf, vfprintf)
640 # else
641 #  if defined __ELF__ || defined __GNU_LIBRARY__
642 #   include <gnu-stabs.h>
643 #   ifdef weak_alias
644 weak_alias (_IO_vfprintf, vfprintf);
645 #   endif
646 #  endif
647 # endif
648 #endif
649
650
651 /* Handle an unknown format specifier.  This prints out a canonicalized
652    representation of the format spec itself.  */
653
654 static int
655 printf_unknown (s, info, args)
656   FILE *s;
657   const struct printf_info *info;
658   const void **const args;
659 {
660   int done = 0;
661   char work[BUFSIZ];
662   char *const workend = &work[sizeof(work) - 1];
663   register char *w;
664
665   outchar ('%');
666
667   if (info->alt)
668     outchar ('#');
669   if (info->group)
670     outchar ('\'');
671   if (info->showsign)
672     outchar ('+');
673   else if (info->space)
674     outchar (' ');
675   if (info->left)
676     outchar ('-');
677   if (info->pad == '0')
678     outchar ('0');
679
680   if (info->width != 0)
681     {
682       w = _itoa (info->width, workend + 1, 10, 0);
683       while (++w <= workend)
684         outchar (*w);
685     }
686
687   if (info->prec != -1)
688     {
689       outchar ('.');
690       w = _itoa (info->prec, workend + 1, 10, 0);
691       while (++w <= workend)
692         outchar (*w);
693     }
694
695   if (info->spec != '\0')
696     outchar (info->spec);
697
698   return done;
699 }
700 \f
701 /* Group the digits according to the grouping rules of the current locale.
702    The interpretation of GROUPING is as in `struct lconv' from <locale.h>.  */
703
704 static char *
705 group_number (char *w, char *workend, const char *grouping,
706               wchar_t thousands_sep)
707 {
708   int len;
709   char *src, *s;
710
711   /* We treat all negative values like CHAR_MAX.  */
712
713   if (*grouping == CHAR_MAX || *grouping < 0)
714     /* No grouping should be done.  */
715     return w;
716
717   len = *grouping;
718
719   /* Copy existing string so that nothing gets overwritten.  */
720   src = (char *) alloca (workend - w);
721   memcpy (src, w + 1, workend - w);
722   s = &src[workend - w - 1];
723   w = workend;
724
725   /* Process all characters in the string.  */
726   while (s >= src)
727     {
728       *w-- = *s--;
729
730       if (--len == 0 && s >= src)
731         {
732           /* A new group begins.  */
733           *w-- = thousands_sep;
734
735           len = *grouping++;
736           if (*grouping == '\0')
737             /* The previous grouping repeats ad infinitum.  */
738             --grouping;
739           else if (*grouping == CHAR_MAX || *grouping < 0)
740             {
741               /* No further grouping to be done.
742                  Copy the rest of the number.  */
743               do
744                 *w-- = *s--;
745               while (s >= src);
746               break;
747             }
748         }
749     }
750   return w;
751 }
752 \f
753 #ifdef USE_IN_LIBIO
754 /* Helper "class" for `fprintf to unbuffered': creates a temporary buffer.  */
755 struct helper_file
756   {
757     struct _IO_FILE_plus _f;
758     _IO_FILE *_put_stream;
759   };
760
761 static int
762 _IO_helper_overflow (s, c)
763   _IO_FILE *s;
764   int c;
765 {
766   _IO_FILE *target = ((struct helper_file*) s)->_put_stream;
767   int used = s->_IO_write_ptr - s->_IO_write_base;
768   if (used)
769     {
770       _IO_size_t written = _IO_sputn (target, s->_IO_write_base, used);
771       s->_IO_write_ptr -= written;
772     }
773   return _IO_putc (c, s);
774 }
775
776 static const struct _IO_jump_t _IO_helper_jumps =
777   {
778     JUMP_INIT_DUMMY,
779     JUMP_INIT (finish, _IO_default_finish),
780     JUMP_INIT (overflow, _IO_helper_overflow),
781     JUMP_INIT (underflow, _IO_default_underflow),
782     JUMP_INIT (uflow, _IO_default_uflow),
783     JUMP_INIT (pbackfail, _IO_default_pbackfail),
784     JUMP_INIT (xsputn, _IO_default_xsputn),
785     JUMP_INIT (xsgetn, _IO_default_xsgetn),
786     JUMP_INIT (seekoff, _IO_default_seekoff),
787     JUMP_INIT (seekpos, _IO_default_seekpos),
788     JUMP_INIT (setbuf, _IO_default_setbuf),
789     JUMP_INIT (sync, _IO_default_sync),
790     JUMP_INIT (doallocate, _IO_default_doallocate),
791     JUMP_INIT (read, _IO_default_read),
792     JUMP_INIT (write, _IO_default_write),
793     JUMP_INIT (seek, _IO_default_seek),
794     JUMP_INIT (close, _IO_default_close),
795     JUMP_INIT (stat, _IO_default_stat)
796   };
797
798 static int
799 buffered_vfprintf (s, format, args)
800   register _IO_FILE *s;
801   char const *format;
802   _IO_va_list args;
803 {
804   char buf[_IO_BUFSIZ];
805   struct helper_file helper;
806   register _IO_FILE *hp = (_IO_FILE *) &helper;
807   int result, to_flush;
808
809   /* Initialize helper.  */
810   helper._put_stream = s;
811   hp->_IO_write_base = buf;
812   hp->_IO_write_ptr = buf;
813   hp->_IO_write_end = buf + sizeof buf;
814   hp->_IO_file_flags = _IO_MAGIC|_IO_NO_READS;
815   _IO_JUMPS (hp) = (struct _IO_jump_t *) &_IO_helper_jumps;
816
817   /* Now print to helper instead.  */
818   result = _IO_vfprintf (hp, format, args);
819
820   /* Now flush anything from the helper to the S. */
821   if ((to_flush = hp->_IO_write_ptr - hp->_IO_write_base) > 0)
822     {
823       if (_IO_sputn (s, hp->_IO_write_base, to_flush) != to_flush)
824         return -1;
825     }
826
827   return result;
828 }
829
830 #else /* !USE_IN_LIBIO */
831
832 static int
833 buffered_vfprintf (s, format, args)
834   register FILE *s;
835   char const *format;
836   va_list args;
837 {
838   char buf[BUFSIZ];
839   int result;
840
841   s->__bufp = s->__buffer = buf;
842   s->__bufsize = sizeof buf;
843   s->__put_limit = s->__buffer + s->__bufsize;
844   s->__get_limit = s->__buffer;
845
846   /* Now use buffer to print.  */
847   result = vfprintf (s, format, args);
848
849   if (fflush (s) == EOF)
850     result = -1;
851   s->__buffer = s->__bufp = s->__get_limit = s->__put_limit = NULL;
852   s->__bufsize = 0;
853
854   return result;
855 }
856
857
858 /* Pads string with given number of a specified character.
859    This code is taken from iopadn.c of the GNU I/O library.  */
860 #define PADSIZE 16
861 static const char blanks[PADSIZE] =
862 {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '};
863 static const char zeroes[PADSIZE] =
864 {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'};
865
866 ssize_t
867 __printf_pad (s, pad, count)
868      FILE *s;
869      char pad;
870      size_t count;
871 {
872   const char *padptr;
873   register size_t i;
874
875   padptr = pad == ' ' ? blanks : zeroes;
876
877   for (i = count; i >= PADSIZE; i -= PADSIZE)
878     if (PUT (s, padptr, PADSIZE) != PADSIZE)
879       return -1;
880   if (i > 0)
881     if (PUT (s, padptr, i) != i)
882       return -1;
883
884   return count;
885 }
886 #undef PADSIZE
887 #endif /* USE_IN_LIBIO */