25 Localization library [localization]

(is(M, c) || !ctc.is(M, do_narrow(c, dfault)) )

table()[(unsigned char) *p] & m

table()[(unsigned char) *p] & m

do_out(state, from, from_end, from_next, to, to_end, to_next)

do_out(state, from, from + 1, from_next, to, to_end, to_next)

do_in(state, from, from_end, from_next, to, to_end, to_next)

do_in(state, from, from_end, from_next, to, to + 1, to_next)

• (2.1)
  Stage 1: Determine a conversion specifier
• (2.2)
  Stage 2: Extract characters from in and determine a corresponding char value for the format expected by the conversion specification determined in stage 1.
• (2.3)
  Stage 3: Store results

• (3.1)
  Stage 1: The function initializes local variables via

  fmtflags flags = str.flags();
  fmtflags basefield = (flags & ios_base::basefield);
  fmtflags uppercase = (flags & ios_base::uppercase);
  fmtflags boolalpha = (flags & ios_base::boolalpha);

  For conversion to an integral type, the function determines the integral conversion specifier as indicated in Table 68.
  The table is ordered.
  That is, the first line whose condition is true applies.
  Table 68 — Integer conversions
  

  State	stdio equivalent
  basefield == oct	%o
  basefield == hex	%X
  basefield == 0	%i
  signed integral type	%d
  unsigned integral type	%u

  For conversions to a floating type the specifier is %g.
  For conversions to void* the specifier is %p.
  A length modifier is added to the conversion specification, if needed, as indicated in Table 69.
  Table 69 — Length modifier
  

  Type	Length modifier
  short	h
  unsigned short	h
  long	l
  unsigned long	l
  long long	ll
  unsigned long long	ll
  double	l
  long double	L

• (3.2)
  Stage 2: If in == end then stage 2 terminates.
  Otherwise a charT is taken from in and local variables are initialized as if by

  char_type ct = *in;
  char c = src[find(atoms, atoms + sizeof(src) - 1, ct) - atoms];
  if (ct == use_facet<numpunct<charT>>(loc).decimal_point())
  c = '.';
  bool discard =
    ct == use_facet<numpunct<charT>>(loc).thousands_sep()
    && use_facet<numpunct<charT>>(loc).grouping().length() != 0;

  where the values src and atoms are defined as if by:

  static const char src[] = "0123456789abcdefxABCDEFX+-";
  char_type atoms[sizeof(src)];
  use_facet<ctype<charT>>(loc).widen(src, src + sizeof(src), atoms);

  for this value of loc.
  If discard is true, then if '.' has not yet been accumulated, then the position of the character is remembered, but the character is otherwise ignored.
  Otherwise, if '.' has already been accumulated, the character is discarded and Stage 2 terminates.
  If it is not discarded, then a check is made to determine if c is allowed as the next character of an input field of the conversion specifier returned by Stage 1.
  If so, it is accumulated.
  If the character is either discarded or accumulated then in is advanced by ++in and processing returns to the beginning of stage 2.
• (3.3)
  Stage 3: The sequence of chars accumulated in stage 2 (the field) is converted to a numeric value by the rules of one of the functions declared in the header <cstdlib>:
  • (3.3.1)
    For a signed integer value, the function strtoll.
  • (3.3.2)
    For an unsigned integer value, the function strtoull.
  • (3.3.3)
    For a float value, the function strtof.
  • (3.3.4)
    For a double value, the function strtod.
  • (3.3.5)
    For a long double value, the function strtold.
  The numeric value to be stored can be one of:
  • (3.3.6)
    zero, if the conversion function does not convert the entire field.
  • (3.3.7)
    the most positive (or negative) representable value, if the field to be converted to a signed integer type represents a value too large positive (or negative) to be represented in val.
  • (3.3.8)
    the most positive representable value, if the field to be converted to an unsigned integer type represents a value that cannot be represented in val.
  • (3.3.9)
    the converted value, otherwise.
  The resultant numeric value is stored in val.
  If the conversion function does not convert the entire field, or if the field represents a value outside the range of representable values, ios_­base​::​failbit is assigned to err.

locale loc = str.getloc();

• (2.1)
  Stage 1: Determine a printf conversion specifier spec and determine the characters that would be printed by printf ([c.files]) given this conversion specifier for

  printf(spec, val)

  assuming that the current locale is the "C" locale.
• (2.2)
  Stage 2: Adjust the representation by converting each char determined by stage 1 to a charT using a conversion and values returned by members of use_­facet<numpunct<charT>>(str.getloc())
• (2.3)
  Stage 3: Determine where padding is required.
• (2.4)
  Stage 4: Insert the sequence into the out.

