[localization] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpjm8xlqj3/{from.md → to.md} +199 -387

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

@@ -1,17 +1,17 @@
-# Localization library <a id="localization">[[localization]]</a>
-## General <a id="localization.general">[[localization.general]]</a>
-This Clause describes components that C++ programs may use to
-encapsulate (and therefore be more portable when confronting) cultural
-differences. The locale facility includes internationalization support
-for character classification and string collation, numeric, monetary,
-and date/time formatting and parsing, and message retrieval.
 The following subclauses describe components for locales themselves, the
-standard facets, and facilities from the ISO C library, as summarized in
 [[localization.summary]].
 **Table: Localization library summary** <a id="localization.summary">[localization.summary]</a>
 | Subclause             |                              | Header      |
@@ -19,11 +19,11 @@ standard facets, and facilities from the ISO C library, as summarized in
 | [[locales]]           | Locales                      | `<locale>`  |
 | [[locale.categories]] | Standard `locale` categories |             |
 | [[c.locales]]         | C library locales            | `<clocale>` |
-## Header `<locale>` synopsis <a id="locale.syn">[[locale.syn]]</a>
 ``` cpp
 namespace std {
   // [locale], locale
   class locale;
@@ -99,54 +99,58 @@ namespace std {
 ```
 The header `<locale>` defines classes and declares functions that
 encapsulate and manipulate the information peculiar to a locale.[^1]
-## Locales <a id="locales">[[locales]]</a>
-### Class `locale` <a id="locale">[[locale]]</a>
-#### General <a id="locale.general">[[locale.general]]</a>
 ``` cpp
 namespace std {
   class locale {
   public:
-    // types
     class facet;
     class id;
     using category = int;
     static const category   // values assigned here are for exposition only
       none     = 0,
       collate  = 0x010, ctype    = 0x020,
       monetary = 0x040, numeric  = 0x080,
       time     = 0x100, messages = 0x200,
       all = collate | ctype | monetary | numeric | time | messages;
-    // construct/copy/destroy
     locale() noexcept;
     locale(const locale& other) noexcept;
     explicit locale(const char* std_name);
     explicit locale(const string& std_name);
     locale(const locale& other, const char* std_name, category);
     locale(const locale& other, const string& std_name, category);
     template<class Facet> locale(const locale& other, Facet* f);
     locale(const locale& other, const locale& one, category);
     ~locale();                  // not virtual
     const locale& operator=(const locale& other) noexcept;
     template<class Facet> locale combine(const locale& other) const;
-    // locale operations
     string name() const;
     bool operator==(const locale& other) const;
     template<class charT, class traits, class Allocator>
       bool operator()(const basic_string<charT, traits, Allocator>& s1,
                       const basic_string<charT, traits, Allocator>& s2) const;
-    // global locale objects
     static       locale  global(const locale&);
     static const locale& classic();
   };
 }
 ```
@@ -227,13 +231,13 @@ global locale object per thread is *implementation-defined*.
 Implementations should provide one global locale object per thread. If
 there is a single global locale object for the entire program,
 implementations are not required to avoid data races on it
 [[res.on.data.races]].
-#### Types <a id="locale.types">[[locale.types]]</a>
-##### Type `locale::category` <a id="locale.category">[[locale.category]]</a>
 ``` cpp
 using category = int;
 ```
@@ -263,12 +267,10 @@ including at least those shown in [[locale.category.facets]].
 | Category | Includes facets                                       |
 | -------- | ----------------------------------------------------- |
 | collate  | `collate<char>`, `collate<wchar_t>`                   |
 | ctype    | `ctype<char>`, `ctype<wchar_t>`                       |
 |          | `codecvt<char, char, mbstate_t>`                      |
-|          | `codecvt<char16_t, char8_t, mbstate_t>`               |
-|          | `codecvt<char32_t, char8_t, mbstate_t>`               |
 |          | `codecvt<wchar_t, char, mbstate_t>`                   |
 | monetary | `moneypunct<char>`, `moneypunct<wchar_t>`             |
 |          | `moneypunct<char, true>`, `moneypunct<wchar_t, true>` |
 |          | `money_get<char>`, `money_get<wchar_t>`               |
 |          | `money_put<char>`, `money_put<wchar_t>`               |
