[locale.categories] - C++20 → C++23

Files changed (1) hide show

tmp/tmp3gxeplhc/{from.md → to.md} +167 -219

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

@@ -1,7 +1,9 @@
 ## Standard `locale` categories <a id="locale.categories">[[locale.categories]]</a>
 Each of the standard categories includes a family of facets. Some of
 these implement formatting or parsing of a datum, for use by standard or
 users’ iostream operators `<<` and `>>`, as members `put()` and `get()`,
 respectively. Each such member function takes an `ios_base&` argument
 whose members `flags()`, `precision()`, and `width()`, specify the
@@ -14,15 +16,17 @@ The `put()` members make no provision for error reporting. (Any failures
 of the OutputIterator argument can be extracted from the returned
 iterator.) The `get()` members take an `ios_base::iostate&` argument
 whose value they ignore, but set to `ios_base::failbit` in case of a
 parse error.
-Within this clause it is unspecified whether one virtual function calls
-another virtual function.
 ### The `ctype` category <a id="category.ctype">[[category.ctype]]</a>
 ``` cpp
 namespace std {
   class ctype_base {
   public:
     using mask = see below;
@@ -46,10 +50,12 @@ namespace std {
 The type `mask` is a bitmask type [[bitmask.types]].
 #### Class template `ctype` <a id="locale.ctype">[[locale.ctype]]</a>
 ``` cpp
 namespace std {
   template<class charT>
     class ctype : public locale::facet, public ctype_base {
     public:
@@ -219,12 +225,14 @@ charT        do_widen(char c) const;
 const char*  do_widen(const char* low, const char* high, charT* dest) const;
 ```
 *Effects:* Applies the simplest reasonable transformation from a `char`
 value or sequence of `char` values to the corresponding `charT` value or
-values.[^5] The only characters for which unique transformations are
-required are those in the basic source character set [[lex.charset]].
 For any named `ctype` category with a `ctype<charT>` facet `ctc` and
 valid `ctype_base::mask` value `M`,
 `(ctc.is(M, c) || !is(M, do_widen(c)) )` is `true`.[^6]
@@ -241,12 +249,12 @@ const charT* do_narrow(const charT* low, const charT* high, char dfault, char* d
 *Effects:* Applies the simplest reasonable transformation from a `charT`
 value or sequence of `charT` values to the corresponding `char` value or
 values.
-For any character `c` in the basic source character set [[lex.charset]]
-the transformation is such that
 ``` cpp
 do_widen(do_narrow(c, 0)) == c
 ```
@@ -284,10 +292,12 @@ namespace std {
 }
 ```
 #### `ctype<char>` specialization <a id="facet.ctype.special">[[facet.ctype.special]]</a>
 ``` cpp
 namespace std {
   template<>
     class ctype<char> : public locale::facet, public ctype_base {
     public:
@@ -331,12 +341,14 @@ namespace std {
     };
 }
 ```
 A specialization `ctype<char>` is provided so that the member functions
-on type `char` can be implemented inline.[^7] The
-*implementation-defined* value of member `table_size` is at least 256.
 ##### Destructor <a id="facet.ctype.char.dtor">[[facet.ctype.char.dtor]]</a>
 ``` cpp
 ~ctype();
@@ -460,10 +472,12 @@ virtual const char* do_narrow(const char* low, const char* high,
 These functions are described identically as those members of the same
 name in the `ctype` class template [[locale.ctype.members]].
 #### Class template `codecvt` <a id="locale.codecvt">[[locale.codecvt]]</a>
 ``` cpp
 namespace std {
   class codecvt_base {
   public:
     enum result { ok, partial, error, noconv };
@@ -532,19 +546,19 @@ mapped between.
 The specializations required in [[locale.category.facets]]
 [[locale.category]] convert the implementation-defined native character
 set. `codecvt<char, char, mbstate_t>` implements a degenerate
 conversion; it does not convert at all. The specialization
 `codecvt<char16_t, char8_t, mbstate_t>` converts between the UTF-16 and
-UTF-8 encoding forms, and the specialization `codecvt`
-`<char32_t, char8_t, mbstate_t>` converts between the UTF-32 and UTF-8
-encoding forms. `codecvt<wchar_t, char, mbstate_t>` converts between the
-native character sets for ordinary and wide characters. Specializations
-on `mbstate_t` perform conversion between encodings known to the library
-implementer. Other encodings can be converted by specializing on a
-program-defined `stateT` type. Objects of type `stateT` can contain any
-state that is useful to communicate to or from the specialized `do_in`
-or `do_out` members.
 ##### Members <a id="locale.codecvt.members">[[locale.codecvt.members]]</a>
 ``` cpp
 result out(
@@ -657,44 +671,45 @@ shall also return `ok`.[^8]
 [*Note 1*: As a result of operations on `state`, it can return `ok` or
 `partial` and set `from_next == from` and
 `to_next != to`. — *end note*]
-*Remarks:* Its operations on `state` are unspecified.
-[*Note 2*: This argument can be used, for example, to maintain shift
-state, to specify conversion options (such as count only), or to
-identify a cache of seek offsets. — *end note*]
 *Returns:* An enumeration value, as summarized in
 [[locale.codecvt.inout]].
 **Table: `do_in/do_out` result values** <a id="locale.codecvt.inout">[locale.codecvt.inout]</a>
 | Value     | Meaning                                                                                          |
 | --------- | ------------------------------------------------------------------------------------------------ |
 | `ok`      | completed the conversion                                                                         |
 | `partial` | not all source characters converted                                                              |
-| `error`   | encountered a character in {[}`from`, `from_end`{)} that it could not convert                    |
 | `noconv`  | `internT` and `externT` are the same type, and input sequence is identical to converted sequence |
 A return value of `partial`, if `(from_next == from_end)`, indicates
 that either the destination sequence has not absorbed all the available
 destination elements, or that additional source elements are needed
 before another destination element can be produced.
 ``` cpp
 result do_unshift(stateT& state, externT* to, externT* to_end, externT*& to_next) const;
 ```
 *Preconditions:* `(to <= to_end)` is well-defined and `true`; `state` is
 initialized, if at the beginning of a sequence, or else is equal to the
 result of converting the preceding characters in the sequence.
 *Effects:* Places characters starting at `to` that should be appended to
 terminate a sequence when the current `stateT` is given by `state`.[^9]
 Stores no more than `(to_end - to)` destination elements, and leaves the
 `to_next` pointer pointing one beyond the last element successfully
 stored.
 *Returns:* An enumeration value, as summarized in
@@ -770,10 +785,12 @@ namespace std {
 }
 ```
 ### 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]
@@ -788,14 +805,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:
@@ -926,129 +945,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.
@@ -1081,11 +998,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
@@ -1093,10 +1010,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:
@@ -1296,24 +1215,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           |
 | ------------------------------------------------------------------------------ | ------------------ |
@@ -1358,10 +1278,12 @@ and returns `out`.
 ### The numeric punctuation facet <a id="facet.numpunct">[[facet.numpunct]]</a>
 #### Class template `numpunct` <a id="locale.numpunct">[[locale.numpunct]]</a>
 ``` cpp
 namespace std {
   template<class charT>
     class numpunct : public locale::facet {
     public:
@@ -1387,14 +1309,12 @@ namespace std {
       virtual string_type  do_falsename()     const;            // for bool
     };
 }
 ```
-`numpunct<>`
-specifies numeric punctuation. The specializations required in
-[[locale.category.facets]] [[locale.category]], namely
 `numpunct<{}wchar_t>` and `numpunct<char>`, provide classic `"C"`
 numeric formats, i.e., they contain information equivalent to that
 contained in the `"C"` locale or their wide character counterparts as if
 obtained by a call to `widen`.
@@ -1499,14 +1419,15 @@ required specializations return `’,’` or `L’,’`.
 ``` cpp
 string do_grouping() const;
 ```
 *Returns:* A `string` `vec` used as a vector of integer values, in which
-each element `vec[i]` represents the number of digits[^13] in the group
-at position `i`, starting with position 0 as the rightmost group. If
-`vec.size() <= i`, the number is the same as group `(i - 1)`; if
-`(i < 0 || vec[i] <= 0 || vec[i] == CHAR_MAX)`, the size of the digit
 group is unlimited.
 The required specializations return the empty string, indicating no
 grouping.
@@ -1543,10 +1464,12 @@ namespace std {
 ### The collate category <a id="category.collate">[[category.collate]]</a>
 #### Class template `collate` <a id="locale.collate">[[locale.collate]]</a>
 ``` cpp
 namespace std {
   template<class charT>
     class collate : public locale::facet {
     public:
@@ -1576,11 +1499,11 @@ The class `collate<charT>` provides features for use in the collation
 (comparison) and hashing of strings. A locale member function template,
 `operator()`, uses the collate facet to allow a locale to act directly
 as the predicate argument for standard algorithms [[algorithms]] and
 containers operating on strings. The specializations required in
 [[locale.category.facets]] [[locale.category]], namely `collate<char>`
-and `collate<wchar_t>`, apply lexicographic ordering
 [[alg.lex.comparison]].
 Each function compares a string of characters `*p` in the range \[`low`,
 `high`).
@@ -1633,13 +1556,13 @@ long do_hash(const charT* low, const charT* high) const;
 *Returns:* An integer value equal to the result of calling `hash()` on
 any other string for which `do_compare()` returns 0 (equal) when passed
 the two strings.
-[*Note 1*: The probability that the result equals that for another
-string which does not compare equal should be very small, approaching
-`(1.0/numeric_limits<unsigned long>::max())`. — *end note*]
 #### Class template `collate_byname` <a id="locale.collate.byname">[[locale.collate.byname]]</a>
 ``` cpp
 namespace std {
@@ -1657,10 +1580,12 @@ namespace std {
 }
 ```
 ### The time category <a id="category.time">[[category.time]]</a>
 Templates `time_get<charT, InputIterator>` and
 `time_put<charT, OutputIterator>` provide date and time formatting and
 parsing. All specifications of member functions for `time_put` and
 `time_get` in the subclauses of  [[category.time]] only apply to the
 specializations required in Tables  [[tab:locale.category.facets]] and
@@ -1669,10 +1594,12 @@ specializations required in Tables  [[tab:locale.category.facets]] and
 [[locale.categories]], and the `ctype<>` facet, to determine formatting
 details.
 #### Class template `time_get` <a id="locale.time.get">[[locale.time.get]]</a>
 ``` cpp
 namespace std {
   class time_base {
   public:
     enum dateorder { no_order, dmy, mdy, ymd, ydm };
@@ -1722,19 +1649,17 @@ namespace std {
                                ios_base::iostate& err, tm* t, char format, char modifier) const;
     };
 }
 ```
-`time_get`
-is used to parse a character sequence, extracting components of a time
-or date into a `struct tm` object. Each `get` member parses a format as
-produced by a corresponding format specifier to `time_put<>::put`. If
 the sequence being parsed matches the correct format, the corresponding
-members of the `struct tm` argument are set to the values used to
-produce the sequence; otherwise either an error is reported or
-unspecified values are assigned.[^15]
 If the end iterator is reached during parsing by any of the `get()`
 member functions, the member sets `ios_base::eofbit` in `err`.
 ##### Members <a id="locale.time.get.members">[[locale.time.get.members]]</a>
@@ -1800,12 +1725,12 @@ the first of the following conditions holds:
 - The expression `s == end` evaluates to `true`, in which case the
   function evaluates `err = ios_base::eofbit | ios_base::failbit`.
 - 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
@@ -1836,37 +1761,38 @@ so. — *end note*]
 dateorder do_date_order() const;
 ```
 *Returns:* An enumeration value indicating the preferred order of
 components for those date formats that are composed of day, month, and
-year.[^16] Returns `no_order` if the date format specified by `’x’`
-contains other variable components (e.g., Julian day, week number, week
-day).
 ``` cpp
 iter_type do_get_time(iter_type s, iter_type end, ios_base& str,
                       ios_base::iostate& err, tm* t) const;
 ```
 *Effects:* Reads characters starting at `s` until it has extracted those
-`struct tm` members, and remaining format characters, used by
-`time_put<>::put` to produce the format specified by `"%H:%M:%S"`, or
-until it encounters an error or end of sequence.
 *Returns:* An iterator pointing immediately beyond the last character
 recognized as possibly part of a valid time.
 ``` cpp
 iter_type do_get_date(iter_type s, iter_type end, ios_base& str,
                       ios_base::iostate& err, tm* t) const;
 ```
 *Effects:* Reads characters starting at `s` until it has extracted those
-`struct tm` members and remaining format characters used by
-`time_put<>::put` to produce one of the following formats, or until it
-encounters an error. The format depends on the value returned by
-`date_order()` as shown in [[locale.time.get.dogetdate]].
 **Table: `do_get_date` effects** <a id="locale.time.get.dogetdate">[locale.time.get.dogetdate]</a>
 | `date_order()` | Format     |
 | -------------- | ---------- |
@@ -1890,13 +1816,13 @@ iter_type do_get_monthname(iter_type s, iter_type end, ios_base& str,
                            ios_base::iostate& err, tm* t) const;
 ```
 *Effects:* Reads characters starting at `s` until it has extracted the
 (perhaps abbreviated) name of a weekday or month. If it finds an
-abbreviation that is followed by characters that could match a full
-name, it continues reading until it matches the full name or fails. It
-sets the appropriate `struct tm` member accordingly.
 *Returns:* An iterator pointing immediately beyond the last character
 recognized as part of a valid name.
 ``` cpp
@@ -1919,36 +1845,36 @@ iter_type do_get(iter_type s, iter_type end, ios_base& f,
 *Preconditions:* `t` points to an object.
 *Effects:* The function starts by evaluating `err = ios_base::goodbit`.
 It then reads characters starting at `s` until it encounters an error,
-or until it has extracted and assigned those `struct tm` members, and
-any remaining format characters, corresponding to a conversion directive
-appropriate for the ISO/IEC 9945 function `strptime`, formed by
-concatenating `’%’`, the `modifier` character, when non-NUL, and the
-`format` character. When the concatenation fails to yield a complete
-valid directive the function leaves the object pointed to by `t`
-unchanged and evaluates `err |= ios_base::failbit`. When `s == end`
-evaluates to `true` after reading a character the function evaluates
 `err |= ios_base::eofbit`.
-For complex conversion directives such as `%c`, `%x`, or `%X`, or
-directives that involve the optional modifiers `E` or `O`, when the
-function is unable to unambiguously determine some or all `struct tm`
-members from the input sequence \[`s`, `end`), it evaluates
-`err |= ios_base::eofbit`. In such cases the values of those `struct tm`
 members are unspecified and may be outside their valid range.
-*Remarks:* It is unspecified whether multiple calls to `do_get()` with
-the address of the same `struct tm` object will update the current
-contents of the object or simply overwrite its members. Portable
-programs should zero out the object before invoking the function.
 *Returns:* An iterator pointing immediately beyond the last character
 recognized as possibly part of a valid input sequence for the given
 `format` and `modifier`.
 #### Class template `time_get_byname` <a id="locale.time.get.byname">[[locale.time.get.byname]]</a>
 ``` cpp
 namespace std {
   template<class charT, class InputIterator = istreambuf_iterator<charT>>
@@ -2011,18 +1937,20 @@ call to `do_put`; thus, format elements and other characters are
 interleaved in the output in the order in which they appear in the
 pattern. Format sequences are identified by converting each character
 `c` to a `char` value as if by `ct.narrow(c, 0)`, where `ct` is a
 reference to `ctype<charT>` obtained from `str.getloc()`. The first
 character of each sequence is equal to `’%’`, followed by an optional
-modifier character `mod`[^17] and a format specifier character `spec` as
-defined for the function `strftime`. If no modifier character is
-present, `mod` is zero. For each valid format sequence identified, calls
 `do_put(s, str, fill, t, spec, mod)`.
 The second form calls `do_put(s, str, fill, t, format, modifier)`.
-[*Note 1*: The `fill` argument may be used in the
 implementation-defined formats or by derivations. A space character is a
 reasonable default for this argument. — *end note*]
 *Returns:* An iterator pointing immediately after the last character
 produced.
@@ -2036,21 +1964,29 @@ iter_type do_put(iter_type s, ios_base&, char_type fill, const tm* t,
 *Effects:* Formats the contents of the parameter `t` into characters
 placed on the output sequence `s`. Formatting is controlled by the
 parameters `format` and `modifier`, interpreted identically as the
 format specifiers in the string argument to the standard library
-function `strftime()`[^18], except that the sequence of characters
-produced for those specifiers that are described as depending on the C
-locale are instead *implementation-defined*.[^19]
 *Returns:* An iterator pointing immediately after the last character
 produced.
-[*Note 2*: The `fill` argument may be used in the
 implementation-defined formats or by derivations. A space character is a
 reasonable default for this argument. — *end note*]
 #### Class template `time_put_byname` <a id="locale.time.put.byname">[[locale.time.put.byname]]</a>
 ``` cpp
 namespace std {
   template<class charT, class OutputIterator = ostreambuf_iterator<charT>>
@@ -2068,10 +2004,12 @@ namespace std {
 }
 ```
 ### The monetary category <a id="category.monetary">[[category.monetary]]</a>
 These templates handle monetary formats. A template parameter indicates
 whether local or international monetary formats are to be used.
 All specifications of member functions for `money_put` and `money_get`
 in the subclauses of  [[category.monetary]] only apply to the
@@ -2188,11 +2126,11 @@ the result is given a positive sign.
 Digits in the numeric monetary component are extracted and placed in
 `digits`, or into a character buffer `buf1` for conversion to produce a
 value for `units`, in the order in which they appear, preceded by a
 minus sign if and only if the result is negative. The value `units` is
-produced as if by[^20]
 ``` cpp
 for (int i = 0; i < n; ++i)
   buf2[i] = src[find(atoms, atoms+sizeof(src), buf1[i]) - atoms];
 buf2[n] = 0;
@@ -2279,10 +2217,13 @@ minus sign) in `digits` or `buf2`. In `digits`, only the optional
 leading minus sign and the immediately subsequent digit characters (as
 classified according to `ct`) are used; any trailing characters
 (including digits appearing after a non-digit character) are ignored.
 Calls `str.width(0)`.
 *Remarks:* The currency symbol is generated if and only if
 `(str.flags() & str.showbase)` is nonzero. If the number of characters
 generated for the specified format is less than the value returned by
 `str.width()` on entry to the function, then copies of `fill` are
 inserted as necessary to pad to the specified width. For the value `af`
@@ -2294,15 +2235,14 @@ before the other characters.
 [*Note 1*: It is possible, with some combinations of format patterns
 and flag values, to produce output that cannot be parsed using
 `num_get<>::get`. — *end note*]
-*Returns:* An iterator pointing immediately after the last character
-produced.
 #### Class template `moneypunct` <a id="locale.moneypunct">[[locale.moneypunct]]</a>
 ``` cpp
 namespace std {
   class money_base {
   public:
     enum part { none, space, symbol, sign, value };
@@ -2347,14 +2287,16 @@ namespace std {
 The `moneypunct<>` facet defines monetary formatting parameters used by
 `money_get<>` and `money_put<>`. A monetary format is a sequence of four
 components, specified by a `pattern` value `p`, such that the `part`
 value `static_cast<part>(p.field[i])` determines the `i`ᵗʰ component of
-the format[^21] In the `field` member of a `pattern` object, each value
-`symbol`, `sign`, `value`, and either `space` or `none` appears exactly
-once. The value `none`, if present, is not first; the value `space`, if
-present, is neither first nor last.
 Where `none` or `space` appears, whitespace is permitted in the format,
 except where `none` appears at the end, in which case no whitespace is
 permitted. The value `space` indicates that at least one space is
 required at that position. Where `symbol` appears, the sequence of
@@ -2436,25 +2378,25 @@ corresponding virtual member function `do_F()`.
 ``` cpp
 charT do_decimal_point() const;
 ```
 *Returns:* The radix separator to use in case `do_frac_digits()` is
-greater than zero.[^22]
 ``` cpp
 charT do_thousands_sep() const;
 ```
 *Returns:* The digit group separator to use in case `do_grouping()`
-specifies a digit grouping pattern.[^23]
 ``` cpp
 string do_grouping() const;
 ```
 *Returns:* A pattern defined identically as, but not necessarily equal
-to, the result of `numpunct<charT>::do_grouping()`.[^24]
 ``` cpp
 string_type do_curr_symbol() const;
 ```
@@ -2468,19 +2410,21 @@ specified by ISO 4217 followed by a space. — *end note*]
 string_type do_positive_sign() const;
 string_type do_negative_sign() const;
 ```
 *Returns:* `do_positive_sign()` returns the string to use to indicate a
-positive monetary value;[^25] `do_negative_sign()` returns the string to
-use to indicate a negative value.
 ``` cpp
 int do_frac_digits() const;
 ```
 *Returns:* The number of digits after the decimal radix separator, if
-any.[^26]
 ``` cpp
 pattern do_pos_format() const;
 pattern do_neg_format() const;
 ```
@@ -2492,11 +2436,11 @@ pattern do_neg_format() const;
 - `moneypunct<wchar_t>`,
 - `moneypunct<char, true>`, and
 - `moneypunct<wchar_t, true>`,
 return an object of type `pattern` initialized to
-`{ symbol, sign, none, value }`.[^27]
 #### Class template `moneypunct_byname` <a id="locale.moneypunct.byname">[[locale.moneypunct.byname]]</a>
 ``` cpp
 namespace std {
@@ -2515,15 +2459,19 @@ namespace std {
 }
 ```
 ### The message retrieval category <a id="category.messages">[[category.messages]]</a>
 Class `messages<charT>` implements retrieval of strings from message
 catalogs.
 #### Class template `messages` <a id="locale.messages">[[locale.messages]]</a>
 ``` cpp
 namespace std {
   class messages_base {
   public:
     using catalog = unspecified signed integer type;

 ## Standard `locale` categories <a id="locale.categories">[[locale.categories]]</a>
+### General <a id="locale.categories.general">[[locale.categories.general]]</a>
 Each of the standard categories includes a family of facets. Some of
 these implement formatting or parsing of a datum, for use by standard or
 users’ iostream operators `<<` and `>>`, as members `put()` and `get()`,
 respectively. Each such member function takes an `ios_base&` argument
 whose members `flags()`, `precision()`, and `width()`, specify the
 of the OutputIterator argument can be extracted from the returned
 iterator.) The `get()` members take an `ios_base::iostate&` argument
 whose value they ignore, but set to `ios_base::failbit` in case of a
 parse error.
+Within subclause [[locale.categories]] it is unspecified whether one
+virtual function calls another virtual function.
 ### The `ctype` category <a id="category.ctype">[[category.ctype]]</a>
+#### General <a id="category.ctype.general">[[category.ctype.general]]</a>
 ``` cpp
 namespace std {
   class ctype_base {
   public:
     using mask = see below;
 The type `mask` is a bitmask type [[bitmask.types]].
 #### Class template `ctype` <a id="locale.ctype">[[locale.ctype]]</a>
+##### General <a id="locale.ctype.general">[[locale.ctype.general]]</a>
 ``` cpp
 namespace std {
   template<class charT>
     class ctype : public locale::facet, public ctype_base {
     public:
 const char*  do_widen(const char* low, const char* high, charT* dest) const;
 ```
 *Effects:* Applies the simplest reasonable transformation from a `char`
 value or sequence of `char` values to the corresponding `charT` value or
+values.[^5]
+The only characters for which unique transformations are required are
+those in the basic character set [[lex.charset]].
 For any named `ctype` category with a `ctype<charT>` facet `ctc` and
 valid `ctype_base::mask` value `M`,
 `(ctc.is(M, c) || !is(M, do_widen(c)) )` is `true`.[^6]
 *Effects:* Applies the simplest reasonable transformation from a `charT`
 value or sequence of `charT` values to the corresponding `char` value or
 values.
+For any character `c` in the basic character set [[lex.charset]] the
+transformation is such that
 ``` cpp
 do_widen(do_narrow(c, 0)) == c
 ```
 }
 ```
 #### `ctype<char>` specialization <a id="facet.ctype.special">[[facet.ctype.special]]</a>
+##### General <a id="facet.ctype.special.general">[[facet.ctype.special.general]]</a>
 ``` cpp
 namespace std {
   template<>
     class ctype<char> : public locale::facet, public ctype_base {
     public:
     };
 }
 ```
 A specialization `ctype<char>` is provided so that the member functions
+on type `char` can be implemented inline.[^7]
+The *implementation-defined* value of member `table_size` is at least
+256.
 ##### Destructor <a id="facet.ctype.char.dtor">[[facet.ctype.char.dtor]]</a>
 ``` cpp
 ~ctype();
 These functions are described identically as those members of the same
 name in the `ctype` class template [[locale.ctype.members]].
 #### Class template `codecvt` <a id="locale.codecvt">[[locale.codecvt]]</a>
+##### General <a id="locale.codecvt.general">[[locale.codecvt.general]]</a>
 ``` cpp
 namespace std {
   class codecvt_base {
   public:
     enum result { ok, partial, error, noconv };
 The specializations required in [[locale.category.facets]]
 [[locale.category]] convert the implementation-defined native character
 set. `codecvt<char, char, mbstate_t>` implements a degenerate
 conversion; it does not convert at all. The specialization
 `codecvt<char16_t, char8_t, mbstate_t>` converts between the UTF-16 and
+UTF-8 encoding forms, and the specialization
+`codecvt<char32_t, char8_t, mbstate_t>` converts between the UTF-32 and
+UTF-8 encoding forms. `codecvt<wchar_t, char, mbstate_t>` converts
+between the native character sets for ordinary and wide characters.
+Specializations on `mbstate_t` perform conversion between encodings
+known to the library implementer. Other encodings can be converted by
+specializing on a program-defined `stateT` type. Objects of type
+`stateT` can contain any state that is useful to communicate to or from
+the specialized `do_in` or `do_out` members.
 ##### Members <a id="locale.codecvt.members">[[locale.codecvt.members]]</a>
 ``` cpp
 result out(
 [*Note 1*: As a result of operations on `state`, it can return `ok` or
 `partial` and set `from_next == from` and
 `to_next != to`. — *end note*]
 *Returns:* An enumeration value, as summarized in
 [[locale.codecvt.inout]].
 **Table: `do_in/do_out` result values** <a id="locale.codecvt.inout">[locale.codecvt.inout]</a>
 | Value     | Meaning                                                                                          |
 | --------- | ------------------------------------------------------------------------------------------------ |
 | `ok`      | completed the conversion                                                                         |
 | `partial` | not all source characters converted                                                              |
+| `error`   | encountered a character in {[}`from`, `from_end`{)} that cannot be converted                     |
 | `noconv`  | `internT` and `externT` are the same type, and input sequence is identical to converted sequence |
 A return value of `partial`, if `(from_next == from_end)`, indicates
 that either the destination sequence has not absorbed all the available
 destination elements, or that additional source elements are needed
 before another destination element can be produced.
+*Remarks:* Its operations on `state` are unspecified.
+[*Note 2*: This argument can be used, for example, to maintain shift
+state, to specify conversion options (such as count only), or to
+identify a cache of seek offsets. — *end note*]
 ``` cpp
 result do_unshift(stateT& state, externT* to, externT* to_end, externT*& to_next) const;
 ```
 *Preconditions:* `(to <= to_end)` is well-defined and `true`; `state` is
 initialized, if at the beginning of a sequence, or else is equal to the
 result of converting the preceding characters in the sequence.
 *Effects:* Places characters starting at `to` that should be appended to
 terminate a sequence when the current `stateT` is given by `state`.[^9]
 Stores no more than `(to_end - to)` destination elements, and leaves the
 `to_next` pointer pointing one beyond the last element successfully
 stored.
 *Returns:* An enumeration value, as summarized in
 }
 ```
 ### 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           |
 | ------------------------------------------------------------------------------ | ------------------ |
 ### The numeric punctuation facet <a id="facet.numpunct">[[facet.numpunct]]</a>
 #### Class template `numpunct` <a id="locale.numpunct">[[locale.numpunct]]</a>
+##### General <a id="locale.numpunct.general">[[locale.numpunct.general]]</a>
 ``` cpp
 namespace std {
   template<class charT>
     class numpunct : public locale::facet {
     public:
       virtual string_type  do_falsename()     const;            // for bool
     };
 }
 ```
+`numpunct<>` specifies numeric punctuation. The specializations required
+in [[locale.category.facets]] [[locale.category]], namely
 `numpunct<{}wchar_t>` and `numpunct<char>`, provide classic `"C"`
 numeric formats, i.e., they contain information equivalent to that
 contained in the `"C"` locale or their wide character counterparts as if
 obtained by a call to `widen`.
 ``` cpp
 string do_grouping() const;
 ```
 *Returns:* A `string` `vec` used as a vector of integer values, in which
+each element `vec[i]` represents the number of digits[^13]
+in the group at position `i`, starting with position 0 as the rightmost
+group. If `vec.size() <= i`, the number is the same as group `(i - 1)`;
+if `(i < 0 || vec[i] <= 0 || vec[i] == CHAR_MAX)`, the size of the digit
 group is unlimited.
 The required specializations return the empty string, indicating no
 grouping.
 ### The collate category <a id="category.collate">[[category.collate]]</a>
 #### Class template `collate` <a id="locale.collate">[[locale.collate]]</a>
+##### General <a id="locale.collate.general">[[locale.collate.general]]</a>
 ``` cpp
 namespace std {
   template<class charT>
     class collate : public locale::facet {
     public:
 (comparison) and hashing of strings. A locale member function template,
 `operator()`, uses the collate facet to allow a locale to act directly
 as the predicate argument for standard algorithms [[algorithms]] and
 containers operating on strings. The specializations required in
 [[locale.category.facets]] [[locale.category]], namely `collate<char>`
+and `collate<wchar_t>`, apply lexicographical ordering
 [[alg.lex.comparison]].
 Each function compares a string of characters `*p` in the range \[`low`,
 `high`).
 *Returns:* An integer value equal to the result of calling `hash()` on
 any other string for which `do_compare()` returns 0 (equal) when passed
 the two strings.
+*Recommended practice:* The probability that the result equals that for
+another string which does not compare equal should be very small,
+approaching `(1.0/numeric_limits<unsigned long>::max())`.
 #### Class template `collate_byname` <a id="locale.collate.byname">[[locale.collate.byname]]</a>
 ``` cpp
 namespace std {
 }
 ```
 ### The time category <a id="category.time">[[category.time]]</a>
+#### General <a id="category.time.general">[[category.time.general]]</a>
 Templates `time_get<charT, InputIterator>` and
 `time_put<charT, OutputIterator>` provide date and time formatting and
 parsing. All specifications of member functions for `time_put` and
 `time_get` in the subclauses of  [[category.time]] only apply to the
 specializations required in Tables  [[tab:locale.category.facets]] and
 [[locale.categories]], and the `ctype<>` facet, to determine formatting
 details.
 #### Class template `time_get` <a id="locale.time.get">[[locale.time.get]]</a>
+##### General <a id="locale.time.get.general">[[locale.time.get.general]]</a>
 ``` cpp
 namespace std {
   class time_base {
   public:
     enum dateorder { no_order, dmy, mdy, ymd, ydm };
                                ios_base::iostate& err, tm* t, char format, char modifier) const;
     };
 }
 ```
+`time_get` is used to parse a character sequence, extracting components
+of a time or date into a `tm` object. Each `get` member parses a format
+as produced by a corresponding format specifier to `time_put<>::put`. If
 the sequence being parsed matches the correct format, the corresponding
+members of the `tm` argument are set to the values used to produce the
+sequence; otherwise either an error is reported or unspecified values
+are assigned.[^15]
 If the end iterator is reached during parsing by any of the `get()`
 member functions, the member sets `ios_base::eofbit` in `err`.
 ##### Members <a id="locale.time.get.members">[[locale.time.get.members]]</a>
 - The expression `s == end` evaluates to `true`, in which case the
   function evaluates `err = ios_base::eofbit | ios_base::failbit`.
 - 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
+ POSIX 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
 dateorder do_date_order() const;
 ```
 *Returns:* An enumeration value indicating the preferred order of
 components for those date formats that are composed of day, month, and
+year.[^16]
+Returns `no_order` if the date format specified by `’x’` contains other
+variable components (e.g., Julian day, week number, week day).
 ``` cpp
 iter_type do_get_time(iter_type s, iter_type end, ios_base& str,
                       ios_base::iostate& err, tm* t) const;
 ```
 *Effects:* Reads characters starting at `s` until it has extracted those
+`tm` members, and remaining format characters, used by `time_put<>::put`
+to produce the format specified by `"%H:%M:%S"`, or until it encounters
+an error or end of sequence.
 *Returns:* An iterator pointing immediately beyond the last character
 recognized as possibly part of a valid time.
 ``` cpp
 iter_type do_get_date(iter_type s, iter_type end, ios_base& str,
                       ios_base::iostate& err, tm* t) const;
 ```
 *Effects:* Reads characters starting at `s` until it has extracted those
+`tm` members and remaining format characters used by `time_put<>::put`
+to produce one of the following formats, or until it encounters an
+error. The format depends on the value returned by `date_order()` as
+shown in [[locale.time.get.dogetdate]].
 **Table: `do_get_date` effects** <a id="locale.time.get.dogetdate">[locale.time.get.dogetdate]</a>
 | `date_order()` | Format     |
 | -------------- | ---------- |
                            ios_base::iostate& err, tm* t) const;
 ```
 *Effects:* Reads characters starting at `s` until it has extracted the
 (perhaps abbreviated) name of a weekday or month. If it finds an
+abbreviation that is followed by characters that can match a full name,
+it continues reading until it matches the full name or fails. It sets
+the appropriate `tm` member accordingly.
 *Returns:* An iterator pointing immediately beyond the last character
 recognized as part of a valid name.
 ``` cpp
 *Preconditions:* `t` points to an object.
 *Effects:* The function starts by evaluating `err = ios_base::goodbit`.
 It then reads characters starting at `s` until it encounters an error,
+or until it has extracted and assigned those `tm` members, and any
+remaining format characters, corresponding to a conversion specification
+appropriate for the POSIX function `strptime`, formed by concatenating
+`’%’`, the `modifier` character, when non-NUL, and the `format`
+character. When the concatenation fails to yield a complete valid
+directive the function leaves the object pointed to by `t` unchanged and
+evaluates `err |= ios_base::failbit`. When `s == end` evaluates to
+`true` after reading a character the function evaluates
 `err |= ios_base::eofbit`.
+For complex conversion specifications such as `%c`, `%x`, or `%X`, or
+conversion specifications that involve the optional modifiers `E` or
+`O`, when the function is unable to unambiguously determine some or all
+`tm` members from the input sequence \[`s`, `end`), it evaluates
+`err |= ios_base::eofbit`. In such cases the values of those `tm`
 members are unspecified and may be outside their valid range.
 *Returns:* An iterator pointing immediately beyond the last character
 recognized as possibly part of a valid input sequence for the given
 `format` and `modifier`.
+*Remarks:* It is unspecified whether multiple calls to `do_get()` with
+the address of the same `tm` object will update the current contents of
+the object or simply overwrite its members. Portable programs should
+zero out the object before invoking the function.
 #### Class template `time_get_byname` <a id="locale.time.get.byname">[[locale.time.get.byname]]</a>
 ``` cpp
 namespace std {
   template<class charT, class InputIterator = istreambuf_iterator<charT>>
 interleaved in the output in the order in which they appear in the
 pattern. Format sequences are identified by converting each character
 `c` to a `char` value as if by `ct.narrow(c, 0)`, where `ct` is a
 reference to `ctype<charT>` obtained from `str.getloc()`. The first
 character of each sequence is equal to `’%’`, followed by an optional
+modifier character `mod`[^17]
+and a format specifier character `spec` as defined for the function
+`strftime`. If no modifier character is present, `mod` is zero. For each
+valid format sequence identified, calls
 `do_put(s, str, fill, t, spec, mod)`.
 The second form calls `do_put(s, str, fill, t, format, modifier)`.
+[*Note 1*: The `fill` argument can be used in the
 implementation-defined formats or by derivations. A space character is a
 reasonable default for this argument. — *end note*]
 *Returns:* An iterator pointing immediately after the last character
 produced.
 *Effects:* Formats the contents of the parameter `t` into characters
 placed on the output sequence `s`. Formatting is controlled by the
 parameters `format` and `modifier`, interpreted identically as the
 format specifiers in the string argument to the standard library
+function `strftime()`, except that the sequence of characters produced
+for those specifiers that are described as depending on the C locale are
+instead *implementation-defined*.
+[*Note 2*: Interpretation of the `modifier` argument is
+implementation-defined. — *end note*]
 *Returns:* An iterator pointing immediately after the last character
 produced.
+[*Note 3*: The `fill` argument can be used in the
 implementation-defined formats or by derivations. A space character is a
 reasonable default for this argument. — *end note*]
+*Recommended practice:* Interpretation of the `modifier` should follow
+POSIX conventions. Implementations should refer to other standards such
+as POSIX for a specification of the character sequences produced for
+those specifiers described as depending on the C locale.
 #### Class template `time_put_byname` <a id="locale.time.put.byname">[[locale.time.put.byname]]</a>
 ``` cpp
 namespace std {
   template<class charT, class OutputIterator = ostreambuf_iterator<charT>>
 }
 ```
 ### The monetary category <a id="category.monetary">[[category.monetary]]</a>
+#### General <a id="category.monetary.general">[[category.monetary.general]]</a>
 These templates handle monetary formats. A template parameter indicates
 whether local or international monetary formats are to be used.
 All specifications of member functions for `money_put` and `money_get`
 in the subclauses of  [[category.monetary]] only apply to the
 Digits in the numeric monetary component are extracted and placed in
 `digits`, or into a character buffer `buf1` for conversion to produce a
 value for `units`, in the order in which they appear, preceded by a
 minus sign if and only if the result is negative. The value `units` is
+produced as if by[^18]
 ``` cpp
 for (int i = 0; i < n; ++i)
   buf2[i] = src[find(atoms, atoms+sizeof(src), buf1[i]) - atoms];
 buf2[n] = 0;
 leading minus sign and the immediately subsequent digit characters (as
 classified according to `ct`) are used; any trailing characters
 (including digits appearing after a non-digit character) are ignored.
 Calls `str.width(0)`.
+*Returns:* An iterator pointing immediately after the last character
+produced.
 *Remarks:* The currency symbol is generated if and only if
 `(str.flags() & str.showbase)` is nonzero. If the number of characters
 generated for the specified format is less than the value returned by
 `str.width()` on entry to the function, then copies of `fill` are
 inserted as necessary to pad to the specified width. For the value `af`
 [*Note 1*: It is possible, with some combinations of format patterns
 and flag values, to produce output that cannot be parsed using
 `num_get<>::get`. — *end note*]
 #### Class template `moneypunct` <a id="locale.moneypunct">[[locale.moneypunct]]</a>
+##### General <a id="locale.moneypunct.general">[[locale.moneypunct.general]]</a>
 ``` cpp
 namespace std {
   class money_base {
   public:
     enum part { none, space, symbol, sign, value };
 The `moneypunct<>` facet defines monetary formatting parameters used by
 `money_get<>` and `money_put<>`. A monetary format is a sequence of four
 components, specified by a `pattern` value `p`, such that the `part`
 value `static_cast<part>(p.field[i])` determines the `i`ᵗʰ component of
+the format[^19]
+In the `field` member of a `pattern` object, each value `symbol`,
+`sign`, `value`, and either `space` or `none` appears exactly once. The
+value `none`, if present, is not first; the value `space`, if present,
+is neither first nor last.
 Where `none` or `space` appears, whitespace is permitted in the format,
 except where `none` appears at the end, in which case no whitespace is
 permitted. The value `space` indicates that at least one space is
 required at that position. Where `symbol` appears, the sequence of
 ``` cpp
 charT do_decimal_point() const;
 ```
 *Returns:* The radix separator to use in case `do_frac_digits()` is
+greater than zero.[^20]
 ``` cpp
 charT do_thousands_sep() const;
 ```
 *Returns:* The digit group separator to use in case `do_grouping()`
+specifies a digit grouping pattern.[^21]
 ``` cpp
 string do_grouping() const;
 ```
 *Returns:* A pattern defined identically as, but not necessarily equal
+to, the result of `numpunct<charT>::do_grouping()`.[^22]
 ``` cpp
 string_type do_curr_symbol() const;
 ```
 string_type do_positive_sign() const;
 string_type do_negative_sign() const;
 ```
 *Returns:* `do_positive_sign()` returns the string to use to indicate a
+positive monetary value;[^23]
+`do_negative_sign()` returns the string to use to indicate a negative
+value.
 ``` cpp
 int do_frac_digits() const;
 ```
 *Returns:* The number of digits after the decimal radix separator, if
+any.[^24]
 ``` cpp
 pattern do_pos_format() const;
 pattern do_neg_format() const;
 ```
 - `moneypunct<wchar_t>`,
 - `moneypunct<char, true>`, and
 - `moneypunct<wchar_t, true>`,
 return an object of type `pattern` initialized to
+`{ symbol, sign, none, value }`.[^25]
 #### Class template `moneypunct_byname` <a id="locale.moneypunct.byname">[[locale.moneypunct.byname]]</a>
 ``` cpp
 namespace std {
 }
 ```
 ### The message retrieval category <a id="category.messages">[[category.messages]]</a>
+#### General <a id="category.messages.general">[[category.messages.general]]</a>
 Class `messages<charT>` implements retrieval of strings from message
 catalogs.
 #### Class template `messages` <a id="locale.messages">[[locale.messages]]</a>
+##### General <a id="locale.messages.general">[[locale.messages.general]]</a>
 ``` cpp
 namespace std {
   class messages_base {
   public:
     using catalog = unspecified signed integer type;

Diff to HTML by rtfpessoa