stdio-common/vfprintf.c

   1 /* Copyright (C) 1991-2013 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 Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the 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    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, see
  16    <http://www.gnu.org/licenses/>.  */
  17
  18 #include <ctype.h>
  19 #include <limits.h>
  20 #include <printf.h>
  21 #include <stdarg.h>
  22 #include <stdint.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <errno.h>
  26 #include <wchar.h>
  27 #include <bits/libc-lock.h>
  28 #include <sys/param.h>
  29 #include <_itoa.h>
  30 #include <locale/localeinfo.h>
  31 #include <stdio.h>
  32
  33 /* This code is shared between the standard stdio implementation found
  34    in GNU C library and the libio implementation originally found in
  35    GNU libg++.
  36
  37    Beside this it is also shared between the normal and wide character
  38    implementation as defined in ISO/IEC 9899:1990/Amendment 1:1995.  */
  39
  40
  41 #include <libioP.h>
  42 #define FILE            _IO_FILE
  43 #undef va_list
  44 #define va_list _IO_va_list
  45 #undef BUFSIZ
  46 #define BUFSIZ          _IO_BUFSIZ
  47 #define ARGCHECK(S, Format) \
  48   do                                                                          \
  49     {                                                                         \
  50       /* Check file argument for consistence.  */                             \
  51       CHECK_FILE (S, -1);                                                     \
  52       if (S->_flags & _IO_NO_WRITES)                                          \
  53         {                                                                     \
  54           S->_flags |= _IO_ERR_SEEN;                                          \
  55           __set_errno (EBADF);                                                \
  56           return -1;                                                          \
  57         }                                                                     \
  58       if (Format == NULL)                                                     \
  59         {                                                                     \
  60           MAYBE_SET_EINVAL;                                                   \
  61           return -1;                                                          \
  62         }                                                                     \
  63     } while (0)
  64 #define UNBUFFERED_P(S) ((S)->_IO_file_flags & _IO_UNBUFFERED)
  65
  66 #define done_add(val) \
  67   do {                                                                        \
  68     unsigned int _val = val;                                                  \
  69     assert ((unsigned int) done < (unsigned int) INT_MAX);                    \
  70     if (__glibc_unlikely (INT_MAX - done < _val))                             \
  71       {                                                                       \
  72         done = -1;                                                            \
  73          __set_errno (EOVERFLOW);                                             \
  74         goto all_done;                                                        \
  75       }                                                                       \
  76     done += _val;                                                             \
  77   } while (0)
  78
  79 #ifndef COMPILE_WPRINTF
  80 # define vfprintf       _IO_vfprintf_internal
  81 # define CHAR_T         char
  82 # define UCHAR_T        unsigned char
  83 # define INT_T          int
  84 # define L_(Str)        Str
  85 # define ISDIGIT(Ch)    ((unsigned int) ((Ch) - '0') < 10)
  86 # define STR_LEN(Str)   strlen (Str)
  87
  88 # define PUT(F, S, N)   _IO_sputn ((F), (S), (N))
  89 # define PAD(Padchar) \
  90   do {                                                                        \
  91     if (width > 0)                                                            \
  92       {                                                                       \
  93         unsigned int d = _IO_padn (s, (Padchar), width);                      \
  94         if (__glibc_unlikely (d == EOF))                                      \
  95           {                                                                   \
  96             done = -1;                                                        \
  97             goto all_done;                                                    \
  98           }                                                                   \
  99         done_add (d);                                                         \
 100       }                                                                       \
 101   } while (0)
 102 # define PUTC(C, F)     _IO_putc_unlocked (C, F)
 103 # define ORIENT         if (_IO_vtable_offset (s) == 0 && _IO_fwide (s, -1) != -1)\
 104                           return -1
 105 #else
 106 # define vfprintf       _IO_vfwprintf
 107 # define CHAR_T         wchar_t
 108 /* This is a hack!!!  There should be a type uwchar_t.  */
 109 # define UCHAR_T        unsigned int /* uwchar_t */
 110 # define INT_T          wint_t
 111 # define L_(Str)        L##Str
 112 # define ISDIGIT(Ch)    ((unsigned int) ((Ch) - L'0') < 10)
 113 # define STR_LEN(Str)   __wcslen (Str)
 114
 115 # include <_itowa.h>
 116
 117 # define PUT(F, S, N)   _IO_sputn ((F), (S), (N))
 118 # define PAD(Padchar) \
 119   do {                                                                        \
 120     if (width > 0)                                                            \
 121       {                                                                       \
 122         unsigned int d = _IO_wpadn (s, (Padchar), width);                     \
 123         if (__glibc_unlikely (d == EOF))                                      \
 124           {                                                                   \
 125             done = -1;                                                        \
 126             goto all_done;                                                    \
 127           }                                                                   \
 128         done_add (d);                                                         \
 129       }                                                                       \
 130   } while (0)
 131 # define PUTC(C, F)     _IO_putwc_unlocked (C, F)
 132 # define ORIENT         if (_IO_fwide (s, 1) != 1) return -1
 133
 134 # undef _itoa
 135 # define _itoa(Val, Buf, Base, Case) _itowa (Val, Buf, Base, Case)
 136 # define _itoa_word(Val, Buf, Base, Case) _itowa_word (Val, Buf, Base, Case)
 137 # undef EOF
 138 # define EOF WEOF
 139 #endif
 140
 141 #include "_i18n_number.h"
 142
 143 /* Include the shared code for parsing the format string.  */
 144 #include "printf-parse.h"
 145
 146
 147 #define outchar(Ch)                                                           \
 148   do                                                                          \
 149     {                                                                         \
 150       const INT_T outc = (Ch);                                                \
 151       if (PUTC (outc, s) == EOF || done == INT_MAX)                           \
 152         {                                                                     \
 153           done = -1;                                                          \
 154           goto all_done;                                                      \
 155         }                                                                     \
 156       ++done;                                                                 \
 157     }                                                                         \
 158   while (0)
 159
 160 #define outstring(String, Len)                                                \
 161   do                                                                          \
 162     {                                                                         \
 163       assert ((size_t) done <= (size_t) INT_MAX);                             \
 164       if ((size_t) PUT (s, (String), (Len)) != (size_t) (Len))                \
 165         {                                                                     \
 166           done = -1;                                                          \
 167           goto all_done;                                                      \
 168         }                                                                     \
 169       if (__glibc_unlikely (INT_MAX - done < (Len)))                          \
 170       {                                                                       \
 171         done = -1;                                                            \
 172          __set_errno (EOVERFLOW);                                             \
 173         goto all_done;                                                        \
 174       }                                                                       \
 175       done += (Len);                                                          \
 176     }                                                                         \
 177   while (0)
 178
 179 /* For handling long_double and longlong we use the same flag.  If
 180    `long' and `long long' are effectively the same type define it to
 181    zero.  */
 182 #if LONG_MAX == LONG_LONG_MAX
 183 # define is_longlong 0
 184 #else
 185 # define is_longlong is_long_double
 186 #endif
 187
 188 /* If `long' and `int' is effectively the same type we don't have to
 189    handle `long separately.  */
 190 #if INT_MAX == LONG_MAX
 191 # define is_long_num    0
 192 #else
 193 # define is_long_num    is_long
 194 #endif
 195
 196
 197 /* Global variables.  */
 198 static const CHAR_T null[] = L_("(null)");
 199
 200
 201 /* Helper function to provide temporary buffering for unbuffered streams.  */
 202 static int buffered_vfprintf (FILE *stream, const CHAR_T *fmt, va_list)
 203      __THROW __attribute__ ((noinline)) internal_function;
 204
 205 /* Handle unknown format specifier.  */
 206 static int printf_unknown (FILE *, const struct printf_info *,
 207                            const void *const *) __THROW;
 208
 209 /* Group digits of number string.  */
 210 #ifdef COMPILE_WPRINTF
 211 static CHAR_T *group_number (CHAR_T *, CHAR_T *, const char *, wchar_t)
 212      __THROW internal_function;
 213 #else
 214 static CHAR_T *group_number (CHAR_T *, CHAR_T *, const char *, const char *)
 215      __THROW internal_function;
 216 #endif
 217
 218
 219 /* The function itself.  */
 220 int
 221 vfprintf (FILE *s, const CHAR_T *format, va_list ap)
 222 {
 223   /* The character used as thousands separator.  */
 224 #ifdef COMPILE_WPRINTF
 225   wchar_t thousands_sep = L'\0';
 226 #else
 227   const char *thousands_sep = NULL;
 228 #endif
 229
 230   /* The string describing the size of groups of digits.  */
 231   const char *grouping;
 232
 233   /* Place to accumulate the result.  */
 234   int done;
 235
 236   /* Current character in format string.  */
 237   const UCHAR_T *f;
 238
 239   /* End of leading constant string.  */
 240   const UCHAR_T *lead_str_end;
 241
 242   /* Points to next format specifier.  */
 243   const UCHAR_T *end_of_spec;
 244
 245   /* Buffer intermediate results.  */
 246   CHAR_T work_buffer[1000];
 247   CHAR_T *workstart = NULL;
 248   CHAR_T *workend;
 249
 250   /* We have to save the original argument pointer.  */
 251   va_list ap_save;
 252
 253   /* Count number of specifiers we already processed.  */
 254   int nspecs_done;
 255
 256   /* For the %m format we may need the current `errno' value.  */
 257   int save_errno = errno;
 258
 259   /* 1 if format is in read-only memory, -1 if it is in writable memory,
 260      0 if unknown.  */
 261   int readonly_format = 0;
 262
 263   /* For the argument descriptions, which may be allocated on the heap.  */
 264   void *args_malloced = NULL;
 265
 266   /* This table maps a character into a number representing a
 267      class.  In each step there is a destination label for each
 268      class.  */
 269   static const uint8_t jump_table[] =
 270   {
 271     /* ' ' */  1,            0,            0, /* '#' */  4,
 272                0, /* '%' */ 14,            0, /* '\''*/  6,
 273                0,            0, /* '*' */  7, /* '+' */  2,
 274                0, /* '-' */  3, /* '.' */  9,            0,
 275     /* '0' */  5, /* '1' */  8, /* '2' */  8, /* '3' */  8,
 276     /* '4' */  8, /* '5' */  8, /* '6' */  8, /* '7' */  8,
 277     /* '8' */  8, /* '9' */  8,            0,            0,
 278                0,            0,            0,            0,
 279                0, /* 'A' */ 26,            0, /* 'C' */ 25,
 280                0, /* 'E' */ 19, /* F */   19, /* 'G' */ 19,
 281                0, /* 'I' */ 29,            0,            0,
 282     /* 'L' */ 12,            0,            0,            0,
 283                0,            0,            0, /* 'S' */ 21,
 284                0,            0,            0,            0,
 285     /* 'X' */ 18,            0, /* 'Z' */ 13,            0,
 286                0,            0,            0,            0,
 287                0, /* 'a' */ 26,            0, /* 'c' */ 20,
 288     /* 'd' */ 15, /* 'e' */ 19, /* 'f' */ 19, /* 'g' */ 19,
 289     /* 'h' */ 10, /* 'i' */ 15, /* 'j' */ 28,            0,
 290     /* 'l' */ 11, /* 'm' */ 24, /* 'n' */ 23, /* 'o' */ 17,
 291     /* 'p' */ 22, /* 'q' */ 12,            0, /* 's' */ 21,
 292     /* 't' */ 27, /* 'u' */ 16,            0,            0,
 293     /* 'x' */ 18,            0, /* 'z' */ 13
 294   };
 295
 296 #define NOT_IN_JUMP_RANGE(Ch) ((Ch) < L_(' ') || (Ch) > L_('z'))
 297 #define CHAR_CLASS(Ch) (jump_table[(INT_T) (Ch) - L_(' ')])
 298 #ifdef SHARED
 299   /* 'int' is enough and it saves some space on 64 bit systems.  */
 300 # define JUMP_TABLE_TYPE const int
 301 # define JUMP(ChExpr, table)                                                  \
 302       do                                                                      \
 303         {                                                                     \
 304           int offset;                                                         \
 305           void *ptr;                                                          \
 306           spec = (ChExpr);                                                    \
 307           offset = NOT_IN_JUMP_RANGE (spec) ? REF (form_unknown)              \
 308             : table[CHAR_CLASS (spec)];                                       \
 309           ptr = &&do_form_unknown + offset;                                   \
 310           goto *ptr;                                                          \
 311         }                                                                     \
 312       while (0)
 313 #else
 314 # define JUMP_TABLE_TYPE const void *const
 315 # define JUMP(ChExpr, table)                                                  \
 316       do                                                                      \
 317         {                                                                     \
 318           const void *ptr;                                                    \
 319           spec = (ChExpr);                                                    \
 320           ptr = NOT_IN_JUMP_RANGE (spec) ? REF (form_unknown)                 \
 321             : table[CHAR_CLASS (spec)];                                       \
 322           goto *ptr;                                                          \
 323         }                                                                     \
 324       while (0)
 325 #endif
 326
 327 #define STEP0_3_TABLE                                                         \
 328     /* Step 0: at the beginning.  */                                          \
 329     static JUMP_TABLE_TYPE step0_jumps[30] =                                  \
 330     {                                                                         \
 331       REF (form_unknown),                                                     \
 332       REF (flag_space),         /* for ' ' */                                 \
 333       REF (flag_plus),          /* for '+' */                                 \
 334       REF (flag_minus),         /* for '-' */                                 \
 335       REF (flag_hash),          /* for '<hash>' */                            \
 336       REF (flag_zero),          /* for '0' */                                 \
 337       REF (flag_quote),         /* for '\'' */                                \
 338       REF (width_asterics),     /* for '*' */                                 \
 339       REF (width),              /* for '1'...'9' */                           \
 340       REF (precision),          /* for '.' */                                 \
 341       REF (mod_half),           /* for 'h' */                                 \
 342       REF (mod_long),           /* for 'l' */                                 \
 343       REF (mod_longlong),       /* for 'L', 'q' */                            \
 344       REF (mod_size_t),         /* for 'z', 'Z' */                            \
 345       REF (form_percent),       /* for '%' */                                 \
 346       REF (form_integer),       /* for 'd', 'i' */                            \
 347       REF (form_unsigned),      /* for 'u' */                                 \
 348       REF (form_octal),         /* for 'o' */                                 \
 349       REF (form_hexa),          /* for 'X', 'x' */                            \
 350       REF (form_float),         /* for 'E', 'e', 'F', 'f', 'G', 'g' */        \
 351       REF (form_character),     /* for 'c' */                                 \
 352       REF (form_string),        /* for 's', 'S' */                            \
 353       REF (form_pointer),       /* for 'p' */                                 \
 354       REF (form_number),        /* for 'n' */                                 \
 355       REF (form_strerror),      /* for 'm' */                                 \
 356       REF (form_wcharacter),    /* for 'C' */                                 \
 357       REF (form_floathex),      /* for 'A', 'a' */                            \
 358       REF (mod_ptrdiff_t),      /* for 't' */                                 \
 359       REF (mod_intmax_t),       /* for 'j' */                                 \
 360       REF (flag_i18n),          /* for 'I' */                                 \
 361     };                                                                        \
 362     /* Step 1: after processing width.  */                                    \
 363     static JUMP_TABLE_TYPE step1_jumps[30] =                                  \
 364     {                                                                         \
 365       REF (form_unknown),                                                     \
 366       REF (form_unknown),       /* for ' ' */                                 \
 367       REF (form_unknown),       /* for '+' */                                 \
 368       REF (form_unknown),       /* for '-' */                                 \
 369       REF (form_unknown),       /* for '<hash>' */                            \
 370       REF (form_unknown),       /* for '0' */                                 \
 371       REF (form_unknown),       /* for '\'' */                                \
 372       REF (form_unknown),       /* for '*' */                                 \
 373       REF (form_unknown),       /* for '1'...'9' */                           \
 374       REF (precision),          /* for '.' */                                 \
 375       REF (mod_half),           /* for 'h' */                                 \
 376       REF (mod_long),           /* for 'l' */                                 \
 377       REF (mod_longlong),       /* for 'L', 'q' */                            \
 378       REF (mod_size_t),         /* for 'z', 'Z' */                            \
 379       REF (form_percent),       /* for '%' */                                 \
 380       REF (form_integer),       /* for 'd', 'i' */                            \
 381       REF (form_unsigned),      /* for 'u' */                                 \
 382       REF (form_octal),         /* for 'o' */                                 \
 383       REF (form_hexa),          /* for 'X', 'x' */                            \
 384       REF (form_float),         /* for 'E', 'e', 'F', 'f', 'G', 'g' */        \
 385       REF (form_character),     /* for 'c' */                                 \
 386       REF (form_string),        /* for 's', 'S' */                            \
 387       REF (form_pointer),       /* for 'p' */                                 \
 388       REF (form_number),        /* for 'n' */                                 \
 389       REF (form_strerror),      /* for 'm' */                                 \
 390       REF (form_wcharacter),    /* for 'C' */                                 \
 391       REF (form_floathex),      /* for 'A', 'a' */                            \
 392       REF (mod_ptrdiff_t),      /* for 't' */                                 \
 393       REF (mod_intmax_t),       /* for 'j' */                                 \
 394       REF (form_unknown)        /* for 'I' */                                 \
 395     };                                                                        \
 396     /* Step 2: after processing precision.  */                                \
 397     static JUMP_TABLE_TYPE step2_jumps[30] =                                  \
 398     {                                                                         \
 399       REF (form_unknown),                                                     \
 400       REF (form_unknown),       /* for ' ' */                                 \
 401       REF (form_unknown),       /* for '+' */                                 \
 402       REF (form_unknown),       /* for '-' */                                 \
 403       REF (form_unknown),       /* for '<hash>' */                            \
 404       REF (form_unknown),       /* for '0' */                                 \
 405       REF (form_unknown),       /* for '\'' */                                \
 406       REF (form_unknown),       /* for '*' */                                 \
 407       REF (form_unknown),       /* for '1'...'9' */                           \
 408       REF (form_unknown),       /* for '.' */                                 \
 409       REF (mod_half),           /* for 'h' */                                 \
 410       REF (mod_long),           /* for 'l' */                                 \
 411       REF (mod_longlong),       /* for 'L', 'q' */                            \
 412       REF (mod_size_t),         /* for 'z', 'Z' */                            \
 413       REF (form_percent),       /* for '%' */                                 \
 414       REF (form_integer),       /* for 'd', 'i' */                            \
 415       REF (form_unsigned),      /* for 'u' */                                 \
 416       REF (form_octal),         /* for 'o' */                                 \
 417       REF (form_hexa),          /* for 'X', 'x' */                            \
 418       REF (form_float),         /* for 'E', 'e', 'F', 'f', 'G', 'g' */        \
 419       REF (form_character),     /* for 'c' */                                 \
 420       REF (form_string),        /* for 's', 'S' */                            \
 421       REF (form_pointer),       /* for 'p' */                                 \
 422       REF (form_number),        /* for 'n' */                                 \
 423       REF (form_strerror),      /* for 'm' */                                 \
 424       REF (form_wcharacter),    /* for 'C' */                                 \
 425       REF (form_floathex),      /* for 'A', 'a' */                            \
 426       REF (mod_ptrdiff_t),      /* for 't' */                                 \
 427       REF (mod_intmax_t),       /* for 'j' */                                 \
 428       REF (form_unknown)        /* for 'I' */                                 \
 429     };                                                                        \
 430     /* Step 3a: after processing first 'h' modifier.  */                      \
 431     static JUMP_TABLE_TYPE step3a_jumps[30] =                                 \
 432     {                                                                         \
 433       REF (form_unknown),                                                     \
 434       REF (form_unknown),       /* for ' ' */                                 \
 435       REF (form_unknown),       /* for '+' */                                 \
 436       REF (form_unknown),       /* for '-' */                                 \
 437       REF (form_unknown),       /* for '<hash>' */                            \
 438       REF (form_unknown),       /* for '0' */                                 \
 439       REF (form_unknown),       /* for '\'' */                                \
 440       REF (form_unknown),       /* for '*' */                                 \
 441       REF (form_unknown),       /* for '1'...'9' */                           \
 442       REF (form_unknown),       /* for '.' */                                 \
 443       REF (mod_halfhalf),       /* for 'h' */                                 \
 444       REF (form_unknown),       /* for 'l' */                                 \
 445       REF (form_unknown),       /* for 'L', 'q' */                            \
 446       REF (form_unknown),       /* for 'z', 'Z' */                            \
 447       REF (form_percent),       /* for '%' */                                 \
 448       REF (form_integer),       /* for 'd', 'i' */                            \
 449       REF (form_unsigned),      /* for 'u' */                                 \
 450       REF (form_octal),         /* for 'o' */                                 \
 451       REF (form_hexa),          /* for 'X', 'x' */                            \
 452       REF (form_unknown),       /* for 'E', 'e', 'F', 'f', 'G', 'g' */        \
 453       REF (form_unknown),       /* for 'c' */                                 \
 454       REF (form_unknown),       /* for 's', 'S' */                            \
 455       REF (form_unknown),       /* for 'p' */                                 \
 456       REF (form_number),        /* for 'n' */                                 \
 457       REF (form_unknown),       /* for 'm' */                                 \
 458       REF (form_unknown),       /* for 'C' */                                 \
 459       REF (form_unknown),       /* for 'A', 'a' */                            \
 460       REF (form_unknown),       /* for 't' */                                 \
 461       REF (form_unknown),       /* for 'j' */                                 \
 462       REF (form_unknown)        /* for 'I' */                                 \
 463     };                                                                        \
 464     /* Step 3b: after processing first 'l' modifier.  */                      \
 465     static JUMP_TABLE_TYPE step3b_jumps[30] =                                 \
 466     {                                                                         \
 467       REF (form_unknown),                                                     \
 468       REF (form_unknown),       /* for ' ' */                                 \
 469       REF (form_unknown),       /* for '+' */                                 \
 470       REF (form_unknown),       /* for '-' */                                 \
 471       REF (form_unknown),       /* for '<hash>' */                            \
 472       REF (form_unknown),       /* for '0' */                                 \
 473       REF (form_unknown),       /* for '\'' */                                \
 474       REF (form_unknown),       /* for '*' */                                 \
 475       REF (form_unknown),       /* for '1'...'9' */                           \
 476       REF (form_unknown),       /* for '.' */                                 \
 477       REF (form_unknown),       /* for 'h' */                                 \
 478       REF (mod_longlong),       /* for 'l' */                                 \
 479       REF (form_unknown),       /* for 'L', 'q' */                            \
 480       REF (form_unknown),       /* for 'z', 'Z' */                            \
 481       REF (form_percent),       /* for '%' */                                 \
 482       REF (form_integer),       /* for 'd', 'i' */                            \
 483       REF (form_unsigned),      /* for 'u' */                                 \
 484       REF (form_octal),         /* for 'o' */                                 \
 485       REF (form_hexa),          /* for 'X', 'x' */                            \
 486       REF (form_float),         /* for 'E', 'e', 'F', 'f', 'G', 'g' */        \
 487       REF (form_character),     /* for 'c' */                                 \
 488       REF (form_string),        /* for 's', 'S' */                            \
 489       REF (form_pointer),       /* for 'p' */                                 \
 490       REF (form_number),        /* for 'n' */                                 \
 491       REF (form_strerror),      /* for 'm' */                                 \
 492       REF (form_wcharacter),    /* for 'C' */                                 \
 493       REF (form_floathex),      /* for 'A', 'a' */                            \
 494       REF (form_unknown),       /* for 't' */                                 \
 495       REF (form_unknown),       /* for 'j' */                                 \
 496       REF (form_unknown)        /* for 'I' */                                 \
 497     }
 498
 499 #define STEP4_TABLE                                                           \
 500     /* Step 4: processing format specifier.  */                               \
 501     static JUMP_TABLE_TYPE step4_jumps[30] =                                  \
 502     {                                                                         \
 503       REF (form_unknown),                                                     \
 504       REF (form_unknown),       /* for ' ' */                                 \
 505       REF (form_unknown),       /* for '+' */                                 \
 506       REF (form_unknown),       /* for '-' */                                 \
 507       REF (form_unknown),       /* for '<hash>' */                            \
 508       REF (form_unknown),       /* for '0' */                                 \
 509       REF (form_unknown),       /* for '\'' */                                \
 510       REF (form_unknown),       /* for '*' */                                 \
 511       REF (form_unknown),       /* for '1'...'9' */                           \
 512       REF (form_unknown),       /* for '.' */                                 \
 513       REF (form_unknown),       /* for 'h' */                                 \
 514       REF (form_unknown),       /* for 'l' */                                 \
 515       REF (form_unknown),       /* for 'L', 'q' */                            \
 516       REF (form_unknown),       /* for 'z', 'Z' */                            \
 517       REF (form_percent),       /* for '%' */                                 \
 518       REF (form_integer),       /* for 'd', 'i' */                            \
 519       REF (form_unsigned),      /* for 'u' */                                 \
 520       REF (form_octal),         /* for 'o' */                                 \
 521       REF (form_hexa),          /* for 'X', 'x' */                            \
 522       REF (form_float),         /* for 'E', 'e', 'F', 'f', 'G', 'g' */        \
 523       REF (form_character),     /* for 'c' */                                 \
 524       REF (form_string),        /* for 's', 'S' */                            \
 525       REF (form_pointer),       /* for 'p' */                                 \
 526       REF (form_number),        /* for 'n' */                                 \
 527       REF (form_strerror),      /* for 'm' */                                 \
 528       REF (form_wcharacter),    /* for 'C' */                                 \
 529       REF (form_floathex),      /* for 'A', 'a' */                            \
 530       REF (form_unknown),       /* for 't' */                                 \
 531       REF (form_unknown),       /* for 'j' */                                 \
 532       REF (form_unknown)        /* for 'I' */                                 \
 533     }
 534
 535
 536 #define process_arg(fspec)                                                    \
 537       /* Start real work.  We know about all flags and modifiers and          \
 538          now process the wanted format specifier.  */                         \
 539     LABEL (form_percent):                                                     \
 540       /* Write a literal "%".  */                                             \
 541       outchar (L_('%'));                                                      \
 542       break;                                                                  \
 543                                                                               \
 544     LABEL (form_integer):                                                     \
 545       /* Signed decimal integer.  */                                          \
 546       base = 10;                                                              \
 547                                                                               \
 548       if (is_longlong)                                                        \
 549         {                                                                     \
 550           long long int signed_number;                                        \
 551                                                                               \
 552           if (fspec == NULL)                                                  \
 553             signed_number = va_arg (ap, long long int);                       \
 554           else                                                                \
 555             signed_number = args_value[fspec->data_arg].pa_long_long_int;     \
 556                                                                               \
 557           is_negative = signed_number < 0;                                    \
 558           number.longlong = is_negative ? (- signed_number) : signed_number;  \
 559                                                                               \
 560           goto LABEL (longlong_number);                                       \
 561         }                                                                     \
 562       else                                                                    \
 563         {                                                                     \
 564           long int signed_number;                                             \
 565                                                                               \
 566           if (fspec == NULL)                                                  \
 567             {                                                                 \
 568               if (is_long_num)                                                \
 569                 signed_number = va_arg (ap, long int);                        \
 570               else if (is_char)                                               \
 571                 signed_number = (signed char) va_arg (ap, unsigned int);      \
 572               else if (!is_short)                                             \
 573                 signed_number = va_arg (ap, int);                             \
 574               else                                                            \
 575                 signed_number = (short int) va_arg (ap, unsigned int);        \
 576             }                                                                 \
 577           else                                                                \
 578             if (is_long_num)                                                  \
 579               signed_number = args_value[fspec->data_arg].pa_long_int;        \
 580             else if (is_char)                                                 \
 581               signed_number = (signed char)                                   \
 582                 args_value[fspec->data_arg].pa_u_int;                         \
 583             else if (!is_short)                                               \
 584               signed_number = args_value[fspec->data_arg].pa_int;             \
 585             else                                                              \
 586               signed_number = (short int)                                     \
 587                 args_value[fspec->data_arg].pa_u_int;                         \
 588                                                                               \
 589           is_negative = signed_number < 0;                                    \
 590           number.word = is_negative ? (- signed_number) : signed_number;      \
 591                                                                               \
 592           goto LABEL (number);                                                \
 593         }                                                                     \
 594       /* NOTREACHED */                                                        \
 595                                                                               \
 596     LABEL (form_unsigned):                                                    \
 597       /* Unsigned decimal integer.  */                                        \
 598       base = 10;                                                              \
 599       goto LABEL (unsigned_number);                                           \
 600       /* NOTREACHED */                                                        \
 601                                                                               \
 602     LABEL (form_octal):                                                       \
 603       /* Unsigned octal integer.  */                                          \
 604       base = 8;                                                               \
 605       goto LABEL (unsigned_number);                                           \
 606       /* NOTREACHED */                                                        \
 607                                                                               \
 608     LABEL (form_hexa):                                                        \
 609       /* Unsigned hexadecimal integer.  */                                    \
 610       base = 16;                                                              \
 611                                                                               \
 612     LABEL (unsigned_number):      /* Unsigned number of base BASE.  */        \
 613                                                                               \
 614       /* ISO specifies the `+' and ` ' flags only for signed                  \
 615          conversions.  */                                                     \
 616       is_negative = 0;                                                        \
 617       showsign = 0;                                                           \
 618       space = 0;                                                              \
 619                                                                               \
 620       if (is_longlong)                                                        \
 621         {                                                                     \
 622           if (fspec == NULL)                                                  \
 623             number.longlong = va_arg (ap, unsigned long long int);            \
 624           else                                                                \
 625             number.longlong = args_value[fspec->data_arg].pa_u_long_long_int; \
 626                                                                               \
 627         LABEL (longlong_number):                                              \
 628           if (prec < 0)                                                       \
 629             /* Supply a default precision if none was given.  */              \
 630             prec = 1;                                                         \
 631           else                                                                \
 632             /* We have to take care for the '0' flag.  If a precision         \
 633                is given it must be ignored.  */                               \
 634             pad = L_(' ');                                                    \
 635                                                                               \
 636           /* If the precision is 0 and the number is 0 nothing has to         \
 637              be written for the number, except for the 'o' format in          \
 638              alternate form.  */                                              \
 639           if (prec == 0 && number.longlong == 0)                              \
 640             {                                                                 \
 641               string = workend;                                               \
 642               if (base == 8 && alt)                                           \
 643                 *--string = L_('0');                                          \
 644             }                                                                 \
 645           else                                                                \
 646             {                                                                 \
 647               /* Put the number in WORK.  */                                  \
 648               string = _itoa (number.longlong, workend, base,                 \
 649                               spec == L_('X'));                               \
 650               if (group && grouping)                                          \
 651                 string = group_number (string, workend, grouping,             \
 652                                        thousands_sep);                        \
 653                                                                               \
 654               if (use_outdigits && base == 10)                                \
 655                 string = _i18n_number_rewrite (string, workend, workend);     \
 656             }                                                                 \
 657           /* Simplify further test for num != 0.  */                          \
 658           number.word = number.longlong != 0;                                 \
 659         }                                                                     \
 660       else                                                                    \
 661         {                                                                     \
 662           if (fspec == NULL)                                                  \
 663             {                                                                 \
 664               if (is_long_num)                                                \
 665                 number.word = va_arg (ap, unsigned long int);                 \
 666               else if (is_char)                                               \
 667                 number.word = (unsigned char) va_arg (ap, unsigned int);      \
 668               else if (!is_short)                                             \
 669                 number.word = va_arg (ap, unsigned int);                      \
 670               else                                                            \
 671                 number.word = (unsigned short int) va_arg (ap, unsigned int); \
 672             }                                                                 \
 673           else                                                                \
 674             if (is_long_num)                                                  \
 675               number.word = args_value[fspec->data_arg].pa_u_long_int;        \
 676             else if (is_char)                                                 \
 677               number.word = (unsigned char)                                   \
 678                 args_value[fspec->data_arg].pa_u_int;                         \
 679             else if (!is_short)                                               \
 680               number.word = args_value[fspec->data_arg].pa_u_int;             \
 681             else                                                              \
 682               number.word = (unsigned short int)                              \
 683                 args_value[fspec->data_arg].pa_u_int;                         \
 684                                                                               \
 685         LABEL (number):                                                       \
 686           if (prec < 0)                                                       \
 687             /* Supply a default precision if none was given.  */              \
 688             prec = 1;                                                         \
 689           else                                                                \
 690             /* We have to take care for the '0' flag.  If a precision         \
 691                is given it must be ignored.  */                               \
 692             pad = L_(' ');                                                    \
 693                                                                               \
 694           /* If the precision is 0 and the number is 0 nothing has to         \
 695              be written for the number, except for the 'o' format in          \
 696              alternate form.  */                                              \
 697           if (prec == 0 && number.word == 0)                                  \
 698             {                                                                 \
 699               string = workend;                                               \
 700               if (base == 8 && alt)                                           \
 701                 *--string = L_('0');                                          \
 702             }                                                                 \
 703           else                                                                \
 704             {                                                                 \
 705               /* Put the number in WORK.  */                                  \
 706               string = _itoa_word (number.word, workend, base,                \
 707                                    spec == L_('X'));                          \
 708               if (group && grouping)                                          \
 709                 string = group_number (string, workend, grouping,             \
 710                                        thousands_sep);                        \
 711                                                                               \
 712               if (use_outdigits && base == 10)                                \
 713                 string = _i18n_number_rewrite (string, workend, workend);     \
 714             }                                                                 \
 715         }                                                                     \
 716                                                                               \
 717       if (prec <= workend - string && number.word != 0 && alt && base == 8)   \
 718         /* Add octal marker.  */                                              \
 719         *--string = L_('0');                                                  \
 720                                                                               \
 721       prec = MAX (0, prec - (workend - string));                              \
 722                                                                               \
 723       if (!left)                                                              \
 724         {                                                                     \
 725           width -= workend - string + prec;                                   \
 726                                                                               \
 727           if (number.word != 0 && alt && base == 16)                          \
 728             /* Account for 0X hex marker.  */                                 \
 729             width -= 2;                                                       \
 730                                                                               \
 731           if (is_negative || showsign || space)                               \
 732             --width;                                                          \
 733                                                                               \
 734           if (pad == L_(' '))                                                 \
 735             {                                                                 \
 736               PAD (L_(' '));                                                  \
 737               width = 0;                                                      \
 738             }                                                                 \
 739                                                                               \
 740           if (is_negative)                                                    \
 741             outchar (L_('-'));                                                \
 742           else if (showsign)                                                  \
 743             outchar (L_('+'));                                                \
 744           else if (space)                                                     \
 745             outchar (L_(' '));                                                \
 746                                                                               \
 747           if (number.word != 0 && alt && base == 16)                          \
 748             {                                                                 \
 749               outchar (L_('0'));                                              \
 750               outchar (spec);                                                 \
 751             }                                                                 \
 752                                                                               \
 753           width += prec;                                                      \
 754           PAD (L_('0'));                                                      \
 755                                                                               \
 756           outstring (string, workend - string);                               \
 757                                                                               \
 758           break;                                                              \
 759         }                                                                     \
 760       else                                                                    \
 761         {                                                                     \
 762           if (is_negative)                                                    \
 763             {                                                                 \
 764               outchar (L_('-'));                                              \
 765               --width;                                                        \
 766             }                                                                 \
 767           else if (showsign)                                                  \
 768             {                                                                 \
 769               outchar (L_('+'));                                              \
 770               --width;                                                        \
 771             }                                                                 \
 772           else if (space)                                                     \
 773             {                                                                 \
 774               outchar (L_(' '));                                              \
 775               --width;                                                        \
 776             }                                                                 \
 777                                                                               \
 778           if (number.word != 0 && alt && base == 16)                          \
 779             {                                                                 \
 780               outchar (L_('0'));                                              \
 781               outchar (spec);                                                 \
 782               width -= 2;                                                     \
 783             }                                                                 \
 784                                                                               \
 785           width -= workend - string + prec;                                   \
 786                                                                               \
 787           if (prec > 0)                                                       \
 788             {                                                                 \
 789               int temp = width;                                               \
 790               width = prec;                                                   \
 791               PAD (L_('0'));                                                  \
 792               width = temp;                                                   \
 793             }                                                                 \
 794                                                                               \
 795           outstring (string, workend - string);                               \
 796                                                                               \
 797           PAD (L_(' '));                                                      \
 798           break;                                                              \
 799         }                                                                     \
 800                                                                               \
 801     LABEL (form_float):                                                       \
 802       {                                                                       \
 803         /* Floating-point number.  This is handled by printf_fp.c.  */        \
 804         const void *ptr;                                                      \
 805         int function_done;                                                    \
 806                                                                               \
 807         if (fspec == NULL)                                                    \
 808           {                                                                   \
 809             if (__ldbl_is_dbl)                                                \
 810               is_long_double = 0;                                             \
 811                                                                               \
 812             struct printf_info info = { .prec = prec,                         \
 813                                         .width = width,                       \
 814                                         .spec = spec,                         \
 815                                         .is_long_double = is_long_double,     \
 816                                         .is_short = is_short,                 \
 817                                         .is_long = is_long,                   \
 818                                         .alt = alt,                           \
 819                                         .space = space,                       \
 820                                         .left = left,                         \
 821                                         .showsign = showsign,                 \
 822                                         .group = group,                       \
 823                                         .pad = pad,                           \
 824                                         .extra = 0,                           \
 825                                         .i18n = use_outdigits,                \
 826                                         .wide = sizeof (CHAR_T) != 1 };       \
 827                                                                               \
 828             if (is_long_double)                                               \
 829               the_arg.pa_long_double = va_arg (ap, long double);              \
 830             else                                                              \
 831               the_arg.pa_double = va_arg (ap, double);                        \
 832             ptr = (const void *) &the_arg;                                    \
 833                                                                               \
 834             function_done = __printf_fp (s, &info, &ptr);                     \
 835           }                                                                   \
 836         else                                                                  \
 837           {                                                                   \
 838             ptr = (const void *) &args_value[fspec->data_arg];                \
 839             if (__ldbl_is_dbl)                                                \
 840               {                                                               \
 841                 fspec->data_arg_type = PA_DOUBLE;                             \
 842                 fspec->info.is_long_double = 0;                               \
 843               }                                                               \
 844                                                                               \
 845             function_done = __printf_fp (s, &fspec->info, &ptr);              \
 846           }                                                                   \
 847                                                                               \
 848         if (function_done < 0)                                                \
 849           {                                                                   \
 850             /* Error in print handler; up to handler to set errno.  */        \
 851             done = -1;                                                        \
 852             goto all_done;                                                    \
 853           }                                                                   \
 854                                                                               \
 855         done_add (function_done);                                             \
 856       }                                                                       \
 857       break;                                                                  \
 858                                                                               \
 859     LABEL (form_floathex):                                                    \
 860       {                                                                       \
 861         /* Floating point number printed as hexadecimal number.  */           \
 862         const void *ptr;                                                      \
 863         int function_done;                                                    \
 864                                                                               \
 865         if (fspec == NULL)                                                    \
 866           {                                                                   \
 867             if (__ldbl_is_dbl)                                                \
 868               is_long_double = 0;                                             \
 869                                                                               \
 870             struct printf_info info = { .prec = prec,                         \
 871                                         .width = width,                       \
 872                                         .spec = spec,                         \
 873                                         .is_long_double = is_long_double,     \
 874                                         .is_short = is_short,                 \
 875                                         .is_long = is_long,                   \
 876                                         .alt = alt,                           \
 877                                         .space = space,                       \
 878                                         .left = left,                         \
 879                                         .showsign = showsign,                 \
 880                                         .group = group,                       \
 881                                         .pad = pad,                           \
 882                                         .extra = 0,                           \
 883                                         .wide = sizeof (CHAR_T) != 1 };       \
 884                                                                               \
 885             if (is_long_double)                                               \
 886               the_arg.pa_long_double = va_arg (ap, long double);              \
 887             else                                                              \
 888               the_arg.pa_double = va_arg (ap, double);                        \
 889             ptr = (const void *) &the_arg;                                    \
 890                                                                               \
 891             function_done = __printf_fphex (s, &info, &ptr);                  \
 892           }                                                                   \
 893         else                                                                  \
 894           {                                                                   \
 895             ptr = (const void *) &args_value[fspec->data_arg];                \
 896             if (__ldbl_is_dbl)                                                \
 897               fspec->info.is_long_double = 0;                                 \
 898                                                                               \
 899             function_done = __printf_fphex (s, &fspec->info, &ptr);           \
 900           }                                                                   \
 901                                                                               \
 902         if (function_done < 0)                                                \
 903           {                                                                   \
 904             /* Error in print handler; up to handler to set errno.  */        \
 905             done = -1;                                                        \
 906             goto all_done;                                                    \
 907           }                                                                   \
 908                                                                               \
 909         done_add (function_done);                                             \
 910       }                                                                       \
 911       break;                                                                  \
 912                                                                               \
 913     LABEL (form_pointer):                                                     \
 914       /* Generic pointer.  */                                                 \
 915       {                                                                       \
 916         const void *ptr;                                                      \
 917         if (fspec == NULL)                                                    \
 918           ptr = va_arg (ap, void *);                                          \
 919         else                                                                  \
 920           ptr = args_value[fspec->data_arg].pa_pointer;                       \
 921         if (ptr != NULL)                                                      \
 922           {                                                                   \
 923             /* If the pointer is not NULL, write it as a %#x spec.  */        \
 924             base = 16;                                                        \
 925             number.word = (unsigned long int) ptr;                            \
 926             is_negative = 0;                                                  \
 927             alt = 1;                                                          \
 928             group = 0;                                                        \
 929             spec = L_('x');                                                   \
 930             goto LABEL (number);                                              \
 931           }                                                                   \
 932         else                                                                  \
 933           {                                                                   \
 934             /* Write "(nil)" for a nil pointer.  */                           \
 935             string = (CHAR_T *) L_("(nil)");                                  \
 936             /* Make sure the full string "(nil)" is printed.  */              \
 937             if (prec < 5)                                                     \
 938               prec = 5;                                                       \
 939             is_long = 0;        /* This is no wide-char string.  */           \
 940             goto LABEL (print_string);                                        \
 941           }                                                                   \
 942       }                                                                       \
 943       /* NOTREACHED */                                                        \
 944                                                                               \
 945     LABEL (form_number):                                                      \
 946       if (s->_flags2 & _IO_FLAGS2_FORTIFY)                                    \
 947         {                                                                     \
 948           if (! readonly_format)                                              \
 949             {                                                                 \
 950               extern int __readonly_area (const void *, size_t)               \
 951                 attribute_hidden;                                             \
 952               readonly_format                                                 \
 953                 = __readonly_area (format, ((STR_LEN (format) + 1)            \
 954                                             * sizeof (CHAR_T)));              \
 955             }                                                                 \
 956           if (readonly_format < 0)                                            \
 957             __libc_fatal ("*** %n in writable segment detected ***\n");       \
 958         }                                                                     \
 959       /* Answer the count of characters written.  */                          \
 960       if (fspec == NULL)                                                      \
 961         {                                                                     \
 962           if (is_longlong)                                                    \
 963             *(long long int *) va_arg (ap, void *) = done;                    \
 964           else if (is_long_num)                                               \
 965             *(long int *) va_arg (ap, void *) = done;                         \
 966           else if (is_char)                                                   \
 967             *(char *) va_arg (ap, void *) = done;                             \
 968           else if (!is_short)                                                 \
 969             *(int *) va_arg (ap, void *) = done;                              \
 970           else                                                                \
 971             *(short int *) va_arg (ap, void *) = done;                        \
 972         }                                                                     \
 973       else                                                                    \
 974         if (is_longlong)                                                      \
 975           *(long long int *) args_value[fspec->data_arg].pa_pointer = done;   \
 976         else if (is_long_num)                                                 \
 977           *(long int *) args_value[fspec->data_arg].pa_pointer = done;        \
 978         else if (is_char)                                                     \
 979           *(char *) args_value[fspec->data_arg].pa_pointer = done;            \
 980         else if (!is_short)                                                   \
 981           *(int *) args_value[fspec->data_arg].pa_pointer = done;             \
 982         else                                                                  \
 983           *(short int *) args_value[fspec->data_arg].pa_pointer = done;       \
 984       break;                                                                  \
 985                                                                               \
 986     LABEL (form_strerror):                                                    \
 987       /* Print description of error ERRNO.  */                                \
 988       string =                                                                \
 989         (CHAR_T *) __strerror_r (save_errno, (char *) work_buffer,            \
 990                                  sizeof work_buffer);                         \
 991       is_long = 0;              /* This is no wide-char string.  */           \
 992       goto LABEL (print_string)
 993
 994 #ifdef COMPILE_WPRINTF
 995 # define process_string_arg(fspec) \
 996     LABEL (form_character):                                                   \
 997       /* Character.  */                                                       \
 998       if (is_long)                                                            \
 999         goto LABEL (form_wcharacter);                                         \
1000       --width;  /* Account for the character itself.  */                      \
1001       if (!left)                                                              \
1002         PAD (L' ');                                                           \
1003       if (fspec == NULL)                                                      \
1004         outchar (__btowc ((unsigned char) va_arg (ap, int))); /* Promoted. */ \
1005       else                                                                    \
1006         outchar (__btowc ((unsigned char)                                     \
1007                           args_value[fspec->data_arg].pa_int));               \
1008       if (left)                                                               \
1009         PAD (L' ');                                                           \
1010       break;                                                                  \
1011                                                                               \
1012     LABEL (form_wcharacter):                                                  \
1013       {                                                                       \
1014         /* Wide character.  */                                                \
1015         --width;                                                              \
1016         if (!left)                                                            \
1017           PAD (L' ');                                                         \
1018         if (fspec == NULL)                                                    \
1019           outchar (va_arg (ap, wchar_t));                                     \
1020         else                                                                  \
1021           outchar (args_value[fspec->data_arg].pa_wchar);                     \
1022         if (left)                                                             \
1023           PAD (L' ');                                                         \
1024       }                                                                       \
1025       break;                                                                  \
1026                                                                               \
1027     LABEL (form_string):                                                      \
1028       {                                                                       \
1029         size_t len;                                                           \
1030         int string_malloced;                                                  \
1031                                                                               \
1032         /* The string argument could in fact be `char *' or `wchar_t *'.      \
1033            But this should not make a difference here.  */                    \
1034         if (fspec == NULL)                                                    \
1035           string = (CHAR_T *) va_arg (ap, const wchar_t *);                   \
1036         else                                                                  \
1037           string = (CHAR_T *) args_value[fspec->data_arg].pa_wstring;         \
1038                                                                               \
1039         /* Entry point for printing other strings.  */                        \
1040       LABEL (print_string):                                                   \
1041                                                                               \
1042         string_malloced = 0;                                                  \
1043         if (string == NULL)                                                   \
1044           {                                                                   \
1045             /* Write "(null)" if there's space.  */                           \
1046             if (prec == -1                                                    \
1047                 || prec >= (int) (sizeof (null) / sizeof (null[0])) - 1)      \
1048               {                                                               \
1049                 string = (CHAR_T *) null;                                     \
1050                 len = (sizeof (null) / sizeof (null[0])) - 1;                 \
1051               }                                                               \
1052             else                                                              \
1053               {                                                               \
1054                 string = (CHAR_T *) L"";                                      \
1055                 len = 0;                                                      \
1056               }                                                               \
1057           }                                                                   \
1058         else if (!is_long && spec != L_('S'))                                 \
1059           {                                                                   \
1060             /* This is complicated.  We have to transform the multibyte       \
1061                string into a wide character string.  */                       \
1062             const char *mbs = (const char *) string;                          \
1063             mbstate_t mbstate;                                                \
1064                                                                               \
1065             len = prec != -1 ? __strnlen (mbs, (size_t) prec) : strlen (mbs); \
1066                                                                               \
1067             /* Allocate dynamically an array which definitely is long         \
1068                enough for the wide character version.  Each byte in the       \
1069                multi-byte string can produce at most one wide character.  */  \
1070             if (__libc_use_alloca (len * sizeof (wchar_t)))                   \
1071               string = (CHAR_T *) alloca (len * sizeof (wchar_t));            \
1072             else if ((string = (CHAR_T *) malloc (len * sizeof (wchar_t)))    \
1073                      == NULL)                                                 \
1074               {                                                               \
1075                 done = -1;                                                    \
1076                 goto all_done;                                                \
1077               }                                                               \
1078             else                                                              \
1079               string_malloced = 1;                                            \
1080                                                                               \
1081             memset (&mbstate, '\0', sizeof (mbstate_t));                      \
1082             len = __mbsrtowcs (string, &mbs, len, &mbstate);                  \
1083             if (len == (size_t) -1)                                           \
1084               {                                                               \
1085                 /* Illegal multibyte character.  */                           \
1086                 done = -1;                                                    \
1087                 goto all_done;                                                \
1088               }                                                               \
1089           }                                                                   \
1090         else                                                                  \
1091           {                                                                   \
1092             if (prec != -1)                                                   \
1093               /* Search for the end of the string, but don't search past      \
1094                  the length specified by the precision.  */                   \
1095               len = __wcsnlen (string, prec);                                 \
1096             else                                                              \
1097               len = __wcslen (string);                                        \
1098           }                                                                   \
1099                                                                               \
1100         if ((width -= len) < 0)                                               \
1101           {                                                                   \
1102             outstring (string, len);                                          \
1103             break;                                                            \
1104           }                                                                   \
1105                                                                               \
1106         if (!left)                                                            \
1107           PAD (L' ');                                                         \
1108         outstring (string, len);                                              \
1109         if (left)                                                             \
1110           PAD (L' ');                                                         \
1111         if (__glibc_unlikely (string_malloced))                               \
1112           free (string);                                                      \
1113       }                                                                       \
1114       break;
1115 #else
1116 # define process_string_arg(fspec) \
1117     LABEL (form_character):                                                   \
1118       /* Character.  */                                                       \
1119       if (is_long)                                                            \
1120         goto LABEL (form_wcharacter);                                         \
1121       --width;  /* Account for the character itself.  */                      \
1122       if (!left)                                                              \
1123         PAD (' ');                                                            \
1124       if (fspec == NULL)                                                      \
1125         outchar ((unsigned char) va_arg (ap, int)); /* Promoted.  */          \
1126       else                                                                    \
1127         outchar ((unsigned char) args_value[fspec->data_arg].pa_int);         \
1128       if (left)                                                               \
1129         PAD (' ');                                                            \
1130       break;                                                                  \
1131                                                                               \
1132     LABEL (form_wcharacter):                                                  \
1133       {                                                                       \
1134         /* Wide character.  */                                                \
1135         char buf[MB_CUR_MAX];                                                 \
1136         mbstate_t mbstate;                                                    \
1137         size_t len;                                                           \
1138                                                                               \
1139         memset (&mbstate, '\0', sizeof (mbstate_t));                          \
1140         len = __wcrtomb (buf, (fspec == NULL ? va_arg (ap, wchar_t)           \
1141                                : args_value[fspec->data_arg].pa_wchar),       \
1142                          &mbstate);                                           \
1143         if (len == (size_t) -1)                                               \
1144           {                                                                   \
1145             /* Something went wrong during the conversion.  Bail out.  */     \
1146             done = -1;                                                        \
1147             goto all_done;                                                    \
1148           }                                                                   \
1149         width -= len;                                                         \
1150         if (!left)                                                            \
1151           PAD (' ');                                                          \
1152         outstring (buf, len);                                                 \
1153         if (left)                                                             \
1154           PAD (' ');                                                          \
1155       }                                                                       \
1156       break;                                                                  \
1157                                                                               \
1158     LABEL (form_string):                                                      \
1159       {                                                                       \
1160         size_t len;                                                           \
1161         int string_malloced;                                                  \
1162                                                                               \
1163         /* The string argument could in fact be `char *' or `wchar_t *'.      \
1164            But this should not make a difference here.  */                    \
1165         if (fspec == NULL)                                                    \
1166           string = (char *) va_arg (ap, const char *);                        \
1167         else                                                                  \
1168           string = (char *) args_value[fspec->data_arg].pa_string;            \
1169                                                                               \
1170         /* Entry point for printing other strings.  */                        \
1171       LABEL (print_string):                                                   \
1172                                                                               \
1173         string_malloced = 0;                                                  \
1174         if (string == NULL)                                                   \
1175           {                                                                   \
1176             /* Write "(null)" if there's space.  */                           \
1177             if (prec == -1 || prec >= (int) sizeof (null) - 1)                \
1178               {                                                               \
1179                 string = (char *) null;                                       \
1180                 len = sizeof (null) - 1;                                      \
1181               }                                                               \
1182             else                                                              \
1183               {                                                               \
1184                 string = (char *) "";                                         \
1185                 len = 0;                                                      \
1186               }                                                               \
1187           }                                                                   \
1188         else if (!is_long && spec != L_('S'))                                 \
1189           {                                                                   \
1190             if (prec != -1)                                                   \
1191               /* Search for the end of the string, but don't search past      \
1192                  the length (in bytes) specified by the precision.  */        \
1193               len = __strnlen (string, prec);                                 \
1194             else                                                              \
1195               len = strlen (string);                                          \
1196           }                                                                   \
1197         else                                                                  \
1198           {                                                                   \
1199             const wchar_t *s2 = (const wchar_t *) string;                     \
1200             mbstate_t mbstate;                                                \
1201                                                                               \
1202             memset (&mbstate, '\0', sizeof (mbstate_t));                      \
1203                                                                               \
1204             if (prec >= 0)                                                    \
1205               {                                                               \
1206                 /* The string `s2' might not be NUL terminated.  */           \
1207                 if (__libc_use_alloca (prec))                                 \
1208                   string = (char *) alloca (prec);                            \
1209                 else if ((string = (char *) malloc (prec)) == NULL)           \
1210                   {                                                           \
1211                     done = -1;                                                \
1212                     goto all_done;                                            \
1213                   }                                                           \
1214                 else                                                          \
1215                   string_malloced = 1;                                        \
1216                 len = __wcsrtombs (string, &s2, prec, &mbstate);              \
1217               }                                                               \
1218             else                                                              \
1219               {                                                               \
1220                 len = __wcsrtombs (NULL, &s2, 0, &mbstate);                   \
1221                 if (len != (size_t) -1)                                       \
1222                   {                                                           \
1223                     assert (__mbsinit (&mbstate));                            \
1224                     s2 = (const wchar_t *) string;                            \
1225                     if (__libc_use_alloca (len + 1))                          \
1226                       string = (char *) alloca (len + 1);                     \
1227                     else if ((string = (char *) malloc (len + 1)) == NULL)    \
1228                       {                                                       \
1229                         done = -1;                                            \
1230                         goto all_done;                                        \
1231                       }                                                       \
1232                     else                                                      \
1233                       string_malloced = 1;                                    \
1234                     (void) __wcsrtombs (string, &s2, len + 1, &mbstate);      \
1235                   }                                                           \
1236               }                                                               \
1237                                                                               \
1238             if (len == (size_t) -1)                                           \
1239               {                                                               \
1240                 /* Illegal wide-character string.  */                         \
1241                 done = -1;                                                    \
1242                 goto all_done;                                                \
1243               }                                                               \
1244           }                                                                   \
1245                                                                               \
1246         if ((width -= len) < 0)                                               \
1247           {                                                                   \
1248             outstring (string, len);                                          \
1249             break;                                                            \
1250           }                                                                   \
1251                                                                               \
1252         if (!left)                                                            \
1253           PAD (' ');                                                          \
1254         outstring (string, len);                                              \
1255         if (left)                                                             \
1256           PAD (' ');                                                          \
1257         if (__glibc_unlikely (string_malloced))                               \
1258           free (string);                                                      \
1259       }                                                                       \
1260       break;
1261 #endif
1262
1263   /* Orient the stream.  */
1264 #ifdef ORIENT
1265   ORIENT;
1266 #endif
1267
1268   /* Sanity check of arguments.  */
1269   ARGCHECK (s, format);
1270
1271 #ifdef ORIENT
1272   /* Check for correct orientation.  */
1273   if (_IO_vtable_offset (s) == 0 &&
1274       _IO_fwide (s, sizeof (CHAR_T) == 1 ? -1 : 1)
1275       != (sizeof (CHAR_T) == 1 ? -1 : 1))
1276     /* The stream is already oriented otherwise.  */
1277     return EOF;
1278 #endif
1279
1280   if (UNBUFFERED_P (s))
1281     /* Use a helper function which will allocate a local temporary buffer
1282        for the stream and then call us again.  */
1283     return buffered_vfprintf (s, format, ap);
1284
1285   /* Initialize local variables.  */
1286   done = 0;
1287   grouping = (const char *) -1;
1288 #ifdef __va_copy
1289   /* This macro will be available soon in gcc's <stdarg.h>.  We need it
1290      since on some systems `va_list' is not an integral type.  */
1291   __va_copy (ap_save, ap);
1292 #else
1293   ap_save = ap;
1294 #endif
1295   nspecs_done = 0;
1296
1297 #ifdef COMPILE_WPRINTF
1298   /* Find the first format specifier.  */
1299   f = lead_str_end = __find_specwc ((const UCHAR_T *) format);
1300 #else
1301   /* Find the first format specifier.  */
1302   f = lead_str_end = __find_specmb ((const UCHAR_T *) format);
1303 #endif
1304
1305   /* Lock stream.  */
1306   _IO_cleanup_region_start ((void (*) (void *)) &_IO_funlockfile, s);
1307   _IO_flockfile (s);
1308
1309   /* Write the literal text before the first format.  */
1310   outstring ((const UCHAR_T *) format,
1311              lead_str_end - (const UCHAR_T *) format);
1312
1313   /* If we only have to print a simple string, return now.  */
1314   if (*f == L_('\0'))
1315     goto all_done;
1316
1317   /* Use the slow path in case any printf handler is registered.  */
1318   if (__glibc_unlikely (__printf_function_table != NULL
1319                         || __printf_modifier_table != NULL
1320                         || __printf_va_arg_table != NULL))
1321     goto do_positional;
1322
1323   /* Process whole format string.  */
1324   do
1325     {
1326 #ifdef SHARED
1327 # define REF(Name) &&do_##Name - &&do_form_unknown
1328 #else
1329 # define REF(Name) &&do_##Name
1330 #endif
1331 #define LABEL(Name) do_##Name
1332       STEP0_3_TABLE;
1333       STEP4_TABLE;
1334
1335       union printf_arg *args_value;     /* This is not used here but ... */
1336       int is_negative;  /* Flag for negative number.  */
1337       union
1338       {
1339         unsigned long long int longlong;
1340         unsigned long int word;
1341       } number;
1342       int base;
1343       union printf_arg the_arg;
1344       CHAR_T *string;   /* Pointer to argument string.  */
1345       int alt = 0;      /* Alternate format.  */
1346       int space = 0;    /* Use space prefix if no sign is needed.  */
1347       int left = 0;     /* Left-justify output.  */
1348       int showsign = 0; /* Always begin with plus or minus sign.  */
1349       int group = 0;    /* Print numbers according grouping rules.  */
1350       int is_long_double = 0; /* Argument is long double/ long long int.  */
1351       int is_short = 0; /* Argument is short int.  */
1352       int is_long = 0;  /* Argument is long int.  */
1353       int is_char = 0;  /* Argument is promoted (unsigned) char.  */
1354       int width = 0;    /* Width of output; 0 means none specified.  */
1355       int prec = -1;    /* Precision of output; -1 means none specified.  */
1356       /* This flag is set by the 'I' modifier and selects the use of the
1357          `outdigits' as determined by the current locale.  */
1358       int use_outdigits = 0;
1359       UCHAR_T pad = L_(' ');/* Padding character.  */
1360       CHAR_T spec;
1361
1362       workstart = NULL;
1363       workend = &work_buffer[sizeof (work_buffer) / sizeof (CHAR_T)];
1364
1365       /* Get current character in format string.  */
1366       JUMP (*++f, step0_jumps);
1367
1368       /* ' ' flag.  */
1369     LABEL (flag_space):
1370       space = 1;
1371       JUMP (*++f, step0_jumps);
1372
1373       /* '+' flag.  */
1374     LABEL (flag_plus):
1375       showsign = 1;
1376       JUMP (*++f, step0_jumps);
1377
1378       /* The '-' flag.  */
1379     LABEL (flag_minus):
1380       left = 1;
1381       pad = L_(' ');
1382       JUMP (*++f, step0_jumps);
1383
1384       /* The '#' flag.  */
1385     LABEL (flag_hash):
1386       alt = 1;
1387       JUMP (*++f, step0_jumps);
1388
1389       /* The '0' flag.  */
1390     LABEL (flag_zero):
1391       if (!left)
1392         pad = L_('0');
1393       JUMP (*++f, step0_jumps);
1394
1395       /* The '\'' flag.  */
1396     LABEL (flag_quote):
1397       group = 1;
1398
1399       if (grouping == (const char *) -1)
1400         {
1401 #ifdef COMPILE_WPRINTF
1402           thousands_sep = _NL_CURRENT_WORD (LC_NUMERIC,
1403                                             _NL_NUMERIC_THOUSANDS_SEP_WC);
1404 #else
1405           thousands_sep = _NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP);
1406 #endif
1407
1408           grouping = _NL_CURRENT (LC_NUMERIC, GROUPING);
1409           if (*grouping == '\0' || *grouping == CHAR_MAX
1410 #ifdef COMPILE_WPRINTF
1411               || thousands_sep == L'\0'
1412 #else
1413               || *thousands_sep == '\0'
1414 #endif
1415               )
1416             grouping = NULL;
1417         }
1418       JUMP (*++f, step0_jumps);
1419
1420     LABEL (flag_i18n):
1421       use_outdigits = 1;
1422       JUMP (*++f, step0_jumps);
1423
1424       /* Get width from argument.  */
1425     LABEL (width_asterics):
1426       {
1427         const UCHAR_T *tmp;     /* Temporary value.  */
1428
1429         tmp = ++f;
1430         if (ISDIGIT (*tmp))
1431           {
1432             int pos = read_int (&tmp);
1433
1434             if (pos == -1)
1435               {
1436                 __set_errno (EOVERFLOW);
1437                 done = -1;
1438                 goto all_done;
1439               }
1440
1441             if (pos && *tmp == L_('$'))
1442               /* The width comes from a positional parameter.  */
1443               goto do_positional;
1444           }
1445         width = va_arg (ap, int);
1446
1447         /* Negative width means left justified.  */
1448         if (width < 0)
1449           {
1450             width = -width;
1451             pad = L_(' ');
1452             left = 1;
1453           }
1454
1455         if (__glibc_unlikely (width >= INT_MAX / sizeof (CHAR_T) - 32))
1456           {
1457             __set_errno (EOVERFLOW);
1458             done = -1;
1459             goto all_done;
1460           }
1461
1462         if (width >= sizeof (work_buffer) / sizeof (work_buffer[0]) - 32)
1463           {
1464             /* We have to use a special buffer.  The "32" is just a safe
1465                bet for all the output which is not counted in the width.  */
1466             size_t needed = ((size_t) width + 32) * sizeof (CHAR_T);
1467             if (__libc_use_alloca (needed))
1468               workend = (CHAR_T *) alloca (needed) + width + 32;
1469             else
1470               {
1471                 workstart = (CHAR_T *) malloc (needed);
1472                 if (workstart == NULL)
1473                   {
1474                     done = -1;
1475                     goto all_done;
1476                   }
1477                 workend = workstart + width + 32;
1478               }
1479           }
1480       }
1481       JUMP (*f, step1_jumps);
1482
1483       /* Given width in format string.  */
1484     LABEL (width):
1485       width = read_int (&f);
1486
1487       if (__glibc_unlikely (width == -1
1488                             || width >= INT_MAX / sizeof (CHAR_T) - 32))
1489         {
1490           __set_errno (EOVERFLOW);
1491           done = -1;
1492           goto all_done;
1493         }
1494
1495       if (width >= sizeof (work_buffer) / sizeof (work_buffer[0]) - 32)
1496         {
1497           /* We have to use a special buffer.  The "32" is just a safe
1498              bet for all the output which is not counted in the width.  */
1499           size_t needed = ((size_t) width + 32) * sizeof (CHAR_T);
1500           if (__libc_use_alloca (needed))
1501             workend = (CHAR_T *) alloca (needed) + width + 32;
1502           else
1503             {
1504               workstart = (CHAR_T *) malloc (needed);
1505               if (workstart == NULL)
1506                 {
1507                   done = -1;
1508                   goto all_done;
1509                 }
1510               workend = workstart + width + 32;
1511             }
1512         }
1513       if (*f == L_('$'))
1514         /* Oh, oh.  The argument comes from a positional parameter.  */
1515         goto do_positional;
1516       JUMP (*f, step1_jumps);
1517
1518     LABEL (precision):
1519       ++f;
1520       if (*f == L_('*'))
1521         {
1522           const UCHAR_T *tmp;   /* Temporary value.  */
1523
1524           tmp = ++f;
1525           if (ISDIGIT (*tmp))
1526             {
1527               int pos = read_int (&tmp);
1528
1529               if (pos == -1)
1530                 {
1531                   __set_errno (EOVERFLOW);
1532                   done = -1;
1533                   goto all_done;
1534                 }
1535
1536               if (pos && *tmp == L_('$'))
1537                 /* The precision comes from a positional parameter.  */
1538                 goto do_positional;
1539             }
1540           prec = va_arg (ap, int);
1541
1542           /* If the precision is negative the precision is omitted.  */
1543           if (prec < 0)
1544             prec = -1;
1545         }
1546       else if (ISDIGIT (*f))
1547         {
1548           prec = read_int (&f);
1549
1550           /* The precision was specified in this case as an extremely
1551              large positive value.  */
1552           if (prec == -1)
1553             {
1554               __set_errno (EOVERFLOW);
1555               done = -1;
1556               goto all_done;
1557             }
1558         }
1559       else
1560         prec = 0;
1561       if (prec > width
1562           && prec > sizeof (work_buffer) / sizeof (work_buffer[0]) - 32)
1563         {
1564           if (__glibc_unlikely (prec >= INT_MAX / sizeof (CHAR_T) - 32))
1565             {
1566               __set_errno (EOVERFLOW);
1567               done = -1;
1568               goto all_done;
1569             }
1570           size_t needed = ((size_t) prec + 32) * sizeof (CHAR_T);
1571
1572           if (__libc_use_alloca (needed))
1573             workend = (CHAR_T *) alloca (needed) + prec + 32;
1574           else
1575             {
1576               workstart = (CHAR_T *) malloc (needed);
1577               if (workstart == NULL)
1578                 {
1579                   done = -1;
1580                   goto all_done;
1581                 }
1582               workend = workstart + prec + 32;
1583             }
1584         }
1585       JUMP (*f, step2_jumps);
1586
1587       /* Process 'h' modifier.  There might another 'h' following.  */
1588     LABEL (mod_half):
1589       is_short = 1;
1590       JUMP (*++f, step3a_jumps);
1591
1592       /* Process 'hh' modifier.  */
1593     LABEL (mod_halfhalf):
1594       is_short = 0;
1595       is_char = 1;
1596       JUMP (*++f, step4_jumps);
1597
1598       /* Process 'l' modifier.  There might another 'l' following.  */
1599     LABEL (mod_long):
1600       is_long = 1;
1601       JUMP (*++f, step3b_jumps);
1602
1603       /* Process 'L', 'q', or 'll' modifier.  No other modifier is
1604          allowed to follow.  */
1605     LABEL (mod_longlong):
1606       is_long_double = 1;
1607       is_long = 1;
1608       JUMP (*++f, step4_jumps);
1609
1610     LABEL (mod_size_t):
1611       is_long_double = sizeof (size_t) > sizeof (unsigned long int);
1612       is_long = sizeof (size_t) > sizeof (unsigned int);
1613       JUMP (*++f, step4_jumps);
1614
1615     LABEL (mod_ptrdiff_t):
1616       is_long_double = sizeof (ptrdiff_t) > sizeof (unsigned long int);
1617       is_long = sizeof (ptrdiff_t) > sizeof (unsigned int);
1618       JUMP (*++f, step4_jumps);
1619
1620     LABEL (mod_intmax_t):
1621       is_long_double = sizeof (intmax_t) > sizeof (unsigned long int);
1622       is_long = sizeof (intmax_t) > sizeof (unsigned int);
1623       JUMP (*++f, step4_jumps);
1624
1625       /* Process current format.  */
1626       while (1)
1627         {
1628           process_arg (((struct printf_spec *) NULL));
1629           process_string_arg (((struct printf_spec *) NULL));
1630
1631         LABEL (form_unknown):
1632           if (spec == L_('\0'))
1633             {
1634               /* The format string ended before the specifier is complete.  */
1635               __set_errno (EINVAL);
1636               done = -1;
1637               goto all_done;
1638             }
1639
1640           /* If we are in the fast loop force entering the complicated
1641              one.  */
1642           goto do_positional;
1643         }
1644
1645       /* The format is correctly handled.  */
1646       ++nspecs_done;
1647
1648       if (__glibc_unlikely (workstart != NULL))
1649         free (workstart);
1650       workstart = NULL;
1651
1652       /* Look for next format specifier.  */
1653 #ifdef COMPILE_WPRINTF
1654       f = __find_specwc ((end_of_spec = ++f));
1655 #else
1656       f = __find_specmb ((end_of_spec = ++f));
1657 #endif
1658
1659       /* Write the following constant string.  */
1660       outstring (end_of_spec, f - end_of_spec);
1661     }
1662   while (*f != L_('\0'));
1663
1664   /* Unlock stream and return.  */
1665   goto all_done;
1666
1667   /* Here starts the more complex loop to handle positional parameters.  */
1668 do_positional:
1669   {
1670     /* Array with information about the needed arguments.  This has to
1671        be dynamically extensible.  */
1672     size_t nspecs = 0;
1673     /* A more or less arbitrary start value.  */
1674     size_t nspecs_size = 32 * sizeof (struct printf_spec);
1675     struct printf_spec *specs = alloca (nspecs_size);
1676
1677     /* The number of arguments the format string requests.  This will
1678        determine the size of the array needed to store the argument
1679        attributes.  */
1680     size_t nargs = 0;
1681     size_t bytes_per_arg;
1682     union printf_arg *args_value;
1683     int *args_size;
1684     int *args_type;
1685
1686     /* Positional parameters refer to arguments directly.  This could
1687        also determine the maximum number of arguments.  Track the
1688        maximum number.  */
1689     size_t max_ref_arg = 0;
1690
1691     /* Just a counter.  */
1692     size_t cnt;
1693
1694     if (__glibc_unlikely (workstart != NULL))
1695       free (workstart);
1696     workstart = NULL;
1697
1698     if (grouping == (const char *) -1)
1699       {
1700 #ifdef COMPILE_WPRINTF
1701         thousands_sep = _NL_CURRENT_WORD (LC_NUMERIC,
1702                                           _NL_NUMERIC_THOUSANDS_SEP_WC);
1703 #else
1704         thousands_sep = _NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP);
1705 #endif
1706
1707         grouping = _NL_CURRENT (LC_NUMERIC, GROUPING);
1708         if (*grouping == '\0' || *grouping == CHAR_MAX)
1709           grouping = NULL;
1710       }
1711
1712     for (f = lead_str_end; *f != L_('\0'); f = specs[nspecs++].next_fmt)
1713       {
1714         if (nspecs * sizeof (*specs) >= nspecs_size)
1715           {
1716             /* Extend the array of format specifiers.  */
1717             struct printf_spec *old = specs;
1718             specs = extend_alloca (specs, nspecs_size, 2 * nspecs_size);
1719
1720             /* Copy the old array's elements to the new space.  */
1721             memmove (specs, old, nspecs * sizeof (*specs));
1722           }
1723
1724         /* Parse the format specifier.  */
1725 #ifdef COMPILE_WPRINTF
1726         nargs += __parse_one_specwc (f, nargs, &specs[nspecs], &max_ref_arg);
1727 #else
1728         nargs += __parse_one_specmb (f, nargs, &specs[nspecs], &max_ref_arg);
1729 #endif
1730       }
1731
1732     /* Determine the number of arguments the format string consumes.  */
1733     nargs = MAX (nargs, max_ref_arg);
1734     /* Calculate total size needed to represent a single argument across
1735        all three argument-related arrays.  */
1736     bytes_per_arg = (sizeof (*args_value) + sizeof (*args_size)
1737                      + sizeof (*args_type));
1738
1739     /* Check for potential integer overflow.  */
1740     if (__glibc_unlikely (nargs > INT_MAX / bytes_per_arg))
1741       {
1742          __set_errno (EOVERFLOW);
1743          done = -1;
1744          goto all_done;
1745       }
1746
1747     /* Allocate memory for all three argument arrays.  */
1748     if (__libc_use_alloca (nargs * bytes_per_arg))
1749         args_value = alloca (nargs * bytes_per_arg);
1750     else
1751       {
1752         args_value = args_malloced = malloc (nargs * bytes_per_arg);
1753         if (args_value == NULL)
1754           {
1755             done = -1;
1756             goto all_done;
1757           }
1758       }
1759
1760     /* Set up the remaining two arrays to each point past the end of the
1761        prior array, since space for all three has been allocated now.  */
1762     args_size = &args_value[nargs].pa_int;
1763     args_type = &args_size[nargs];
1764     memset (args_type, s->_flags2 & _IO_FLAGS2_FORTIFY ? '\xff' : '\0',
1765             nargs * sizeof (*args_type));
1766
1767     /* XXX Could do sanity check here: If any element in ARGS_TYPE is
1768        still zero after this loop, format is invalid.  For now we
1769        simply use 0 as the value.  */
1770
1771     /* Fill in the types of all the arguments.  */
1772     for (cnt = 0; cnt < nspecs; ++cnt)
1773       {
1774         /* If the width is determined by an argument this is an int.  */
1775         if (specs[cnt].width_arg != -1)
1776           args_type[specs[cnt].width_arg] = PA_INT;
1777
1778         /* If the precision is determined by an argument this is an int.  */
1779         if (specs[cnt].prec_arg != -1)
1780           args_type[specs[cnt].prec_arg] = PA_INT;
1781
1782         switch (specs[cnt].ndata_args)
1783           {
1784           case 0:               /* No arguments.  */
1785             break;
1786           case 1:               /* One argument; we already have the
1787                                    type and size.  */
1788             args_type[specs[cnt].data_arg] = specs[cnt].data_arg_type;
1789             args_size[specs[cnt].data_arg] = specs[cnt].size;
1790             break;
1791           default:
1792             /* We have more than one argument for this format spec.
1793                We must call the arginfo function again to determine
1794                all the types.  */
1795             (void) (*__printf_arginfo_table[specs[cnt].info.spec])
1796               (&specs[cnt].info,
1797                specs[cnt].ndata_args, &args_type[specs[cnt].data_arg],
1798                &args_size[specs[cnt].data_arg]);
1799             break;
1800           }
1801       }
1802
1803     /* Now we know all the types and the order.  Fill in the argument
1804        values.  */
1805     for (cnt = 0; cnt < nargs; ++cnt)
1806       switch (args_type[cnt])
1807         {
1808 #define T(tag, mem, type)                                                     \
1809         case tag:                                                             \
1810           args_value[cnt].mem = va_arg (ap_save, type);                       \
1811           break
1812
1813         T (PA_WCHAR, pa_wchar, wint_t);
1814         case PA_CHAR:                           /* Promoted.  */
1815         case PA_INT|PA_FLAG_SHORT:              /* Promoted.  */
1816 #if LONG_MAX == INT_MAX
1817         case PA_INT|PA_FLAG_LONG:
1818 #endif
1819         T (PA_INT, pa_int, int);
1820 #if LONG_MAX == LONG_LONG_MAX
1821         case PA_INT|PA_FLAG_LONG:
1822 #endif
1823         T (PA_INT|PA_FLAG_LONG_LONG, pa_long_long_int, long long int);
1824 #if LONG_MAX != INT_MAX && LONG_MAX != LONG_LONG_MAX
1825 # error "he?"
1826 #endif
1827         case PA_FLOAT:                          /* Promoted.  */
1828         T (PA_DOUBLE, pa_double, double);
1829         case PA_DOUBLE|PA_FLAG_LONG_DOUBLE:
1830           if (__ldbl_is_dbl)
1831             {
1832               args_value[cnt].pa_double = va_arg (ap_save, double);
1833               args_type[cnt] &= ~PA_FLAG_LONG_DOUBLE;
1834             }
1835           else
1836             args_value[cnt].pa_long_double = va_arg (ap_save, long double);
1837           break;
1838         case PA_STRING:                         /* All pointers are the same */
1839         case PA_WSTRING:                        /* All pointers are the same */
1840         T (PA_POINTER, pa_pointer, void *);
1841 #undef T
1842         default:
1843           if ((args_type[cnt] & PA_FLAG_PTR) != 0)
1844             args_value[cnt].pa_pointer = va_arg (ap_save, void *);
1845           else if (__glibc_unlikely (__printf_va_arg_table != NULL)
1846                    && __printf_va_arg_table[args_type[cnt] - PA_LAST] != NULL)
1847             {
1848               args_value[cnt].pa_user = alloca (args_size[cnt]);
1849               (*__printf_va_arg_table[args_type[cnt] - PA_LAST])
1850                 (args_value[cnt].pa_user, &ap_save);
1851             }
1852           else
1853             args_value[cnt].pa_long_double = 0.0;
1854           break;
1855         case -1:
1856           /* Error case.  Not all parameters appear in N$ format
1857              strings.  We have no way to determine their type.  */
1858           assert (s->_flags2 & _IO_FLAGS2_FORTIFY);
1859           __libc_fatal ("*** invalid %N$ use detected ***\n");
1860         }
1861
1862     /* Now walk through all format specifiers and process them.  */
1863     for (; (size_t) nspecs_done < nspecs; ++nspecs_done)
1864       {
1865 #undef REF
1866 #ifdef SHARED
1867 # define REF(Name) &&do2_##Name - &&do_form_unknown
1868 #else
1869 # define REF(Name) &&do2_##Name
1870 #endif
1871 #undef LABEL
1872 #define LABEL(Name) do2_##Name
1873         STEP4_TABLE;
1874
1875         int is_negative;
1876         union
1877         {
1878           unsigned long long int longlong;
1879           unsigned long int word;
1880         } number;
1881         int base;
1882         union printf_arg the_arg;
1883         CHAR_T *string;         /* Pointer to argument string.  */
1884
1885         /* Fill variables from values in struct.  */
1886         int alt = specs[nspecs_done].info.alt;
1887         int space = specs[nspecs_done].info.space;
1888         int left = specs[nspecs_done].info.left;
1889         int showsign = specs[nspecs_done].info.showsign;
1890         int group = specs[nspecs_done].info.group;
1891         int is_long_double = specs[nspecs_done].info.is_long_double;
1892         int is_short = specs[nspecs_done].info.is_short;
1893         int is_char = specs[nspecs_done].info.is_char;
1894         int is_long = specs[nspecs_done].info.is_long;
1895         int width = specs[nspecs_done].info.width;
1896         int prec = specs[nspecs_done].info.prec;
1897         int use_outdigits = specs[nspecs_done].info.i18n;
1898         char pad = specs[nspecs_done].info.pad;
1899         CHAR_T spec = specs[nspecs_done].info.spec;
1900
1901         workstart = NULL;
1902         workend = &work_buffer[sizeof (work_buffer) / sizeof (CHAR_T)];
1903
1904         /* Fill in last information.  */
1905         if (specs[nspecs_done].width_arg != -1)
1906           {
1907             /* Extract the field width from an argument.  */
1908             specs[nspecs_done].info.width =
1909               args_value[specs[nspecs_done].width_arg].pa_int;
1910
1911             if (specs[nspecs_done].info.width < 0)
1912               /* If the width value is negative left justification is
1913                  selected and the value is taken as being positive.  */
1914               {
1915                 specs[nspecs_done].info.width *= -1;
1916                 left = specs[nspecs_done].info.left = 1;
1917               }
1918             width = specs[nspecs_done].info.width;
1919           }
1920
1921         if (specs[nspecs_done].prec_arg != -1)
1922           {
1923             /* Extract the precision from an argument.  */
1924             specs[nspecs_done].info.prec =
1925               args_value[specs[nspecs_done].prec_arg].pa_int;
1926
1927             if (specs[nspecs_done].info.prec < 0)
1928               /* If the precision is negative the precision is
1929                  omitted.  */
1930               specs[nspecs_done].info.prec = -1;
1931
1932             prec = specs[nspecs_done].info.prec;
1933           }
1934
1935         /* Maybe the buffer is too small.  */
1936         if (MAX (prec, width) + 32 > (int) (sizeof (work_buffer)
1937                                             / sizeof (CHAR_T)))
1938           {
1939             if (__libc_use_alloca ((MAX (prec, width) + 32)
1940                                    * sizeof (CHAR_T)))
1941               workend = ((CHAR_T *) alloca ((MAX (prec, width) + 32)
1942                                             * sizeof (CHAR_T))
1943                          + (MAX (prec, width) + 32));
1944             else
1945               {
1946                 workstart = (CHAR_T *) malloc ((MAX (prec, width) + 32)
1947                                                * sizeof (CHAR_T));
1948                 if (workstart == NULL)
1949                   {
1950                     done = -1;
1951                     goto all_done;
1952                   }
1953                 workend = workstart + (MAX (prec, width) + 32);
1954               }
1955           }
1956
1957         /* Process format specifiers.  */
1958         while (1)
1959           {
1960             extern printf_function **__printf_function_table;
1961             int function_done;
1962
1963             if (spec <= UCHAR_MAX
1964                 && __printf_function_table != NULL
1965                 && __printf_function_table[(size_t) spec] != NULL)
1966               {
1967                 const void **ptr = alloca (specs[nspecs_done].ndata_args
1968                                            * sizeof (const void *));
1969
1970                 /* Fill in an array of pointers to the argument values.  */
1971                 for (unsigned int i = 0; i < specs[nspecs_done].ndata_args;
1972                      ++i)
1973                   ptr[i] = &args_value[specs[nspecs_done].data_arg + i];
1974
1975                 /* Call the function.  */
1976                 function_done = __printf_function_table[(size_t) spec]
1977                   (s, &specs[nspecs_done].info, ptr);
1978
1979                 if (function_done != -2)
1980                   {
1981                     /* If an error occurred we don't have information
1982                        about # of chars.  */
1983                     if (function_done < 0)
1984                       {
1985                         /* Function has set errno.  */
1986                         done = -1;
1987                         goto all_done;
1988                       }
1989
1990                     done_add (function_done);
1991                     break;
1992                   }
1993               }
1994
1995             JUMP (spec, step4_jumps);
1996
1997             process_arg ((&specs[nspecs_done]));
1998             process_string_arg ((&specs[nspecs_done]));
1999
2000           LABEL (form_unknown):
2001             {
2002               unsigned int i;
2003               const void **ptr;
2004
2005               ptr = alloca (specs[nspecs_done].ndata_args
2006                             * sizeof (const void *));
2007
2008               /* Fill in an array of pointers to the argument values.  */
2009               for (i = 0; i < specs[nspecs_done].ndata_args; ++i)
2010                 ptr[i] = &args_value[specs[nspecs_done].data_arg + i];
2011
2012               /* Call the function.  */
2013               function_done = printf_unknown (s, &specs[nspecs_done].info,
2014                                               ptr);
2015
2016               /* If an error occurred we don't have information about #
2017                  of chars.  */
2018               if (function_done < 0)
2019                 {
2020                   /* Function has set errno.  */
2021                   done = -1;
2022                   goto all_done;
2023                 }
2024
2025               done_add (function_done);
2026             }
2027             break;
2028           }
2029
2030         if (__glibc_unlikely (workstart != NULL))
2031           free (workstart);
2032         workstart = NULL;
2033
2034         /* Write the following constant string.  */
2035         outstring (specs[nspecs_done].end_of_fmt,
2036                    specs[nspecs_done].next_fmt
2037                    - specs[nspecs_done].end_of_fmt);
2038       }
2039   }
2040
2041 all_done:
2042   if (__glibc_unlikely (args_malloced != NULL))
2043     free (args_malloced);
2044   if (__glibc_unlikely (workstart != NULL))
2045     free (workstart);
2046   /* Unlock the stream.  */
2047   _IO_funlockfile (s);
2048   _IO_cleanup_region_end (0);
2049
2050   return done;
2051 }
2052 \f
2053 /* Handle an unknown format specifier.  This prints out a canonicalized
2054    representation of the format spec itself.  */
2055 static int
2056 printf_unknown (FILE *s, const struct printf_info *info,
2057                 const void *const *args)
2058
2059 {
2060   int done = 0;
2061   CHAR_T work_buffer[MAX (sizeof (info->width), sizeof (info->prec)) * 3];
2062   CHAR_T *const workend
2063     = &work_buffer[sizeof (work_buffer) / sizeof (CHAR_T)];
2064   CHAR_T *w;
2065
2066   outchar (L_('%'));
2067
2068   if (info->alt)
2069     outchar (L_('#'));
2070   if (info->group)
2071     outchar (L_('\''));
2072   if (info->showsign)
2073     outchar (L_('+'));
2074   else if (info->space)
2075     outchar (L_(' '));
2076   if (info->left)
2077     outchar (L_('-'));
2078   if (info->pad == L_('0'))
2079     outchar (L_('0'));
2080   if (info->i18n)
2081     outchar (L_('I'));
2082
2083   if (info->width != 0)
2084     {
2085       w = _itoa_word (info->width, workend, 10, 0);
2086       while (w < workend)
2087         outchar (*w++);
2088     }
2089
2090   if (info->prec != -1)
2091     {
2092       outchar (L_('.'));
2093       w = _itoa_word (info->prec, workend, 10, 0);
2094       while (w < workend)
2095         outchar (*w++);
2096     }
2097
2098   if (info->spec != L_('\0'))
2099     outchar (info->spec);
2100
2101  all_done:
2102   return done;
2103 }
2104 \f
2105 /* Group the digits according to the grouping rules of the current locale.
2106    The interpretation of GROUPING is as in `struct lconv' from <locale.h>.  */
2107 static CHAR_T *
2108 internal_function
2109 group_number (CHAR_T *w, CHAR_T *rear_ptr, const char *grouping,
2110 #ifdef COMPILE_WPRINTF
2111               wchar_t thousands_sep
2112 #else
2113               const char *thousands_sep
2114 #endif
2115               )
2116 {
2117   int len;
2118   CHAR_T *src, *s;
2119 #ifndef COMPILE_WPRINTF
2120   int tlen = strlen (thousands_sep);
2121 #endif
2122
2123   /* We treat all negative values like CHAR_MAX.  */
2124
2125   if (*grouping == CHAR_MAX || *grouping <= 0)
2126     /* No grouping should be done.  */
2127     return w;
2128
2129   len = *grouping++;
2130
2131   /* Copy existing string so that nothing gets overwritten.  */
2132   src = (CHAR_T *) alloca ((rear_ptr - w) * sizeof (CHAR_T));
2133   s = (CHAR_T *) __mempcpy (src, w,
2134                             (rear_ptr - w) * sizeof (CHAR_T));
2135   w = rear_ptr;
2136
2137   /* Process all characters in the string.  */
2138   while (s > src)
2139     {
2140       *--w = *--s;
2141
2142       if (--len == 0 && s > src)
2143         {
2144           /* A new group begins.  */
2145 #ifdef COMPILE_WPRINTF
2146           *--w = thousands_sep;
2147 #else
2148           int cnt = tlen;
2149           do
2150             *--w = thousands_sep[--cnt];
2151           while (cnt > 0);
2152 #endif
2153
2154           if (*grouping == CHAR_MAX
2155 #if CHAR_MIN < 0
2156                    || *grouping < 0
2157 #endif
2158                    )
2159             {
2160               /* No further grouping to be done.
2161                  Copy the rest of the number.  */
2162               do
2163                 *--w = *--s;
2164               while (s > src);
2165               break;
2166             }
2167           else if (*grouping != '\0')
2168             /* The previous grouping repeats ad infinitum.  */
2169             len = *grouping++;
2170           else
2171             len = grouping[-1];
2172         }
2173     }
2174   return w;
2175 }
2176 \f
2177 /* Helper "class" for `fprintf to unbuffered': creates a temporary buffer.  */
2178 struct helper_file
2179   {
2180     struct _IO_FILE_plus _f;
2181 #ifdef COMPILE_WPRINTF
2182     struct _IO_wide_data _wide_data;
2183 #endif
2184     _IO_FILE *_put_stream;
2185 #ifdef _IO_MTSAFE_IO
2186     _IO_lock_t lock;
2187 #endif
2188   };
2189
2190 static int
2191 _IO_helper_overflow (_IO_FILE *s, int c)
2192 {
2193   _IO_FILE *target = ((struct helper_file*) s)->_put_stream;
2194 #ifdef COMPILE_WPRINTF
2195   int used = s->_wide_data->_IO_write_ptr - s->_wide_data->_IO_write_base;
2196   if (used)
2197     {
2198       _IO_size_t written = _IO_sputn (target, s->_wide_data->_IO_write_base,
2199                                       used);
2200       if (written == 0 || written == WEOF)
2201         return WEOF;
2202       __wmemmove (s->_wide_data->_IO_write_base,
2203                   s->_wide_data->_IO_write_base + written,
2204                   used - written);
2205       s->_wide_data->_IO_write_ptr -= written;
2206     }
2207 #else
2208   int used = s->_IO_write_ptr - s->_IO_write_base;
2209   if (used)
2210     {
2211       _IO_size_t written = _IO_sputn (target, s->_IO_write_base, used);
2212       if (written == 0 || written == EOF)
2213         return EOF;
2214       memmove (s->_IO_write_base, s->_IO_write_base + written,
2215                used - written);
2216       s->_IO_write_ptr -= written;
2217     }
2218 #endif
2219   return PUTC (c, s);
2220 }
2221
2222 #ifdef COMPILE_WPRINTF
2223 static const struct _IO_jump_t _IO_helper_jumps =
2224 {
2225   JUMP_INIT_DUMMY,
2226   JUMP_INIT (finish, _IO_wdefault_finish),
2227   JUMP_INIT (overflow, _IO_helper_overflow),
2228   JUMP_INIT (underflow, _IO_default_underflow),
2229   JUMP_INIT (uflow, _IO_default_uflow),
2230   JUMP_INIT (pbackfail, (_IO_pbackfail_t) _IO_wdefault_pbackfail),
2231   JUMP_INIT (xsputn, _IO_wdefault_xsputn),
2232   JUMP_INIT (xsgetn, _IO_wdefault_xsgetn),
2233   JUMP_INIT (seekoff, _IO_default_seekoff),
2234   JUMP_INIT (seekpos, _IO_default_seekpos),
2235   JUMP_INIT (setbuf, _IO_default_setbuf),
2236   JUMP_INIT (sync, _IO_default_sync),
2237   JUMP_INIT (doallocate, _IO_wdefault_doallocate),
2238   JUMP_INIT (read, _IO_default_read),
2239   JUMP_INIT (write, _IO_default_write),
2240   JUMP_INIT (seek, _IO_default_seek),
2241   JUMP_INIT (close, _IO_default_close),
2242   JUMP_INIT (stat, _IO_default_stat)
2243 };
2244 #else
2245 static const struct _IO_jump_t _IO_helper_jumps =
2246 {
2247   JUMP_INIT_DUMMY,
2248   JUMP_INIT (finish, _IO_default_finish),
2249   JUMP_INIT (overflow, _IO_helper_overflow),
2250   JUMP_INIT (underflow, _IO_default_underflow),
2251   JUMP_INIT (uflow, _IO_default_uflow),
2252   JUMP_INIT (pbackfail, _IO_default_pbackfail),
2253   JUMP_INIT (xsputn, _IO_default_xsputn),
2254   JUMP_INIT (xsgetn, _IO_default_xsgetn),
2255   JUMP_INIT (seekoff, _IO_default_seekoff),
2256   JUMP_INIT (seekpos, _IO_default_seekpos),
2257   JUMP_INIT (setbuf, _IO_default_setbuf),
2258   JUMP_INIT (sync, _IO_default_sync),
2259   JUMP_INIT (doallocate, _IO_default_doallocate),
2260   JUMP_INIT (read, _IO_default_read),
2261   JUMP_INIT (write, _IO_default_write),
2262   JUMP_INIT (seek, _IO_default_seek),
2263   JUMP_INIT (close, _IO_default_close),
2264   JUMP_INIT (stat, _IO_default_stat)
2265 };
2266 #endif
2267
2268 static int
2269 internal_function
2270 buffered_vfprintf (_IO_FILE *s, const CHAR_T *format,
2271                    _IO_va_list args)
2272 {
2273   CHAR_T buf[_IO_BUFSIZ];
2274   struct helper_file helper;
2275   _IO_FILE *hp = (_IO_FILE *) &helper._f;
2276   int result, to_flush;
2277
2278   /* Orient the stream.  */
2279 #ifdef ORIENT
2280   ORIENT;
2281 #endif
2282
2283   /* Initialize helper.  */
2284   helper._put_stream = s;
2285 #ifdef COMPILE_WPRINTF
2286   hp->_wide_data = &helper._wide_data;
2287   _IO_wsetp (hp, buf, buf + sizeof buf / sizeof (CHAR_T));
2288   hp->_mode = 1;
2289 #else
2290   _IO_setp (hp, buf, buf + sizeof buf);
2291   hp->_mode = -1;
2292 #endif
2293   hp->_IO_file_flags = _IO_MAGIC|_IO_NO_READS|_IO_USER_LOCK;
2294 #if _IO_JUMPS_OFFSET
2295   hp->_vtable_offset = 0;
2296 #endif
2297 #ifdef _IO_MTSAFE_IO
2298   hp->_lock = NULL;
2299 #endif
2300   hp->_flags2 = s->_flags2;
2301   _IO_JUMPS (&helper._f) = (struct _IO_jump_t *) &_IO_helper_jumps;
2302
2303   /* Now print to helper instead.  */
2304 #ifndef COMPILE_WPRINTF
2305   result = _IO_vfprintf (hp, format, args);
2306 #else
2307   result = vfprintf (hp, format, args);
2308 #endif
2309
2310   /* Lock stream.  */
2311   __libc_cleanup_region_start (1, (void (*) (void *)) &_IO_funlockfile, s);
2312   _IO_flockfile (s);
2313
2314   /* Now flush anything from the helper to the S. */
2315 #ifdef COMPILE_WPRINTF
2316   if ((to_flush = (hp->_wide_data->_IO_write_ptr
2317                    - hp->_wide_data->_IO_write_base)) > 0)
2318     {
2319       if ((int) _IO_sputn (s, hp->_wide_data->_IO_write_base, to_flush)
2320           != to_flush)
2321         result = -1;
2322     }
2323 #else
2324   if ((to_flush = hp->_IO_write_ptr - hp->_IO_write_base) > 0)
2325     {
2326       if ((int) _IO_sputn (s, hp->_IO_write_base, to_flush) != to_flush)
2327         result = -1;
2328     }
2329 #endif
2330
2331   /* Unlock the stream.  */
2332   _IO_funlockfile (s);
2333   __libc_cleanup_region_end (0);
2334
2335   return result;
2336 }
2337
2338 #undef vfprintf
2339 #ifdef COMPILE_WPRINTF
2340 strong_alias (_IO_vfwprintf, __vfwprintf);
2341 ldbl_weak_alias (_IO_vfwprintf, vfwprintf);
2342 #else
2343 ldbl_strong_alias (_IO_vfprintf_internal, vfprintf);
2344 ldbl_hidden_def (_IO_vfprintf_internal, vfprintf)
2345 ldbl_strong_alias (_IO_vfprintf_internal, _IO_vfprintf);
2346 ldbl_hidden_def (_IO_vfprintf_internal, _IO_vfprintf)
2347 #endif