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

Files changed (1) hide show

tmp/tmpvhnurqlt/{from.md → to.md} +142 -140

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

@@ -1,8 +1,8 @@
-## 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
@@ -16,45 +16,45 @@ 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 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;
     // numeric values are for exposition only.
-    static const mask space  = 1 << 0;
-    static const mask print  = 1 << 1;
-    static const mask cntrl  = 1 << 2;
-    static const mask upper  = 1 << 3;
-    static const mask lower  = 1 << 4;
-    static const mask alpha  = 1 << 5;
-    static const mask digit  = 1 << 6;
-    static const mask punct  = 1 << 7;
-    static const mask xdigit = 1 << 8;
-    static const mask blank  = 1 << 9;
-    static const mask alnum  = alpha | digit;
-    static const mask graph  = alnum | punct;
   };
 }
 ```
 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 {
@@ -105,11 +105,11 @@ input parsing.
 The specializations required in [[locale.category.facets]]
 [[locale.category]], namely `ctype<char>` and `ctype<wchar_t>`,
 implement character classing appropriate to the implementation’s native
 character set.
-##### `ctype` members <a id="locale.ctype.members">[[locale.ctype.members]]</a>
 ``` cpp
 bool         is(mask m, charT c) const;
 const charT* is(const charT* low, const charT* high, mask* vec) const;
 ```
@@ -127,11 +127,11 @@ const charT* scan_not(mask m, const charT* low, const charT* high) const;
 ```
 *Returns:* `do_scan_not(m, low, high)`.
 ``` cpp
-charT        toupper(charT) const;
 const charT* toupper(charT* low, const charT* high) const;
 ```
 *Returns:* `do_toupper(c)` or `do_toupper(low, high)`.
