[locale.num.get] - C++20 → C++23

Files changed (1) hide show

tmp/tmptrgl2s53/{from.md → to.md} +14 -114

tmp/tmptrgl2s53/{from.md → to.md} RENAMED Viewed

@@ -1,7 +1,9 @@
 #### Class template `num_get` <a id="locale.num.get">[[locale.num.get]]</a>
 ``` cpp
 namespace std {
   template<class charT, class InputIterator = istreambuf_iterator<charT>>
     class num_get : public locale::facet {
     public:
@@ -132,129 +134,27 @@ The details of this operation occur in three stages
   determined in stage 1.
 - Stage 3: Store results
 The details of the stages are presented below.
-- **Stage 1:**
-The function initializes local variables via
-``` cpp
-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 [[facet.num.get.int]]. The
-table is ordered. That is, the first line whose condition is true
-applies.
-**Table: Integer conversions** <a id="facet.num.get.int">[facet.num.get.int]</a>
-| 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-point 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 [[facet.num.get.length]].
-**Table: Length modifier** <a id="facet.num.get.length">[facet.num.get.length]</a>
-| 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`             |
-- **Stage 2:**
-If `in == end` then stage 2 terminates. Otherwise a `charT` is taken
-from `in` and local variables are initialized as if by
-``` cpp
-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:
-``` cpp
-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.
-- **Stage 3:**
-The sequence of `char`s 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>`:
-- For a signed integer value, the function `strtoll`.
-- For an unsigned integer value, the function `strtoull`.
-- For a `float` value, the function `strtof`.
-- For a `double` value, the function `strtod`.
-- For a `long double` value, the function `strtold`.
-The numeric value to be stored can be one of:
-- zero, if the conversion function does not convert the entire field.
-- 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`.
-- 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`.
-- 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`.
 Digit grouping is checked. That is, the positions of discarded
-separators is examined for consistency with
 `use_facet<numpunct<charT>>(loc).grouping()`. If they are not consistent
 then `ios_base::failbit` is assigned to `err`.
 In any case, if stage 2 processing was terminated by the test for
 `in == end` then `err |= ios_base::eofbit` is performed.
@@ -287,11 +187,11 @@ character successfully matched. If `val` is set, then `err` is set to
 `str.goodbit`; or to `str.eofbit` if, when seeking another character to
 match, it is found that `(in == end)`. If `val` is not set, then `err`
 is set to `str.failbit`; or to `(str.failbit|str.eofbit)` if the reason
 for the failure was that `(in == end)`.
-[*Example 1*: For targets `true`: `"a"` and `false`: `"abb"`, the input
 sequence `"a"` yields `val == true` and `err == str.eofbit`; the input
 sequence `"abc"` yields `err = str.failbit`, with `in` ending at the
 `’c’` element. For targets `true`: `"1"` and `false`: `"0"`, the input
 sequence `"1"` yields `val == true` and `err == str.goodbit`. For empty
 targets `("")`, any input sequence yields

 #### Class template `num_get` <a id="locale.num.get">[[locale.num.get]]</a>
+##### General <a id="locale.num.get.general">[[locale.num.get.general]]</a>
 ``` cpp
 namespace std {
   template<class charT, class InputIterator = istreambuf_iterator<charT>>
     class num_get : public locale::facet {
     public:
   determined in stage 1.
 - Stage 3: Store results
 The details of the stages are presented below.
+[*Example 1*:
+Given an input sequence of `"0x1a.bp+07p"`,
+- if the conversion specifier returned by Stage 1 is `%d`, `"0"` is
+  accumulated;
+- if the conversion specifier returned by Stage 1 is `%i`, `"0x1a"` are
+  accumulated;
+- if the conversion specifier returned by Stage 1 is `%g`,
+ `"0x1a.bp+07"` are accumulated.
+In all cases, the remainder is left in the input.
+— *end example*]
 Digit grouping is checked. That is, the positions of discarded
+separators are examined for consistency with
 `use_facet<numpunct<charT>>(loc).grouping()`. If they are not consistent
 then `ios_base::failbit` is assigned to `err`.
 In any case, if stage 2 processing was terminated by the test for
 `in == end` then `err |= ios_base::eofbit` is performed.
 `str.goodbit`; or to `str.eofbit` if, when seeking another character to
 match, it is found that `(in == end)`. If `val` is not set, then `err`
 is set to `str.failbit`; or to `(str.failbit|str.eofbit)` if the reason
 for the failure was that `(in == end)`.
+[*Example 2*: For targets `true`: `"a"` and `false`: `"abb"`, the input
 sequence `"a"` yields `val == true` and `err == str.eofbit`; the input
 sequence `"abc"` yields `err = str.failbit`, with `in` ending at the
 `’c’` element. For targets `true`: `"1"` and `false`: `"0"`, the input
 sequence `"1"` yields `val == true` and `err == str.goodbit`. For empty
 targets `("")`, any input sequence yields

Diff to HTML by rtfpessoa