len = prec != -1 ? prec : strlen (mbs);			      \
len = prec != -1 ? (size_t) prec : strlen (mbs);		      \
static CHAR_T *group_number __P ((CHAR_T *, CHAR_T *, const char *,				  const char *)) internal_function;#endif/* The function itself.  */intvfprintf (FILE *s, const CHAR_T *format, va_list ap){  /* The character used as thousands separator.  */#ifdef COMPILE_WPRINTF  wchar_t thousands_sep = L'\0';#else  const char *thousands_sep = NULL;#endif  /* 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[1000];  CHAR_T *workstart = NULL;  CHAR_T *workend;  /* State for restartable multibyte character handling functions.  */#ifndef COMPILE_WPRINTF  mbstate_t mbstate;#endif  /* 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;  /* This table maps a character into a number representing a     class.  In each step there is a destination label for each     class.  */  static const int 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_(' ')])#if defined HAVE_SUBTRACT_LOCAL_LABELS && defined SHARED  /* 'int' is enough and it saves some space on 64 bit systems.  */# define JUMP_TABLE_TYPE const int# define JUMP(ChExpr, table)						      \      do								      \	{								      \	  int offset;							      \	  void *__unbounded ptr;					      \	  spec = (ChExpr);						      \	  offset = NOT_IN_JUMP_RANGE (spec) ? REF (form_unknown)	      \	    : table[CHAR_CLASS (spec)];					      \	  ptr = &&do_form_unknown + offset;				      \	  goto *ptr;							      \	}								      \      while (0)#else# define JUMP_TABLE_TYPE const void *const# define JUMP(ChExpr, table)						      \      do								      \	{								      \	  const void *__unbounded 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 (flag_i18n)	        /* 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 (flag_i18n)	        /* 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  /* `char' and `short int' will be promoted to `int'.  */  \		signed_number = va_arg (ap, int);			      \	    }								      \	  else								      \	    if (is_long_num)						      \	      signed_number = args_value[fspec->data_arg].pa_long_int;	      \	    else if (!is_short)						      \	      signed_number = args_value[fspec->data_arg].pa_int;	      \	    else	      						      \	      signed_number = args_value[fspec->data_arg].pa_short_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 (string, workend, grouping,	      \				       thousands_sep);			      \									      \	      if (use_outdigits && base == 10)				      \		string = _i18n_number_rewrite (string, 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_char;			      \	    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_short_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 (string, workend, grouping,	      \				       thousands_sep);			      \									      \	      if (use_outdigits && base == 10)				      \		string = _i18n_number_rewrite (string, 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)						      \	  {								      \	    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 };	      \									      \	    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];		      \									      \	    function_done = __printf_fp (s, &fspec->info, &ptr);	      \	  }								      \									      \	if (function_done < 0)						      \	  {								      \	    /* Error in print handler.  */				      \	    done = -1;							      \	    goto all_done;						      \	  }								      \									      \	done += function_done;						      \      }									      \      break;								      \									      \    LABEL (form_floathex):						      \      {									      \        /* Floating point number printed as hexadecimal number.  */	      \	const void *ptr;						      \	int function_done;						      \									      \	if (fspec == NULL)						      \	  {								      \	    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 };	      \									      \	    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];		      \									      \	    function_done = __printf_fphex (s, &fspec->info, &ptr);	      \	  }								      \									      \	if (function_done < 0)						      \	  {								      \	    /* Error in print handler.  */				      \	    done = -1;							      \	    goto all_done;						      \	  }								      \									      \	done += 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;							      \	    is_long = 0;	/* This is no wide-char string.  */	      \	    goto LABEL (print_string);					      \	  }								      \      }									      \      /* NOTREACHED */							      \									      \    LABEL (form_number):						      \      /* 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,	      \				 sizeof work_buffer);			      \      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_char));	      \      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) (sizeof (null) / sizeof (null[0])) - 1)      \	      {								      \		string = (CHAR_T *) null;				      \		len = (sizeof (null) / sizeof (null[0])) - 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 ? prec : strlen (mbs);			      \									      \	    /* Allocate dynamically an array which definitely is long	      \	       enough for the wide character version.  */		      \	    if (len < 8192)						      \	      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 (__builtin_expect (string_malloced, 0))			      \	  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_char);	      \      if (left)								      \	PAD (' ');							      \      break;								      \									      \    LABEL (form_wcharacter):						      \      {									      \	/* Wide character.  */						      \	char buf[MB_CUR_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 wron gduring 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.  Also    \		   don't use incomplete characters.  */			      \		if (_NL_CURRENT_WORD (LC_CTYPE, _NL_CTYPE_MB_CUR_MAX) == 1)   \		  len = __strnlen (string, prec);			      \		else							      \		  {							      \		    /* In case we have a multibyte character set the	      \		       situation is more compilcated.  We must not copy	      \		       bytes at the end which form an incomplete character. */\		    wchar_t ignore[prec];				      \		    const char *str2 = string;				      \		    mbstate_t ps;					      \									      \		    memset (&ps, '\0', sizeof (ps));			      \		    if (__mbsnrtowcs (ignore, &str2, prec, prec, &ps)	      \			== (size_t) -1)					      \		      {							      \			done = -1;					      \			goto all_done;					      \		      }							      \		    if (str2 == NULL)					      \		      len = strlen (string);				      \		    else						      \		      len = str2 - string - (ps.__count);		      \		  }							      \	      }								      \	    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 (prec < 32768)					      \		  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 (len + 1 < 32768)				      \		      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 (__builtin_expect (string_malloced, 0))			      \	  free (string);						      \      }									      \      break;#endif  /* Orient the stream.  */#ifdef ORIENT  ORIENT;#endif  /* Sanity check of arguments.  */  ARGCHECK (s, format);#ifdef ORIENT  /* Check for correct orientation.  */  if (# ifdef USE_IN_LIBIO      s->_vtable_offset == 0 &&# endif      _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_spec ((const UCHAR_T *) format);#else  /* Put state for processing format string in initial state.  */  memset (&mbstate, '\0', sizeof (mbstate_t));  /* Find the first format specifier.  */  f = lead_str_end = find_spec (format, &mbstate);#endif  /* Lock stream.  */#ifdef USE_IN_LIBIO  __libc_cleanup_region_start (1, (void (*) (void *)) &_IO_funlockfile, s);  _IO_flockfile (s);#else  __libc_cleanup_region_start (1, (void (*) (void *)) &__funlockfile, s);  __flockfile (s);#endif  /* 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;  /* Process whole format string.  */  do    {#if defined HAVE_SUBTRACT_LOCAL_LABELS && defined SHARED# define REF(Name) &&do_##Name - &&do_form_unknown#else# define REF(Name) &&do_##Name#endif#define LABEL(Name) do_##Name      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[sizeof (work_buffer) / sizeof (CHAR_T)];      /* 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) && read_int (&tmp) && *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 (width + 32 >= (int) (sizeof (work_buffer)				 / sizeof (work_buffer[0])))	  {	    /* We have to use a special buffer.  The "32" is just a safe	       bet for all the output which is not counted in the width.  */	    if (width < (int) (32768 / sizeof (CHAR_T)))	      workend = ((CHAR_T *) alloca ((width + 32) * sizeof (CHAR_T))			 + (width + 32));	    else	      {		workstart = (CHAR_T *) malloc ((width + 32) * sizeof (CHAR_T));		if (workstart == NULL)		  {		    done = -1;		    goto all_done;		  }		workend = workstart + (width + 32);	      }	  }      }      JUMP (*f, step1_jumps);      /* Given width in format string.  */    LABEL (width):      width = read_int (&f);      if (width + 32 >= (int) (sizeof (work_buffer) / sizeof (work_buffer[0])))	{	  /* We have to use a special buffer.  The "32" is just a safe	     bet for all the output which is not counted in the width.  */	  if (width < (int) (32768 / sizeof (CHAR_T)))	    workend = ((CHAR_T *) alloca ((width + 32) * sizeof (CHAR_T))		       + (width + 32));	  else	    {	      workstart = (CHAR_T *) malloc ((width + 32) * sizeof (CHAR_T));	      if (workstart == NULL)		{		  done = -1;		  goto all_done;		}	      workend = workstart + (width + 32);	    }	}      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) && read_int (&tmp) > 0 && *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);      else	prec = 0;      if (prec > width	  && prec + 32 > (int)(sizeof (work_buffer) / sizeof (work_buffer[0])))	{	  if (prec < (int) (32768 / sizeof (CHAR_T)))	    workend = alloca (prec + 32) + (prec + 32);	  else	    {	      workstart = (CHAR_T *) malloc ((prec + 32) * sizeof (CHAR_T));	      if (workstart == NULL)		{		  done = -1;		  goto all_done;		}	      workend = workstart + (prec + 32);	    }	}      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.  */	      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 (__builtin_expect (workstart != NULL, 0))	free (workstart);      workstart = NULL;      /* Look for next format specifier.  */#ifdef COMPILE_WPRINTF      f = find_spec ((end_of_spec = ++f));#else      f = find_spec ((end_of_spec = ++f), &mbstate);#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;  /* Here starts the more complex loop to handle positional parameters.  */do_positional:  {    /* Array with information about the needed arguments.  This has to       be dynamically extensible.  */    size_t nspecs = 0;    size_t nspecs_max = 32;	/* A more or less arbitrary start value.  */    struct printf_spec *specs      = alloca (nspecs_max * sizeof (struct printf_spec));    /* 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;    int *args_type;    union printf_arg *args_value = NULL;    /* 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;    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 (f = lead_str_end; *f != L_('\0'); f = specs[nspecs++].next_fmt)      {	if (nspecs >= nspecs_max)	  {	    /* Extend the array of format specifiers.  */	    struct printf_spec *old = specs;	    nspecs_max *= 2;	    specs = alloca (nspecs_max * sizeof (struct printf_spec));	    if (specs == &old[nspecs])	      /* Stack grows up, OLD was the last thing allocated;		 extend it.  */	      nspecs_max += nspecs_max / 2;	    else	      {		/* Copy the old array's elements to the new space.  */		memcpy (specs, old, nspecs * sizeof (struct printf_spec));		if (old == &specs[nspecs])		  /* Stack grows down, OLD was just below the new		     SPECS.  We can use that space when the new space		     runs out.  */		  nspecs_max += nspecs_max / 2;	      }	  }	/* Parse the format specifier.  */#ifdef COMPILE_WPRINTF	nargs += parse_one_spec (f, nargs, &specs[nspecs], &max_ref_arg);#else	nargs += parse_one_spec (f, nargs, &specs[nspecs], &max_ref_arg,				 &mbstate);#endif      }    /* Determine the number of arguments the format string consumes.  */    nargs = MAX (nargs, max_ref_arg);    /* Allocate memory for the argument descriptions.  */    args_type = alloca (nargs * sizeof (int));    memset (args_type, 0, nargs * sizeof (int));    args_value = alloca (nargs * sizeof (union printf_arg));    /* 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.  */	    args_type[specs[cnt].data_arg] = specs[cnt].data_arg_type;	    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]);	    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_save, type);			      \	  break	T (PA_CHAR, pa_char, int); /* Promoted.  */	T (PA_WCHAR, pa_wchar, wint_t);	T (PA_INT|PA_FLAG_SHORT, pa_short_int, int); /* Promoted.  */	T (PA_INT, pa_int, int);	T (PA_INT|PA_FLAG_LONG, pa_long_int, long int);	T (PA_INT|PA_FLAG_LONG_LONG, pa_long_long_int, long long int);	T (PA_FLOAT, pa_float, double);	/* Promoted.  */	T (PA_DOUBLE, pa_double, double);	T (PA_DOUBLE|PA_FLAG_LONG_DOUBLE, pa_long_double, long double);	T (PA_STRING, pa_string, const char *);	T (PA_WSTRING, pa_wstring, const wchar_t *);	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_save, void *);	  else	    args_value[cnt].pa_long_double = 0.0;	  break;	}    /* Now walk through all format specifiers and process them.  */    for (; (size_t) nspecs_done < nspecs; ++nspecs_done)      {#undef REF#if defined HAVE_SUBTRACT_LOCAL_LABELS && defined SHARED# define REF(Name) &&do2_##Name - &&do_form_unknown#else# define REF(Name) &&do2_##Name#endif#undef LABEL#define LABEL(Name) do2_##Name	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;	CHAR_T *workstart = NULL;	/* 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) + 32 > (int) (sizeof (work_buffer)					    / sizeof (CHAR_T)))	  {	    if (MAX (prec, width) < (int) (32768 / sizeof (CHAR_T)))	      workend = ((CHAR_T *) alloca ((MAX (prec, width) + 32)					    * sizeof (CHAR_T))			 + (MAX (prec, width) + 32));	    else	      {		workstart = (CHAR_T *) malloc ((MAX (prec, width) + 32)					       * sizeof (CHAR_T));		workend = workstart + (MAX (prec, width) + 32);	      }	  }	/* Process format specifiers.  */	while (1)	  {	    JUMP (spec, step4_jumps);	    process_arg ((&specs[nspecs_done]));	    process_string_arg ((&specs[nspecs_done]));	  LABEL (form_unknown):	    {	      extern printf_function **__printf_function_table;	      int function_done;	      printf_function *function;	      unsigned int i;	      const void **ptr;	      function =		(__printf_function_table == NULL ? NULL :		 __printf_function_table[specs[nspecs_done].info.spec]);	      if (function == NULL)		function = &printf_unknown;	      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 = (*function) (s, &specs[nspecs_done].info, ptr);	      /* If an error occurred we don't have information about #		 of chars.  */	      if (function_done < 0)		{		  done = -1;		  goto all_done;		}	      done += function_done;	    }	    break;	  }	if (__builtin_expect (workstart != NULL, 0))	  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 (__builtin_expect (workstart != NULL, 0))    free (workstart);  /* Unlock the stream.  */#ifdef USE_IN_LIBIO  _IO_funlockfile (s);#else  __funlockfile (s);#endif  __libc_cleanup_region_end (0);  return done;}