@@ -295,12 +297,10 @@ templates identified as members of a category, and for those shown in
 | Category | Includes facets                                           |
 | -------- | --------------------------------------------------------- |
 | collate  | `collate_byname<char>`, `collate_byname<wchar_t>`         |
 | ctype    | `ctype_byname<char>`, `ctype_byname<wchar_t>`             |
 |          | `codecvt_byname<char, char, mbstate_t>`                   |
-|          | `codecvt_byname<char16_t, char8_t, mbstate_t>`            |
-|          | `codecvt_byname<char32_t, char8_t, mbstate_t>`            |
 |          | `codecvt_byname<wchar_t, char, mbstate_t>`                |
 | monetary | `moneypunct_byname<char, International>`                  |
 |          | `moneypunct_byname<wchar_t, International>`               |
 |          | `money_get<C, InputIterator>`                             |
 |          | `money_put<C, OutputIterator>`                            |
@@ -327,16 +327,17 @@ In declarations of facets, a template parameter with name
 `InputIterator` or `OutputIterator` indicates the set of all possible
 specializations on parameters that meet the *Cpp17InputIterator*
 requirements or *Cpp17OutputIterator* requirements, respectively
 [[iterator.requirements]]. A template parameter with name `C` represents
 the set of types containing `char`, `wchar_t`, and any other