• (5.1)
  Stage 1: The first action of stage 1 is to determine a conversion specifier.
  The tables that describe this determination use the following local variables

  fmtflags flags = str.flags();
  fmtflags basefield =  (flags & (ios_base::basefield));
  fmtflags uppercase =  (flags & (ios_base::uppercase));
  fmtflags floatfield = (flags & (ios_base::floatfield));
  fmtflags showpos =    (flags & (ios_base::showpos));
  fmtflags showbase =   (flags & (ios_base::showbase));
  fmtflags showpoint =  (flags & (ios_base::showpoint));

  All tables used in describing stage 1 are ordered.
  That is, the first line whose condition is true applies.
  A line without a condition is the default behavior when none of the earlier lines apply.
  For conversion from an integral type other than a character type, the function determines the integral conversion specifier as indicated in Table 70.
  Table 70 — Integer conversions
  

  State	stdio equivalent
  basefield == ios_­base​::​oct	%o
  (basefield == ios_­base​::​hex) && !uppercase	%x
  (basefield == ios_­base​::​hex)	%X
  for a signed integral type	%d
  for an unsigned integral type	%u

  For conversion from a floating-point type, the function determines the floating-point conversion specifier as indicated in Table 71.
  Table 71 — Floating-point conversions
  

  State	stdio equivalent
  floatfield == ios_­base​::​fixed	%f
  floatfield == ios_­base​::​scientific && !uppercase	%e
  floatfield == ios_­base​::​scientific	%E
  floatfield == (ios_­base​::​fixed | ios_­base​::​scientific) && !uppercase	%a
  floatfield == (ios_­base​::​fixed | ios_­base​::​scientific)	%A
  !uppercase	%g
  otherwise	%G

  For conversions from an integral or floating-point type a length modifier is added to the conversion specifier as indicated in Table 72.
  Table 72 — Length modifier
  

  Type	Length modifier
  long	l
  long long	ll
  unsigned long	l
  unsigned long long	ll
  long double	L
  otherwise	none

  The conversion specifier has the following optional additional qualifiers prepended as indicated in Table 73.
  Table 73 — Numeric conversions
  

  Type(s)	State	stdio equivalent
  an integral type	showpos	+
  	showbase	#
  a floating-point type	showpos	+
  	showpoint	#

  For conversion from a floating-point type, if floatfield != (ios_­base​::​fixed | ios_­base​::​​scientific), str.precision() is specified as precision in the conversion specification.
  Otherwise, no precision is specified.
  For conversion from void* the specifier is %p.
  The representations at the end of stage 1 consists of the char's that would be printed by a call of printf(s, val) where s is the conversion specifier determined above.
• (5.2)
  Stage 2: Any character c other than a decimal point(.) is converted to a charT via use_­facet<ctype<charT>>(loc).widen( c )
  A local variable punct is initialized via

  const numpunct<charT>& punct = use_facet<numpunct<charT>>(str.getloc());

  For arithmetic types, punct.thousands_­sep() characters are inserted into the sequence as determined by the value returned by punct.do_­grouping() using the method described in [facet.numpunct.virtuals]
  Decimal point characters(.) are replaced by punct.decimal_­point()
• (5.3)
  Stage 3: A local variable is initialized as

  fmtflags adjustfield = (flags & (ios_base::adjustfield));

  The location of any padding240 is determined according to Table 74.
  Table 74 — Fill padding
  

  State	Location
  adjustfield == ios_­base​::​left	pad after
  adjustfield == ios_­base​::​right	pad before
  adjustfield == internal and a sign occurs in the representation	pad after the sign
  adjustfield == internal and representation after stage 1 began with 0x or 0X	pad after x or X
  otherwise	pad before

  If str.width() is nonzero and the number of charT's in the sequence after stage 2 is less than str.​width(), then enough fill characters are added to the sequence at the position indicated for padding to bring the length of the sequence to str.width().
  str.width(0) is called.
• (5.4)
  Stage 4: The sequence of charT's at the end of stage 3 are output via

  *out++ = c

string_type s =
  val ? use_facet<numpunct<charT>>(loc).truename()
      : use_facet<numpunct<charT>>(loc).falsename();

• (8.1)
  The expression fmt == fmtend evaluates to true.
• (8.2)
  The expression err == ios_­base​::​goodbit evaluates to false.
• (8.3)
  The expression s == end evaluates to true, in which case the function evaluates err = ios_­base​::​eofbit | ios_­base​::​failbit.
• (8.4)
  The next element of fmt is equal to '%', optionally followed by a modifier character, followed by a conversion specifier character, format, together forming a conversion specification valid for the ISO/IEC 9945 function strptime.
  If the number of elements in the range [fmt, fmtend) is not sufficient to unambiguously determine whether the conversion specification is complete and valid, the function evaluates err = ios_­base​::​failbit.
  Otherwise, the function evaluates s = do_­get(s, end, f, err, t, format, modifier), where the value of modifier is '\0' when the optional modifier is absent from the conversion specification.
  If err == ios_­base​::​goodbit holds after the evaluation of the expression, the function increments fmt to point just past the end of the conversion specification and continues looping.
• (8.5)
  The expression isspace(*fmt, f.getloc()) evaluates to true, in which case the function first increments fmt until fmt == fmtend || !isspace(*fmt, f.getloc()) evaluates to true, then advances s until s == end || !isspace(*s, f.getloc()) is true, and finally resumes looping.
• (8.6)
  The next character read from s matches the element pointed to by fmt in a case-insensitive comparison, in which case the function evaluates ++fmt, ++s and continues looping.
  Otherwise, the function evaluates err = ios_­base​::​failbit.