diff options
Diffstat (limited to 'stdio-common/vfprintf.c')
| -rw-r--r-- | stdio-common/vfprintf.c | 2351 |
1 files changed, 7 insertions, 2344 deletions
diff --git a/stdio-common/vfprintf.c b/stdio-common/vfprintf.c index ae412e4b84..13a10db99b 100644 --- a/stdio-common/vfprintf.c +++ b/stdio-common/vfprintf.c @@ -15,2350 +15,13 @@ License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ -#include <array_length.h> -#include <ctype.h> -#include <limits.h> -#include <printf.h> -#include <stdarg.h> -#include <stdint.h> -#include <stdlib.h> -#include <string.h> -#include <errno.h> -#include <wchar.h> -#include <libc-lock.h> -#include <sys/param.h> -#include <_itoa.h> -#include <locale/localeinfo.h> -#include <stdio.h> -#include <scratch_buffer.h> +#include <libio/libioP.h> -/* This code is shared between the standard stdio implementation found - in GNU C library and the libio implementation originally found in - GNU libg++. - - Beside this it is also shared between the normal and wide character - implementation as defined in ISO/IEC 9899:1990/Amendment 1:1995. */ - -#include <libioP.h> - -/* In some cases we need extra space for all the output which is not - counted in the width of the string. We assume 32 characters is - enough. */ -#define EXTSIZ 32 -#define ARGCHECK(S, Format) \ - do \ - { \ - /* Check file argument for consistence. */ \ - CHECK_FILE (S, -1); \ - if (S->_flags & _IO_NO_WRITES) \ - { \ - S->_flags |= _IO_ERR_SEEN; \ - __set_errno (EBADF); \ - return -1; \ - } \ - if (Format == NULL) \ - { \ - __set_errno (EINVAL); \ - return -1; \ - } \ - } while (0) -#define UNBUFFERED_P(S) ((S)->_flags & _IO_UNBUFFERED) - -#define done_add(val) \ - do { \ - unsigned int _val = val; \ - assert ((unsigned int) done < (unsigned int) INT_MAX); \ - if (__glibc_unlikely (INT_MAX - done < _val)) \ - { \ - done = -1; \ - __set_errno (EOVERFLOW); \ - goto all_done; \ - } \ - done += _val; \ - } while (0) - -#ifndef COMPILE_WPRINTF -# define vfprintf _IO_vfprintf_internal -# define CHAR_T char -# define UCHAR_T unsigned char -# define INT_T int -typedef const char *THOUSANDS_SEP_T; -# define L_(Str) Str -# define ISDIGIT(Ch) ((unsigned int) ((Ch) - '0') < 10) -# define STR_LEN(Str) strlen (Str) - -# define PUT(F, S, N) _IO_sputn ((F), (S), (N)) -# define PAD(Padchar) \ - do { \ - if (width > 0) \ - { \ - ssize_t written = _IO_padn (s, (Padchar), width); \ - if (__glibc_unlikely (written != width)) \ - { \ - done = -1; \ - goto all_done; \ - } \ - done_add (written); \ - } \ - } while (0) -# define PUTC(C, F) _IO_putc_unlocked (C, F) -# define ORIENT if (_IO_vtable_offset (s) == 0 && _IO_fwide (s, -1) != -1)\ - return -1 -#else -# define vfprintf _IO_vfwprintf -# define CHAR_T wchar_t -/* This is a hack!!! There should be a type uwchar_t. */ -# define UCHAR_T unsigned int /* uwchar_t */ -# define INT_T wint_t -typedef wchar_t THOUSANDS_SEP_T; -# define L_(Str) L##Str -# define ISDIGIT(Ch) ((unsigned int) ((Ch) - L'0') < 10) -# define STR_LEN(Str) __wcslen (Str) - -# include <_itowa.h> - -# define PUT(F, S, N) _IO_sputn ((F), (S), (N)) -# define PAD(Padchar) \ - do { \ - if (width > 0) \ - { \ - ssize_t written = _IO_wpadn (s, (Padchar), width); \ - if (__glibc_unlikely (written != width)) \ - { \ - done = -1; \ - goto all_done; \ - } \ - done_add (written); \ - } \ - } while (0) -# define PUTC(C, F) _IO_putwc_unlocked (C, F) -# define ORIENT if (_IO_fwide (s, 1) != 1) return -1 - -# undef _itoa -# define _itoa(Val, Buf, Base, Case) _itowa (Val, Buf, Base, Case) -# define _itoa_word(Val, Buf, Base, Case) _itowa_word (Val, Buf, Base, Case) -# undef EOF -# define EOF WEOF -#endif - -#include "_i18n_number.h" - -/* Include the shared code for parsing the format string. */ -#include "printf-parse.h" - - -#define outchar(Ch) \ - do \ - { \ - const INT_T outc = (Ch); \ - if (PUTC (outc, s) == EOF || done == INT_MAX) \ - { \ - done = -1; \ - goto all_done; \ - } \ - ++done; \ - } \ - while (0) - -#define outstring(String, Len) \ - do \ - { \ - assert ((size_t) done <= (size_t) INT_MAX); \ - if ((size_t) PUT (s, (String), (Len)) != (size_t) (Len)) \ - { \ - done = -1; \ - goto all_done; \ - } \ - if (__glibc_unlikely (INT_MAX - done < (Len))) \ - { \ - done = -1; \ - __set_errno (EOVERFLOW); \ - goto all_done; \ - } \ - done += (Len); \ - } \ - while (0) - -/* For handling long_double and longlong we use the same flag. If - `long' and `long long' are effectively the same type define it to - zero. */ -#if LONG_MAX == LONG_LONG_MAX -# define is_longlong 0 -#else -# define is_longlong is_long_double -#endif - -/* If `long' and `int' is effectively the same type we don't have to - handle `long separately. */ -#if INT_MAX == LONG_MAX -# define is_long_num 0 -#else -# define is_long_num is_long -#endif - - -/* Global constants. */ -static const CHAR_T null[] = L_("(null)"); - -/* Size of the work_buffer variable (in characters, not bytes. */ -enum { WORK_BUFFER_SIZE = 1000 / sizeof (CHAR_T) }; - -/* This table maps a character into a number representing a class. In - each step there is a destination label for each class. */ -static const uint8_t jump_table[] = - { - /* ' ' */ 1, 0, 0, /* '#' */ 4, - 0, /* '%' */ 14, 0, /* '\''*/ 6, - 0, 0, /* '*' */ 7, /* '+' */ 2, - 0, /* '-' */ 3, /* '.' */ 9, 0, - /* '0' */ 5, /* '1' */ 8, /* '2' */ 8, /* '3' */ 8, - /* '4' */ 8, /* '5' */ 8, /* '6' */ 8, /* '7' */ 8, - /* '8' */ 8, /* '9' */ 8, 0, 0, - 0, 0, 0, 0, - 0, /* 'A' */ 26, 0, /* 'C' */ 25, - 0, /* 'E' */ 19, /* F */ 19, /* 'G' */ 19, - 0, /* 'I' */ 29, 0, 0, - /* 'L' */ 12, 0, 0, 0, - 0, 0, 0, /* 'S' */ 21, - 0, 0, 0, 0, - /* 'X' */ 18, 0, /* 'Z' */ 13, 0, - 0, 0, 0, 0, - 0, /* 'a' */ 26, 0, /* 'c' */ 20, - /* 'd' */ 15, /* 'e' */ 19, /* 'f' */ 19, /* 'g' */ 19, - /* 'h' */ 10, /* 'i' */ 15, /* 'j' */ 28, 0, - /* 'l' */ 11, /* 'm' */ 24, /* 'n' */ 23, /* 'o' */ 17, - /* 'p' */ 22, /* 'q' */ 12, 0, /* 's' */ 21, - /* 't' */ 27, /* 'u' */ 16, 0, 0, - /* 'x' */ 18, 0, /* 'z' */ 13 - }; - -#define NOT_IN_JUMP_RANGE(Ch) ((Ch) < L_(' ') || (Ch) > L_('z')) -#define CHAR_CLASS(Ch) (jump_table[(INT_T) (Ch) - L_(' ')]) -#define LABEL(Name) do_##Name -#ifdef SHARED - /* 'int' is enough and it saves some space on 64 bit systems. */ -# define JUMP_TABLE_TYPE const int -# define JUMP_TABLE_BASE_LABEL do_form_unknown -# define REF(Name) &&do_##Name - &&JUMP_TABLE_BASE_LABEL -# define JUMP(ChExpr, table) \ - do \ - { \ - int offset; \ - void *ptr; \ - spec = (ChExpr); \ - offset = NOT_IN_JUMP_RANGE (spec) ? REF (form_unknown) \ - : table[CHAR_CLASS (spec)]; \ - ptr = &&JUMP_TABLE_BASE_LABEL + offset; \ - goto *ptr; \ - } \ - while (0) -#else -# define JUMP_TABLE_TYPE const void *const -# define REF(Name) &&do_##Name -# define JUMP(ChExpr, table) \ - do \ - { \ - const void *ptr; \ - spec = (ChExpr); \ - ptr = NOT_IN_JUMP_RANGE (spec) ? REF (form_unknown) \ - : table[CHAR_CLASS (spec)]; \ - goto *ptr; \ - } \ - while (0) -#endif - -#define STEP0_3_TABLE \ - /* Step 0: at the beginning. */ \ - static JUMP_TABLE_TYPE step0_jumps[30] = \ - { \ - REF (form_unknown), \ - REF (flag_space), /* for ' ' */ \ - REF (flag_plus), /* for '+' */ \ - REF (flag_minus), /* for '-' */ \ - REF (flag_hash), /* for '<hash>' */ \ - REF (flag_zero), /* for '0' */ \ - REF (flag_quote), /* for '\'' */ \ - REF (width_asterics), /* for '*' */ \ - REF (width), /* for '1'...'9' */ \ - REF (precision), /* for '.' */ \ - REF (mod_half), /* for 'h' */ \ - REF (mod_long), /* for 'l' */ \ - REF (mod_longlong), /* for 'L', 'q' */ \ - REF (mod_size_t), /* for 'z', 'Z' */ \ - REF (form_percent), /* for '%' */ \ - REF (form_integer), /* for 'd', 'i' */ \ - REF (form_unsigned), /* for 'u' */ \ - REF (form_octal), /* for 'o' */ \ - REF (form_hexa), /* for 'X', 'x' */ \ - REF (form_float), /* for 'E', 'e', 'F', 'f', 'G', 'g' */ \ - REF (form_character), /* for 'c' */ \ - REF (form_string), /* for 's', 'S' */ \ - REF (form_pointer), /* for 'p' */ \ - REF (form_number), /* for 'n' */ \ - REF (form_strerror), /* for 'm' */ \ - REF (form_wcharacter), /* for 'C' */ \ - REF (form_floathex), /* for 'A', 'a' */ \ - REF (mod_ptrdiff_t), /* for 't' */ \ - REF (mod_intmax_t), /* for 'j' */ \ - REF (flag_i18n), /* for 'I' */ \ - }; \ - /* Step 1: after processing width. */ \ - static JUMP_TABLE_TYPE step1_jumps[30] = \ - { \ - REF (form_unknown), \ - REF (form_unknown), /* for ' ' */ \ - REF (form_unknown), /* for '+' */ \ - REF (form_unknown), /* for '-' */ \ - REF (form_unknown), /* for '<hash>' */ \ - REF (form_unknown), /* for '0' */ \ - REF (form_unknown), /* for '\'' */ \ - REF (form_unknown), /* for '*' */ \ - REF (form_unknown), /* for '1'...'9' */ \ - REF (precision), /* for '.' */ \ - REF (mod_half), /* for 'h' */ \ - REF (mod_long), /* for 'l' */ \ - REF (mod_longlong), /* for 'L', 'q' */ \ - REF (mod_size_t), /* for 'z', 'Z' */ \ - REF (form_percent), /* for '%' */ \ - REF (form_integer), /* for 'd', 'i' */ \ - REF (form_unsigned), /* for 'u' */ \ - REF (form_octal), /* for 'o' */ \ - REF (form_hexa), /* for 'X', 'x' */ \ - REF (form_float), /* for 'E', 'e', 'F', 'f', 'G', 'g' */ \ - REF (form_character), /* for 'c' */ \ - REF (form_string), /* for 's', 'S' */ \ - REF (form_pointer), /* for 'p' */ \ - REF (form_number), /* for 'n' */ \ - REF (form_strerror), /* for 'm' */ \ - REF (form_wcharacter), /* for 'C' */ \ - REF (form_floathex), /* for 'A', 'a' */ \ - REF (mod_ptrdiff_t), /* for 't' */ \ - REF (mod_intmax_t), /* for 'j' */ \ - REF (form_unknown) /* for 'I' */ \ - }; \ - /* Step 2: after processing precision. */ \ - static JUMP_TABLE_TYPE step2_jumps[30] = \ - { \ - REF (form_unknown), \ - REF (form_unknown), /* for ' ' */ \ - REF (form_unknown), /* for '+' */ \ - REF (form_unknown), /* for '-' */ \ - REF (form_unknown), /* for '<hash>' */ \ - REF (form_unknown), /* for '0' */ \ - REF (form_unknown), /* for '\'' */ \ - REF (form_unknown), /* for '*' */ \ - REF (form_unknown), /* for '1'...'9' */ \ - REF (form_unknown), /* for '.' */ \ - REF (mod_half), /* for 'h' */ \ - REF (mod_long), /* for 'l' */ \ - REF (mod_longlong), /* for 'L', 'q' */ \ - REF (mod_size_t), /* for 'z', 'Z' */ \ - REF (form_percent), /* for '%' */ \ - REF (form_integer), /* for 'd', 'i' */ \ - REF (form_unsigned), /* for 'u' */ \ - REF (form_octal), /* for 'o' */ \ - REF (form_hexa), /* for 'X', 'x' */ \ - REF (form_float), /* for 'E', 'e', 'F', 'f', 'G', 'g' */ \ - REF (form_character), /* for 'c' */ \ - REF (form_string), /* for 's', 'S' */ \ - REF (form_pointer), /* for 'p' */ \ - REF (form_number), /* for 'n' */ \ - REF (form_strerror), /* for 'm' */ \ - REF (form_wcharacter), /* for 'C' */ \ - REF (form_floathex), /* for 'A', 'a' */ \ - REF (mod_ptrdiff_t), /* for 't' */ \ - REF (mod_intmax_t), /* for 'j' */ \ - REF (form_unknown) /* for 'I' */ \ - }; \ - /* Step 3a: after processing first 'h' modifier. */ \ - static JUMP_TABLE_TYPE step3a_jumps[30] = \ - { \ - REF (form_unknown), \ - REF (form_unknown), /* for ' ' */ \ - REF (form_unknown), /* for '+' */ \ - REF (form_unknown), /* for '-' */ \ - REF (form_unknown), /* for '<hash>' */ \ - REF (form_unknown), /* for '0' */ \ - REF (form_unknown), /* for '\'' */ \ - REF (form_unknown), /* for '*' */ \ - REF (form_unknown), /* for '1'...'9' */ \ - REF (form_unknown), /* for '.' */ \ - REF (mod_halfhalf), /* for 'h' */ \ - REF (form_unknown), /* for 'l' */ \ - REF (form_unknown), /* for 'L', 'q' */ \ - REF (form_unknown), /* for 'z', 'Z' */ \ - REF (form_percent), /* for '%' */ \ - REF (form_integer), /* for 'd', 'i' */ \ - REF (form_unsigned), /* for 'u' */ \ - REF (form_octal), /* for 'o' */ \ - REF (form_hexa), /* for 'X', 'x' */ \ - REF (form_unknown), /* for 'E', 'e', 'F', 'f', 'G', 'g' */ \ - REF (form_unknown), /* for 'c' */ \ - REF (form_unknown), /* for 's', 'S' */ \ - REF (form_unknown), /* for 'p' */ \ - REF (form_number), /* for 'n' */ \ - REF (form_unknown), /* for 'm' */ \ - REF (form_unknown), /* for 'C' */ \ - REF (form_unknown), /* for 'A', 'a' */ \ - REF (form_unknown), /* for 't' */ \ - REF (form_unknown), /* for 'j' */ \ - REF (form_unknown) /* for 'I' */ \ - }; \ - /* Step 3b: after processing first 'l' modifier. */ \ - static JUMP_TABLE_TYPE step3b_jumps[30] = \ - { \ - REF (form_unknown), \ - REF (form_unknown), /* for ' ' */ \ - REF (form_unknown), /* for '+' */ \ - REF (form_unknown), /* for '-' */ \ - REF (form_unknown), /* for '<hash>' */ \ - REF (form_unknown), /* for '0' */ \ - REF (form_unknown), /* for '\'' */ \ - REF (form_unknown), /* for '*' */ \ - REF (form_unknown), /* for '1'...'9' */ \ - REF (form_unknown), /* for '.' */ \ - REF (form_unknown), /* for 'h' */ \ - REF (mod_longlong), /* for 'l' */ \ - REF (form_unknown), /* for 'L', 'q' */ \ - REF (form_unknown), /* for 'z', 'Z' */ \ - REF (form_percent), /* for '%' */ \ - REF (form_integer), /* for 'd', 'i' */ \ - REF (form_unsigned), /* for 'u' */ \ - REF (form_octal), /* for 'o' */ \ - REF (form_hexa), /* for 'X', 'x' */ \ - REF (form_float), /* for 'E', 'e', 'F', 'f', 'G', 'g' */ \ - REF (form_character), /* for 'c' */ \ - REF (form_string), /* for 's', 'S' */ \ - REF (form_pointer), /* for 'p' */ \ - REF (form_number), /* for 'n' */ \ - REF (form_strerror), /* for 'm' */ \ - REF (form_wcharacter), /* for 'C' */ \ - REF (form_floathex), /* for 'A', 'a' */ \ - REF (form_unknown), /* for 't' */ \ - REF (form_unknown), /* for 'j' */ \ - REF (form_unknown) /* for 'I' */ \ - } - -#define STEP4_TABLE \ - /* Step 4: processing format specifier. */ \ - static JUMP_TABLE_TYPE step4_jumps[30] = \ - { \ - REF (form_unknown), \ - REF (form_unknown), /* for ' ' */ \ - REF (form_unknown), /* for '+' */ \ - REF (form_unknown), /* for '-' */ \ - REF (form_unknown), /* for '<hash>' */ \ - REF (form_unknown), /* for '0' */ \ - REF (form_unknown), /* for '\'' */ \ - REF (form_unknown), /* for '*' */ \ - REF (form_unknown), /* for '1'...'9' */ \ - REF (form_unknown), /* for '.' */ \ - REF (form_unknown), /* for 'h' */ \ - REF (form_unknown), /* for 'l' */ \ - REF (form_unknown), /* for 'L', 'q' */ \ - REF (form_unknown), /* for 'z', 'Z' */ \ - REF (form_percent), /* for '%' */ \ - REF (form_integer), /* for 'd', 'i' */ \ - REF (form_unsigned), /* for 'u' */ \ - REF (form_octal), /* for 'o' */ \ - REF (form_hexa), /* for 'X', 'x' */ \ - REF (form_float), /* for 'E', 'e', 'F', 'f', 'G', 'g' */ \ - REF (form_character), /* for 'c' */ \ - REF (form_string), /* for 's', 'S' */ \ - REF (form_pointer), /* for 'p' */ \ - REF (form_number), /* for 'n' */ \ - REF (form_strerror), /* for 'm' */ \ - REF (form_wcharacter), /* for 'C' */ \ - REF (form_floathex), /* for 'A', 'a' */ \ - REF (form_unknown), /* for 't' */ \ - REF (form_unknown), /* for 'j' */ \ - REF (form_unknown) /* for 'I' */ \ - } - - -#define process_arg(fspec) \ - /* Start real work. We know about all flags and modifiers and \ - now process the wanted format specifier. */ \ - LABEL (form_percent): \ - /* Write a literal "%". */ \ - outchar (L_('%')); \ - break; \ - \ - LABEL (form_integer): \ - /* Signed decimal integer. */ \ - base = 10; \ - \ - if (is_longlong) \ - { \ - long long int signed_number; \ - \ - if (fspec == NULL) \ - signed_number = va_arg (ap, long long int); \ - else \ - signed_number = args_value[fspec->data_arg].pa_long_long_int; \ - \ - is_negative = signed_number < 0; \ - number.longlong = is_negative ? (- signed_number) : signed_number; \ - \ - goto LABEL (longlong_number); \ - } \ - else \ - { \ - long int signed_number; \ - \ - if (fspec == NULL) \ - { \ - if (is_long_num) \ - signed_number = va_arg (ap, long int); \ - else if (is_char) \ - signed_number = (signed char) va_arg (ap, unsigned int); \ - else if (!is_short) \ - signed_number = va_arg (ap, int); \ - else \ - signed_number = (short int) va_arg (ap, unsigned int); \ - } \ - else \ - if (is_long_num) \ - signed_number = args_value[fspec->data_arg].pa_long_int; \ - else if (is_char) \ - signed_number = (signed char) \ - args_value[fspec->data_arg].pa_u_int; \ - else if (!is_short) \ - signed_number = args_value[fspec->data_arg].pa_int; \ - else \ - signed_number = (short int) \ - args_value[fspec->data_arg].pa_u_int; \ - \ - is_negative = signed_number < 0; \ - number.word = is_negative ? (- signed_number) : signed_number; \ - \ - goto LABEL (number); \ - } \ - /* NOTREACHED */ \ - \ - LABEL (form_unsigned): \ - /* Unsigned decimal integer. */ \ - base = 10; \ - goto LABEL (unsigned_number); \ - /* NOTREACHED */ \ - \ - LABEL (form_octal): \ - /* Unsigned octal integer. */ \ - base = 8; \ - goto LABEL (unsigned_number); \ - /* NOTREACHED */ \ - \ - LABEL (form_hexa): \ - /* Unsigned hexadecimal integer. */ \ - base = 16; \ - \ - LABEL (unsigned_number): /* Unsigned number of base BASE. */ \ - \ - /* ISO specifies the `+' and ` ' flags only for signed \ - conversions. */ \ - is_negative = 0; \ - showsign = 0; \ - space = 0; \ - \ - if (is_longlong) \ - { \ - if (fspec == NULL) \ - number.longlong = va_arg (ap, unsigned long long int); \ - else \ - number.longlong = args_value[fspec->data_arg].pa_u_long_long_int; \ - \ - LABEL (longlong_number): \ - if (prec < 0) \ - /* Supply a default precision if none was given. */ \ - prec = 1; \ - else \ - /* We have to take care for the '0' flag. If a precision \ - is given it must be ignored. */ \ - pad = L_(' '); \ - \ - /* If the precision is 0 and the number is 0 nothing has to \ - be written for the number, except for the 'o' format in \ - alternate form. */ \ - if (prec == 0 && number.longlong == 0) \ - { \ - string = workend; \ - if (base == 8 && alt) \ - *--string = L_('0'); \ - } \ - else \ - { \ - /* Put the number in WORK. */ \ - string = _itoa (number.longlong, workend, base, \ - spec == L_('X')); \ - if (group && grouping) \ - string = group_number (work_buffer, string, workend, \ - grouping, thousands_sep); \ - if (use_outdigits && base == 10) \ - string = _i18n_number_rewrite (string, workend, workend); \ - } \ - /* Simplify further test for num != 0. */ \ - number.word = number.longlong != 0; \ - } \ - else \ - { \ - if (fspec == NULL) \ - { \ - if (is_long_num) \ - number.word = va_arg (ap, unsigned long int); \ - else if (is_char) \ - number.word = (unsigned char) va_arg (ap, unsigned int); \ - else if (!is_short) \ - number.word = va_arg (ap, unsigned int); \ - else \ - number.word = (unsigned short int) va_arg (ap, unsigned int); \ - } \ - else \ - if (is_long_num) \ - number.word = args_value[fspec->data_arg].pa_u_long_int; \ - else if (is_char) \ - number.word = (unsigned char) \ - args_value[fspec->data_arg].pa_u_int; \ - else if (!is_short) \ - number.word = args_value[fspec->data_arg].pa_u_int; \ - else \ - number.word = (unsigned short int) \ - args_value[fspec->data_arg].pa_u_int; \ - \ - LABEL (number): \ - if (prec < 0) \ - /* Supply a default precision if none was given. */ \ - prec = 1; \ - else \ - /* We have to take care for the '0' flag. If a precision \ - is given it must be ignored. */ \ - pad = L_(' '); \ - \ - /* If the precision is 0 and the number is 0 nothing has to \ - be written for the number, except for the 'o' format in \ - alternate form. */ \ - if (prec == 0 && number.word == 0) \ - { \ - string = workend; \ - if (base == 8 && alt) \ - *--string = L_('0'); \ - } \ - else \ - { \ - /* Put the number in WORK. */ \ - string = _itoa_word (number.word, workend, base, \ - spec == L_('X')); \ - if (group && grouping) \ - string = group_number (work_buffer, string, workend, \ - grouping, thousands_sep); \ - if (use_outdigits && base == 10) \ - string = _i18n_number_rewrite (string, workend, workend); \ - } \ - } \ - \ - if (prec <= workend - string && number.word != 0 && alt && base == 8) \ - /* Add octal marker. */ \ - *--string = L_('0'); \ - \ - prec = MAX (0, prec - (workend - string)); \ - \ - if (!left) \ - { \ - width -= workend - string + prec; \ - \ - if (number.word != 0 && alt && base == 16) \ - /* Account for 0X hex marker. */ \ - width -= 2; \ - \ - if (is_negative || showsign || space) \ - --width; \ - \ - if (pad == L_(' ')) \ - { \ - PAD (L_(' ')); \ - width = 0; \ - } \ - \ - if (is_negative) \ - outchar (L_('-')); \ - else if (showsign) \ - outchar (L_('+')); \ - else if (space) \ - outchar (L_(' ')); \ - \ - if (number.word != 0 && alt && base == 16) \ - { \ - outchar (L_('0')); \ - outchar (spec); \ - } \ - \ - width += prec; \ - PAD (L_('0')); \ - \ - outstring (string, workend - string); \ - \ - break; \ - } \ - else \ - { \ - if (is_negative) \ - { \ - outchar (L_('-')); \ - --width; \ - } \ - else if (showsign) \ - { \ - outchar (L_('+')); \ - --width; \ - } \ - else if (space) \ - { \ - outchar (L_(' ')); \ - --width; \ - } \ - \ - if (number.word != 0 && alt && base == 16) \ - { \ - outchar (L_('0')); \ - outchar (spec); \ - width -= 2; \ - } \ - \ - width -= workend - string + prec; \ - \ - if (prec > 0) \ - { \ - int temp = width; \ - width = prec; \ - PAD (L_('0')); \ - width = temp; \ - } \ - \ - outstring (string, workend - string); \ - \ - PAD (L_(' ')); \ - break; \ - } \ - \ - LABEL (form_float): \ - { \ - /* Floating-point number. This is handled by printf_fp.c. */ \ - const void *ptr; \ - int function_done; \ - \ - if (fspec == NULL) \ - { \ - if (__ldbl_is_dbl) \ - is_long_double = 0; \ - \ - struct printf_info info = { .prec = prec, \ - .width = width, \ - .spec = spec, \ - .is_long_double = is_long_double, \ - .is_short = is_short, \ - .is_long = is_long, \ - .alt = alt, \ - .space = space, \ - .left = left, \ - .showsign = showsign, \ - .group = group, \ - .pad = pad, \ - .extra = 0, \ - .i18n = use_outdigits, \ - .wide = sizeof (CHAR_T) != 1, \ - .is_binary128 = 0}; \ - \ - if (is_long_double) \ - the_arg.pa_long_double = va_arg (ap, long double); \ - else \ - the_arg.pa_double = va_arg (ap, double); \ - ptr = (const void *) &the_arg; \ - \ - function_done = __printf_fp (s, &info, &ptr); \ - } \ - else \ - { \ - ptr = (const void *) &args_value[fspec->data_arg]; \ - if (__ldbl_is_dbl) \ - { \ - fspec->data_arg_type = PA_DOUBLE; \ - fspec->info.is_long_double = 0; \ - } \ - /* Not supported by *printf functions. */ \ - fspec->info.is_binary128 = 0; \ - \ - function_done = __printf_fp (s, &fspec->info, &ptr); \ - } \ - \ - if (function_done < 0) \ - { \ - /* Error in print handler; up to handler to set errno. */ \ - done = -1; \ - goto all_done; \ - } \ - \ - done_add (function_done); \ - } \ - break; \ - \ - LABEL (form_floathex): \ - { \ - /* Floating point number printed as hexadecimal number. */ \ - const void *ptr; \ - int function_done; \ - \ - if (fspec == NULL) \ - { \ - if (__ldbl_is_dbl) \ - is_long_double = 0; \ - \ - struct printf_info info = { .prec = prec, \ - .width = width, \ - .spec = spec, \ - .is_long_double = is_long_double, \ - .is_short = is_short, \ - .is_long = is_long, \ - .alt = alt, \ - .space = space, \ - .left = left, \ - .showsign = showsign, \ - .group = group, \ - .pad = pad, \ - .extra = 0, \ - .wide = sizeof (CHAR_T) != 1, \ - .is_binary128 = 0}; \ - \ - if (is_long_double) \ - the_arg.pa_long_double = va_arg (ap, long double); \ - else \ - the_arg.pa_double = va_arg (ap, double); \ - ptr = (const void *) &the_arg; \ - \ - function_done = __printf_fphex (s, &info, &ptr); \ - } \ - else \ - { \ - ptr = (const void *) &args_value[fspec->data_arg]; \ - if (__ldbl_is_dbl) \ - fspec->info.is_long_double = 0; \ - /* Not supported by *printf functions. */ \ - fspec->info.is_binary128 = 0; \ - \ - function_done = __printf_fphex (s, &fspec->info, &ptr); \ - } \ - \ - if (function_done < 0) \ - { \ - /* Error in print handler; up to handler to set errno. */ \ - done = -1; \ - goto all_done; \ - } \ - \ - done_add (function_done); \ - } \ - break; \ - \ - LABEL (form_pointer): \ - /* Generic pointer. */ \ - { \ - const void *ptr; \ - if (fspec == NULL) \ - ptr = va_arg (ap, void *); \ - else \ - ptr = args_value[fspec->data_arg].pa_pointer; \ - if (ptr != NULL) \ - { \ - /* If the pointer is not NULL, write it as a %#x spec. */ \ - base = 16; \ - number.word = (unsigned long int) ptr; \ - is_negative = 0; \ - alt = 1; \ - group = 0; \ - spec = L_('x'); \ - goto LABEL (number); \ - } \ - else \ - { \ - /* Write "(nil)" for a nil pointer. */ \ - string = (CHAR_T *) L_("(nil)"); \ - /* Make sure the full string "(nil)" is printed. */ \ - if (prec < 5) \ - prec = 5; \ - /* This is a wide string iff compiling wprintf. */ \ - is_long = sizeof (CHAR_T) > 1; \ - goto LABEL (print_string); \ - } \ - } \ - /* NOTREACHED */ \ - \ - LABEL (form_number): \ - if (s->_flags2 & _IO_FLAGS2_FORTIFY) \ - { \ - if (! readonly_format) \ - { \ - extern int __readonly_area (const void *, size_t) \ - attribute_hidden; \ - readonly_format \ - = __readonly_area (format, ((STR_LEN (format) + 1) \ - * sizeof (CHAR_T))); \ - } \ - if (readonly_format < 0) \ - __libc_fatal ("*** %n in writable segment detected ***\n"); \ - } \ - /* Answer the count of characters written. */ \ - if (fspec == NULL) \ - { \ - if (is_longlong) \ - *(long long int *) va_arg (ap, void *) = done; \ - else if (is_long_num) \ - *(long int *) va_arg (ap, void *) = done; \ - else if (is_char) \ - *(char *) va_arg (ap, void *) = done; \ - else if (!is_short) \ - *(int *) va_arg (ap, void *) = done; \ - else \ - *(short int *) va_arg (ap, void *) = done; \ - } \ - else \ - if (is_longlong) \ - *(long long int *) args_value[fspec->data_arg].pa_pointer = done; \ - else if (is_long_num) \ - *(long int *) args_value[fspec->data_arg].pa_pointer = done; \ - else if (is_char) \ - *(char *) args_value[fspec->data_arg].pa_pointer = done; \ - else if (!is_short) \ - *(int *) args_value[fspec->data_arg].pa_pointer = done; \ - else \ - *(short int *) args_value[fspec->data_arg].pa_pointer = done; \ - break; \ - \ - LABEL (form_strerror): \ - /* Print description of error ERRNO. */ \ - string = \ - (CHAR_T *) __strerror_r (save_errno, (char *) work_buffer, \ - WORK_BUFFER_SIZE * sizeof (CHAR_T)); \ - is_long = 0; /* This is no wide-char string. */ \ - goto LABEL (print_string) - -#ifdef COMPILE_WPRINTF -# define process_string_arg(fspec) \ - LABEL (form_character): \ - /* Character. */ \ - if (is_long) \ - goto LABEL (form_wcharacter); \ - --width; /* Account for the character itself. */ \ - if (!left) \ - PAD (L' '); \ - if (fspec == NULL) \ - outchar (__btowc ((unsigned char) va_arg (ap, int))); /* Promoted. */ \ - else \ - outchar (__btowc ((unsigned char) \ - args_value[fspec->data_arg].pa_int)); \ - if (left) \ - PAD (L' '); \ - break; \ - \ - LABEL (form_wcharacter): \ - { \ - /* Wide character. */ \ - --width; \ - if (!left) \ - PAD (L' '); \ - if (fspec == NULL) \ - outchar (va_arg (ap, wchar_t)); \ - else \ - outchar (args_value[fspec->data_arg].pa_wchar); \ - if (left) \ - PAD (L' '); \ - } \ - break; \ - \ - LABEL (form_string): \ - { \ - size_t len; \ - int string_malloced; \ - \ - /* The string argument could in fact be `char *' or `wchar_t *'. \ - But this should not make a difference here. */ \ - if (fspec == NULL) \ - string = (CHAR_T *) va_arg (ap, const wchar_t *); \ - else \ - string = (CHAR_T *) args_value[fspec->data_arg].pa_wstring; \ - \ - /* Entry point for printing other strings. */ \ - LABEL (print_string): \ - \ - string_malloced = 0; \ - if (string == NULL) \ - { \ - /* Write "(null)" if there's space. */ \ - if (prec == -1 || prec >= (int) array_length (null) - 1) \ - { \ - string = (CHAR_T *) null; \ - len = array_length (null) - 1; \ - } \ - else \ - { \ - string = (CHAR_T *) L""; \ - len = 0; \ - } \ - } \ - else if (!is_long && spec != L_('S')) \ - { \ - /* This is complicated. We have to transform the multibyte \ - string into a wide character string. */ \ - const char *mbs = (const char *) string; \ - mbstate_t mbstate; \ - \ - len = prec != -1 ? __strnlen (mbs, (size_t) prec) : strlen (mbs); \ - \ - /* Allocate dynamically an array which definitely is long \ - enough for the wide character version. Each byte in the \ - multi-byte string can produce at most one wide character. */ \ - if (__glibc_unlikely (len > SIZE_MAX / sizeof (wchar_t))) \ - { \ - __set_errno (EOVERFLOW); \ - done = -1; \ - goto all_done; \ - } \ - else if (__libc_use_alloca (len * sizeof (wchar_t))) \ - string = (CHAR_T *) alloca (len * sizeof (wchar_t)); \ - else if ((string = (CHAR_T *) malloc (len * sizeof (wchar_t))) \ - == NULL) \ - { \ - done = -1; \ - goto all_done; \ - } \ - else \ - string_malloced = 1; \ - \ - memset (&mbstate, '\0', sizeof (mbstate_t)); \ - len = __mbsrtowcs (string, &mbs, len, &mbstate); \ - if (len == (size_t) -1) \ - { \ - /* Illegal multibyte character. */ \ - done = -1; \ - goto all_done; \ - } \ - } \ - else \ - { \ - if (prec != -1) \ - /* Search for the end of the string, but don't search past \ - the length specified by the precision. */ \ - len = __wcsnlen (string, prec); \ - else \ - len = __wcslen (string); \ - } \ - \ - if ((width -= len) < 0) \ - { \ - outstring (string, len); \ - break; \ - } \ - \ - if (!left) \ - PAD (L' '); \ - outstring (string, len); \ - if (left) \ - PAD (L' '); \ - if (__glibc_unlikely (string_malloced)) \ - free (string); \ - } \ - break; -#else -# define process_string_arg(fspec) \ - LABEL (form_character): \ - /* Character. */ \ - if (is_long) \ - goto LABEL (form_wcharacter); \ - --width; /* Account for the character itself. */ \ - if (!left) \ - PAD (' '); \ - if (fspec == NULL) \ - outchar ((unsigned char) va_arg (ap, int)); /* Promoted. */ \ - else \ - outchar ((unsigned char) args_value[fspec->data_arg].pa_int); \ - if (left) \ - PAD (' '); \ - break; \ - \ - LABEL (form_wcharacter): \ - { \ - /* Wide character. */ \ - char buf[MB_LEN_MAX]; \ - mbstate_t mbstate; \ - size_t len; \ - \ - memset (&mbstate, '\0', sizeof (mbstate_t)); \ - len = __wcrtomb (buf, (fspec == NULL ? va_arg (ap, wchar_t) \ - : args_value[fspec->data_arg].pa_wchar), \ - &mbstate); \ - if (len == (size_t) -1) \ - { \ - /* Something went wrong during the conversion. Bail out. */ \ - done = -1; \ - goto all_done; \ - } \ - width -= len; \ - if (!left) \ - PAD (' '); \ - outstring (buf, len); \ - if (left) \ - PAD (' '); \ - } \ - break; \ - \ - LABEL (form_string): \ - { \ - size_t len; \ - int string_malloced; \ - \ - /* The string argument could in fact be `char *' or `wchar_t *'. \ - But this should not make a difference here. */ \ - if (fspec == NULL) \ - string = (char *) va_arg (ap, const char *); \ - else \ - string = (char *) args_value[fspec->data_arg].pa_string; \ - \ - /* Entry point for printing other strings. */ \ - LABEL (print_string): \ - \ - string_malloced = 0; \ - if (string == NULL) \ - { \ - /* Write "(null)" if there's space. */ \ - if (prec == -1 || prec >= (int) sizeof (null) - 1) \ - { \ - string = (char *) null; \ - len = sizeof (null) - 1; \ - } \ - else \ - { \ - string = (char *) ""; \ - len = 0; \ - } \ - } \ - else if (!is_long && spec != L_('S')) \ - { \ - if (prec != -1) \ - /* Search for the end of the string, but don't search past \ - the length (in bytes) specified by the precision. */ \ - len = __strnlen (string, prec); \ - else \ - len = strlen (string); \ - } \ - else \ - { \ - const wchar_t *s2 = (const wchar_t *) string; \ - mbstate_t mbstate; \ - \ - memset (&mbstate, '\0', sizeof (mbstate_t)); \ - \ - if (prec >= 0) \ - { \ - /* The string `s2' might not be NUL terminated. */ \ - if (__libc_use_alloca (prec)) \ - string = (char *) alloca (prec); \ - else if ((string = (char *) malloc (prec)) == NULL) \ - { \ - done = -1; \ - goto all_done; \ - } \ - else \ - string_malloced = 1; \ - len = __wcsrtombs (string, &s2, prec, &mbstate); \ - } \ - else \ - { \ - len = __wcsrtombs (NULL, &s2, 0, &mbstate); \ - if (len != (size_t) -1) \ - { \ - assert (__mbsinit (&mbstate)); \ - s2 = (const wchar_t *) string; \ - if (__libc_use_alloca (len + 1)) \ - string = (char *) alloca (len + 1); \ - else if ((string = (char *) malloc (len + 1)) == NULL) \ - { \ - done = -1; \ - goto all_done; \ - } \ - else \ - string_malloced = 1; \ - (void) __wcsrtombs (string, &s2, len + 1, &mbstate); \ - } \ - } \ - \ - if (len == (size_t) -1) \ - { \ - /* Illegal wide-character string. */ \ - done = -1; \ - goto all_done; \ - } \ - } \ - \ - if ((width -= len) < 0) \ - { \ - outstring (string, len); \ - break; \ - } \ - \ - if (!left) \ - PAD (' '); \ - outstring (string, len); \ - if (left) \ - PAD (' '); \ - if (__glibc_unlikely (string_malloced)) \ - free (string); \ - } \ - break; -#endif - -/* Helper function to provide temporary buffering for unbuffered streams. */ -static int buffered_vfprintf (FILE *stream, const CHAR_T *fmt, va_list) - __THROW __attribute__ ((noinline)); - -/* Handle positional format specifiers. */ -static int printf_positional (FILE *s, - const CHAR_T *format, int readonly_format, - va_list ap, va_list *ap_savep, int done, - int nspecs_done, const UCHAR_T *lead_str_end, - CHAR_T *work_buffer, int save_errno, - const char *grouping, THOUSANDS_SEP_T); - -/* Handle unknown format specifier. */ -static int printf_unknown (FILE *, const struct printf_info *, - const void *const *) __THROW; - -/* Group digits of number string. */ -static CHAR_T *group_number (CHAR_T *, CHAR_T *, CHAR_T *, const char *, - THOUSANDS_SEP_T); - -/* The function itself. */ -int -vfprintf (FILE *s, const CHAR_T *format, va_list ap) +extern int +__vfprintf (FILE *fp, const char *format, va_list ap) { - /* The character used as thousands separator. */ - THOUSANDS_SEP_T thousands_sep = 0; - - /* The string describing the size of groups of digits. */ - const char *grouping; - - /* Place to accumulate the result. */ - int done; - - /* Current character in format string. */ - const UCHAR_T *f; - - /* End of leading constant string. */ - const UCHAR_T *lead_str_end; - - /* Points to next format specifier. */ - const UCHAR_T *end_of_spec; - - /* Buffer intermediate results. */ - CHAR_T work_buffer[WORK_BUFFER_SIZE]; - CHAR_T *workstart = NULL; - CHAR_T *workend; - - /* We have to save the original argument pointer. */ - va_list ap_save; - - /* Count number of specifiers we already processed. */ - int nspecs_done; - - /* For the %m format we may need the current `errno' value. */ - int save_errno = errno; - - /* 1 if format is in read-only memory, -1 if it is in writable memory, - 0 if unknown. */ - int readonly_format = 0; - - /* Orient the stream. */ -#ifdef ORIENT - ORIENT; -#endif - - /* Sanity check of arguments. */ - ARGCHECK (s, format); - -#ifdef ORIENT - /* Check for correct orientation. */ - if (_IO_vtable_offset (s) == 0 && - _IO_fwide (s, sizeof (CHAR_T) == 1 ? -1 : 1) - != (sizeof (CHAR_T) == 1 ? -1 : 1)) - /* The stream is already oriented otherwise. */ - return EOF; -#endif - - if (UNBUFFERED_P (s)) - /* Use a helper function which will allocate a local temporary buffer - for the stream and then call us again. */ - return buffered_vfprintf (s, format, ap); - - /* Initialize local variables. */ - done = 0; - grouping = (const char *) -1; -#ifdef __va_copy - /* This macro will be available soon in gcc's <stdarg.h>. We need it - since on some systems `va_list' is not an integral type. */ - __va_copy (ap_save, ap); -#else - ap_save = ap; -#endif - nspecs_done = 0; - -#ifdef COMPILE_WPRINTF - /* Find the first format specifier. */ - f = lead_str_end = __find_specwc ((const UCHAR_T *) format); -#else - /* Find the first format specifier. */ - f = lead_str_end = __find_specmb ((const UCHAR_T *) format); -#endif - - /* Lock stream. */ - _IO_cleanup_region_start ((void (*) (void *)) &_IO_funlockfile, s); - _IO_flockfile (s); - - /* Write the literal text before the first format. */ - outstring ((const UCHAR_T *) format, - lead_str_end - (const UCHAR_T *) format); - - /* If we only have to print a simple string, return now. */ - if (*f == L_('\0')) - goto all_done; - - /* Use the slow path in case any printf handler is registered. */ - if (__glibc_unlikely (__printf_function_table != NULL - || __printf_modifier_table != NULL - || __printf_va_arg_table != NULL)) - goto do_positional; - - /* Process whole format string. */ - do - { - STEP0_3_TABLE; - STEP4_TABLE; - - union printf_arg *args_value; /* This is not used here but ... */ - int is_negative; /* Flag for negative number. */ - union - { - unsigned long long int longlong; - unsigned long int word; - } number; - int base; - union printf_arg the_arg; - CHAR_T *string; /* Pointer to argument string. */ - int alt = 0; /* Alternate format. */ - int space = 0; /* Use space prefix if no sign is needed. */ - int left = 0; /* Left-justify output. */ - int showsign = 0; /* Always begin with plus or minus sign. */ - int group = 0; /* Print numbers according grouping rules. */ - int is_long_double = 0; /* Argument is long double/ long long int. */ - int is_short = 0; /* Argument is short int. */ - int is_long = 0; /* Argument is long int. */ - int is_char = 0; /* Argument is promoted (unsigned) char. */ - int width = 0; /* Width of output; 0 means none specified. */ - int prec = -1; /* Precision of output; -1 means none specified. */ - /* This flag is set by the 'I' modifier and selects the use of the - `outdigits' as determined by the current locale. */ - int use_outdigits = 0; - UCHAR_T pad = L_(' ');/* Padding character. */ - CHAR_T spec; - - workstart = NULL; - workend = work_buffer + WORK_BUFFER_SIZE; - - /* Get current character in format string. */ - JUMP (*++f, step0_jumps); - - /* ' ' flag. */ - LABEL (flag_space): - space = 1; - JUMP (*++f, step0_jumps); - - /* '+' flag. */ - LABEL (flag_plus): - showsign = 1; - JUMP (*++f, step0_jumps); - - /* The '-' flag. */ - LABEL (flag_minus): - left = 1; - pad = L_(' '); - JUMP (*++f, step0_jumps); - - /* The '#' flag. */ - LABEL (flag_hash): - alt = 1; - JUMP (*++f, step0_jumps); - - /* The '0' flag. */ - LABEL (flag_zero): - if (!left) - pad = L_('0'); - JUMP (*++f, step0_jumps); - - /* The '\'' flag. */ - LABEL (flag_quote): - group = 1; - - if (grouping == (const char *) -1) - { -#ifdef COMPILE_WPRINTF - thousands_sep = _NL_CURRENT_WORD (LC_NUMERIC, - _NL_NUMERIC_THOUSANDS_SEP_WC); -#else - thousands_sep = _NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP); -#endif - - grouping = _NL_CURRENT (LC_NUMERIC, GROUPING); - if (*grouping == '\0' || *grouping == CHAR_MAX -#ifdef COMPILE_WPRINTF - || thousands_sep == L'\0' -#else - || *thousands_sep == '\0' -#endif - ) - grouping = NULL; - } - JUMP (*++f, step0_jumps); - - LABEL (flag_i18n): - use_outdigits = 1; - JUMP (*++f, step0_jumps); - - /* Get width from argument. */ - LABEL (width_asterics): - { - const UCHAR_T *tmp; /* Temporary value. */ - - tmp = ++f; - if (ISDIGIT (*tmp)) - { - int pos = read_int (&tmp); - - if (pos == -1) - { - __set_errno (EOVERFLOW); - done = -1; - goto all_done; - } - - if (pos && *tmp == L_('$')) - /* The width comes from a positional parameter. */ - goto do_positional; - } - width = va_arg (ap, int); - - /* Negative width means left justified. */ - if (width < 0) - { - width = -width; - pad = L_(' '); - left = 1; - } - - if (__glibc_unlikely (width >= INT_MAX / sizeof (CHAR_T) - EXTSIZ)) - { - __set_errno (EOVERFLOW); - done = -1; - goto all_done; - } - - if (width >= WORK_BUFFER_SIZE - EXTSIZ) - { - /* We have to use a special buffer. */ - size_t needed = ((size_t) width + EXTSIZ) * sizeof (CHAR_T); - if (__libc_use_alloca (needed)) - workend = (CHAR_T *) alloca (needed) + width + EXTSIZ; - else - { - workstart = (CHAR_T *) malloc (needed); - if (workstart == NULL) - { - done = -1; - goto all_done; - } - workend = workstart + width + EXTSIZ; - } - } - } - JUMP (*f, step1_jumps); - - /* Given width in format string. */ - LABEL (width): - width = read_int (&f); - - if (__glibc_unlikely (width == -1 - || width >= INT_MAX / sizeof (CHAR_T) - EXTSIZ)) - { - __set_errno (EOVERFLOW); - done = -1; - goto all_done; - } - - if (width >= WORK_BUFFER_SIZE - EXTSIZ) - { - /* We have to use a special buffer. */ - size_t needed = ((size_t) width + EXTSIZ) * sizeof (CHAR_T); - if (__libc_use_alloca (needed)) - workend = (CHAR_T *) alloca (needed) + width + EXTSIZ; - else - { - workstart = (CHAR_T *) malloc (needed); - if (workstart == NULL) - { - done = -1; - goto all_done; - } - workend = workstart + width + EXTSIZ; - } - } - if (*f == L_('$')) - /* Oh, oh. The argument comes from a positional parameter. */ - goto do_positional; - JUMP (*f, step1_jumps); - - LABEL (precision): - ++f; - if (*f == L_('*')) - { - const UCHAR_T *tmp; /* Temporary value. */ - - tmp = ++f; - if (ISDIGIT (*tmp)) - { - int pos = read_int (&tmp); - - if (pos == -1) - { - __set_errno (EOVERFLOW); - done = -1; - goto all_done; - } - - if (pos && *tmp == L_('$')) - /* The precision comes from a positional parameter. */ - goto do_positional; - } - prec = va_arg (ap, int); - - /* If the precision is negative the precision is omitted. */ - if (prec < 0) - prec = -1; - } - else if (ISDIGIT (*f)) - { - prec = read_int (&f); - - /* The precision was specified in this case as an extremely - large positive value. */ - if (prec == -1) - { - __set_errno (EOVERFLOW); - done = -1; - goto all_done; - } - } - else - prec = 0; - if (prec > width && prec > WORK_BUFFER_SIZE - EXTSIZ) - { - /* Deallocate any previously allocated buffer because it is - too small. */ - if (__glibc_unlikely (workstart != NULL)) - free (workstart); - workstart = NULL; - if (__glibc_unlikely (prec >= INT_MAX / sizeof (CHAR_T) - EXTSIZ)) - { - __set_errno (EOVERFLOW); - done = -1; - goto all_done; - } - size_t needed = ((size_t) prec + EXTSIZ) * sizeof (CHAR_T); - - if (__libc_use_alloca (needed)) - workend = (CHAR_T *) alloca (needed) + prec + EXTSIZ; - else - { - workstart = (CHAR_T *) malloc (needed); - if (workstart == NULL) - { - done = -1; - goto all_done; - } - workend = workstart + prec + EXTSIZ; - } - } - JUMP (*f, step2_jumps); - - /* Process 'h' modifier. There might another 'h' following. */ - LABEL (mod_half): - is_short = 1; - JUMP (*++f, step3a_jumps); - - /* Process 'hh' modifier. */ - LABEL (mod_halfhalf): - is_short = 0; - is_char = 1; - JUMP (*++f, step4_jumps); - - /* Process 'l' modifier. There might another 'l' following. */ - LABEL (mod_long): - is_long = 1; - JUMP (*++f, step3b_jumps); - - /* Process 'L', 'q', or 'll' modifier. No other modifier is - allowed to follow. */ - LABEL (mod_longlong): - is_long_double = 1; - is_long = 1; - JUMP (*++f, step4_jumps); - - LABEL (mod_size_t): - is_long_double = sizeof (size_t) > sizeof (unsigned long int); - is_long = sizeof (size_t) > sizeof (unsigned int); - JUMP (*++f, step4_jumps); - - LABEL (mod_ptrdiff_t): - is_long_double = sizeof (ptrdiff_t) > sizeof (unsigned long int); - is_long = sizeof (ptrdiff_t) > sizeof (unsigned int); - JUMP (*++f, step4_jumps); - - LABEL (mod_intmax_t): - is_long_double = sizeof (intmax_t) > sizeof (unsigned long int); - is_long = sizeof (intmax_t) > sizeof (unsigned int); - JUMP (*++f, step4_jumps); - - /* Process current format. */ - while (1) - { - process_arg (((struct printf_spec *) NULL)); - process_string_arg (((struct printf_spec *) NULL)); - - LABEL (form_unknown): - if (spec == L_('\0')) - { - /* The format string ended before the specifier is complete. */ - __set_errno (EINVAL); - done = -1; - goto all_done; - } - - /* If we are in the fast loop force entering the complicated - one. */ - goto do_positional; - } - - /* The format is correctly handled. */ - ++nspecs_done; - - if (__glibc_unlikely (workstart != NULL)) - free (workstart); - workstart = NULL; - - /* Look for next format specifier. */ -#ifdef COMPILE_WPRINTF - f = __find_specwc ((end_of_spec = ++f)); -#else - f = __find_specmb ((end_of_spec = ++f)); -#endif - - /* Write the following constant string. */ - outstring (end_of_spec, f - end_of_spec); - } - while (*f != L_('\0')); - - /* Unlock stream and return. */ - goto all_done; - - /* Hand off processing for positional parameters. */ -do_positional: - if (__glibc_unlikely (workstart != NULL)) - { - free (workstart); - workstart = NULL; - } - done = printf_positional (s, format, readonly_format, ap, &ap_save, - done, nspecs_done, lead_str_end, work_buffer, - save_errno, grouping, thousands_sep); - - all_done: - if (__glibc_unlikely (workstart != NULL)) - free (workstart); - /* Unlock the stream. */ - _IO_funlockfile (s); - _IO_cleanup_region_end (0); - - return done; -} - -static int -printf_positional (FILE *s, const CHAR_T *format, int readonly_format, - va_list ap, va_list *ap_savep, int done, int nspecs_done, - const UCHAR_T *lead_str_end, - CHAR_T *work_buffer, int save_errno, - const char *grouping, THOUSANDS_SEP_T thousands_sep) -{ - /* For positional argument handling. */ - struct scratch_buffer specsbuf; - scratch_buffer_init (&specsbuf); - struct printf_spec *specs = specsbuf.data; - size_t specs_limit = specsbuf.length / sizeof (specs[0]); - - /* Used as a backing store for args_value, args_size, args_type - below. */ - struct scratch_buffer argsbuf; - scratch_buffer_init (&argsbuf); - - /* Array with information about the needed arguments. This has to - be dynamically extensible. */ - size_t nspecs = 0; - - /* The number of arguments the format string requests. This will - determine the size of the array needed to store the argument - attributes. */ - size_t nargs = 0; - - /* Positional parameters refer to arguments directly. This could - also determine the maximum number of arguments. Track the - maximum number. */ - size_t max_ref_arg = 0; - - /* Just a counter. */ - size_t cnt; - - CHAR_T *workstart = NULL; - - if (grouping == (const char *) -1) - { -#ifdef COMPILE_WPRINTF - thousands_sep = _NL_CURRENT_WORD (LC_NUMERIC, - _NL_NUMERIC_THOUSANDS_SEP_WC); -#else - thousands_sep = _NL_CURRENT (LC_NUMERIC, THOUSANDS_SEP); -#endif - - grouping = _NL_CURRENT (LC_NUMERIC, GROUPING); - if (*grouping == '\0' || *grouping == CHAR_MAX) - grouping = NULL; - } - - for (const UCHAR_T *f = lead_str_end; *f != L_('\0'); - f = specs[nspecs++].next_fmt) - { - if (nspecs == specs_limit) - { - if (!scratch_buffer_grow_preserve (&specsbuf)) - { - done = -1; - goto all_done; - } - specs = specsbuf.data; - specs_limit = specsbuf.length / sizeof (specs[0]); - } - - /* Parse the format specifier. */ -#ifdef COMPILE_WPRINTF - nargs += __parse_one_specwc (f, nargs, &specs[nspecs], &max_ref_arg); -#else - nargs += __parse_one_specmb (f, nargs, &specs[nspecs], &max_ref_arg); -#endif - } - - /* Determine the number of arguments the format string consumes. */ - nargs = MAX (nargs, max_ref_arg); - - union printf_arg *args_value; - int *args_size; - int *args_type; - { - /* Calculate total size needed to represent a single argument - across all three argument-related arrays. */ - size_t bytes_per_arg - = sizeof (*args_value) + sizeof (*args_size) + sizeof (*args_type); - if (!scratch_buffer_set_array_size (&argsbuf, nargs, bytes_per_arg)) - { - done = -1; - goto all_done; - } - args_value = argsbuf.data; - /* Set up the remaining two arrays to each point past the end of - the prior array, since space for all three has been allocated - now. */ - args_size = &args_value[nargs].pa_int; - args_type = &args_size[nargs]; - memset (args_type, s->_flags2 & _IO_FLAGS2_FORTIFY ? '\xff' : '\0', - nargs * sizeof (*args_type)); - } - - /* XXX Could do sanity check here: If any element in ARGS_TYPE is - still zero after this loop, format is invalid. For now we - simply use 0 as the value. */ - - /* Fill in the types of all the arguments. */ - for (cnt = 0; cnt < nspecs; ++cnt) - { - /* If the width is determined by an argument this is an int. */ - if (specs[cnt].width_arg != -1) - args_type[specs[cnt].width_arg] = PA_INT; - - /* If the precision is determined by an argument this is an int. */ - if (specs[cnt].prec_arg != -1) - args_type[specs[cnt].prec_arg] = PA_INT; - - switch (specs[cnt].ndata_args) - { - case 0: /* No arguments. */ - break; - case 1: /* One argument; we already have the - type and size. */ - args_type[specs[cnt].data_arg] = specs[cnt].data_arg_type; - args_size[specs[cnt].data_arg] = specs[cnt].size; - break; - default: - /* We have more than one argument for this format spec. - We must call the arginfo function again to determine - all the types. */ - (void) (*__printf_arginfo_table[specs[cnt].info.spec]) - (&specs[cnt].info, - specs[cnt].ndata_args, &args_type[specs[cnt].data_arg], - &args_size[specs[cnt].data_arg]); - break; - } - } - - /* Now we know all the types and the order. Fill in the argument - values. */ - for (cnt = 0; cnt < nargs; ++cnt) - switch (args_type[cnt]) - { -#define T(tag, mem, type) \ - case tag: \ - args_value[cnt].mem = va_arg (*ap_savep, type); \ - break - - T (PA_WCHAR, pa_wchar, wint_t); - case PA_CHAR: /* Promoted. */ - case PA_INT|PA_FLAG_SHORT: /* Promoted. */ -#if LONG_MAX == INT_MAX - case PA_INT|PA_FLAG_LONG: -#endif - T (PA_INT, pa_int, int); -#if LONG_MAX == LONG_LONG_MAX - case PA_INT|PA_FLAG_LONG: -#endif - T (PA_INT|PA_FLAG_LONG_LONG, pa_long_long_int, long long int); -#if LONG_MAX != INT_MAX && LONG_MAX != LONG_LONG_MAX -# error "he?" -#endif - case PA_FLOAT: /* Promoted. */ - T (PA_DOUBLE, pa_double, double); - case PA_DOUBLE|PA_FLAG_LONG_DOUBLE: - if (__ldbl_is_dbl) - { - args_value[cnt].pa_double = va_arg (*ap_savep, double); - args_type[cnt] &= ~PA_FLAG_LONG_DOUBLE; - } - else - args_value[cnt].pa_long_double = va_arg (*ap_savep, long double); - break; - case PA_STRING: /* All pointers are the same */ - case PA_WSTRING: /* All pointers are the same */ - T (PA_POINTER, pa_pointer, void *); -#undef T - default: - if ((args_type[cnt] & PA_FLAG_PTR) != 0) - args_value[cnt].pa_pointer = va_arg (*ap_savep, void *); - else if (__glibc_unlikely (__printf_va_arg_table != NULL) - && __printf_va_arg_table[args_type[cnt] - PA_LAST] != NULL) - { - args_value[cnt].pa_user = alloca (args_size[cnt]); - (*__printf_va_arg_table[args_type[cnt] - PA_LAST]) - (args_value[cnt].pa_user, ap_savep); - } - else - args_value[cnt].pa_long_double = 0.0; - break; - case -1: - /* Error case. Not all parameters appear in N$ format - strings. We have no way to determine their type. */ - assert (s->_flags2 & _IO_FLAGS2_FORTIFY); - __libc_fatal ("*** invalid %N$ use detected ***\n"); - } - - /* Now walk through all format specifiers and process them. */ - for (; (size_t) nspecs_done < nspecs; ++nspecs_done) - { - STEP4_TABLE; - - int is_negative; - union - { - unsigned long long int longlong; - unsigned long int word; - } number; - int base; - union printf_arg the_arg; - CHAR_T *string; /* Pointer to argument string. */ - - /* Fill variables from values in struct. */ - int alt = specs[nspecs_done].info.alt; - int space = specs[nspecs_done].info.space; - int left = specs[nspecs_done].info.left; - int showsign = specs[nspecs_done].info.showsign; - int group = specs[nspecs_done].info.group; - int is_long_double = specs[nspecs_done].info.is_long_double; - int is_short = specs[nspecs_done].info.is_short; - int is_char = specs[nspecs_done].info.is_char; - int is_long = specs[nspecs_done].info.is_long; - int width = specs[nspecs_done].info.width; - int prec = specs[nspecs_done].info.prec; - int use_outdigits = specs[nspecs_done].info.i18n; - char pad = specs[nspecs_done].info.pad; - CHAR_T spec = specs[nspecs_done].info.spec; - - workstart = NULL; - CHAR_T *workend = work_buffer + WORK_BUFFER_SIZE; - - /* Fill in last information. */ - if (specs[nspecs_done].width_arg != -1) - { - /* Extract the field width from an argument. */ - specs[nspecs_done].info.width = - args_value[specs[nspecs_done].width_arg].pa_int; - - if (specs[nspecs_done].info.width < 0) - /* If the width value is negative left justification is - selected and the value is taken as being positive. */ - { - specs[nspecs_done].info.width *= -1; - left = specs[nspecs_done].info.left = 1; - } - width = specs[nspecs_done].info.width; - } - - if (specs[nspecs_done].prec_arg != -1) - { - /* Extract the precision from an argument. */ - specs[nspecs_done].info.prec = - args_value[specs[nspecs_done].prec_arg].pa_int; - - if (specs[nspecs_done].info.prec < 0) - /* If the precision is negative the precision is - omitted. */ - specs[nspecs_done].info.prec = -1; - - prec = specs[nspecs_done].info.prec; - } - - /* Maybe the buffer is too small. */ - if (MAX (prec, width) + EXTSIZ > WORK_BUFFER_SIZE) - { - if (__libc_use_alloca ((MAX (prec, width) + EXTSIZ) - * sizeof (CHAR_T))) - workend = ((CHAR_T *) alloca ((MAX (prec, width) + EXTSIZ) - * sizeof (CHAR_T)) - + (MAX (prec, width) + EXTSIZ)); - else - { - workstart = (CHAR_T *) malloc ((MAX (prec, width) + EXTSIZ) - * sizeof (CHAR_T)); - if (workstart == NULL) - { - done = -1; - goto all_done; - } - workend = workstart + (MAX (prec, width) + EXTSIZ); - } - } - - /* Process format specifiers. */ - while (1) - { - extern printf_function **__printf_function_table; - int function_done; - - if (spec <= UCHAR_MAX - && __printf_function_table != NULL - && __printf_function_table[(size_t) spec] != NULL) - { - const void **ptr = alloca (specs[nspecs_done].ndata_args - * sizeof (const void *)); - - /* Fill in an array of pointers to the argument values. */ - for (unsigned int i = 0; i < specs[nspecs_done].ndata_args; - ++i) - ptr[i] = &args_value[specs[nspecs_done].data_arg + i]; - - /* Call the function. */ - function_done = __printf_function_table[(size_t) spec] - (s, &specs[nspecs_done].info, ptr); - - if (function_done != -2) - { - /* If an error occurred we don't have information - about # of chars. */ - if (function_done < 0) - { - /* Function has set errno. */ - done = -1; - goto all_done; - } - - done_add (function_done); - break; - } - } - - JUMP (spec, step4_jumps); - - process_arg ((&specs[nspecs_done])); - process_string_arg ((&specs[nspecs_done])); - - LABEL (form_unknown): - { - unsigned int i; - const void **ptr; - - ptr = alloca (specs[nspecs_done].ndata_args - * sizeof (const void *)); - - /* Fill in an array of pointers to the argument values. */ - for (i = 0; i < specs[nspecs_done].ndata_args; ++i) - ptr[i] = &args_value[specs[nspecs_done].data_arg + i]; - - /* Call the function. */ - function_done = printf_unknown (s, &specs[nspecs_done].info, - ptr); - - /* If an error occurred we don't have information about # - of chars. */ - if (function_done < 0) - { - /* Function has set errno. */ - done = -1; - goto all_done; - } - - done_add (function_done); - } - break; - } - - if (__glibc_unlikely (workstart != NULL)) - free (workstart); - workstart = NULL; - - /* Write the following constant string. */ - outstring (specs[nspecs_done].end_of_fmt, - specs[nspecs_done].next_fmt - - specs[nspecs_done].end_of_fmt); - } - all_done: - if (__glibc_unlikely (workstart != NULL)) - free (workstart); - scratch_buffer_free (&argsbuf); - scratch_buffer_free (&specsbuf); - return done; + return __vfprintf_internal (fp, format, ap, 0); } - -/* Handle an unknown format specifier. This prints out a canonicalized - representation of the format spec itself. */ -static int -printf_unknown (FILE *s, const struct printf_info *info, - const void *const *args) - -{ - int done = 0; - CHAR_T work_buffer[MAX (sizeof (info->width), sizeof (info->prec)) * 3]; - CHAR_T *const workend - = &work_buffer[sizeof (work_buffer) / sizeof (CHAR_T)]; - CHAR_T *w; - - outchar (L_('%')); - - if (info->alt) - outchar (L_('#')); - if (info->group) - outchar (L_('\'')); - if (info->showsign) - outchar (L_('+')); - else if (info->space) - outchar (L_(' ')); - if (info->left) - outchar (L_('-')); - if (info->pad == L_('0')) - outchar (L_('0')); - if (info->i18n) - outchar (L_('I')); - - if (info->width != 0) - { - w = _itoa_word (info->width, workend, 10, 0); - while (w < workend) - outchar (*w++); - } - - if (info->prec != -1) - { - outchar (L_('.')); - w = _itoa_word (info->prec, workend, 10, 0); - while (w < workend) - outchar (*w++); - } - - if (info->spec != L_('\0')) - outchar (info->spec); - - all_done: - return done; -} - -/* Group the digits from W to REAR_PTR according to the grouping rules - of the current locale. The interpretation of GROUPING is as in - `struct lconv' from <locale.h>. The grouped number extends from - the returned pointer until REAR_PTR. FRONT_PTR to W is used as a - scratch area. */ -static CHAR_T * -group_number (CHAR_T *front_ptr, CHAR_T *w, CHAR_T *rear_ptr, - const char *grouping, THOUSANDS_SEP_T thousands_sep) -{ - /* Length of the current group. */ - int len; -#ifndef COMPILE_WPRINTF - /* Length of the separator (in wide mode, the separator is always a - single wide character). */ - int tlen = strlen (thousands_sep); -#endif - - /* We treat all negative values like CHAR_MAX. */ - - if (*grouping == CHAR_MAX || *grouping <= 0) - /* No grouping should be done. */ - return w; - - len = *grouping++; - - /* Copy existing string so that nothing gets overwritten. */ - memmove (front_ptr, w, (rear_ptr - w) * sizeof (CHAR_T)); - CHAR_T *s = front_ptr + (rear_ptr - w); - - w = rear_ptr; - - /* Process all characters in the string. */ - while (s > front_ptr) - { - *--w = *--s; - - if (--len == 0 && s > front_ptr) - { - /* A new group begins. */ -#ifdef COMPILE_WPRINTF - if (w != s) - *--w = thousands_sep; - else - /* Not enough room for the separator. */ - goto copy_rest; -#else - int cnt = tlen; - if (tlen < w - s) - do - *--w = thousands_sep[--cnt]; - while (cnt > 0); - else - /* Not enough room for the separator. */ - goto copy_rest; -#endif - - if (*grouping == CHAR_MAX -#if CHAR_MIN < 0 - || *grouping < 0 -#endif - ) - { - copy_rest: - /* No further grouping to be done. Copy the rest of the - number. */ - memmove (w, s, (front_ptr -s) * sizeof (CHAR_T)); - break; - } - else if (*grouping != '\0') - len = *grouping++; - else - /* The previous grouping repeats ad infinitum. */ - len = grouping[-1]; - } - } - return w; -} - -/* Helper "class" for `fprintf to unbuffered': creates a temporary buffer. */ -struct helper_file - { - struct _IO_FILE_plus _f; -#ifdef COMPILE_WPRINTF - struct _IO_wide_data _wide_data; -#endif - FILE *_put_stream; -#ifdef _IO_MTSAFE_IO - _IO_lock_t lock; -#endif - }; - -static int -_IO_helper_overflow (FILE *s, int c) -{ - FILE *target = ((struct helper_file*) s)->_put_stream; -#ifdef COMPILE_WPRINTF - int used = s->_wide_data->_IO_write_ptr - s->_wide_data->_IO_write_base; - if (used) - { - size_t written = _IO_sputn (target, s->_wide_data->_IO_write_base, used); - if (written == 0 || written == WEOF) - return WEOF; - __wmemmove (s->_wide_data->_IO_write_base, - s->_wide_data->_IO_write_base + written, - used - written); - s->_wide_data->_IO_write_ptr -= written; - } -#else - int used = s->_IO_write_ptr - s->_IO_write_base; - if (used) - { - size_t written = _IO_sputn (target, s->_IO_write_base, used); - if (written == 0 || written == EOF) - return EOF; - memmove (s->_IO_write_base, s->_IO_write_base + written, - used - written); - s->_IO_write_ptr -= written; - } -#endif - return PUTC (c, s); -} - -#ifdef COMPILE_WPRINTF -static const struct _IO_jump_t _IO_helper_jumps libio_vtable = -{ - JUMP_INIT_DUMMY, - JUMP_INIT (finish, _IO_wdefault_finish), - JUMP_INIT (overflow, _IO_helper_overflow), - JUMP_INIT (underflow, _IO_default_underflow), - JUMP_INIT (uflow, _IO_default_uflow), - JUMP_INIT (pbackfail, (_IO_pbackfail_t) _IO_wdefault_pbackfail), - JUMP_INIT (xsputn, _IO_wdefault_xsputn), - JUMP_INIT (xsgetn, _IO_wdefault_xsgetn), - JUMP_INIT (seekoff, _IO_default_seekoff), - JUMP_INIT (seekpos, _IO_default_seekpos), - JUMP_INIT (setbuf, _IO_default_setbuf), - JUMP_INIT (sync, _IO_default_sync), - JUMP_INIT (doallocate, _IO_wdefault_doallocate), - JUMP_INIT (read, _IO_default_read), - JUMP_INIT (write, _IO_default_write), - JUMP_INIT (seek, _IO_default_seek), - JUMP_INIT (close, _IO_default_close), - JUMP_INIT (stat, _IO_default_stat) -}; -#else -static const struct _IO_jump_t _IO_helper_jumps libio_vtable = -{ - JUMP_INIT_DUMMY, - JUMP_INIT (finish, _IO_default_finish), - JUMP_INIT (overflow, _IO_helper_overflow), - JUMP_INIT (underflow, _IO_default_underflow), - JUMP_INIT (uflow, _IO_default_uflow), - JUMP_INIT (pbackfail, _IO_default_pbackfail), - JUMP_INIT (xsputn, _IO_default_xsputn), - JUMP_INIT (xsgetn, _IO_default_xsgetn), - JUMP_INIT (seekoff, _IO_default_seekoff), - JUMP_INIT (seekpos, _IO_default_seekpos), - JUMP_INIT (setbuf, _IO_default_setbuf), - JUMP_INIT (sync, _IO_default_sync), - JUMP_INIT (doallocate, _IO_default_doallocate), - JUMP_INIT (read, _IO_default_read), - JUMP_INIT (write, _IO_default_write), - JUMP_INIT (seek, _IO_default_seek), - JUMP_INIT (close, _IO_default_close), - JUMP_INIT (stat, _IO_default_stat) -}; -#endif - -static int -buffered_vfprintf (FILE *s, const CHAR_T *format, va_list args) -{ - CHAR_T buf[BUFSIZ]; - struct helper_file helper; - FILE *hp = (FILE *) &helper._f; - int result, to_flush; - - /* Orient the stream. */ -#ifdef ORIENT - ORIENT; -#endif - - /* Initialize helper. */ - helper._put_stream = s; -#ifdef COMPILE_WPRINTF - hp->_wide_data = &helper._wide_data; - _IO_wsetp (hp, buf, buf + sizeof buf / sizeof (CHAR_T)); - hp->_mode = 1; -#else - _IO_setp (hp, buf, buf + sizeof buf); - hp->_mode = -1; -#endif - hp->_flags = _IO_MAGIC|_IO_NO_READS|_IO_USER_LOCK; -#if _IO_JUMPS_OFFSET - hp->_vtable_offset = 0; -#endif -#ifdef _IO_MTSAFE_IO - hp->_lock = NULL; -#endif - hp->_flags2 = s->_flags2; - _IO_JUMPS (&helper._f) = (struct _IO_jump_t *) &_IO_helper_jumps; - - /* Now print to helper instead. */ -#ifndef COMPILE_WPRINTF - result = _IO_vfprintf (hp, format, args); -#else - result = vfprintf (hp, format, args); -#endif - - /* Lock stream. */ - __libc_cleanup_region_start (1, (void (*) (void *)) &_IO_funlockfile, s); - _IO_flockfile (s); - - /* Now flush anything from the helper to the S. */ -#ifdef COMPILE_WPRINTF - if ((to_flush = (hp->_wide_data->_IO_write_ptr - - hp->_wide_data->_IO_write_base)) > 0) - { - if ((int) _IO_sputn (s, hp->_wide_data->_IO_write_base, to_flush) - != to_flush) - result = -1; - } -#else - if ((to_flush = hp->_IO_write_ptr - hp->_IO_write_base) > 0) - { - if ((int) _IO_sputn (s, hp->_IO_write_base, to_flush) != to_flush) - result = -1; - } -#endif - - /* Unlock the stream. */ - _IO_funlockfile (s); - __libc_cleanup_region_end (0); - - return result; -} - -#undef vfprintf -#ifdef COMPILE_WPRINTF -strong_alias (_IO_vfwprintf, __vfwprintf); -ldbl_weak_alias (_IO_vfwprintf, vfwprintf); -#else -ldbl_strong_alias (_IO_vfprintf_internal, vfprintf); -ldbl_hidden_def (_IO_vfprintf_internal, vfprintf) -ldbl_strong_alias (_IO_vfprintf_internal, _IO_vfprintf); -ldbl_hidden_def (_IO_vfprintf_internal, _IO_vfprintf) -#endif +ldbl_strong_alias (__vfprintf, _IO_vfprintf); +ldbl_strong_alias (__vfprintf, vfprintf); +ldbl_hidden_def (__vfprintf, vfprintf) |