-*implementation-defined* character types that meet the requirements for
-a character on which any of the iostream components can be instantiated.
-A template parameter with name `International` represents the set of all
-possible specializations on a bool parameter.
-##### Class `locale::facet` <a id="locale.facet">[[locale.facet]]</a>
 ``` cpp
 namespace std {
   class locale::facet {
   protected:
@@ -371,11 +372,11 @@ For `refs == 0`, the implementation performs
 facet) when the last `locale` object containing the facet is destroyed;
 for `refs == 1`, the implementation never destroys the facet.
 Constructors of all facets defined in this Clause take such an argument
 and pass it along to their `facet` base class constructor. All
-one-argument constructors defined in this Clause are *explicit*,
 preventing their participation in implicit conversions.
 For some standard facets a standard “…`_byname`” class, derived from it,
 implements the virtual function semantics equivalent to that facet of
 the locale constructed by `locale(const char*)` with the same name. Each
@@ -386,11 +387,11 @@ takes a `string` argument `str` and a `refs` argument, which has the
 same effect as calling the first constructor with the two arguments
 `str.c_str()` and `refs`. If there is no “…`_byname`” version of a
 facet, the base class implements named locale semantics itself by
 reference to other facets.
-##### Class `locale::id` <a id="locale.id">[[locale.id]]</a>
 ``` cpp
 namespace std {
   class locale::id {
   public:
@@ -403,19 +404,19 @@ namespace std {
 The class `locale::id` provides identification of a locale facet
 interface, used as an index for lookup and to encapsulate
 initialization.
-[*Note 1*: Because facets are used by iostreams, potentially while
 static constructors are running, their initialization cannot depend on
 programmed static initialization. One initialization strategy is for
 `locale` to initialize each facet’s `id` member the first time an
 instance of the facet is installed into a locale. This depends only on
 static storage being zero before constructors run
 [[basic.start.static]]. — *end note*]
-#### Constructors and destructor <a id="locale.cons">[[locale.cons]]</a>
 ``` cpp
 locale() noexcept;
 ```
@@ -501,11 +502,11 @@ const locale& operator=(const locale& other) noexcept;
 *Effects:* Creates a copy of `other`, replacing the current value.
 *Returns:* `*this`.
-#### Members <a id="locale.members">[[locale.members]]</a>
 ``` cpp
 template<class Facet> locale combine(const locale& other) const;
 ```
@@ -523,11 +524,21 @@ string name() const;
 ```
 *Returns:* The name of `*this`, if it has one; otherwise, the string
 `"*"`.
-#### Operators <a id="locale.operators">[[locale.operators]]</a>
 ``` cpp
 bool operator==(const locale& other) const;
 ```
@@ -539,16 +550,17 @@ copy of the other, or each has a name and the names are identical;
 template<class charT, class traits, class Allocator>
   bool operator()(const basic_string<charT, traits, Allocator>& s1,
                   const basic_string<charT, traits, Allocator>& s2) const;
 ```
-*Effects:* Compares two strings according to the `collate<charT>` facet.
 *Returns:*
 ``` cpp
-use_facet<collate<charT>>(*this).compare(s1.data(), s1.data() + s1.size(),
                                               s2.data(), s2.data() + s2.size()) < 0
 ```
 *Remarks:* This member operator template (and therefore `locale` itself)
 meets the requirements for a comparator predicate template
@@ -563,11 +575,11 @@ locale `loc` simply by [[alg.sort]], [[vector]]:
 std::sort(v.begin(), v.end(), loc);
 ```
 — *end example*]
-#### Static members <a id="locale.statics">[[locale.statics]]</a>
 ``` cpp
 static locale global(const locale& loc);
 ```
@@ -585,11 +597,11 @@ otherwise, the effect on the C locale, if any, is
 *Returns:* The previous value of `locale()`.
 *Remarks:* No library function other than `locale::global()` affects the
 value returned by `locale()`.
-[*Note 1*: See  [[c.locales]] for data race considerations when
 `setlocale` is invoked. — *end note*]
 ``` cpp
 static const locale& classic();
 ```
@@ -600,11 +612,11 @@ The `"C"` locale.
 equivalent to the value `locale("C")`.
 *Remarks:* This locale, its facets, and their member functions, do not
 change with time.
-### `locale` globals <a id="locale.global.templates">[[locale.global.templates]]</a>
 ``` cpp
 template<class Facet> const Facet& use_facet(const locale& loc);
 ```
@@ -623,13 +635,13 @@ template<class Facet> bool has_facet(const locale& loc) noexcept;
 ```
 *Returns:* `true` if the facet requested is present in `loc`; otherwise
 `false`.
-### Convenience interfaces <a id="locale.convenience">[[locale.convenience]]</a>
-#### Character classification <a id="classification">[[classification]]</a>
 ``` cpp
 template<class charT> bool isspace (charT c, const locale& loc);
 template<class charT> bool isprint (charT c, const locale& loc);
 template<class charT> bool iscntrl (charT c, const locale& loc);
@@ -651,11 +663,11 @@ use_facet<ctype<charT>>(loc).is(ctype_base::F, c)
 ```
 where `F` is the `ctype_base::mask` value corresponding to that function
 [[category.ctype]].[^4]
-#### Character conversions <a id="conversions.character">[[conversions.character]]</a>
 ``` cpp
 template<class charT> charT toupper(charT c, const locale& loc);
 ```
@@ -665,13 +677,13 @@ template<class charT> charT toupper(charT c, const locale& loc);
 template<class charT> charT tolower(charT c, const locale& loc);
 ```
 *Returns:* `use_facet<ctype<charT>>(loc).tolower(c)`.
-## 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
@@ -685,45 +697,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 {
@@ -774,11 +786,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;
 ```
@@ -796,11 +808,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)`.
@@ -823,11 +835,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;
 ```
@@ -899,11 +911,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]`.
@@ -942,30 +954,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 {
@@ -1015,20 +1027,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.
@@ -1111,21 +1123,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;
@@ -1139,13 +1151,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:
@@ -1213,23 +1225,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,
@@ -1277,11 +1286,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,
@@ -1303,13 +1312,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
@@ -1420,14 +1429,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;
@@ -1436,11 +1445,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> {
@@ -1452,13 +1461,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]
@@ -1476,13 +1485,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 {
@@ -1546,11 +1555,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,
@@ -1575,11 +1584,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,
@@ -1604,17 +1613,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*:
@@ -1664,12 +1673,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
@@ -1677,13 +1686,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 {
@@ -1719,11 +1728,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;
@@ -1734,11 +1743,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;
@@ -1817,11 +1826,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`               |
@@ -1943,15 +1953,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 {
@@ -2040,11 +2050,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;
 ```
@@ -2067,11 +2077,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;
 ```
@@ -2109,11 +2119,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> {
@@ -2129,15 +2139,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 {
@@ -2174,11 +2184,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;
 ```
@@ -2195,11 +2205,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;
 ```
@@ -2229,11 +2239,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> {
@@ -2247,13 +2257,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
@@ -2261,13 +2271,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:
@@ -2329,11 +2339,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;
 ```
@@ -2422,11 +2432,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;
 ```
@@ -2540,11 +2550,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> {
@@ -2559,11 +2569,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 {
@@ -2587,11 +2599,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,
@@ -2606,27 +2618,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;
 ```
@@ -2637,26 +2647,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> {
@@ -2671,13 +2681,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`
@@ -2686,11 +2696,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 {
@@ -2718,22 +2730,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,
@@ -2743,18 +2755,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*]
@@ -2795,11 +2807,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;
@@ -2816,11 +2828,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 {
@@ -2846,20 +2860,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,
@@ -2904,13 +2918,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:
@@ -2956,11 +2970,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.
@@ -3023,11 +3037,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;
@@ -3040,60 +3054,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;
 ```
@@ -3105,13 +3119,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> {
@@ -3126,20 +3140,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:
@@ -3172,11 +3186,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;
 ```
@@ -3192,11 +3206,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;
 ```
@@ -3231,11 +3245,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> {
@@ -3250,13 +3264,13 @@ namespace std {
       ~messages_byname();
     };
 }
 ```
-## C library locales <a id="c.locales">[[c.locales]]</a>
-### Header `<clocale>` synopsis <a id="clocale.syn">[[clocale.syn]]</a>
 ``` cpp
 namespace std {
   struct lconv;
@@ -3274,11 +3288,11 @@ namespace std {
 ```
 The contents and meaning of the header `<clocale>` are the same as the C
 standard library header `<locale.h>`.
-### Data races <a id="clocale.data.races">[[clocale.data.races]]</a>
 Calls to the function `setlocale` may introduce a data race
 [[res.on.data.races]] with other calls to `setlocale` or with calls to
 the functions listed in [[setlocale.data.races]].
@@ -3297,207 +3311,5 @@ See also: ISO C 7.11
 | `isdigit` | `iswblank` | `iswupper`  | `strerror`   | `wcstombs` |
 | `isgraph` | `iswcntrl` | `iswxdigit` | `strtod`     | `wcsxfrm`  |
 | `islower` | `iswctype` | `isxdigit`  | `strxfrm`    | `wctomb`   |
-<!-- Link reference definitions -->
-[alg.lex.comparison]: algorithms.md#alg.lex.comparison
-[alg.sort]: algorithms.md#alg.sort
-[algorithms]: algorithms.md#algorithms
-[basic.start.static]: basic.md#basic.start.static
-[bitmask.types]: library.md#bitmask.types
-[c.files]: input.md#c.files
-[c.locales]: #c.locales
-[category.collate]: #category.collate
-[category.ctype]: #category.ctype
-[category.ctype.general]: #category.ctype.general
-[category.messages]: #category.messages
-[category.messages.general]: #category.messages.general
-[category.monetary]: #category.monetary
-[category.monetary.general]: #category.monetary.general
-[category.numeric]: #category.numeric
-[category.numeric.general]: #category.numeric.general
-[category.time]: #category.time
-[category.time.general]: #category.time.general
-[classification]: #classification
-[clocale.data.races]: #clocale.data.races
-[clocale.syn]: #clocale.syn
-[conversions.character]: #conversions.character
-[facet.ctype.char.dtor]: #facet.ctype.char.dtor
-[facet.ctype.char.members]: #facet.ctype.char.members
-[facet.ctype.char.statics]: #facet.ctype.char.statics
-[facet.ctype.char.virtuals]: #facet.ctype.char.virtuals
-[facet.ctype.special]: #facet.ctype.special
-[facet.ctype.special.general]: #facet.ctype.special.general
-[facet.num.get.members]: #facet.num.get.members
-[facet.num.get.virtuals]: #facet.num.get.virtuals
-[facet.num.put.members]: #facet.num.put.members
-[facet.num.put.virtuals]: #facet.num.put.virtuals
-[facet.numpunct]: #facet.numpunct
-[facet.numpunct.members]: #facet.numpunct.members
-[facet.numpunct.virtuals]: #facet.numpunct.virtuals
-[file.streams]: input.md#file.streams
-[ios.base]: input.md#ios.base
-[istream.formatted]: input.md#istream.formatted
-[istream.formatted.reqmts]: input.md#istream.formatted.reqmts
-[iterator.requirements]: iterators.md#iterator.requirements
-[lex.charset]: lex.md#lex.charset
-[locale]: #locale
-[locale.categories]: #locale.categories
-[locale.categories.general]: #locale.categories.general
-[locale.category]: #locale.category
-[locale.category.facets]: #locale.category.facets
-[locale.codecvt]: #locale.codecvt
-[locale.codecvt.byname]: #locale.codecvt.byname
-[locale.codecvt.general]: #locale.codecvt.general
-[locale.codecvt.inout]: #locale.codecvt.inout
-[locale.codecvt.members]: #locale.codecvt.members
-[locale.codecvt.unshift]: #locale.codecvt.unshift
-[locale.codecvt.virtuals]: #locale.codecvt.virtuals
-[locale.collate]: #locale.collate
-[locale.collate.byname]: #locale.collate.byname
-[locale.collate.general]: #locale.collate.general
-[locale.collate.members]: #locale.collate.members
-[locale.collate.virtuals]: #locale.collate.virtuals
-[locale.cons]: #locale.cons
-[locale.convenience]: #locale.convenience
-[locale.ctype]: #locale.ctype
-[locale.ctype.byname]: #locale.ctype.byname
-[locale.ctype.general]: #locale.ctype.general
-[locale.ctype.members]: #locale.ctype.members
-[locale.ctype.virtuals]: #locale.ctype.virtuals
-[locale.facet]: #locale.facet
-[locale.general]: #locale.general
-[locale.global.templates]: #locale.global.templates
-[locale.id]: #locale.id
-[locale.members]: #locale.members
-[locale.messages]: #locale.messages
-[locale.messages.byname]: #locale.messages.byname
-[locale.messages.general]: #locale.messages.general
-[locale.messages.members]: #locale.messages.members
-[locale.messages.virtuals]: #locale.messages.virtuals
-[locale.money.get]: #locale.money.get
-[locale.money.get.members]: #locale.money.get.members
-[locale.money.get.virtuals]: #locale.money.get.virtuals
-[locale.money.put]: #locale.money.put
-[locale.money.put.members]: #locale.money.put.members
-[locale.money.put.virtuals]: #locale.money.put.virtuals
-[locale.moneypunct]: #locale.moneypunct
-[locale.moneypunct.byname]: #locale.moneypunct.byname
-[locale.moneypunct.general]: #locale.moneypunct.general
-[locale.moneypunct.members]: #locale.moneypunct.members
-[locale.moneypunct.virtuals]: #locale.moneypunct.virtuals
-[locale.nm.put]: #locale.nm.put
-[locale.nm.put.general]: #locale.nm.put.general
-[locale.num.get]: #locale.num.get
-[locale.num.get.general]: #locale.num.get.general
-[locale.numpunct]: #locale.numpunct
-[locale.numpunct.byname]: #locale.numpunct.byname
-[locale.numpunct.general]: #locale.numpunct.general
-[locale.operators]: #locale.operators
-[locale.spec]: #locale.spec
-[locale.statics]: #locale.statics
-[locale.syn]: #locale.syn
-[locale.time.get]: #locale.time.get
-[locale.time.get.byname]: #locale.time.get.byname
-[locale.time.get.dogetdate]: #locale.time.get.dogetdate
-[locale.time.get.general]: #locale.time.get.general
-[locale.time.get.members]: #locale.time.get.members
-[locale.time.get.virtuals]: #locale.time.get.virtuals
-[locale.time.put]: #locale.time.put
-[locale.time.put.byname]: #locale.time.put.byname
-[locale.time.put.members]: #locale.time.put.members
-[locale.time.put.virtuals]: #locale.time.put.virtuals
-[locale.types]: #locale.types
-[locales]: #locales
-[localization]: #localization
-[localization.general]: #localization.general
-[localization.summary]: #localization.summary
-[ostream.formatted.reqmts]: input.md#ostream.formatted.reqmts
-[res.on.data.races]: library.md#res.on.data.races
-[sequence.reqmts]: containers.md#sequence.reqmts
-[setlocale.data.races]: #setlocale.data.races
-[tab:locale.category.facets]: #tab:locale.category.facets
-[tab:locale.spec]: #tab:locale.spec
-[vector]: containers.md#vector
-[^1]: In this subclause, the type name `tm` is an incomplete type that
-    is defined in `<ctime>`.
-[^2]: Note that in the call to `put`, the stream is implicitly converted
-    to an `ostreambuf_iterator<charT, traits>`.
-[^3]: This is a complete list of requirements; there are no other
-    requirements. Thus, a facet class need not have a public copy
-    constructor, assignment, default constructor, destructor, etc.
-[^4]: When used in a loop, it is faster to cache the `ctype<>` facet and
-    use it directly, or use the vector form of `ctype<>::is`.
-[^5]: The parameter `c` of `do_widen` is intended to accept values
-    derived from *character-literal*s for conversion to the locale’s
-    encoding.
-[^6]: In other words, the transformed character is not a member of any
-    character classification that `c` is not also a member of.
-[^7]: Only the `char` (not `unsigned char` and `signed char`) form is
-    provided. The specialization is specified in the standard, and not
-    left as an implementation detail, because it affects the derivation
-    interface for `ctype<char>`.
-[^8]: Informally, this means that `basic_filebuf` assumes that the
-    mappings from internal to external characters is 1 to N: that a
-    `codecvt` facet that is used by `basic_filebuf` can translate
-    characters one internal character at a time.
-[^9]: Typically these will be characters to return the state to
-    `stateT()`.
-[^10]: If `encoding()` yields `-1`, then more than `max_length()`
-    `externT` elements can be consumed when producing a single `internT`
-    character, and additional `externT` elements can appear at the end
-    of a sequence after those that yield the final `internT` character.
-[^11]: Parsing `"-1"` correctly into, e.g., an `unsigned short` requires
-    that the corresponding member `get()` at least extract the sign
-    before delegating.
-[^12]: The conversion specification `#o` generates a leading `0` which
-    is *not* a padding character.
-[^13]: Thus, the string `"\003"` specifies groups of 3 digits each, and
-    `"3"` probably indicates groups of 51 (!) digits each, because 51 is
-    the ASCII value of `"3"`.
-[^14]: This function is useful when one string is being compared to many
-    other strings.
-[^15]: In other words, user confirmation is required for reliable
-    parsing of user-entered dates and times, but machine-generated
-    formats can be parsed reliably. This allows parsers to be aggressive
-    about interpreting user variations on standard formats.
-[^16]: This function is intended as a convenience only, for common
-    formats, and can return `no_order` in valid locales.
-[^17]: Although the C programming language defines no modifiers, most
-    vendors do.
-[^18]: The semantics here are different from `ct.narrow`.
-[^19]: An array of `char`, rather than an array of `part`, is specified
-    for `pattern::field` purely for efficiency.
-[^20]: In common U.S. locales this is `’.’`.
-[^21]: In common U.S. locales this is `’,’`.
-[^22]: To specify grouping by 3s, the value is `"\003"` *not* `"3"`.
-[^23]: This is usually the empty string.
-[^24]: In common U.S. locales, this is 2.
-[^25]: Note that the international symbol returned by `do_curr_symbol()`
-    usually contains a space, itself; for example, `"USD "`.

+## Localization library <a id="localization">[[localization]]</a>
+### General <a id="localization.general">[[localization.general]]</a>
+Subclause [[localization]] describes components that C++ programs may
+use to encapsulate (and therefore be more portable when confronting)
+cultural differences. The locale facility includes internationalization
+support for character classification and string collation, numeric,
+monetary, and date/time formatting and parsing, and message retrieval.
 The following subclauses describe components for locales themselves, the
+standard facets, and facilities from the C library, as summarized in
 [[localization.summary]].
 **Table: Localization library summary** <a id="localization.summary">[localization.summary]</a>
 | Subclause             |                              | Header      |
 | [[locales]]           | Locales                      | `<locale>`  |
 | [[locale.categories]] | Standard `locale` categories |             |
 | [[c.locales]]         | C library locales            | `<clocale>` |
+### Header `<locale>` synopsis <a id="locale.syn">[[locale.syn]]</a>
 ``` cpp
 namespace std {
   // [locale], locale
   class locale;
 ```
 The header `<locale>` defines classes and declares functions that
 encapsulate and manipulate the information peculiar to a locale.[^1]
+### Locales <a id="locales">[[locales]]</a>
+#### Class `locale` <a id="locale">[[locale]]</a>
+##### General <a id="locale.general">[[locale.general]]</a>
 ``` cpp
 namespace std {
   class locale {
   public:
+    // [locale.types], types
+    // [locale.facet], class locale::facet
     class facet;
+    // [locale.id], class locale::id
     class id;
+    // [locale.category], type locale::category
     using category = int;
     static const category   // values assigned here are for exposition only
       none     = 0,
       collate  = 0x010, ctype    = 0x020,
       monetary = 0x040, numeric  = 0x080,
       time     = 0x100, messages = 0x200,
       all = collate | ctype | monetary | numeric | time | messages;
+    // [locale.cons], construct/copy/destroy
     locale() noexcept;
     locale(const locale& other) noexcept;
     explicit locale(const char* std_name);
     explicit locale(const string& std_name);
     locale(const locale& other, const char* std_name, category);
     locale(const locale& other, const string& std_name, category);
     template<class Facet> locale(const locale& other, Facet* f);
     locale(const locale& other, const locale& one, category);
     ~locale();                  // not virtual
     const locale& operator=(const locale& other) noexcept;
+    // [locale.members], locale operations
     template<class Facet> locale combine(const locale& other) const;
     string name() const;
+    text_encoding encoding() const;
     bool operator==(const locale& other) const;
     template<class charT, class traits, class Allocator>
       bool operator()(const basic_string<charT, traits, Allocator>& s1,
                       const basic_string<charT, traits, Allocator>& s2) const;
+    // [locale.statics], global locale objects
     static       locale  global(const locale&);
     static const locale& classic();
   };
 }
 ```
 Implementations should provide one global locale object per thread. If
 there is a single global locale object for the entire program,
 implementations are not required to avoid data races on it
 [[res.on.data.races]].
+##### Types <a id="locale.types">[[locale.types]]</a>
+###### Type `locale::category` <a id="locale.category">[[locale.category]]</a>
 ``` cpp
 using category = int;
 ```
 | Category | Includes facets                                       |
 | -------- | ----------------------------------------------------- |
 | collate  | `collate<char>`, `collate<wchar_t>`                   |
 | ctype    | `ctype<char>`, `ctype<wchar_t>`                       |
 |          | `codecvt<char, char, mbstate_t>`                      |
 |          | `codecvt<wchar_t, char, mbstate_t>`                   |
 | monetary | `moneypunct<char>`, `moneypunct<wchar_t>`             |
 |          | `moneypunct<char, true>`, `moneypunct<wchar_t, true>` |
 |          | `money_get<char>`, `money_get<wchar_t>`               |
 |          | `money_put<char>`, `money_put<wchar_t>`               |
 | Category | Includes facets                                           |
 | -------- | --------------------------------------------------------- |
 | collate  | `collate_byname<char>`, `collate_byname<wchar_t>`         |
 | ctype    | `ctype_byname<char>`, `ctype_byname<wchar_t>`             |
 |          | `codecvt_byname<char, char, mbstate_t>`                   |
 |          | `codecvt_byname<wchar_t, char, mbstate_t>`                |
 | monetary | `moneypunct_byname<char, International>`                  |
 |          | `moneypunct_byname<wchar_t, International>`               |
 |          | `money_get<C, InputIterator>`                             |
 |          | `money_put<C, OutputIterator>`                            |
 `InputIterator` or `OutputIterator` indicates the set of all possible
 specializations on parameters that meet the *Cpp17InputIterator*
 requirements or *Cpp17OutputIterator* requirements, respectively
 [[iterator.requirements]]. A template parameter with name `C` represents
 the set of types containing `char`, `wchar_t`, and any other
+*implementation-defined* character container types
+[[defns.character.container]] that meet the requirements for a character
+on which any of the iostream components can be instantiated. A template
+parameter with name `International` represents the set of all possible
+specializations on a bool parameter.
+###### Class `locale::facet` <a id="locale.facet">[[locale.facet]]</a>
 ``` cpp
 namespace std {
   class locale::facet {
   protected:
 facet) when the last `locale` object containing the facet is destroyed;
 for `refs == 1`, the implementation never destroys the facet.
 Constructors of all facets defined in this Clause take such an argument
 and pass it along to their `facet` base class constructor. All
+one-argument constructors defined in this Clause are explicit,
 preventing their participation in implicit conversions.
 For some standard facets a standard “…`_byname`” class, derived from it,
 implements the virtual function semantics equivalent to that facet of
 the locale constructed by `locale(const char*)` with the same name. Each
 same effect as calling the first constructor with the two arguments
 `str.c_str()` and `refs`. If there is no “…`_byname`” version of a
 facet, the base class implements named locale semantics itself by
 reference to other facets.
+###### Class `locale::id` <a id="locale.id">[[locale.id]]</a>
 ``` cpp
 namespace std {
   class locale::id {
   public:
 The class `locale::id` provides identification of a locale facet
 interface, used as an index for lookup and to encapsulate
 initialization.
+[*Note 2*: Because facets are used by iostreams, potentially while
 static constructors are running, their initialization cannot depend on
 programmed static initialization. One initialization strategy is for
 `locale` to initialize each facet’s `id` member the first time an
 instance of the facet is installed into a locale. This depends only on
 static storage being zero before constructors run
 [[basic.start.static]]. — *end note*]
+##### Constructors and destructor <a id="locale.cons">[[locale.cons]]</a>
 ``` cpp
 locale() noexcept;
 ```
 *Effects:* Creates a copy of `other`, replacing the current value.
 *Returns:* `*this`.
+##### Members <a id="locale.members">[[locale.members]]</a>
 ``` cpp
 template<class Facet> locale combine(const locale& other) const;
 ```
 ```
 *Returns:* The name of `*this`, if it has one; otherwise, the string
 `"*"`.
+``` cpp
+text_encoding encoding() const;
+```
+*Mandates:* `CHAR_BIT == 8` is `true`.
+*Returns:* A `text_encoding` object representing the
+implementation-defined encoding scheme associated with the locale
+`*this`.
+##### Operators <a id="locale.operators">[[locale.operators]]</a>
 ``` cpp
 bool operator==(const locale& other) const;
 ```
 template<class charT, class traits, class Allocator>
   bool operator()(const basic_string<charT, traits, Allocator>& s1,
                   const basic_string<charT, traits, Allocator>& s2) const;
 ```
+*Effects:* Compares two strings according to the `std::collate<charT>`
+facet.
 *Returns:*
 ``` cpp
+use_facet<std::collate<charT>>(*this).compare(s1.data(), s1.data() + s1.size(),
                                               s2.data(), s2.data() + s2.size()) < 0
 ```
 *Remarks:* This member operator template (and therefore `locale` itself)
 meets the requirements for a comparator predicate template
 std::sort(v.begin(), v.end(), loc);
 ```
 — *end example*]
+##### Static members <a id="locale.statics">[[locale.statics]]</a>
 ``` cpp
 static locale global(const locale& loc);
 ```
 *Returns:* The previous value of `locale()`.
 *Remarks:* No library function other than `locale::global()` affects the
 value returned by `locale()`.
+[*Note 2*: See  [[c.locales]] for data race considerations when
 `setlocale` is invoked. — *end note*]
 ``` cpp
 static const locale& classic();
 ```
 equivalent to the value `locale("C")`.
 *Remarks:* This locale, its facets, and their member functions, do not
 change with time.
+#### `locale` globals <a id="locale.global.templates">[[locale.global.templates]]</a>
 ``` cpp
 template<class Facet> const Facet& use_facet(const locale& loc);
 ```
 ```
 *Returns:* `true` if the facet requested is present in `loc`; otherwise
 `false`.
+#### Convenience interfaces <a id="locale.convenience">[[locale.convenience]]</a>
+##### Character classification <a id="classification">[[classification]]</a>
 ``` cpp
 template<class charT> bool isspace (charT c, const locale& loc);
 template<class charT> bool isprint (charT c, const locale& loc);
 template<class charT> bool iscntrl (charT c, const locale& loc);
 ```
 where `F` is the `ctype_base::mask` value corresponding to that function
 [[category.ctype]].[^4]
+##### Character conversions <a id="conversions.character">[[conversions.character]]</a>
 ``` cpp
 template<class charT> charT toupper(charT c, const locale& loc);
 ```
 template<class charT> charT tolower(charT c, const locale& loc);
 ```
 *Returns:* `use_facet<ctype<charT>>(loc).tolower(c)`.
+### 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> {
       ~messages_byname();
     };
 }
 ```
+### C library locales <a id="c.locales">[[c.locales]]</a>
+#### Header `<clocale>` synopsis <a id="clocale.syn">[[clocale.syn]]</a>
 ``` cpp
 namespace std {
   struct lconv;
 ```
 The contents and meaning of the header `<clocale>` are the same as the C
 standard library header `<locale.h>`.
+#### Data races <a id="clocale.data.races">[[clocale.data.races]]</a>
 Calls to the function `setlocale` may introduce a data race
 [[res.on.data.races]] with other calls to `setlocale` or with calls to
 the functions listed in [[setlocale.data.races]].
 | `isdigit` | `iswblank` | `iswupper`  | `strerror`   | `wcstombs` |
 | `isgraph` | `iswcntrl` | `iswxdigit` | `strtod`     | `wcsxfrm`  |
 | `islower` | `iswctype` | `isxdigit`  | `strxfrm`    | `wctomb`   |

Diff to HTML by rtfpessoa