@@ -154,11 +154,11 @@ char         narrow(charT c, char dfault) const;
 const charT* narrow(const charT* low, const charT* high, char dfault, char* to) const;
 ```
 *Returns:* `do_narrow(c, dfault)` or `do_narrow(low, high, dfault, to)`.
-##### `ctype` virtual functions <a id="locale.ctype.virtuals">[[locale.ctype.virtuals]]</a>
 ``` cpp
 bool         do_is(mask m, charT c) const;
 const charT* do_is(const charT* low, const charT* high, mask* vec) const;
 ```
@@ -230,11 +230,11 @@ 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]
 The second form transforms each character `*p` in the range \[`low`,
 `high`), placing the result in `dest[p - low]`.
@@ -273,30 +273,30 @@ the result (or `dfault` if no simple transformation is readily
 available) in `dest[p - low]`.
 *Returns:* The first form returns the transformed value; or `dfault` if
 no mapping is readily available. The second form returns `high`.
-#### Class template `ctype_byname` <a id="locale.ctype.byname">[[locale.ctype.byname]]</a>
 ``` cpp
 namespace std {
   template<class charT>
     class ctype_byname : public ctype<charT> {
     public:
-      using mask = typename ctype<charT>::mask;
       explicit ctype_byname(const char*, size_t refs = 0);
       explicit ctype_byname(const string&, size_t refs = 0);
     protected:
       ~ctype_byname();
     };
 }
 ```
-#### `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 {
@@ -346,20 +346,20 @@ 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();
 ```
 *Effects:* If the constructor’s first argument was nonzero, and its
 second argument was `true`, does `delete [] table()`.
-##### Members <a id="facet.ctype.char.members">[[facet.ctype.char.members]]</a>
 In the following member descriptions, for `unsigned char` values `v`
 where `v >= table_size`, `table()[v]` is assumed to have an
 implementation-specific value (possibly different for each such value
 `v`) without performing the array lookup.
@@ -442,21 +442,21 @@ const mask* table() const noexcept;
 ```
 *Returns:* The first constructor argument, if it was nonzero, otherwise
 `classic_table()`.
-##### Static members <a id="facet.ctype.char.statics">[[facet.ctype.char.statics]]</a>
 ``` cpp
 static const mask* classic_table() noexcept;
 ```
 *Returns:* A pointer to the initial element of an array of size
 `table_size` which represents the classifications of characters in the
 `"C"` locale.
-##### Virtual functions <a id="facet.ctype.char.virtuals">[[facet.ctype.char.virtuals]]</a>
 ``` cpp
 char        do_toupper(char) const;
 const char* do_toupper(char* low, const char* high) const;
 char        do_tolower(char) const;
@@ -470,13 +470,13 @@ 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>
-##### General <a id="locale.codecvt.general">[[locale.codecvt.general]]</a>
 ``` cpp
 namespace std {
   class codecvt_base {
   public:
@@ -544,23 +544,20 @@ The `stateT` argument selects the pair of character encodings being
 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(
   stateT& state,
   const internT* from, const internT* from_end, const internT*& from_next,
@@ -608,11 +605,11 @@ int length(stateT& state, const externT* from, const externT* from_end, size_t m
 int max_length() const noexcept;
 ```
 *Returns:* `do_max_length()`.
-##### Virtual functions <a id="locale.codecvt.virtuals">[[locale.codecvt.virtuals]]</a>
 ``` cpp
 result do_out(
   stateT& state,
   const internT* from, const internT* from_end, const internT*& from_next,
@@ -634,13 +631,13 @@ the sequence.
 destination `to`. Converts no more than `(from_end - from)` source
 elements, and stores no more than `(to_end - to)` destination elements.
 Stops if it encounters a character it cannot convert. It always leaves
 the `from_next` and `to_next` pointers pointing one beyond the last
-element successfully converted. If returns `noconv`, `internT` and
-`externT` are the same type and the converted sequence is identical to
-the input sequence \[`from`, `from``next`). `to_next` is set equal to
 `to`, the value of `state` is unchanged, and there are no changes to the
 values in \[`to`, `to_end`).
 A `codecvt` facet that is used by `basic_filebuf` [[file.streams]] shall
 have the property that if
@@ -751,14 +748,14 @@ sequence.
 *Effects:* The effect on the `state` argument is as if it called
 `do_in(state, from, from_end, from, to, to + max, to)` for `to` pointing
 to a buffer of at least `max` elements.
-*Returns:* `(from_next-from)` where `from_next` is the largest value in
-the range \[`from`, `from_end`\] such that the sequence of values in the
-range \[`from`, `from_next`) represents `max` or fewer valid complete
-characters of type `internT`. The specialization
 `codecvt<char, char, mbstate_t>`, returns the lesser of `max` and
 `(from_end - from)`.
 ``` cpp
 int do_max_length() const noexcept;
@@ -767,11 +764,11 @@ int do_max_length() const noexcept;
 *Returns:* The maximum value that `do_length(state, from, from_end, 1)`
 can return for any valid range \[`from`, `from_end`) and `stateT` value
 `state`. The specialization
 `codecvt<char, char, mbstate_t>::do_max_length()` returns 1.
-#### Class template `codecvt_byname` <a id="locale.codecvt.byname">[[locale.codecvt.byname]]</a>
 ``` cpp
 namespace std {
   template<class internT, class externT, class stateT>
     class codecvt_byname : public codecvt<internT, externT, stateT> {
@@ -783,13 +780,13 @@ namespace std {
       ~codecvt_byname();
     };
 }
 ```
-### 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]
@@ -807,13 +804,13 @@ 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 {
@@ -877,11 +874,11 @@ namespace std {
 ```
 The facet `num_get` is used to parse numeric values from an input
 sequence such as an istream.
-##### Members <a id="facet.num.get.members">[[facet.num.get.members]]</a>
 ``` cpp
 iter_type get(iter_type in, iter_type end, ios_base& str,
               ios_base::iostate& err, bool& val) const;
 iter_type get(iter_type in, iter_type end, ios_base& str,
@@ -906,11 +903,11 @@ iter_type get(iter_type in, iter_type end, ios_base& str,
               ios_base::iostate& err, void*& val) const;
 ```
 *Returns:* `do_get(in, end, str, err, val)`.
-##### Virtual functions <a id="facet.num.get.virtuals">[[facet.num.get.virtuals]]</a>
 ``` cpp
 iter_type do_get(iter_type in, iter_type end, ios_base& str,
                  ios_base::iostate& err, long& val) const;
 iter_type do_get(iter_type in, iter_type end, ios_base& str,
@@ -935,17 +932,17 @@ iter_type do_get(iter_type in, iter_type end, ios_base& str,
 *Effects:* Reads characters from `in`, interpreting them according to
 `str.flags()`, `use_facet<ctype<charT>>(loc)`, and
 `use_facet<numpunct<charT>>(loc)`, where `loc` is `str.getloc()`.
-The details of this operation occur in three stages
-- Stage 1: Determine a conversion specifier
 - Stage 2: Extract characters from `in` and determine a corresponding
   `char` value for the format expected by the conversion specification
   determined in stage 1.
-- Stage 3: Store results
 The details of the stages are presented below.
 [*Example 1*:
@@ -995,12 +992,12 @@ Otherwise `false` is stored and `ios_base::failbit` is assigned to
 The `in` iterator is always left pointing one position beyond the last
 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 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
@@ -1008,13 +1005,13 @@ sequence `"1"` yields `val == true` and `err == str.goodbit`. For empty
 targets `("")`, any input sequence yields
 `err == str.failbit`. — *end example*]
 *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 {
@@ -1050,11 +1047,11 @@ namespace std {
 ```
 The facet `num_put` is used to format numeric values to a character
 sequence such as an ostream.
-##### Members <a id="facet.num.put.members">[[facet.num.put.members]]</a>
 ``` cpp
 iter_type put(iter_type out, ios_base& str, char_type fill, bool val) const;
 iter_type put(iter_type out, ios_base& str, char_type fill, long val) const;
 iter_type put(iter_type out, ios_base& str, char_type fill, long long val) const;
@@ -1065,11 +1062,11 @@ iter_type put(iter_type out, ios_base& str, char_type fill, long double val) con
 iter_type put(iter_type out, ios_base& str, char_type fill, const void* val) const;
 ```
 *Returns:* `do_put(out, str, fill, val)`.
-##### Virtual functions <a id="facet.num.put.virtuals">[[facet.num.put.virtuals]]</a>
 ``` cpp
 iter_type do_put(iter_type out, ios_base& str, char_type fill, long val) const;
 iter_type do_put(iter_type out, ios_base& str, char_type fill, long long val) const;
 iter_type do_put(iter_type out, ios_base& str, char_type fill, unsigned long val) const;
@@ -1148,11 +1145,12 @@ floating-point conversion specifier as indicated in
 **Table: Floating-point conversions** <a id="facet.num.put.fp">[facet.num.put.fp]</a>
 | 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`               |
@@ -1274,15 +1272,15 @@ string_type s =
 ```
 and then inserts each character `c` of `s` into `out` via `*out++ = c`
 and returns `out`.
-### 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 {
@@ -1371,11 +1369,11 @@ e:
 where the number of digits between is as specified by `do_grouping()`.
 For parsing, if the portion contains no thousands-separators, no
 grouping constraint is applied.
-##### Members <a id="facet.numpunct.members">[[facet.numpunct.members]]</a>
 ``` cpp
 char_type decimal_point() const;
 ```
@@ -1398,11 +1396,11 @@ string_type truename()  const;
 string_type falsename() const;
 ```
 *Returns:* `do_truename()` or `do_falsename()`, respectively.
-##### Virtual functions <a id="facet.numpunct.virtuals">[[facet.numpunct.virtuals]]</a>
 ``` cpp
 char_type do_decimal_point() const;
 ```
@@ -1440,11 +1438,11 @@ string_type do_falsename() const;
 `false`, respectively.
 In the base class implementation these names are `"true"` and `"false"`,
 or `L"true"` and `L"false"`.
-#### Class template `numpunct_byname` <a id="locale.numpunct.byname">[[locale.numpunct.byname]]</a>
 ``` cpp
 namespace std {
   template<class charT>
     class numpunct_byname : public numpunct<charT> {
@@ -1460,15 +1458,15 @@ namespace std {
       ~numpunct_byname();
     };
 }
 ```
-### 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 {
@@ -1505,11 +1503,11 @@ and `collate<wchar_t>`, apply lexicographical ordering
 [[alg.lex.comparison]].
 Each function compares a string of characters `*p` in the range \[`low`,
 `high`).
-##### Members <a id="locale.collate.members">[[locale.collate.members]]</a>
 ``` cpp
 int compare(const charT* low1, const charT* high1,
             const charT* low2, const charT* high2) const;
 ```
@@ -1526,11 +1524,11 @@ string_type transform(const charT* low, const charT* high) const;
 long hash(const charT* low, const charT* high) const;
 ```
 *Returns:* `do_hash(low, high)`.
-##### Virtual functions <a id="locale.collate.virtuals">[[locale.collate.virtuals]]</a>
 ``` cpp
 int do_compare(const charT* low1, const charT* high1,
                const charT* low2, const charT* high2) const;
 ```
@@ -1560,11 +1558,11 @@ 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 {
   template<class charT>
     class collate_byname : public collate<charT> {
@@ -1578,13 +1576,13 @@ namespace std {
       ~collate_byname();
     };
 }
 ```
-### 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
@@ -1592,13 +1590,13 @@ specializations required in Tables  [[tab:locale.category.facets]] and
 [[tab:locale.spec]] [[locale.category]]. Their members use their
 `ios_base&`, `ios_base::iostate&`, and `fill` arguments as described in
 [[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:
@@ -1660,11 +1658,11 @@ 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>
 ``` cpp
 dateorder date_order() const;
 ```
@@ -1753,11 +1751,11 @@ by what means the function performs case-insensitive comparison or
 whether multi-character sequences are considered while doing
 so. — *end note*]
 *Returns:* `s`.
-##### Virtual functions <a id="locale.time.get.virtuals">[[locale.time.get.virtuals]]</a>
 ``` cpp
 dateorder do_date_order() const;
 ```
@@ -1871,11 +1869,11 @@ recognized as possibly part of a valid input sequence for the given
 *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>>
     class time_get_byname : public time_get<charT, InputIterator> {
@@ -1890,11 +1888,13 @@ namespace std {
       ~time_get_byname();
     };
 }
 ```
-#### Class template `time_put` <a id="locale.time.put">[[locale.time.put]]</a>
 ``` cpp
 namespace std {
   template<class charT, class OutputIterator = ostreambuf_iterator<charT>>
     class time_put : public locale::facet {
@@ -1918,11 +1918,11 @@ namespace std {
                                char format, char modifier) const;
     };
 }
 ```
-##### Members <a id="locale.time.put.members">[[locale.time.put.members]]</a>
 ``` cpp
 iter_type put(iter_type s, ios_base& str, char_type fill, const tm* t,
               const charT* pattern, const charT* pat_end) const;
 iter_type put(iter_type s, ios_base& str, char_type fill, const tm* t,
@@ -1937,27 +1937,25 @@ 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 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.
-##### Virtual functions <a id="locale.time.put.virtuals">[[locale.time.put.virtuals]]</a>
 ``` cpp
 iter_type do_put(iter_type s, ios_base&, char_type fill, const tm* t,
                  char format, char modifier) const;
 ```
@@ -1968,26 +1966,26 @@ 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>>
     class time_put_byname : public time_put<charT, OutputIterator> {
@@ -2002,13 +2000,13 @@ namespace std {
       ~time_put_byname();
     };
 }
 ```
-### 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`
@@ -2017,11 +2015,13 @@ specializations required in Tables  [[tab:locale.category.facets]] and
 [[tab:locale.spec]] [[locale.category]]. Their members use their
 `ios_base&`, `ios_base::iostate&`, and `fill` arguments as described in
 [[locale.categories]], and the `moneypunct<>` and `ctype<>` facets, to
 determine formatting details.
-#### Class template `money_get` <a id="locale.money.get">[[locale.money.get]]</a>
 ``` cpp
 namespace std {
   template<class charT, class InputIterator = istreambuf_iterator<charT>>
     class money_get : public locale::facet {
@@ -2049,22 +2049,22 @@ namespace std {
                                ios_base::iostate& err, string_type& digits) const;
     };
 }
 ```
-##### Members <a id="locale.money.get.members">[[locale.money.get.members]]</a>
 ``` cpp
 iter_type get(iter_type s, iter_type end, bool intl, ios_base& f,
               ios_base::iostate& err, long double& quant) const;
 iter_type get(iter_type s, iter_type end, bool intl, ios_base& f,
               ios_base::iostate& err, string_type& quant) const;
 ```
 *Returns:* `do_get(s, end, intl, f, err, quant)`.
-##### Virtual functions <a id="locale.money.get.virtuals">[[locale.money.get.virtuals]]</a>
 ``` cpp
 iter_type do_get(iter_type s, iter_type end, bool intl, ios_base& str,
                  ios_base::iostate& err, long double& units) const;
 iter_type do_get(iter_type s, iter_type end, bool intl, ios_base& str,
@@ -2074,18 +2074,18 @@ iter_type do_get(iter_type s, iter_type end, bool intl, ios_base& str,
 *Effects:* Reads characters from `s` to parse and construct a monetary
 value according to the format specified by a `moneypunct<charT, Intl>`
 facet reference `mp` and the character mapping specified by a
 `ctype<charT>` facet reference `ct` obtained from the locale returned by
 `str.getloc()`, and `str.flags()`. If a valid sequence is recognized,
-does not change `err`; otherwise, sets `err` to `(err|str.failbit)`, or
-`(err|str.failbit|str.eofbit)` if no more characters are available, and
-does not change `units` or `digits`. Uses the pattern returned by
-`mp.neg_format()` to parse all values. The result is returned as an
-integral value stored in `units` or as a sequence of digits possibly
-preceded by a minus sign (as produced by `ct.widen(c)` where `c` is
-`’-’` or in the range from `’0’` through `’9’` (inclusive)) stored in
-`digits`.
 [*Example 1*: The sequence `$1,056.23` in a common United States locale
 would yield, for `units`, `105623`, or, for `digits`,
 `"105623"`. — *end example*]
@@ -2126,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[^18]
 ``` cpp
 for (int i = 0; i < n; ++i)
   buf2[i] = src[find(atoms, atoms + sizeof(src), buf1[i]) - atoms];
 buf2[n] = 0;
@@ -2147,11 +2147,13 @@ ct.widen(src, src + sizeof(src) - 1, atoms);
 ```
 *Returns:* An iterator pointing immediately beyond the last character
 recognized as part of a valid monetary quantity.
-#### Class template `money_put` <a id="locale.money.put">[[locale.money.put]]</a>
 ``` cpp
 namespace std {
   template<class charT, class OutputIterator = ostreambuf_iterator<charT>>
     class money_put : public locale::facet {
@@ -2177,20 +2179,20 @@ namespace std {
                                const string_type& digits) const;
     };
 }
 ```
-##### Members <a id="locale.money.put.members">[[locale.money.put.members]]</a>
 ``` cpp
 iter_type put(iter_type s, bool intl, ios_base& f, char_type fill, long double quant) const;
 iter_type put(iter_type s, bool intl, ios_base& f, char_type fill, const string_type& quant) const;
 ```
-*Returns:* `do_put(s, intl, f, loc, quant)`.
-##### Virtual functions <a id="locale.money.put.virtuals">[[locale.money.put.virtuals]]</a>
 ``` cpp
 iter_type do_put(iter_type s, bool intl, ios_base& str,
                  char_type fill, long double units) const;
 iter_type do_put(iter_type s, bool intl, ios_base& str,
@@ -2235,13 +2237,13 @@ 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*]
-#### 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:
@@ -2287,11 +2289,11 @@ 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[^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.
@@ -2354,11 +2356,11 @@ by `frac_digits()`.
 The placement of thousands-separator characters (if any) is determined
 by the value returned by `grouping()`, defined identically as the member
 `numpunct<>::do_grouping()`.
-##### Members <a id="locale.moneypunct.members">[[locale.moneypunct.members]]</a>
 ``` cpp
 charT       decimal_point() const;
 charT       thousands_sep() const;
 string      grouping()      const;
@@ -2371,60 +2373,60 @@ pattern      neg_format()    const;
 ```
 Each of these functions `F` returns the result of calling the
 corresponding virtual member function `do_F()`.
-##### Virtual functions <a id="locale.moneypunct.virtuals">[[locale.moneypunct.virtuals]]</a>
 ``` 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;
 ```
 *Returns:* A string to use as the currency identifier symbol.
-[*Note 1*: For specializations where the second template parameter is
 `true`, this is typically four characters long: a three-letter code as
 specified by ISO 4217 followed by a space. — *end note*]
 ``` cpp
 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;
 ```
@@ -2436,13 +2438,13 @@ 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 {
   template<class charT, bool Intl = false>
     class moneypunct_byname : public moneypunct<charT, Intl> {
@@ -2457,20 +2459,20 @@ namespace std {
       ~moneypunct_byname();
     };
 }
 ```
-### 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:
@@ -2503,11 +2505,11 @@ namespace std {
 ```
 Values of type `messages_base::catalog` usable as arguments to members
 `get` and `close` can be obtained only by calling member `open`.
-##### Members <a id="locale.messages.members">[[locale.messages.members]]</a>
 ``` cpp
 catalog open(const string& name, const locale& loc) const;
 ```
@@ -2523,11 +2525,11 @@ string_type get(catalog cat, int set, int msgid, const string_type& dfault) cons
 void close(catalog cat) const;
 ```
 *Effects:* Calls `do_close(cat)`.
-##### Virtual functions <a id="locale.messages.virtuals">[[locale.messages.virtuals]]</a>
 ``` cpp
 catalog do_open(const string& name, const locale& loc) const;
 ```
@@ -2562,11 +2564,11 @@ closed.
 *Effects:* Releases unspecified resources associated with `cat`.
 *Remarks:* The limit on such resources, if any, is
 *implementation-defined*.
-#### Class template `messages_byname` <a id="locale.messages.byname">[[locale.messages.byname]]</a>
 ``` cpp
 namespace std {
   template<class charT>
     class messages_byname : public messages<charT> {

+### 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
 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 [[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;
     // numeric values are for exposition only.
+    static constexpr mask space  = 1 << 0;
+    static constexpr mask print  = 1 << 1;
+    static constexpr mask cntrl  = 1 << 2;
+    static constexpr mask upper  = 1 << 3;
+    static constexpr mask lower  = 1 << 4;
+    static constexpr mask alpha  = 1 << 5;
+    static constexpr mask digit  = 1 << 6;
+    static constexpr mask punct  = 1 << 7;
+    static constexpr mask xdigit = 1 << 8;
+    static constexpr mask blank  = 1 << 9;
+    static constexpr mask alnum  = alpha | digit;
+    static constexpr mask graph  = alnum | punct;
   };
 }
 ```
 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 {
 The specializations required in [[locale.category.facets]]
 [[locale.category]], namely `ctype<char>` and `ctype<wchar_t>`,
 implement character classing appropriate to the implementation’s native
 character set.
+###### `ctype` members <a id="locale.ctype.members">[[locale.ctype.members]]</a>
 ``` cpp
 bool         is(mask m, charT c) const;
 const charT* is(const charT* low, const charT* high, mask* vec) const;
 ```
 ```
 *Returns:* `do_scan_not(m, low, high)`.
 ``` cpp
+charT        toupper(charT c) const;
 const charT* toupper(charT* low, const charT* high) const;
 ```
 *Returns:* `do_toupper(c)` or `do_toupper(low, high)`.
 const charT* narrow(const charT* low, const charT* high, char dfault, char* to) const;
 ```
 *Returns:* `do_narrow(c, dfault)` or `do_narrow(low, high, dfault, to)`.
+###### `ctype` virtual functions <a id="locale.ctype.virtuals">[[locale.ctype.virtuals]]</a>
 ``` cpp
 bool         do_is(mask m, charT c) const;
 const charT* do_is(const charT* low, const charT* high, mask* vec) const;
 ```
 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<char>` facet `ctc` and
 valid `ctype_base::mask` value `M`,
 `(ctc.is(M, c) || !is(M, do_widen(c)) )` is `true`.[^6]
 The second form transforms each character `*p` in the range \[`low`,
 `high`), placing the result in `dest[p - low]`.
 available) in `dest[p - low]`.
 *Returns:* The first form returns the transformed value; or `dfault` if
 no mapping is readily available. The second form returns `high`.
+##### Class template `ctype_byname` <a id="locale.ctype.byname">[[locale.ctype.byname]]</a>
 ``` cpp
 namespace std {
   template<class charT>
     class ctype_byname : public ctype<charT> {
     public:
+      using mask = ctype<charT>::mask;
       explicit ctype_byname(const char*, size_t refs = 0);
       explicit ctype_byname(const string&, size_t refs = 0);
     protected:
       ~ctype_byname();
     };
 }
 ```
+##### `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 {
 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();
 ```
 *Effects:* If the constructor’s first argument was nonzero, and its
 second argument was `true`, does `delete [] table()`.
+###### Members <a id="facet.ctype.char.members">[[facet.ctype.char.members]]</a>
 In the following member descriptions, for `unsigned char` values `v`
 where `v >= table_size`, `table()[v]` is assumed to have an
 implementation-specific value (possibly different for each such value
 `v`) without performing the array lookup.
 ```
 *Returns:* The first constructor argument, if it was nonzero, otherwise
 `classic_table()`.
+###### Static members <a id="facet.ctype.char.statics">[[facet.ctype.char.statics]]</a>
 ``` cpp
 static const mask* classic_table() noexcept;
 ```
 *Returns:* A pointer to the initial element of an array of size
 `table_size` which represents the classifications of characters in the
 `"C"` locale.
+###### Virtual functions <a id="facet.ctype.char.virtuals">[[facet.ctype.char.virtuals]]</a>
 ``` cpp
 char        do_toupper(char) const;
 const char* do_toupper(char* low, const char* high) const;
 char        do_tolower(char) const;
 ```
 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:
 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.
+`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(
   stateT& state,
   const internT* from, const internT* from_end, const internT*& from_next,
 int max_length() const noexcept;
 ```
 *Returns:* `do_max_length()`.
+###### Virtual functions <a id="locale.codecvt.virtuals">[[locale.codecvt.virtuals]]</a>
 ``` cpp
 result do_out(
   stateT& state,
   const internT* from, const internT* from_end, const internT*& from_next,
 destination `to`. Converts no more than `(from_end - from)` source
 elements, and stores no more than `(to_end - to)` destination elements.
 Stops if it encounters a character it cannot convert. It always leaves
 the `from_next` and `to_next` pointers pointing one beyond the last
+element successfully converted. If it returns `noconv`, `internT` and
+`externT` are the same type, and the converted sequence is identical to
+the input sequence \[`from`, `from``next`), `to_next` is set equal to
 `to`, the value of `state` is unchanged, and there are no changes to the
 values in \[`to`, `to_end`).
 A `codecvt` facet that is used by `basic_filebuf` [[file.streams]] shall
 have the property that if
 *Effects:* The effect on the `state` argument is as if it called
 `do_in(state, from, from_end, from, to, to + max, to)` for `to` pointing
 to a buffer of at least `max` elements.
+*Returns:* `(from_next - from)` where `from_next` is the largest value
+in the range \[`from`, `from_end`\] such that the sequence of values in
+the range \[`from`, `from_next`) represents `max` or fewer valid
+complete characters of type `internT`. The specialization
 `codecvt<char, char, mbstate_t>`, returns the lesser of `max` and
 `(from_end - from)`.
 ``` cpp
 int do_max_length() const noexcept;
 *Returns:* The maximum value that `do_length(state, from, from_end, 1)`
 can return for any valid range \[`from`, `from_end`) and `stateT` value
 `state`. The specialization
 `codecvt<char, char, mbstate_t>::do_max_length()` returns 1.
+##### Class template `codecvt_byname` <a id="locale.codecvt.byname">[[locale.codecvt.byname]]</a>
 ``` cpp
 namespace std {
   template<class internT, class externT, class stateT>
     class codecvt_byname : public codecvt<internT, externT, stateT> {
       ~codecvt_byname();
     };
 }
 ```
+#### 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]
 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 {
 ```
 The facet `num_get` is used to parse numeric values from an input
 sequence such as an istream.
+###### Members <a id="facet.num.get.members">[[facet.num.get.members]]</a>
 ``` cpp
 iter_type get(iter_type in, iter_type end, ios_base& str,
               ios_base::iostate& err, bool& val) const;
 iter_type get(iter_type in, iter_type end, ios_base& str,
               ios_base::iostate& err, void*& val) const;
 ```
 *Returns:* `do_get(in, end, str, err, val)`.
+###### Virtual functions <a id="facet.num.get.virtuals">[[facet.num.get.virtuals]]</a>
 ``` cpp
 iter_type do_get(iter_type in, iter_type end, ios_base& str,
                  ios_base::iostate& err, long& val) const;
 iter_type do_get(iter_type in, iter_type end, ios_base& str,
 *Effects:* Reads characters from `in`, interpreting them according to
 `str.flags()`, `use_facet<ctype<charT>>(loc)`, and
 `use_facet<numpunct<charT>>(loc)`, where `loc` is `str.getloc()`.
+The details of this operation occur in three stages:
+- Stage 1: Determine a conversion specifier.
 - Stage 2: Extract characters from `in` and determine a corresponding
   `char` value for the format expected by the conversion specification
   determined in stage 1.
+- Stage 3: Store results.
 The details of the stages are presented below.
 [*Example 1*:
 The `in` iterator is always left pointing one position beyond the last
 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 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
 targets `("")`, any input sequence yields
 `err == str.failbit`. — *end example*]
 *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 {
 ```
 The facet `num_put` is used to format numeric values to a character
 sequence such as an ostream.
+###### Members <a id="facet.num.put.members">[[facet.num.put.members]]</a>
 ``` cpp
 iter_type put(iter_type out, ios_base& str, char_type fill, bool val) const;
 iter_type put(iter_type out, ios_base& str, char_type fill, long val) const;
 iter_type put(iter_type out, ios_base& str, char_type fill, long long val) const;
 iter_type put(iter_type out, ios_base& str, char_type fill, const void* val) const;
 ```
 *Returns:* `do_put(out, str, fill, val)`.
+###### Virtual functions <a id="facet.num.put.virtuals">[[facet.num.put.virtuals]]</a>
 ``` cpp
 iter_type do_put(iter_type out, ios_base& str, char_type fill, long val) const;
 iter_type do_put(iter_type out, ios_base& str, char_type fill, long long val) const;
 iter_type do_put(iter_type out, ios_base& str, char_type fill, unsigned long val) const;
 **Table: Floating-point conversions** <a id="facet.num.put.fp">[facet.num.put.fp]</a>
 | State                                                                  | `stdio` equivalent |
 | ---------------------------------------------------------------------- | ------------------ |
+| `floatfield == ios_base::fixed && !uppercase` | `%f`               |
+| `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`               |
 ```
 and then inserts each character `c` of `s` into `out` via `*out++ = c`
 and returns `out`.
+#### 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 {
 where the number of digits between is as specified by `do_grouping()`.
 For parsing, if the portion contains no thousands-separators, no
 grouping constraint is applied.
+###### Members <a id="facet.numpunct.members">[[facet.numpunct.members]]</a>
 ``` cpp
 char_type decimal_point() const;
 ```
 string_type falsename() const;
 ```
 *Returns:* `do_truename()` or `do_falsename()`, respectively.
+###### Virtual functions <a id="facet.numpunct.virtuals">[[facet.numpunct.virtuals]]</a>
 ``` cpp
 char_type do_decimal_point() const;
 ```
 `false`, respectively.
 In the base class implementation these names are `"true"` and `"false"`,
 or `L"true"` and `L"false"`.
+##### Class template `numpunct_byname` <a id="locale.numpunct.byname">[[locale.numpunct.byname]]</a>
 ``` cpp
 namespace std {
   template<class charT>
     class numpunct_byname : public numpunct<charT> {
       ~numpunct_byname();
     };
 }
 ```
+#### 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 {
 [[alg.lex.comparison]].
 Each function compares a string of characters `*p` in the range \[`low`,
 `high`).
+###### Members <a id="locale.collate.members">[[locale.collate.members]]</a>
 ``` cpp
 int compare(const charT* low1, const charT* high1,
             const charT* low2, const charT* high2) const;
 ```
 long hash(const charT* low, const charT* high) const;
 ```
 *Returns:* `do_hash(low, high)`.
+###### Virtual functions <a id="locale.collate.virtuals">[[locale.collate.virtuals]]</a>
 ``` cpp
 int do_compare(const charT* low1, const charT* high1,
                const charT* low2, const charT* high2) const;
 ```
 *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 {
   template<class charT>
     class collate_byname : public collate<charT> {
       ~collate_byname();
     };
 }
 ```
+#### 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
 [[tab:locale.spec]] [[locale.category]]. Their members use their
 `ios_base&`, `ios_base::iostate&`, and `fill` arguments as described in
 [[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:
 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>
 ``` cpp
 dateorder date_order() const;
 ```
 whether multi-character sequences are considered while doing
 so. — *end note*]
 *Returns:* `s`.
+###### Virtual functions <a id="locale.time.get.virtuals">[[locale.time.get.virtuals]]</a>
 ``` cpp
 dateorder do_date_order() const;
 ```
 *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>>
     class time_get_byname : public time_get<charT, InputIterator> {
       ~time_get_byname();
     };
 }
 ```
+##### Class template `time_put` <a id="locale.time.put">[[locale.time.put]]</a>
+###### General <a id="locale.time.put.general">[[locale.time.put.general]]</a>
 ``` cpp
 namespace std {
   template<class charT, class OutputIterator = ostreambuf_iterator<charT>>
     class time_put : public locale::facet {
                                char format, char modifier) const;
     };
 }
 ```
+###### Members <a id="locale.time.put.members">[[locale.time.put.members]]</a>
 ``` cpp
 iter_type put(iter_type s, ios_base& str, char_type fill, const tm* t,
               const charT* pattern, const charT* pat_end) const;
 iter_type put(iter_type s, ios_base& str, char_type fill, const tm* t,
 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` 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 2*: 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.
+###### Virtual functions <a id="locale.time.put.virtuals">[[locale.time.put.virtuals]]</a>
 ``` cpp
 iter_type do_put(iter_type s, ios_base&, char_type fill, const tm* t,
                  char format, char modifier) const;
 ```
 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 3*: Interpretation of the `modifier` argument is
 implementation-defined. — *end note*]
 *Returns:* An iterator pointing immediately after the last character
 produced.
+[*Note 4*: 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>>
     class time_put_byname : public time_put<charT, OutputIterator> {
       ~time_put_byname();
     };
 }
 ```
+#### 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`
 [[tab:locale.spec]] [[locale.category]]. Their members use their
 `ios_base&`, `ios_base::iostate&`, and `fill` arguments as described in
 [[locale.categories]], and the `moneypunct<>` and `ctype<>` facets, to
 determine formatting details.
+##### Class template `money_get` <a id="locale.money.get">[[locale.money.get]]</a>
+###### General <a id="locale.money.get.general">[[locale.money.get.general]]</a>
 ``` cpp
 namespace std {
   template<class charT, class InputIterator = istreambuf_iterator<charT>>
     class money_get : public locale::facet {
                                ios_base::iostate& err, string_type& digits) const;
     };
 }
 ```
+###### Members <a id="locale.money.get.members">[[locale.money.get.members]]</a>
 ``` cpp
 iter_type get(iter_type s, iter_type end, bool intl, ios_base& f,
               ios_base::iostate& err, long double& quant) const;
 iter_type get(iter_type s, iter_type end, bool intl, ios_base& f,
               ios_base::iostate& err, string_type& quant) const;
 ```
 *Returns:* `do_get(s, end, intl, f, err, quant)`.
+###### Virtual functions <a id="locale.money.get.virtuals">[[locale.money.get.virtuals]]</a>
 ``` cpp
 iter_type do_get(iter_type s, iter_type end, bool intl, ios_base& str,
                  ios_base::iostate& err, long double& units) const;
 iter_type do_get(iter_type s, iter_type end, bool intl, ios_base& str,
 *Effects:* Reads characters from `s` to parse and construct a monetary
 value according to the format specified by a `moneypunct<charT, Intl>`
 facet reference `mp` and the character mapping specified by a
 `ctype<charT>` facet reference `ct` obtained from the locale returned by
 `str.getloc()`, and `str.flags()`. If a valid sequence is recognized,
+does not change `err`; otherwise, sets `err` to `(err | str.failbit)`,
+or `(err | str.failbit | str.eofbit)` if no more characters are
+available, and does not change `units` or `digits`. Uses the pattern
+returned by `mp.neg_format()` to parse all values. The result is
+returned as an integral value stored in `units` or as a sequence of
+digits possibly preceded by a minus sign (as produced by `ct.widen(c)`
+where `c` is `’-’` or in the range from `’0’` through `’9’` (inclusive))
+stored in `digits`.
 [*Example 1*: The sequence `$1,056.23` in a common United States locale
 would yield, for `units`, `105623`, or, for `digits`,
 `"105623"`. — *end example*]
 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[^17]
 ``` cpp
 for (int i = 0; i < n; ++i)
   buf2[i] = src[find(atoms, atoms + sizeof(src), buf1[i]) - atoms];
 buf2[n] = 0;
 ```
 *Returns:* An iterator pointing immediately beyond the last character
 recognized as part of a valid monetary quantity.
+##### Class template `money_put` <a id="locale.money.put">[[locale.money.put]]</a>
+###### General <a id="locale.money.put.general">[[locale.money.put.general]]</a>
 ``` cpp
 namespace std {
   template<class charT, class OutputIterator = ostreambuf_iterator<charT>>
     class money_put : public locale::facet {
                                const string_type& digits) const;
     };
 }
 ```
+###### Members <a id="locale.money.put.members">[[locale.money.put.members]]</a>
 ``` cpp
 iter_type put(iter_type s, bool intl, ios_base& f, char_type fill, long double quant) const;
 iter_type put(iter_type s, bool intl, ios_base& f, char_type fill, const string_type& quant) const;
 ```
+*Returns:* `do_put(s, intl, f, fill, quant)`.
+###### Virtual functions <a id="locale.money.put.virtuals">[[locale.money.put.virtuals]]</a>
 ``` cpp
 iter_type do_put(iter_type s, bool intl, ios_base& str,
                  char_type fill, long double units) const;
 iter_type do_put(iter_type s, bool intl, ios_base& str,
 [*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:
 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.[^18]
 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.
 The placement of thousands-separator characters (if any) is determined
 by the value returned by `grouping()`, defined identically as the member
 `numpunct<>::do_grouping()`.
+###### Members <a id="locale.moneypunct.members">[[locale.moneypunct.members]]</a>
 ``` cpp
 charT       decimal_point() const;
 charT       thousands_sep() const;
 string      grouping()      const;
 ```
 Each of these functions `F` returns the result of calling the
 corresponding virtual member function `do_F()`.
+###### Virtual functions <a id="locale.moneypunct.virtuals">[[locale.moneypunct.virtuals]]</a>
 ``` cpp
 charT do_decimal_point() const;
 ```
 *Returns:* The radix separator to use in case `do_frac_digits()` is
+greater than zero.[^19]
 ``` cpp
 charT do_thousands_sep() const;
 ```
 *Returns:* The digit group separator to use in case `do_grouping()`
+specifies a digit grouping pattern.[^20]
 ``` cpp
 string do_grouping() const;
 ```
 *Returns:* A pattern defined identically as, but not necessarily equal
+to, the result of `numpunct<charT>::do_grouping()`.[^21]
 ``` cpp
 string_type do_curr_symbol() const;
 ```
 *Returns:* A string to use as the currency identifier symbol.
+[*Note 2*: For specializations where the second template parameter is
 `true`, this is typically four characters long: a three-letter code as
 specified by ISO 4217 followed by a space. — *end note*]
 ``` cpp
 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;[^22]
 `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.[^23]
 ``` 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 }`.[^24]
+##### Class template `moneypunct_byname` <a id="locale.moneypunct.byname">[[locale.moneypunct.byname]]</a>
 ``` cpp
 namespace std {
   template<class charT, bool Intl = false>
     class moneypunct_byname : public moneypunct<charT, Intl> {
       ~moneypunct_byname();
     };
 }
 ```
+#### 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:
 ```
 Values of type `messages_base::catalog` usable as arguments to members
 `get` and `close` can be obtained only by calling member `open`.
+###### Members <a id="locale.messages.members">[[locale.messages.members]]</a>
 ``` cpp
 catalog open(const string& name, const locale& loc) const;
 ```
 void close(catalog cat) const;
 ```
 *Effects:* Calls `do_close(cat)`.
+###### Virtual functions <a id="locale.messages.virtuals">[[locale.messages.virtuals]]</a>
 ``` cpp
 catalog do_open(const string& name, const locale& loc) const;
 ```
 *Effects:* Releases unspecified resources associated with `cat`.
 *Remarks:* The limit on such resources, if any, is
 *implementation-defined*.
+##### Class template `messages_byname` <a id="locale.messages.byname">[[locale.messages.byname]]</a>
 ``` cpp
 namespace std {
   template<class charT>
     class messages_byname : public messages<charT> {

Diff to HTML by rtfpessoa