[category.numeric] - C++20 → C++23

Files changed (1) hide show

tmp/tmp3nv41xgx/{from.md → to.md} +24 -119

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

@@ -1,7 +1,9 @@
 ### The numeric category <a id="category.numeric">[[category.numeric]]</a>
 The classes `num_get<>` and `num_put<>` handle numeric formatting and
 parsing. Virtual functions are provided for several numeric types.
 Implementations may (but are not required to) delegate extraction of
 smaller types to extractors for larger types.[^11]
@@ -16,14 +18,16 @@ specifications [[locale.categories]], and to its imbued locale for the
 `numpunct<>` facet to identify all numeric punctuation preferences, and
 also for the `ctype<>` facet to perform character classification.
 Extractor and inserter members of the standard iostreams use `num_get<>`
 and `num_put<>` member functions for formatting and parsing numeric
-values ([[istream.formatted.reqmts]], [[ostream.formatted.reqmts]]).
 #### 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:
@@ -154,129 +158,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.
@@ -309,11 +211,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
@@ -321,10 +223,12 @@ targets `("")`, any input sequence yields
 *Returns:* `in`.
 #### Class template `num_put` <a id="locale.nm.put">[[locale.nm.put]]</a>
 ``` cpp
 namespace std {
   template<class charT, class OutputIterator = ostreambuf_iterator<charT>>
     class num_put : public locale::facet {
     public:
@@ -524,24 +428,25 @@ const numpunct<charT>& punct = use_facet<numpunct<charT>>(loc);
 ```
 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()`
 - **Stage 3:**
 A local variable is initialized as
 ``` cpp
 fmtflags adjustfield = (flags & (ios_base::adjustfield));
 ```
-The location of any padding[^12] is determined according to
-[[facet.num.put.fill]].
 **Table: Fill padding** <a id="facet.num.put.fill">[facet.num.put.fill]</a>
 | State                                                                          | Location           |
 | ------------------------------------------------------------------------------ | ------------------ |

 ### The numeric category <a id="category.numeric">[[category.numeric]]</a>
+#### General <a id="category.numeric.general">[[category.numeric.general]]</a>
 The classes `num_get<>` and `num_put<>` handle numeric formatting and
 parsing. Virtual functions are provided for several numeric types.
 Implementations may (but are not required to) delegate extraction of
 smaller types to extractors for larger types.[^11]
 `numpunct<>` facet to identify all numeric punctuation preferences, and
 also for the `ctype<>` facet to perform character classification.
 Extractor and inserter members of the standard iostreams use `num_get<>`
 and `num_put<>` member functions for formatting and parsing numeric
+values [[istream.formatted.reqmts]], [[ostream.formatted.reqmts]].
 #### 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
 *Returns:* `in`.
 #### Class template `num_put` <a id="locale.nm.put">[[locale.nm.put]]</a>
+##### General <a id="locale.nm.put.general">[[locale.nm.put.general]]</a>
 ``` cpp
 namespace std {
   template<class charT, class OutputIterator = ostreambuf_iterator<charT>>
     class num_put : public locale::facet {
     public:
 ```
 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()`.
 - **Stage 3:**
 A local variable is initialized as
 ``` cpp
 fmtflags adjustfield = (flags & (ios_base::adjustfield));
 ```
+The location of any padding[^12]
+is determined according to [[facet.num.put.fill]].
 **Table: Fill padding** <a id="facet.num.put.fill">[facet.num.put.fill]</a>
 | State                                                                          | Location           |
 | ------------------------------------------------------------------------------ | ------------------ |

Diff to HTML by rtfpessoa