[localization] - C++17 → C++20

Files changed (1) hide show

tmp/tmp3jjhceud/{from.md → to.md} +363 -550

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

@@ -1,25 +1,25 @@
 # 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
-Table  [[tab:localization.lib.summary]].
-**Table: Localization library summary** <a id="tab:localization.lib.summary">[tab:localization.lib.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>
@@ -107,22 +107,22 @@ encapsulate and manipulate the information peculiar to a locale.[^1]
 ``` 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);
@@ -131,21 +131,20 @@ namespace std {
     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:
- basic_string<char>                  name() const;
     bool operator==(const locale& other) 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();
   };
 }
 ```
@@ -166,29 +165,29 @@ An iostream `operator<<` might be implemented as:[^2]
 template<class charT, class traits>
 basic_ostream<charT, traits>&
 operator<< (basic_ostream<charT, traits>& s, Date d) {
   typename basic_ostream<charT, traits>::sentry cerberos(s);
   if (cerberos) {
-    ios_base::iostate err = ios_base::iostate::goodbit;
     tm tmbuf; d.extract(tmbuf);
       use_facet<time_put<charT, ostreambuf_iterator<charT, traits>>>(
- s.getloc()).put(s, s, s.fill(), err, &tmbuf, 'x');
- s.setstate(err);            // might throw
   }
   return s;
 }
 ```
 — *end example*]
 In the call to `use_facet<Facet>(loc)`, the type argument chooses a
 facet, making available all members of the named type. If `Facet` is not
-present in a locale, it throws the standard exception `bad_cast`. A
-C++program can check if a locale implements a particular facet with the
 function template `has_facet<Facet>()`. User-defined facets may be
-installed in a locale, and used identically as may standard facets (
-[[facets.examples]]).
 [*Note 1*:
 All locale semantics are accessed via `use_facet<>` and `has_facet<>`,
 except that:
@@ -198,11 +197,11 @@ except that:
   is provided so that a locale may be used as a predicate argument to
   the standard collections, to collate strings.
 - Convenient global interfaces are provided for traditional `ctype`
   functions such as `isdigit()` and `isspace()`, so that given a locale
   object `loc` a C++ program can call `isspace(c, loc)`. (This eases
-  upgrading existing extractors ([[istream.formatted]]).)
 — *end note*]
 Once a facet reference is obtained from a locale object by calling
 `use_facet<>`, that reference remains usable, and the results from
@@ -220,14 +219,14 @@ of) itself. For an unnamed locale, `locale::name()` returns the string
 Whether there is one global locale object for the entire program or one
 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]]).
-#### `locale` types <a id="locale.types">[[locale.types]]</a>
 ##### Type `locale::category` <a id="locale.category">[[locale.category]]</a>
 ``` cpp
 using category = int;
@@ -252,22 +251,21 @@ category, represents the union of the two categories.
 member functions expecting a `category` argument require one of the
 `category` values defined above, or the union of two or more such
 values. Such a `category` value identifies a set of locale categories.
 Each locale category, in turn, identifies a set of locale facets,
-including at least those shown in Table
-[[tab:localization.category.facets]].
-**Table: Locale category facets** <a id="tab:localization.category.facets">[tab:localization.category.facets]</a>
 | Category | Includes facets                                       |
 | -------- | ----------------------------------------------------- |
 | collate  | `collate<char>`, `collate<wchar_t>`                   |
 | ctype    | `ctype<char>`, `ctype<wchar_t>`                       |
 |          | `codecvt<char, char, mbstate_t>`                      |
-|          | `codecvt<char16_t, char, mbstate_t>` |
-|          | `codecvt<char32_t, 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>`               |
@@ -278,28 +276,28 @@ including at least those shown in Table
 |          | `time_put<char>`, `time_put<wchar_t>`                 |
 | messages | `messages<char>`, `messages<wchar_t>`                 |
 For any locale `loc` either constructed, or returned by
-`locale::classic()`, and any facet `Facet` shown in Table
-[[tab:localization.category.facets]], `has_facet<Facet>(loc)` is `true`.
-Each `locale` member function which takes a `locale::category` argument
 operates on the corresponding set of facets.
 An implementation is required to provide those specializations for facet
 templates identified as members of a category, and for those shown in
-Table  [[tab:localization.required.specializations]].
-**Table: Required specializations** <a id="tab:localization.required.specializations">[tab:localization.required.specializations]</a>
 | 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, char, mbstate_t>` |
-|          | `codecvt_byname<char32_t, 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>`                            |
@@ -322,18 +320,18 @@ The provided implementation of members of facets `num_get<charT>` and
 obtained by calling member `getloc()` on the `ios_base&` argument to
 these functions.
 In declarations of facets, a template parameter with name
 `InputIterator` or `OutputIterator` indicates the set of all possible
-specializations on parameters that satisfy the requirements of an Input
-Iterator or an Output Iterator, 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 satisfy 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 {
@@ -359,11 +357,11 @@ static ::std::locale::id id;
 Template parameters in this Clause which are required to be facets are
 those named `Facet` in declarations. A program that passes a type that
 is *not* a facet, or a type that refers to a volatile-qualified facet,
 as an (explicit or deduced) template parameter to a locale function
 expecting a facet, is ill-formed. A const-qualified facet is a valid
-template argument to any locale function that expects a Facet template
 parameter.
 The `refs` argument to the constructor is used for lifetime management.
 For `refs == 0`, the implementation performs
 `delete static_cast<locale::facet*>(f)` (where `f` is a pointer to the
@@ -407,35 +405,27 @@ 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*]
-#### `locale` constructors and destructor <a id="locale.cons">[[locale.cons]]</a>
 ``` cpp
 locale() noexcept;
 ```
-Default constructor: a snapshot of the current global locale.
 *Effects:* Constructs a copy of the argument last passed to
 `locale::global(locale&)`, if it has been called; else, the resulting
 facets have virtual function semantics identical to those of
 `locale::classic()`.
-[*Note 1*: This constructor is commonly used as the default value for
-arguments of functions that take a `const locale&`
-argument. — *end note*]
-``` cpp
-locale(const locale& other) noexcept;
-```
-*Effects:* Constructs a locale which is a copy of `other`.
 ``` cpp
 explicit locale(const char* std_name);
 ```
@@ -500,17 +490,11 @@ const locale& operator=(const locale& other) noexcept;
 *Effects:* Creates a copy of `other`, replacing the current value.
 *Returns:* `*this`.
-``` cpp
-~locale();
-```
-A non-virtual destructor that throws no exceptions.
-#### `locale` members <a id="locale.members">[[locale.members]]</a>
 ``` cpp
 template<class Facet> locale combine(const locale& other) const;
 ```
@@ -522,43 +506,37 @@ except for that one facet of `other` that is identified by `Facet`.
 *Throws:* `runtime_error` if `has_facet<Facet>(other)` is `false`.
 *Remarks:* The resulting locale has no name.
 ``` cpp
-basic_string<char> name() const;
 ```
 *Returns:* The name of `*this`, if it has one; otherwise, the string
 `"*"`.
-#### `locale` operators <a id="locale.operators">[[locale.operators]]</a>
 ``` cpp
 bool operator==(const locale& other) const;
 ```
 *Returns:* `true` if both arguments are the same locale, or one is a
 copy of the other, or each has a name and the names are identical;
 `false` otherwise.
-``` cpp
-bool operator!=(const locale& other) const;
-```
-*Returns:* `!(*this == other)`.
 ``` cpp
 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.
 *Remarks:* This member operator template (and therefore `locale` itself)
-satisfies requirements for a comparator predicate template argument
-(Clause  [[algorithms]]) applied to strings.
 *Returns:*
 ``` cpp
 use_facet<collate<charT>>(*this).compare(s1.data(), s1.data() + s1.size(),
@@ -574,28 +552,29 @@ locale `loc` simply by ([[alg.sort]], [[vector]]):
 std::sort(v.begin(), v.end(), loc);
 ```
 — *end example*]
-#### `locale` static members <a id="locale.statics">[[locale.statics]]</a>
 ``` cpp
 static locale global(const locale& loc);
 ```
-Sets the global locale to its argument.
-*Effects:* Causes future calls to the constructor `locale()` to return a
-copy of the argument. If the argument has a name, does
 ``` cpp
 setlocale(LC_ALL, loc.name().c_str());
 ```
 otherwise, the effect on the C locale, if any, is
-*implementation-defined*. No library function other than
-`locale::global()` shall affect the value returned by `locale()`.
 [*Note 1*: See  [[c.locales]] for data race considerations when
 `setlocale` is invoked. — *end note*]
 *Returns:* The previous value of `locale()`.
@@ -616,11 +595,11 @@ change with time.
 ``` cpp
 template<class Facet> const Facet& use_facet(const locale& loc);
 ```
-*Requires:* `Facet` is a facet class whose definition contains the
 public static member `id` as defined in  [[locale.facet]].
 *Returns:* A reference to the corresponding facet of `loc`, if present.
 *Throws:* `bad_cast` if `has_facet<Facet>(loc)` is `false`.
@@ -658,12 +637,12 @@ Each of these functions `isF` returns the result of the expression:
 ``` cpp
 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]
 #### Conversions <a id="conversions">[[conversions]]</a>
 ##### Character conversions <a id="conversions.character">[[conversions.character]]</a>
@@ -684,17 +663,17 @@ template <class charT> charT tolower(charT c, const locale& loc);
 Each of the standard categories includes a family of facets. Some of
 these implement formatting or parsing of a datum, for use by standard or
 users’ iostream operators `<<` and `>>`, as members `put()` and `get()`,
 respectively. Each such member function takes an `ios_base&` argument
 whose members `flags()`, `precision()`, and `width()`, specify the
-format of the corresponding datum ([[ios.base]]). Those functions which
 need to use other facets call its member `getloc()` to retrieve the
 locale imbued there. Formatting facets use the character argument `fill`
 to fill out the specified width where necessary.
 The `put()` members make no provision for error reporting. (Any failures
-of the OutputIterator argument must be extracted from the returned
 iterator.) The `get()` members take an `ios_base::iostate&` argument
 whose value they ignore, but set to `ios_base::failbit` in case of a
 parse error.
 Within this clause it is unspecified whether one virtual function calls
@@ -704,11 +683,11 @@ another virtual function.
 ``` cpp
 namespace std {
   class ctype_base {
   public:
-    using mask = T;
     // numeric values are for exposition only.
     static const mask space  = 1 << 0;
     static const mask print  = 1 << 1;
     static const mask cntrl  = 1 << 2;
@@ -723,11 +702,11 @@ namespace std {
     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>
 ``` cpp
 namespace std {
@@ -775,35 +754,32 @@ namespace std {
 Class `ctype` encapsulates the C library `<cctype>` features. `istream`
 members are required to use `ctype<>` for character classing during
 input parsing.
-The specializations required in Table
-[[tab:localization.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_is(m, c)` or `do_is(low, high, vec)`.
 ``` cpp
-const charT* scan_is(mask m,
-                     const charT* low, const charT* high) const;
 ```
 *Returns:* `do_scan_is(m, low, high)`.
 ``` cpp
-const charT* scan_not(mask m,
-                      const charT* low, const charT* high) const;
 ```
 *Returns:* `do_scan_not(m, low, high)`.
 ``` cpp
@@ -827,22 +803,20 @@ const char* widen(const char* low, const char* high, charT* to) const;
 *Returns:* `do_widen(c)` or `do_widen(low, high, to)`.
 ``` cpp
 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;
 ```
 *Effects:* Classifies a character or sequence of characters. For each
 argument character, identifies a value `M` of type `ctype_base::mask`.
 The second form identifies a value `M` of type `ctype_base::mask` for
@@ -900,18 +874,17 @@ which a corresponding lower-case character exists, with that character.
 if it is known to exist, or its argument if not. The second form returns
 `high`.
 ``` cpp
 charT        do_widen(char c) const;
-const char*  do_widen(const char* low, const char* high,
-                      charT* dest) const;
 ```
 *Effects:* Applies the simplest reasonable transformation from a `char`
 value or sequence of `char` values to the corresponding `charT` value or
 values.[^5] The only characters for which unique transformations are
-required are those in the basic source character set ([[lex.charset]]).
 For any named `ctype` category with a `ctype <charT>` facet `ctc` and
 valid `ctype_base::mask` value `M`,
 `(ctc.is(M, c) || !is(M, do_widen(c)) )` is `true`.[^6]
@@ -921,20 +894,19 @@ The second form transforms each character `*p` in the range \[`low`,
 *Returns:* The first form returns the transformed value. The second form
 returns `high`.
 ``` cpp
 char         do_narrow(charT c, char dfault) const;
-const charT* do_narrow(const charT* low, const charT* high,
-                       char dfault, char* dest) const;
 ```
 *Effects:* Applies the simplest reasonable transformation from a `charT`
 value or sequence of `charT` values to the corresponding `char` value or
 values.
-For any character `c` in the basic source character
-set ([[lex.charset]]) the transformation is such that
 ``` cpp
 do_widen(do_narrow(c, 0)) == c
 ```
@@ -963,45 +935,42 @@ namespace std {
     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` specializations <a id="facet.ctype.special">[[facet.ctype.special]]</a>
 ``` cpp
 namespace std {
   template<>
     class ctype<char> : public locale::facet, public ctype_base {
     public:
       using char_type = char;
-      explicit ctype(const mask* tab = 0, bool del = false,
-                     size_t refs = 0);
       bool is(mask m, char c) const;
       const char* is(const char* low, const char* high, mask* vec) const;
-      const char* scan_is (mask m,
- const char* low, const char* high) const;
-      const char* scan_not(mask m,
-                           const char* low, const char* high) const;
       char        toupper(char c) const;
       const char* toupper(char* low, const char* high) const;
       char        tolower(char c) const;
       const char* tolower(char* low, const char* high) const;
       char  widen(char c) const;
       const char* widen(const char* low, const char* high, char* to) const;
       char  narrow(char c, char dfault) const;
-      const char* narrow(const char* low, const char* high, char dfault,
-                         char* to) const;
       static locale::id id;
       static const size_t table_size = implementation-defined;
       const mask* table() const noexcept;
@@ -1013,66 +982,60 @@ namespace std {
       virtual const char* do_toupper(char* low, const char* high) const;
       virtual char        do_tolower(char c) const;
       virtual const char* do_tolower(char* low, const char* high) const;
       virtual char        do_widen(char c) const;
-      virtual const char* do_widen(const char* low,
-                                   const char* high,
-                                   char* to) const;
       virtual char        do_narrow(char c, char dfault) const;
-      virtual const char* do_narrow(const char* low,
-                                    const char* high,
                                     char dfault, char* to) const;
     };
 }
 ```
 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.
-##### `ctype<char>` 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()`.
-##### `ctype<char>` 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.
 ``` cpp
-explicit ctype(const mask* tbl = 0, bool del = false,
-               size_t refs = 0);
 ```
-*Requires:* `tbl` either 0 or an array of at least `table_size`
-elements.
 *Effects:* Passes its `refs` argument to its base class constructor.
 ``` cpp
 bool        is(mask m, char c) const;
-const char* is(const char* low, const char* high,
-               mask* vec) const;
 ```
 *Effects:* The second form, for all `*p` in the range \[`low`, `high`),
 assigns into `vec[p - low]` the value `table()[(unsigned char)*p]`.
 *Returns:* The first form returns `table()[(unsigned char)c] & m`; the
 second form returns `high`.
 ``` cpp
-const char* scan_is(mask m,
-                    const char* low, const char* high) const;
 ```
 *Returns:* The smallest `p` in the range \[`low`, `high`) such that
 ``` cpp
@@ -1080,12 +1043,11 @@ table()[(unsigned char) *p] & m
 ```
 is `true`.
 ``` cpp
-const char* scan_not(mask m,
-                     const char* low, const char* high) const;
 ```
 *Returns:* The smallest `p` in the range \[`low`, `high`) such that
 ``` cpp
@@ -1108,20 +1070,18 @@ const char* tolower(char* low, const char* high) const;
 *Returns:* `do_tolower(c)` or `do_tolower(low, high)`, respectively.
 ``` cpp
 char  widen(char c) const;
-const char* widen(const char* low, const char* high,
-    char* to) const;
 ```
 *Returns:* `do_widen(c)` or `do_widen(low, high, to)`, respectively.
 ``` cpp
 char        narrow(char c, char dfault) const;
-const char* narrow(const char* low, const char* high,
-                   char dfault, char* to) const;
 ```
 *Returns:* `do_narrow(c, dfault)` or `do_narrow(low, high, dfault, to)`,
 respectively.
@@ -1130,40 +1090,37 @@ const mask* table() const noexcept;
 ```
 *Returns:* The first constructor argument, if it was nonzero, otherwise
 `classic_table()`.
-##### `ctype<char>` 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.
-##### `ctype<char>` 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;
 const char* do_tolower(char* low, const char* high) const;
 virtual char        do_widen(char c) const;
-virtual const char* do_widen(const char* low,
-                             const char* high,
-                             char* to) const;
 virtual char        do_narrow(char c, char dfault) const;
-virtual const char* do_narrow(const char* low,
-                              const char* high,
                               char dfault, char* to) 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>
 ``` cpp
 namespace std {
@@ -1224,33 +1181,32 @@ namespace std {
 }
 ```
 The class `codecvt<internT, externT, stateT>` is for use when converting
 from one character encoding to another, such as from wide characters to
-multibyte characters or between wide character encodings such as Unicode
 and EUC.
 The `stateT` argument selects the pair of character encodings being
 mapped between.
-The specializations required in Table
-[[tab:localization.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, char, mbstate_t>` converts between the UTF-16 and
 UTF-8 encoding forms, and the specialization `codecvt`
-`<char32_t, char, 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 narrow 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
-user-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.
-##### `codecvt` 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,
@@ -1298,11 +1254,11 @@ int length(stateT& state, const externT* from, const externT* from_end, size_t m
 int max_length() const noexcept;
 ```
 *Returns:* `do_max_length()`.
-##### `codecvt` 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,
@@ -1312,14 +1268,14 @@ result do_in(
     stateT& state,
     const externT* from, const externT* from_end, const externT*& from_next,
     internT* to, internT* to_end, internT*& to_next) const;
 ```
-*Requires:* `(from <= from_end && to <= to_end)` well-defined and
-`true`; `state` initialized, if at the beginning of a sequence, or else
-equal to the result of converting the preceding characters in the
-sequence.
 *Effects:* Translates characters in the source range \[`from`,
 `from_end`), placing the results in sequential positions starting at
 destination `to`. Converts no more than `(from_end - from)` source
 elements, and stores no more than `(to_end - to)` destination elements.
@@ -1330,12 +1286,12 @@ 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
 ``` cpp
 do_out(state, from, from_end, from_next, to, to_end, to_next)
 ```
@@ -1368,13 +1324,13 @@ shall also return `ok`.[^8]
 [*Note 2*: This argument can be used, for example, to maintain shift
 state, to specify conversion options (such as count only), or to
 identify a cache of seek offsets. — *end note*]
 *Returns:* An enumeration value, as summarized in
-Table  [[tab:localization.convert.result.values.out.in]].
-**Table: `do_in/do_out` result values** <a id="tab:localization.convert.result.values.out.in">[tab:localization.convert.result.values.out.in]</a>
 | Value     | Meaning                                                                                          |
 | --------- | ------------------------------------------------------------------------------------------------ |
 | `ok`      | completed the conversion                                                                         |
 | `partial` | not all source characters converted                                                              |
@@ -1389,24 +1345,24 @@ before another destination element can be produced.
 ``` cpp
 result do_unshift(stateT& state, externT* to, externT* to_end, externT*& to_next) const;
 ```
-*Requires:* `(to <= to_end)` well defined and `true`; state initialized,
-if at the beginning of a sequence, or else equal to the result of
-converting the preceding characters in the sequence.
 *Effects:* Places characters starting at `to` that should be appended to
 terminate a sequence when the current `stateT` is given by `state`.[^9]
 Stores no more than `(to_end - to)` destination elements, and leaves the
 `to_next` pointer pointing one beyond the last element successfully
 stored.
 *Returns:* An enumeration value, as summarized in
-Table  [[tab:localization.convert.result.values.unshift]].
-**Table: `do_unshift` result values** <a id="tab:localization.convert.result.values.unshift">[tab:localization.convert.result.values.unshift]</a>
 | Value     | Meaning                                                                                                              |
 | --------- | -------------------------------------------------------------------------------------------------------------------- |
 | `ok`      | completed the sequence                                                                                               |
 | `partial` | space for more than `to_end - to` destination elements was needed to terminate a sequence given the value of `state` |
@@ -1431,15 +1387,16 @@ valid argument values. `codecvt<char, char, mbstate_t>` returns `true`.
 ``` cpp
 int do_length(stateT& state, const externT* from, const externT* from_end, size_t max) const;
 ```
-*Requires:* `(from <= from_end)` well-defined and `true`; `state`
-initialized, if at the beginning of a sequence, or else equal to the
-result of converting the preceding characters in the 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
@@ -1464,10 +1421,11 @@ namespace std {
   template<class internT, class externT, class stateT>
     class codecvt_byname : public codecvt<internT, externT, stateT> {
     public:
       explicit codecvt_byname(const char*, size_t refs = 0);
       explicit codecvt_byname(const string&, size_t refs = 0);
     protected:
       ~codecvt_byname();
     };
 }
 ```
@@ -1479,19 +1437,18 @@ 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]
 All specifications of member functions for `num_put` and `num_get` in
 the subclauses of  [[category.numeric]] only apply to the
-specializations required in Tables  [[tab:localization.category.facets]]
-and  [[tab:localization.required.specializations]] (
-[[locale.category]]), namely `num_get<char>`, `num_get<wchar_t>`,
-`num_get<C, InputIterator>`, `num_put<char>`, `num_put<wchar_t>`, and
-`num_put<C, OutputIterator>`. These specializations refer to the
-`ios_base&` argument for formatting specifications (
-[[locale.categories]]), and to its imbued locale for the `numpunct<>`
-facet to identify all numeric punctuation preferences, and also for the
-`ctype<>` facet to perform character classification.
 Extractor and inserter members of the standard iostreams use `num_get<>`
 and `num_put<>` member functions for formatting and parsing numeric
 values ([[istream.formatted.reqmts]], [[ostream.formatted.reqmts]]).
@@ -1561,11 +1518,11 @@ namespace std {
 ```
 The facet `num_get` is used to parse numeric values from an input
 sequence such as an istream.
-##### `num_get` 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,
@@ -1590,11 +1547,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)`.
-##### `num_get` 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,
@@ -1641,32 +1598,32 @@ fmtflags basefield = (flags & ios_base::basefield);
 fmtflags uppercase = (flags & ios_base::uppercase);
 fmtflags boolalpha = (flags & ios_base::boolalpha);
 ```
 For conversion to an integral type, the function determines the integral
-conversion specifier as indicated in
-Table [[tab:localization.integer.conversions.in]]. The table is
-ordered. That is, the first line whose condition is true applies.
-**Table: Integer conversions** <a id="tab:localization.integer.conversions.in">[tab:localization.integer.conversions.in]</a>
 | State                    | `stdio` equivalent |
 | ------------------------ | ------------------ |
 | `basefield == oct`       | `%o`               |
 | `basefield == hex`       | `%X`               |
 | `basefield == 0`         | `%i` `signed` integral type | `%d` |
 | `unsigned` integral type | `%u`               |
-For conversions to a floating type the specifier is `%g`.
 For conversions to `void*` the specifier is `%p`.
 A length modifier is added to the conversion specification, if needed,
-as indicated in Table [[tab:localization.length.modifier.in]].
-**Table: Length modifier** <a id="tab:localization.length.modifier.in">[tab:localization.length.modifier.in]</a>
 | Type                 | Length modifier |
 | -------------------- | --------------- |
 | `short`              | `h`             |
 | `unsigned short`     | `h`             |
@@ -1834,11 +1791,11 @@ namespace std {
 ```
 The facet `num_put` is used to format numeric values to a character
 sequence such as an ostream.
-##### `num_put` 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;
@@ -1849,11 +1806,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)`.
-##### `num_put` 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;
@@ -1862,30 +1819,30 @@ iter_type do_put(iter_type out, ios_base& str, char_type fill, double val) const
 iter_type do_put(iter_type out, ios_base& str, char_type fill, long double val) const;
 iter_type do_put(iter_type out, ios_base& str, char_type fill, const void* val) const;
 ```
 *Effects:* Writes characters to the sequence `out`, formatting `val` as
-desired. In the following description, a local variable initialized
-with:
 ``` cpp
 locale loc = str.getloc();
 ```
 The details of this operation occur in several stages:
 - Stage 1: Determine a printf conversion specifier `spec` and determine
-  the characters that would be printed by `printf` ([[c.files]]) given
   this conversion specifier for
   ``` cpp
   printf(spec, val)
   ```
   assuming that the current locale is the `"C"` locale.
 - Stage 2: Adjust the representation by converting each `char`
   determined by stage 1 to a `charT` using a conversion and values
-  returned by members of `use_facet<numpunct<charT>>(str.getloc())`
 - Stage 3: Determine where padding is required.
 - Stage 4: Insert the sequence into the `out`.
 Detailed descriptions of each stage follow.
@@ -1911,13 +1868,13 @@ All tables used in describing stage 1 are ordered. That is, the first
 line whose condition is true applies. A line without a condition is the
 default behavior when none of the earlier lines apply.
 For conversion from an integral type other than a character type, the
 function determines the integral conversion specifier as indicated in
-Table [[tab:localization.integer.conversions.out]].
-**Table: Integer conversions** <a id="tab:localization.integer.conversions.out">[tab:localization.integer.conversions.out]</a>
 | State                                        | `stdio` equivalent |
 | -------------------------------------------- | ------------------ |
 | `basefield == ios_base::oct`                 | `%o`               |
 | `(basefield == ios_base::hex) && !uppercase` | `%x`               |
@@ -1926,13 +1883,13 @@ Table [[tab:localization.integer.conversions.out]].
 | for an `unsigned` integral type              | `%u`               |
 For conversion from a floating-point type, the function determines the
 floating-point conversion specifier as indicated in
-Table [[tab:localization.fp.conversions.out]].
-**Table: Floating-point conversions** <a id="tab:localization.fp.conversions.out">[tab:localization.fp.conversions.out]</a>
 | State                                                                  | `stdio` equivalent |
 | ---------------------------------------------------------------------- | ------------------ |
 | `floatfield == ios_base::fixed`                                        | `%f`               |
 | `floatfield == ios_base::scientific && !uppercase`                     | `%e`               |
@@ -1943,13 +1900,13 @@ Table [[tab:localization.fp.conversions.out]].
 | otherwise                                                              | `%G`               |
 For conversions from an integral or floating-point type a length
 modifier is added to the conversion specifier as indicated in
-Table [[tab:localization.length.modifier.out]].
-**Table: Length modifier** <a id="tab:localization.length.modifier.out">[tab:localization.length.modifier.out]</a>
 | Type                 | Length modifier |
 | -------------------- | --------------- |
 | `long`               | `l`             |
 | `long long`          | `ll`            |
@@ -1958,14 +1915,13 @@ Table [[tab:localization.length.modifier.out]].
 | `long double`        | `L`             |
 | otherwise            | none            |
 The conversion specifier has the following optional additional
-qualifiers prepended as indicated in
-Table [[tab:localization.numeric.conversions]].
-**Table: Numeric conversions** <a id="tab:localization.numeric.conversions">[tab:localization.numeric.conversions]</a>
 | Type(s)               | State       | `stdio` equivalent |
 | --------------------- | ----------- | ------------------ |
 | an integral type      | `showpos`   | `+`                |
 |                       | `showbase`  | `#`                |
@@ -1985,16 +1941,20 @@ would be printed by a call of `printf(s, val)` where `s` is the
 conversion specifier determined above.
 - **Stage 2:**
 Any character `c` other than a decimal point(.) is converted to a
-`charT` via `use_facet<ctype<charT>>(loc).widen( c )`
 A local variable `punct` is initialized via
 ``` cpp
-const numpunct<charT>& punct = use_facet<numpunct<charT>>(str.getloc());
 ```
 For arithmetic types, `punct.thousands_sep()` characters are inserted
 into the sequence as determined by the value returned by
 `punct.do_grouping()` using the method described
@@ -2009,13 +1969,13 @@ A local variable is initialized as
 ``` cpp
 fmtflags adjustfield = (flags & (ios_base::adjustfield));
 ```
 The location of any padding[^12] is determined according to
-Table [[tab:localization.fill.padding]].
-**Table: Fill padding** <a id="tab:localization.fill.padding">[tab:localization.fill.padding]</a>
 | State                                                                          | Location           |
 | ------------------------------------------------------------------------------ | ------------------ |
 | `adjustfield == ios_base::left`                                                | pad after          |
 | `adjustfield == ios_base::right`                                               | pad before         |
@@ -2089,43 +2049,73 @@ namespace std {
 }
 ```
 `numpunct<>`
-specifies numeric punctuation. The specializations required in Table
-[[tab:localization.category.facets]] ([[locale.category]]), namely
 `numpunct<{}wchar_t>` and `numpunct<char>`, provide classic `"C"`
 numeric formats, i.e., they contain information equivalent to that
 contained in the `"C"` locale or their wide character counterparts as if
 obtained by a call to `widen`.
-The syntax for number formats is as follows, where `digit` represents
-the radix set specified by the `fmtflags` argument value, and
-`thousands-sep` and `decimal-point` are the results of corresponding
-`numpunct<charT>` members. Integer values have the format:
-``` cpp
-integer   ::= [sign] units
-sign      ::= plusminus
-plusminus ::= '+' | '-'
-units     ::= digits [thousands-sep units]
-digits    ::= digit [digits]
 ```
 and floating-point values have:
-``` cpp
-floatval ::= [sign] units [decimal-point [digits]] [e [sign] digits] |
-             [sign]        decimal-point  digits   [e [sign] digits]
-e        ::= 'e' | 'E'
 ```
-where the number of digits between `thousands-sep`s is as specified by
-`do_grouping()`. For parsing, if the `digits` portion contains no
-thousands-separators, no grouping constraint is applied.
-##### `numpunct` members <a id="facet.numpunct.members">[[facet.numpunct.members]]</a>
 ``` cpp
 char_type decimal_point() const;
 ```
@@ -2148,11 +2138,11 @@ string_type truename()  const;
 string_type falsename() const;
 ```
 *Returns:* `do_truename()` or `do_falsename()`, respectively.
-##### `numpunct` virtual functions <a id="facet.numpunct.virtuals">[[facet.numpunct.virtuals]]</a>
 ``` cpp
 char_type do_decimal_point() const;
 ```
@@ -2168,16 +2158,16 @@ required specializations return `’,’` or `L’,’`.
 ``` cpp
 string do_grouping() const;
 ```
-*Returns:* A basic_string\<char\> `vec` used as a vector of integer
-values, in which each element `vec[i]` represents the number of
-digits[^13] in the group at position `i`, starting with position 0 as
-the rightmost group. If `vec.size() <= i`, the number is the same as
-group `(i - 1)`; if `(i < 0 || vec[i] <= 0 || vec[i] == CHAR_MAX)`, the
-size of the digit group is unlimited.
 The required specializations return the empty string, indicating no
 grouping.
 ``` cpp
@@ -2202,10 +2192,11 @@ namespace std {
       using char_type   = charT;
       using string_type = basic_string<charT>;
       explicit numpunct_byname(const char*, size_t refs = 0);
       explicit numpunct_byname(const string&, size_t refs = 0);
     protected:
       ~numpunct_byname();
     };
 }
 ```
@@ -2242,20 +2233,20 @@ namespace std {
 ```
 The class `collate<charT>` provides features for use in the collation
 (comparison) and hashing of strings. A locale member function template,
 `operator()`, uses the collate facet to allow a locale to act directly
-as the predicate argument for standard algorithms (Clause
-[[algorithms]]) and containers operating on strings. The specializations
-required in Table  [[tab:localization.category.facets]] (
-[[locale.category]]), namely `collate<char>` and `collate<wchar_t>`,
-apply lexicographic ordering ([[alg.lex.comparison]]).
 Each function compares a string of characters `*p` in the range \[`low`,
 `high`).
-##### `collate` 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;
 ```
@@ -2272,22 +2263,22 @@ string_type transform(const charT* low, const charT* high) const;
 long hash(const charT* low, const charT* high) const;
 ```
 *Returns:* `do_hash(low, high)`.
-##### `collate` 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;
 ```
 *Returns:* `1` if the first string is greater than the second, `-1` if
 less, zero otherwise. The specializations required in
-Table  [[tab:localization.category.facets]] ([[locale.category]]),
-namely `collate<char>` and `collate<wchar_t>`, implement a
-lexicographical comparison ([[alg.lex.comparison]]).
 ``` cpp
 string_type do_transform(const charT* low, const charT* high) const;
 ```
@@ -2317,10 +2308,11 @@ namespace std {
     public:
       using string_type = basic_string<charT>;
       explicit collate_byname(const char*, size_t refs = 0);
       explicit collate_byname(const string&, size_t refs = 0);
     protected:
       ~collate_byname();
     };
 }
 ```
@@ -2329,14 +2321,13 @@ namespace std {
 Templates `time_get<charT, InputIterator>` and
 `time_put<charT, OutputIterator>` provide date and time formatting and
 parsing. All specifications of member functions for `time_put` and
 `time_get` in the subclauses of  [[category.time]] only apply to the
-specializations required in Tables  [[tab:localization.category.facets]]
-and  [[tab:localization.required.specializations]] (
-[[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>
@@ -2404,11 +2395,11 @@ produce the sequence; otherwise either an error is reported or
 unspecified values are assigned.[^15]
 If the end iterator is reached during parsing by any of the `get()`
 member functions, the member sets `ios_base::eofbit` in `err`.
-##### `time_get` members <a id="locale.time.get.members">[[locale.time.get.members]]</a>
 ``` cpp
 dateorder date_order() const;
 ```
@@ -2455,11 +2446,11 @@ iter_type get(iter_type s, iter_type end, ios_base& f, ios_base::iostate& err,
 ``` cpp
 iter_type get(iter_type s, iter_type end, ios_base& f, ios_base::iostate& err,
               tm* t, const char_type* fmt, const char_type* fmtend) const;
 ```
-*Requires:* \[`fmt`, `fmtend`) shall be a valid range.
 *Effects:* The function starts by evaluating `err = ios_base::goodbit`.
 It then enters a loop, reading zero or more characters from `s` at each
 iteration. Unless otherwise specified below, the loop terminates when
 the first of the following conditions holds:
@@ -2497,11 +2488,11 @@ by what means the function performs case-insensitive comparison or
 whether multi-character sequences are considered while doing
 so. — *end note*]
 *Returns:* `s`.
-##### `time_get` virtual functions <a id="locale.time.get.virtuals">[[locale.time.get.virtuals]]</a>
 ``` cpp
 dateorder do_date_order() const;
 ```
@@ -2531,14 +2522,13 @@ iter_type do_get_date(iter_type s, iter_type end, ios_base& str,
 *Effects:* Reads characters starting at `s` until it has extracted those
 `struct tm` members and remaining format characters used by
 `time_put<>::put` to produce one of the following formats, or until it
 encounters an error. The format depends on the value returned by
-`date_order()` as shown in
-Table  [[tab:lib.locale.time.get.virtuals.dogetdate]].
-**Table: `do_get_date` effects** <a id="tab:lib.locale.time.get.virtuals.dogetdate">[tab:lib.locale.time.get.virtuals.dogetdate]</a>
 | `date_order()` | Format     |
 | -------------- | ---------- |
 | `no_order`     | `"%m%d%y"` |
 | `dmy`          | `"%d%m%y"` |
@@ -2585,11 +2575,11 @@ recognized as part of a valid year identifier.
 ``` cpp
 iter_type do_get(iter_type s, iter_type end, ios_base& f,
                  ios_base::iostate& err, tm* t, char format, char modifier) const;
 ```
-*Requires:* `t` shall point to an object.
 *Effects:* The function starts by evaluating `err = ios_base::goodbit`.
 It then reads characters starting at `s` until it encounters an error,
 or until it has extracted and assigned those `struct tm` members, and
 any remaining format characters, corresponding to a conversion directive
@@ -2609,11 +2599,11 @@ members from the input sequence \[`s`, `end`), it evaluates
 members are unspecified and may be outside their valid range.
 *Remarks:* It is unspecified whether multiple calls to `do_get()` with
 the address of the same `struct tm` object will update the current
 contents of the object or simply overwrite its members. Portable
-programs must zero out the object before invoking the function.
 *Returns:* An iterator pointing immediately beyond the last character
 recognized as possibly part of a valid input sequence for the given
 `format` and `modifier`.
@@ -2627,10 +2617,11 @@ namespace std {
       using dateorder = time_base::dateorder;
       using iter_type = InputIterator;
       explicit time_get_byname(const char*, size_t refs = 0);
       explicit time_get_byname(const string&, size_t refs = 0);
     protected:
       ~time_get_byname();
     };
 }
 ```
@@ -2661,11 +2652,11 @@ namespace std {
                                char format, char modifier) const;
     };
 }
 ```
-##### `time_put` 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,
@@ -2694,11 +2685,11 @@ 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.
-##### `time_put` 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;
 ```
@@ -2721,18 +2712,18 @@ reasonable default for this argument. — *end note*]
 #### Class template `time_put_byname` <a id="locale.time.put.byname">[[locale.time.put.byname]]</a>
 ``` cpp
 namespace std {
   template<class charT, class OutputIterator = ostreambuf_iterator<charT>>
- class time_put_byname : public time_put<charT, OutputIterator>
-  {
     public:
       using char_type = charT;
       using iter_type = OutputIterator;
       explicit time_put_byname(const char*, size_t refs = 0);
       explicit time_put_byname(const string&, size_t refs = 0);
     protected:
       ~time_put_byname();
     };
 }
 ```
@@ -2742,14 +2733,13 @@ namespace std {
 These templates handle monetary formats. A template parameter indicates
 whether local or international monetary formats are to be used.
 All specifications of member functions for `money_put` and `money_get`
 in the subclauses of  [[category.monetary]] only apply to the
-specializations required in Tables  [[tab:localization.category.facets]]
-and  [[tab:localization.required.specializations]] (
-[[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>
@@ -2781,31 +2771,28 @@ namespace std {
                                ios_base::iostate& err, string_type& digits) const;
     };
 }
 ```
-##### `money_get` 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(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)`.
-##### `money_get` 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, ios_base::iostate& err,
-                 string_type& digits) const;
 ```
 *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
@@ -2815,11 +2802,11 @@ 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*]
@@ -2834,13 +2821,13 @@ Where `money_base::space` or `money_base::none` appears as the last
 element in the format pattern, no white space is consumed. Otherwise,
 where `money_base::space` appears in any of the initial elements of the
 format pattern, at least one white space character is required. Where
 `money_base::none` appears in any of the initial elements of the format
 pattern, white space is allowed but not required. If
-`(str.flags() & str.showbase)` is false, the currency symbol is optional
-and is consumed only if other characters are needed to complete the
-format; otherwise, the currency symbol is required.
 If the first character (if any) in the string `pos` returned by
 `mp.positive_sign()` or the string `neg` returned by
 `mp.negative_sign()` is recognized in the position indicated by `sign`
 in the format pattern, it is consumed and any remaining characters in
@@ -2912,22 +2899,20 @@ namespace std {
                                const string_type& digits) const;
     };
 }
 ```
-##### `money_put` 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)`.
-##### `money_put` 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,
@@ -3021,11 +3006,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`th component of
 the format[^21] In the `field` member of a `pattern` object, each value
 `symbol`, `sign`, `value`, and either `space` or `none` appears exactly
 once. The value `none`, if present, is not first; the value `space`, if
 present, is neither first nor last.
@@ -3041,44 +3026,57 @@ required. Any remaining characters of the sign sequence are required
 after all other format components. Where `value` appears, the absolute
 numeric monetary value is required.
 The format of the numeric monetary value is a decimal number:
-``` cpp
-value ::= units [ decimal-point [ digits ]] |
     decimal-point digits
 ```
 if `frac_digits()` returns a positive value, or
-``` cpp
-value ::= units
 ```
-otherwise. The symbol `decimal-point` indicates the character returned
-by `decimal_point()`. The other symbols are defined as follows:
-``` cpp
-units ::= digits [ thousands-sep units ]
-digits ::= adigit [ digits ]
 ```
-In the syntax specification, the symbol `adigit` is any of the values
-`ct.widen(c)` for `c` in the range `'0'` through `'9'`, inclusive, and
 `ct` is a reference of type `const ctype<charT>&` obtained as described
-in the definitions of `money_get<>` and `money_put<>`. The symbol
-`thousands-sep` is the character returned by `thousands_sep()`. The
-space character used is the value `ct.widen(' ')`. White space
-characters are those characters `c` for which `ci.is(space, c)` returns
-`true`. The number of digits required after the decimal point (if any)
-is exactly the value returned 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()`.
-##### `moneypunct` members <a id="locale.moneypunct.members">[[locale.moneypunct.members]]</a>
 ``` cpp
 charT        decimal_point() const;
 charT        thousands_sep() const;
 string       grouping()      const;
@@ -3091,11 +3089,11 @@ pattern      neg_format()    const;
 ```
 Each of these functions `F` returns the result of calling the
 corresponding virtual member function `do_F()`.
-##### `moneypunct` virtual functions <a id="locale.moneypunct.virtuals">[[locale.moneypunct.virtuals]]</a>
 ``` cpp
 charT do_decimal_point() const;
 ```
@@ -3118,39 +3116,47 @@ to, the result of `numpunct<charT>::do_grouping()`.[^24]
 ``` cpp
 string_type do_curr_symbol() const;
 ```
-*Returns:* A string to use as the currency identifier symbol.[^25]
 ``` 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;[^26] `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.[^27]
 ``` cpp
 pattern do_pos_format() const;
 pattern do_neg_format() const;
 ```
 *Returns:* The specializations required in
-Table  [[tab:localization.required.specializations]] ([[locale.category]]),
-namely `moneypunct<char>`, `moneypunct<wchar_t>`,
-`moneypunct<char, true>`, and `moneypunct<wchar_t, true>`, return an
-object of type `pattern` initialized to
-`{ symbol, sign, none, value }`.[^28]
 #### Class template `moneypunct_byname` <a id="locale.moneypunct.byname">[[locale.moneypunct.byname]]</a>
 ``` cpp
 namespace std {
@@ -3160,10 +3166,11 @@ namespace std {
       using pattern     = money_base::pattern;
       using string_type = basic_string<charT>;
       explicit moneypunct_byname(const char*, size_t refs = 0);
       explicit moneypunct_byname(const string&, size_t refs = 0);
     protected:
       ~moneypunct_byname();
     };
 }
 ```
@@ -3188,34 +3195,34 @@ namespace std {
       using char_type   = charT;
       using string_type = basic_string<charT>;
       explicit messages(size_t refs = 0);
-      catalog open(const basic_string<char>& fn, const locale&) const;
       string_type get(catalog c, int set, int msgid,
                        const string_type& dfault) const;
       void close(catalog c) const;
       static locale::id id;
     protected:
       ~messages();
-      virtual catalog do_open(const basic_string<char>&, const locale&) const;
       virtual string_type do_get(catalog, int set, int msgid,
                                  const string_type& dfault) const;
       virtual void do_close(catalog) const;
     };
 }
 ```
 Values of type `messages_base::catalog` usable as arguments to members
 `get` and `close` can be obtained only by calling member `open`.
-##### `messages` members <a id="locale.messages.members">[[locale.messages.members]]</a>
 ``` cpp
-catalog open(const basic_string<char>& name, const locale& loc) const;
 ```
 *Returns:* `do_open(name, loc)`.
 ``` cpp
@@ -3228,14 +3235,14 @@ string_type get(catalog cat, int set, int msgid, const string_type& dfault) cons
 void close(catalog cat) const;
 ```
 *Effects:* Calls `do_close(cat)`.
-##### `messages` virtual functions <a id="locale.messages.virtuals">[[locale.messages.virtuals]]</a>
 ``` cpp
-catalog do_open(const basic_string<char>& name, const locale& loc) const;
 ```
 *Returns:* A value that may be passed to `get()` to retrieve a message
 from the message catalog identified by the string `name` according to an
 *implementation-defined* mapping. The result can be used until it is
@@ -3248,22 +3255,22 @@ conversion when retrieving messages, if needed.
 ``` cpp
 string_type do_get(catalog cat, int set, int msgid, const string_type& dfault) const;
 ```
-*Requires:* `cat` shall be a catalog obtained from `open()` and not yet
 closed.
 *Returns:* A message identified by arguments `set`, `msgid`, and
 `dfault`, according to an *implementation-defined* mapping. If no such
 message can be found, returns `dfault`.
 ``` cpp
 void do_close(catalog cat) const;
 ```
-*Requires:* `cat` shall be a catalog obtained from `open()` and not yet
 closed.
 *Effects:* Releases unspecified resources associated with `cat`.
 *Remarks:* The limit on such resources, if any, is
@@ -3279,208 +3286,17 @@ namespace std {
       using catalog     = messages_base::catalog;
       using string_type = basic_string<charT>;
       explicit messages_byname(const char*, size_t refs = 0);
       explicit messages_byname(const string&, size_t refs = 0);
     protected:
       ~messages_byname();
     };
 }
 ```
-### Program-defined facets <a id="facets.examples">[[facets.examples]]</a>
-A C++program may define facets to be added to a locale and used
-identically as the built-in facets. To create a new facet interface,
-C++programs simply derive from `locale::facet` a class containing a
-static member: `static locale::id id`.
-[*Note 1*: The locale member function templates verify its type and
-storage class. — *end note*]
-[*Example 1*:
-Traditional global localization is still easy:
-``` cpp
-#include <iostream>
-#include <locale>
-int main(int argc, char** argv) {
-  using namespace std;
-  locale::global(locale(""));           // set the global locale
-                                        // imbue it on all the std streams
-  cin.imbue(locale());
-  cout.imbue(locale());
-  cerr.imbue(locale());
-  wcin.imbue(locale());
-  wcout.imbue(locale());
-  wcerr.imbue(locale());
-  return MyObject(argc, argv).doit();
-}
-```
-— *end example*]
-[*Example 2*:
-Greater flexibility is possible:
-``` cpp
-#include <iostream>
-#include <locale>
-int main() {
-  using namespace std;
-  cin.imbue(locale(""));        // the user's preferred locale
-  cout.imbue(locale::classic());
-  double f;
-  while (cin >> f) cout << f << endl;
-  return (cin.fail() != 0);
-}
-```
-In a European locale, with input `3.456,78`, output is `3456.78`.
-— *end example*]
-This can be important even for simple programs, which may need to write
-a data file in a fixed format, regardless of a user’s preference.
-[*Example 3*:
-Here is an example of the use of locales in a library interface.
-``` cpp
-// file: Date.h
-#include <iosfwd>
-#include <string>
-#include <locale>
-class Date {
-public:
-  Date(unsigned day, unsigned month, unsigned year);
-  std::string asString(const std::locale& = std::locale());
-};
-std::istream& operator>>(std::istream& s, Date& d);
-std::ostream& operator<<(std::ostream& s, Date d);
-```
-This example illustrates two architectural uses of class `locale`.
-The first is as a default argument in `Date::asString()`, where the
-default is the global (presumably user-preferred) locale.
-The second is in the operators `<<` and `>>`, where a locale
-“hitchhikes” on another object, in this case a stream, to the point
-where it is needed.
-``` cpp
-// file: Date.C
-#include "Date"                 // includes <ctime>
-#include <sstream>
-std::string Date::asString(const std::locale& l) {
-  using namespace std;
-  ostringstream s; s.imbue(l);
-  s << *this; return s.str();
-}
-std::istream& operator>>(std::istream& s, Date& d) {
-  using namespace std;
-  istream::sentry cerberos(s);
-  if (cerberos) {
-    ios_base::iostate err = goodbit;
-    struct tm t;
-    use_facet<time_get<char>>(s.getloc()).get_date(s, 0, s, err, &t);
-    if (!err) d = Date(t.tm_day, t.tm_mon + 1, t.tm_year + 1900);
-    s.setstate(err);
-  }
-  return s;
-}
-```
-— *end example*]
-A locale object may be extended with a new facet simply by constructing
-it with an instance of a class derived from `locale::facet`. The only
-member a C++program must define is the static member `id`, which
-identifies your class interface as a new facet.
-[*Example 4*:
-Classifying Japanese characters:
-``` cpp
-// file: <jctype>
-#include <locale>
-namespace My {
-  using namespace std;
-  class JCtype : public locale::facet {
-  public:
-    static locale::id id;       // required for use as a new locale facet
-    bool is_kanji (wchar_t c) const;
-    JCtype() { }
-  protected:
-    ~JCtype() { }
-  };
-}
-// file: filt.C
-#include <iostream>
-#include <locale>
-#include "jctype"               // above
-std::locale::id My::JCtype::id; // the static JCtype member declared above.
-int main() {
-  using namespace std;
-  using wctype = ctype<wchar_t>;
-  locale loc(locale(""),        // the user's preferred locale ...
-         new My::JCtype);       // and a new feature ...
-  wchar_t c = use_facet<wctype>(loc).widen('!');
-  if (!use_facet<My::JCtype>(loc).is_kanji(c))
-    cout << "no it isn't!" << endl;
-}
-```
-The new facet is used exactly like the built-in facets.
-— *end example*]
-[*Example 5*:
-Replacing an existing facet is even easier. The code does not define a
-member `id` because it is reusing the `numpunct<charT>` facet interface:
-``` cpp
-// file: my_bool.C
-#include <iostream>
-#include <locale>
-#include <string>
-namespace My {
-  using namespace std;
-  using cnumpunct = numpunct_byname<char>;
-  class BoolNames : public cnumpunct {
-  protected:
-    string do_truename()  const { return "Oui Oui!"; }
-    string do_falsename() const { return "Mais Non!"; }
-    ~BoolNames() { }
-  public:
-    BoolNames(const char* name) : cnumpunct(name) { }
-  };
-}
-int main(int argc, char** argv) {
-  using namespace std;
-  // make the user's preferred locale, except for...
-  locale loc(locale(""), new My::BoolNames(""));
-  cout.imbue(loc);
-  cout << boolalpha << "Any arguments today? " << (argc > 1) << endl;
-}
-```
-— *end example*]
 ## C library locales <a id="c.locales">[[c.locales]]</a>
 ### Header `<clocale>` synopsis <a id="clocale.syn">[[clocale.syn]]</a>
 ``` cpp
@@ -3501,17 +3317,17 @@ namespace std {
 ```
 The contents and meaning of the header `<clocale>` are the same as the C
 standard library header `<locale.h>`.
-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 Table  [[tab:setlocale.data.races]].
-ISO C 7.11.
-**Table: Potential `setlocale` data races** <a id="tab:setlocale.data.races">[tab:setlocale.data.races]</a>
 |           |            |             |              |            |
 | --------- | ---------- | ----------- | ------------ | ---------- |
 | `fprintf` | `isprint`  | `iswdigit`  | `localeconv` | `tolower`  |
 | `fscanf`  | `ispunct`  | `iswgraph`  | `mblen`      | `toupper`  |
@@ -3553,23 +3369,25 @@ ISO C 7.11.
 [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
-[facets.examples]: #facets.examples
 [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.category]: #locale.category
 [locale.codecvt]: #locale.codecvt
 [locale.codecvt.byname]: #locale.codecvt.byname
 [locale.codecvt.members]: #locale.codecvt.members
 [locale.codecvt.virtuals]: #locale.codecvt.virtuals
 [locale.collate]: #locale.collate
 [locale.collate.byname]: #locale.collate.byname
 [locale.collate.members]: #locale.collate.members
 [locale.collate.virtuals]: #locale.collate.virtuals
@@ -3600,51 +3418,50 @@ ISO C 7.11.
 [locale.nm.put]: #locale.nm.put
 [locale.num.get]: #locale.num.get
 [locale.numpunct]: #locale.numpunct
 [locale.numpunct.byname]: #locale.numpunct.byname
 [locale.operators]: #locale.operators
 [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.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
 [ostream.formatted.reqmts]: input.md#ostream.formatted.reqmts
 [res.on.data.races]: library.md#res.on.data.races
 [sequence.reqmts]: containers.md#sequence.reqmts
-[tab:lib.locale.time.get.virtuals.dogetdate]: #tab:lib.locale.time.get.virtuals.dogetdate
-[tab:localization.category.facets]: #tab:localization.category.facets
-[tab:localization.convert.result.values.out.in]: #tab:localization.convert.result.values.out.in
-[tab:localization.convert.result.values.unshift]: #tab:localization.convert.result.values.unshift
-[tab:localization.lib.summary]: #tab:localization.lib.summary
-[tab:localization.required.specializations]: #tab:localization.required.specializations
-[tab:setlocale.data.races]: #tab:setlocale.data.races
 [vector]: containers.md#vector
 [^1]: In this subclause, the type name `struct 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 char argument of `do_widen` is intended to accept values
-    derived from character literals 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.
@@ -3692,12 +3509,12 @@ ISO C 7.11.
     vendors do.
 [^18]: Interpretation of the `modifier` argument is
     implementation-defined, but should follow POSIX conventions.
-[^19]: Implementations are encouraged to refer to other standards such
- as POSIX for these definitions.
 [^20]: The semantics here are different from `ct.narrow`.
 [^21]: An array of `char`, rather than an array of `part`, is specified
     for `pattern::field` purely for efficiency.
@@ -3706,15 +3523,11 @@ ISO C 7.11.
 [^23]: In common U.S. locales this is `’,’`.
 [^24]: To specify grouping by 3s, the value is `"\003"` *not* `"3"`.
-[^25]: For international specializations (second template parameter
-    `true`) this is typically four characters long, usually three
-    letters and a space.
-[^26]: This is usually the empty string.
-[^27]: In common U.S. locales, this is 2.
-[^28]: Note that the international symbol returned by `do_curr_sym()`
     usually contains a space, itself; for example, `"USD "`.

 # 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      |
 | --------------------- | ---------------------------- | ----------- |
 | [[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 {
   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 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();
   };
 }
 ```
 template<class charT, class traits>
 basic_ostream<charT, traits>&
 operator<< (basic_ostream<charT, traits>& s, Date d) {
   typename basic_ostream<charT, traits>::sentry cerberos(s);
   if (cerberos) {
     tm tmbuf; d.extract(tmbuf);
+    bool failed =
       use_facet<time_put<charT, ostreambuf_iterator<charT, traits>>>(
+ s.getloc()).put(s, s, s.fill(), &tmbuf, 'x').failed();
+ if (failed)
+      s.setstate(s.badbit);     // might throw
   }
   return s;
 }
 ```
 — *end example*]
 In the call to `use_facet<Facet>(loc)`, the type argument chooses a
 facet, making available all members of the named type. If `Facet` is not
+present in a locale, it throws the standard exception `bad_cast`. A C++
+program can check if a locale implements a particular facet with the
 function template `has_facet<Facet>()`. User-defined facets may be
+installed in a locale, and used identically as may standard facets.
 [*Note 1*:
 All locale semantics are accessed via `use_facet<>` and `has_facet<>`,
 except that:
   is provided so that a locale may be used as a predicate argument to
   the standard collections, to collate strings.
 - Convenient global interfaces are provided for traditional `ctype`
   functions such as `isdigit()` and `isspace()`, so that given a locale
   object `loc` a C++ program can call `isspace(c, loc)`. (This eases
+  upgrading existing extractors [[istream.formatted]].)
 — *end note*]
 Once a facet reference is obtained from a locale object by calling
 `use_facet<>`, that reference remains usable, and the results from
 Whether there is one global locale object for the entire program or one
 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;
 member functions expecting a `category` argument require one of the
 `category` values defined above, or the union of two or more such
 values. Such a `category` value identifies a set of locale categories.
 Each locale category, in turn, identifies a set of locale facets,
+including at least those shown in [[locale.category.facets]].
+**Table: Locale category facets** <a id="locale.category.facets">[locale.category.facets]</a>
 | 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>`               |
 |          | `time_put<char>`, `time_put<wchar_t>`                 |
 | messages | `messages<char>`, `messages<wchar_t>`                 |
 For any locale `loc` either constructed, or returned by
+`locale::classic()`, and any facet `Facet` shown in
+[[locale.category.facets]], `has_facet<Facet>(loc)` is `true`. Each
+`locale` member function which takes a `locale::category` argument
 operates on the corresponding set of facets.
 An implementation is required to provide those specializations for facet
 templates identified as members of a category, and for those shown in
+[[locale.spec]].
+**Table: Required specializations** <a id="locale.spec">[locale.spec]</a>
 | 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>`                            |
 obtained by calling member `getloc()` on the `ios_base&` argument to
 these functions.
 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 {
 Template parameters in this Clause which are required to be facets are
 those named `Facet` in declarations. A program that passes a type that
 is *not* a facet, or a type that refers to a volatile-qualified facet,
 as an (explicit or deduced) template parameter to a locale function
 expecting a facet, is ill-formed. A const-qualified facet is a valid
+template argument to any locale function that expects a `Facet` template
 parameter.
 The `refs` argument to the constructor is used for lifetime management.
 For `refs == 0`, the implementation performs
 `delete static_cast<locale::facet*>(f)` (where `f` is a pointer to the
 [*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;
 ```
 *Effects:* Constructs a copy of the argument last passed to
 `locale::global(locale&)`, if it has been called; else, the resulting
 facets have virtual function semantics identical to those of
 `locale::classic()`.
+[*Note 1*: This constructor yields a copy of the current global locale.
+It is commonly used as a default argument for function parameters of
+type `const locale&`. — *end note*]
 ``` cpp
 explicit locale(const char* std_name);
 ```
 *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;
 ```
 *Throws:* `runtime_error` if `has_facet<Facet>(other)` is `false`.
 *Remarks:* The resulting locale has no name.
 ``` cpp
+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;
 ```
 *Returns:* `true` if both arguments are the same locale, or one is a
 copy of the other, or each has a name and the names are identical;
 `false` otherwise.
 ``` cpp
 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.
 *Remarks:* This member operator template (and therefore `locale` itself)
+meets the requirements for a comparator predicate template
+argument [[algorithms]] applied to strings.
 *Returns:*
 ``` cpp
 use_facet<collate<charT>>(*this).compare(s1.data(), s1.data() + s1.size(),
 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);
 ```
+*Effects:* Sets the global locale to its argument. Causes future calls
+to the constructor `locale()` to return a copy of the argument. If the
+argument has a name, does
 ``` cpp
 setlocale(LC_ALL, loc.name().c_str());
 ```
 otherwise, the effect on the C locale, if any, is
+*implementation-defined*.
+*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*]
 *Returns:* The previous value of `locale()`.
 ``` cpp
 template<class Facet> const Facet& use_facet(const locale& loc);
 ```
+*Mandates:* `Facet` is a facet class whose definition contains the
 public static member `id` as defined in  [[locale.facet]].
 *Returns:* A reference to the corresponding facet of `loc`, if present.
 *Throws:* `bad_cast` if `has_facet<Facet>(loc)` is `false`.
 ``` cpp
 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]
 #### Conversions <a id="conversions">[[conversions]]</a>
 ##### Character conversions <a id="conversions.character">[[conversions.character]]</a>
 Each of the standard categories includes a family of facets. Some of
 these implement formatting or parsing of a datum, for use by standard or
 users’ iostream operators `<<` and `>>`, as members `put()` and `get()`,
 respectively. Each such member function takes an `ios_base&` argument
 whose members `flags()`, `precision()`, and `width()`, specify the
+format of the corresponding datum [[ios.base]]. Those functions which
 need to use other facets call its member `getloc()` to retrieve the
 locale imbued there. Formatting facets use the character argument `fill`
 to fill out the specified width where necessary.
 The `put()` members make no provision for error reporting. (Any failures
+of the OutputIterator argument can be extracted from the returned
 iterator.) The `get()` members take an `ios_base::iostate&` argument
 whose value they ignore, but set to `ios_base::failbit` in case of a
 parse error.
 Within this clause it is unspecified whether one virtual function calls
 ``` 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 graph  = alnum | punct;
   };
 }
 ```
+The type `mask` is a bitmask type [[bitmask.types]].
 #### Class template `ctype` <a id="locale.ctype">[[locale.ctype]]</a>
 ``` cpp
 namespace std {
 Class `ctype` encapsulates the C library `<cctype>` features. `istream`
 members are required to use `ctype<>` for character classing during
 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;
 ```
 *Returns:* `do_is(m, c)` or `do_is(low, high, vec)`.
 ``` cpp
+const charT* scan_is(mask m, const charT* low, const charT* high) const;
 ```
 *Returns:* `do_scan_is(m, low, high)`.
 ``` cpp
+const charT* scan_not(mask m, const charT* low, const charT* high) const;
 ```
 *Returns:* `do_scan_not(m, low, high)`.
 ``` cpp
 *Returns:* `do_widen(c)` or `do_widen(low, high, to)`.
 ``` cpp
 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;
 ```
 *Effects:* Classifies a character or sequence of characters. For each
 argument character, identifies a value `M` of type `ctype_base::mask`.
 The second form identifies a value `M` of type `ctype_base::mask` for
 if it is known to exist, or its argument if not. The second form returns
 `high`.
 ``` cpp
 charT        do_widen(char c) const;
+const char*  do_widen(const char* low, const char* high, charT* dest) const;
 ```
 *Effects:* Applies the simplest reasonable transformation from a `char`
 value or sequence of `char` values to the corresponding `charT` value or
 values.[^5] The only characters for which unique transformations are
+required are those in the basic source character set [[lex.charset]].
 For any named `ctype` category with a `ctype <charT>` facet `ctc` and
 valid `ctype_base::mask` value `M`,
 `(ctc.is(M, c) || !is(M, do_widen(c)) )` is `true`.[^6]
 *Returns:* The first form returns the transformed value. The second form
 returns `high`.
 ``` cpp
 char         do_narrow(charT c, char dfault) const;
+const charT* do_narrow(const charT* low, const charT* high, char dfault, char* dest) const;
 ```
 *Effects:* Applies the simplest reasonable transformation from a `charT`
 value or sequence of `charT` values to the corresponding `char` value or
 values.
+For any character `c` in the basic source character set [[lex.charset]]
+the transformation is such that
 ``` cpp
 do_widen(do_narrow(c, 0)) == c
 ```
     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>
 ``` cpp
 namespace std {
   template<>
     class ctype<char> : public locale::facet, public ctype_base {
     public:
       using char_type = char;
+      explicit ctype(const mask* tab = nullptr, bool del = false, size_t refs = 0);
       bool is(mask m, char c) const;
       const char* is(const char* low, const char* high, mask* vec) const;
+      const char* scan_is (mask m, const char* low, const char* high) const;
+ const char* scan_not(mask m, const char* low, const char* high) const;
       char        toupper(char c) const;
       const char* toupper(char* low, const char* high) const;
       char        tolower(char c) const;
       const char* tolower(char* low, const char* high) const;
       char  widen(char c) const;
       const char* widen(const char* low, const char* high, char* to) const;
       char  narrow(char c, char dfault) const;
+      const char* narrow(const char* low, const char* high, char dfault, char* to) const;
       static locale::id id;
       static const size_t table_size = implementation-defined;
       const mask* table() const noexcept;
       virtual const char* do_toupper(char* low, const char* high) const;
       virtual char        do_tolower(char c) const;
       virtual const char* do_tolower(char* low, const char* high) const;
       virtual char        do_widen(char c) const;
+      virtual const char* do_widen(const char* low, const char* high, char* to) const;
       virtual char        do_narrow(char c, char dfault) const;
+      virtual const char* do_narrow(const char* low, const char* high,
                                     char dfault, char* to) const;
     };
 }
 ```
 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.
 ``` cpp
+explicit ctype(const mask* tbl = nullptr, bool del = false, size_t refs = 0);
 ```
+*Preconditions:* Either `tbl == nullptr` is `true` or \[`tbl`,
+`tbl+table_size`) is a valid range.
 *Effects:* Passes its `refs` argument to its base class constructor.
 ``` cpp
 bool        is(mask m, char c) const;
+const char* is(const char* low, const char* high, mask* vec) const;
 ```
 *Effects:* The second form, for all `*p` in the range \[`low`, `high`),
 assigns into `vec[p - low]` the value `table()[(unsigned char)*p]`.
 *Returns:* The first form returns `table()[(unsigned char)c] & m`; the
 second form returns `high`.
 ``` cpp
+const char* scan_is(mask m, const char* low, const char* high) const;
 ```
 *Returns:* The smallest `p` in the range \[`low`, `high`) such that
 ``` cpp
 ```
 is `true`.
 ``` cpp
+const char* scan_not(mask m, const char* low, const char* high) const;
 ```
 *Returns:* The smallest `p` in the range \[`low`, `high`) such that
 ``` cpp
 *Returns:* `do_tolower(c)` or `do_tolower(low, high)`, respectively.
 ``` cpp
 char  widen(char c) const;
+const char* widen(const char* low, const char* high, char* to) const;
 ```
 *Returns:* `do_widen(c)` or `do_widen(low, high, to)`, respectively.
 ``` cpp
 char        narrow(char c, char dfault) const;
+const char* narrow(const char* low, const char* high, char dfault, char* to) const;
 ```
 *Returns:* `do_narrow(c, dfault)` or `do_narrow(low, high, dfault, to)`,
 respectively.
 ```
 *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;
 const char* do_tolower(char* low, const char* high) const;
 virtual char        do_widen(char c) const;
+virtual const char* do_widen(const char* low, const char* high, char* to) const;
 virtual char        do_narrow(char c, char dfault) const;
+virtual const char* do_narrow(const char* low, const char* high,
                               char dfault, char* to) 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>
 ``` cpp
 namespace std {
 }
 ```
 The class `codecvt<internT, externT, stateT>` is for use when converting
 from one character encoding to another, such as from wide characters to
+multibyte characters or between wide character encodings such as UTF-32
 and EUC.
 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,
 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,
     stateT& state,
     const externT* from, const externT* from_end, const externT*& from_next,
     internT* to, internT* to_end, internT*& to_next) const;
 ```
+*Preconditions:* `(from <= from_end && to <= to_end)` is well-defined
+and `true`; `state` is initialized, if at the beginning of a sequence,
+or else is equal to the result of converting the preceding characters in
+the sequence.
 *Effects:* Translates characters in the source range \[`from`,
 `from_end`), placing the results in sequential positions starting at
 destination `to`. Converts no more than `(from_end - from)` source
 elements, and stores no more than `(to_end - to)` destination elements.
 `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
 ``` cpp
 do_out(state, from, from_end, from_next, to, to_end, to_next)
 ```
 [*Note 2*: This argument can be used, for example, to maintain shift
 state, to specify conversion options (such as count only), or to
 identify a cache of seek offsets. — *end note*]
 *Returns:* An enumeration value, as summarized in
+[[locale.codecvt.inout]].
+**Table: `do_in/do_out` result values** <a id="locale.codecvt.inout">[locale.codecvt.inout]</a>
 | Value     | Meaning                                                                                          |
 | --------- | ------------------------------------------------------------------------------------------------ |
 | `ok`      | completed the conversion                                                                         |
 | `partial` | not all source characters converted                                                              |
 ``` cpp
 result do_unshift(stateT& state, externT* to, externT* to_end, externT*& to_next) const;
 ```
+*Preconditions:* `(to <= to_end)` is well-defined and `true`; `state` is
+initialized, if at the beginning of a sequence, or else is equal to the
+result of converting the preceding characters in the sequence.
 *Effects:* Places characters starting at `to` that should be appended to
 terminate a sequence when the current `stateT` is given by `state`.[^9]
 Stores no more than `(to_end - to)` destination elements, and leaves the
 `to_next` pointer pointing one beyond the last element successfully
 stored.
 *Returns:* An enumeration value, as summarized in
+[[locale.codecvt.unshift]].
+**Table: `do_unshift` result values** <a id="locale.codecvt.unshift">[locale.codecvt.unshift]</a>
 | Value     | Meaning                                                                                                              |
 | --------- | -------------------------------------------------------------------------------------------------------------------- |
 | `ok`      | completed the sequence                                                                                               |
 | `partial` | space for more than `to_end - to` destination elements was needed to terminate a sequence given the value of `state` |
 ``` cpp
 int do_length(stateT& state, const externT* from, const externT* from_end, size_t max) const;
 ```
+*Preconditions:* `(from <= from_end)` is well-defined and `true`;
+`state` is initialized, if at the beginning of a sequence, or else is
+equal to the result of converting the preceding characters in the
+sequence.
+*Effects:* 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
   template<class internT, class externT, class stateT>
     class codecvt_byname : public codecvt<internT, externT, stateT> {
     public:
       explicit codecvt_byname(const char*, size_t refs = 0);
       explicit codecvt_byname(const string&, size_t refs = 0);
     protected:
       ~codecvt_byname();
     };
 }
 ```
 Implementations may (but are not required to) delegate extraction of
 smaller types to extractors for larger types.[^11]
 All specifications of member functions for `num_put` and `num_get` in
 the subclauses of  [[category.numeric]] only apply to the
+specializations required in Tables  [[tab:locale.category.facets]] and
+[[tab:locale.spec]] [[locale.category]], namely `num_get<char>`,
+`num_get<wchar_t>`, `num_get<C, InputIterator>`, `num_put<char>`,
+`num_put<wchar_t>`, and `num_put<C, OutputIterator>`. These
+specializations refer to the `ios_base&` argument for formatting
+specifications [[locale.categories]], and to its imbued locale for the
+`numpunct<>` facet to identify all numeric punctuation preferences, and
+also for the `ctype<>` facet to perform character classification.
 Extractor and inserter members of the standard iostreams use `num_get<>`
 and `num_put<>` member functions for formatting and parsing numeric
 values ([[istream.formatted.reqmts]], [[ostream.formatted.reqmts]]).
 ```
 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,
 fmtflags uppercase = (flags & ios_base::uppercase);
 fmtflags boolalpha = (flags & ios_base::boolalpha);
 ```
 For conversion to an integral type, the function determines the integral
+conversion specifier as indicated in [[facet.num.get.int]]. The
+table is ordered. That is, the first line whose condition is true
+applies.
+**Table: Integer conversions** <a id="facet.num.get.int">[facet.num.get.int]</a>
 | State                    | `stdio` equivalent |
 | ------------------------ | ------------------ |
 | `basefield == oct`       | `%o`               |
 | `basefield == hex`       | `%X`               |
 | `basefield == 0`         | `%i` `signed` integral type | `%d` |
 | `unsigned` integral type | `%u`               |
+For conversions to a floating-point type the specifier is `%g`.
 For conversions to `void*` the specifier is `%p`.
 A length modifier is added to the conversion specification, if needed,
+as indicated in [[facet.num.get.length]].
+**Table: Length modifier** <a id="facet.num.get.length">[facet.num.get.length]</a>
 | Type                 | Length modifier |
 | -------------------- | --------------- |
 | `short`              | `h`             |
 | `unsigned short`     | `h`             |
 ```
 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;
 iter_type do_put(iter_type out, ios_base& str, char_type fill, long double val) const;
 iter_type do_put(iter_type out, ios_base& str, char_type fill, const void* val) const;
 ```
 *Effects:* Writes characters to the sequence `out`, formatting `val` as
+desired. In the following description, `loc` names a local variable
+initialized as
 ``` cpp
 locale loc = str.getloc();
 ```
 The details of this operation occur in several stages:
 - Stage 1: Determine a printf conversion specifier `spec` and determine
+  the characters that would be printed by `printf` [[c.files]] given
   this conversion specifier for
   ``` cpp
   printf(spec, val)
   ```
   assuming that the current locale is the `"C"` locale.
 - Stage 2: Adjust the representation by converting each `char`
   determined by stage 1 to a `charT` using a conversion and values
+  returned by members of `use_facet<numpunct<charT>>(loc)`.
 - Stage 3: Determine where padding is required.
 - Stage 4: Insert the sequence into the `out`.
 Detailed descriptions of each stage follow.
 line whose condition is true applies. A line without a condition is the
 default behavior when none of the earlier lines apply.
 For conversion from an integral type other than a character type, the
 function determines the integral conversion specifier as indicated in
+[[facet.num.put.int]].
+**Table: Integer conversions** <a id="facet.num.put.int">[facet.num.put.int]</a>
 | State                                        | `stdio` equivalent |
 | -------------------------------------------- | ------------------ |
 | `basefield == ios_base::oct`                 | `%o`               |
 | `(basefield == ios_base::hex) && !uppercase` | `%x`               |
 | for an `unsigned` integral type              | `%u`               |
 For conversion from a floating-point type, the function determines the
 floating-point conversion specifier as indicated in
+[[facet.num.put.fp]].
+**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`               |
 | otherwise                                                              | `%G`               |
 For conversions from an integral or floating-point type a length
 modifier is added to the conversion specifier as indicated in
+[[facet.num.put.length]].
+**Table: Length modifier** <a id="facet.num.put.length">[facet.num.put.length]</a>
 | Type                 | Length modifier |
 | -------------------- | --------------- |
 | `long`               | `l`             |
 | `long long`          | `ll`            |
 | `long double`        | `L`             |
 | otherwise            | none            |
 The conversion specifier has the following optional additional
+qualifiers prepended as indicated in [[facet.num.put.conv]].
+**Table: Numeric conversions** <a id="facet.num.put.conv">[facet.num.put.conv]</a>
 | Type(s)               | State       | `stdio` equivalent |
 | --------------------- | ----------- | ------------------ |
 | an integral type      | `showpos`   | `+`                |
 |                       | `showbase`  | `#`                |
 conversion specifier determined above.
 - **Stage 2:**
 Any character `c` other than a decimal point(.) is converted to a
+`charT` via
+``` cpp
+use_facet<ctype<charT>>(loc).widen(c)
+```
 A local variable `punct` is initialized via
 ``` cpp
+const numpunct<charT>& punct = use_facet<numpunct<charT>>(loc);
 ```
 For arithmetic types, `punct.thousands_sep()` characters are inserted
 into the sequence as determined by the value returned by
 `punct.do_grouping()` using the method described
 ``` cpp
 fmtflags adjustfield = (flags & (ios_base::adjustfield));
 ```
 The location of any padding[^12] is determined according to
+[[facet.num.put.fill]].
+**Table: Fill padding** <a id="facet.num.put.fill">[facet.num.put.fill]</a>
 | State                                                                          | Location           |
 | ------------------------------------------------------------------------------ | ------------------ |
 | `adjustfield == ios_base::left`                                                | pad after          |
 | `adjustfield == ios_base::right`                                               | pad before         |
 }
 ```
 `numpunct<>`
+specifies numeric punctuation. The specializations required in
+[[locale.category.facets]] [[locale.category]], namely
 `numpunct<{}wchar_t>` and `numpunct<char>`, provide classic `"C"`
 numeric formats, i.e., they contain information equivalent to that
 contained in the `"C"` locale or their wide character counterparts as if
 obtained by a call to `widen`.
+The syntax for number formats is as follows, where represents the radix
+set specified by the `fmtflags` argument value, and and are the results
+of corresponding `numpunct<charT>` members. Integer values have the
+format:
+``` bnf
+intval:
+ signₒₚₜ units
+```
+``` bnf
+sign:
+    '+'
+    '-'
+```
+``` bnf
+units:
+    digits
+    digits thousands-sep units
+```
+``` bnf
+digits:
+    digit digitsₒₚₜ
 ```
 and floating-point values have:
+``` bnf
+floatval:
+ signₒₚₜ units fractionalₒₚₜ exponentₒₚₜ
+    signₒₚₜ decimal-point digits exponentₒₚₜ
 ```
+``` bnf
+fractional:
+    decimal-point digitsₒₚₜ
+```
+``` bnf
+exponent:
+    e signₒₚₜ digits
+```
+``` bnf
+e:
+    'e'
+    '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;
 ```
 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;
 ```
 ``` cpp
 string do_grouping() const;
 ```
+*Returns:* A `string` `vec` used as a vector of integer values, in which
+each element `vec[i]` represents the number of digits[^13] in the group
+at position `i`, starting with position 0 as the rightmost group. If
+`vec.size() <= i`, the number is the same as group `(i - 1)`; if
+`(i < 0 || vec[i] <= 0 || vec[i] == CHAR_MAX)`, the size of the digit
+group is unlimited.
 The required specializations return the empty string, indicating no
 grouping.
 ``` cpp
       using char_type   = charT;
       using string_type = basic_string<charT>;
       explicit numpunct_byname(const char*, size_t refs = 0);
       explicit numpunct_byname(const string&, size_t refs = 0);
     protected:
       ~numpunct_byname();
     };
 }
 ```
 ```
 The class `collate<charT>` provides features for use in the collation
 (comparison) and hashing of strings. A locale member function template,
 `operator()`, uses the collate facet to allow a locale to act directly
+as the predicate argument for standard algorithms [[algorithms]] and
+containers operating on strings. The specializations required in
+[[locale.category.facets]] [[locale.category]], namely `collate<char>`
+and `collate<wchar_t>`, apply lexicographic ordering
+[[alg.lex.comparison]].
 Each function compares a string of characters `*p` in the range \[`low`,
 `high`).
+##### 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;
 ```
 *Returns:* `1` if the first string is greater than the second, `-1` if
 less, zero otherwise. The specializations required in
+[[locale.category.facets]][[locale.category]], namely `collate<char>`
+and `collate<wchar_t>`, implement a lexicographical
+comparison [[alg.lex.comparison]].
 ``` cpp
 string_type do_transform(const charT* low, const charT* high) const;
 ```
     public:
       using string_type = basic_string<charT>;
       explicit collate_byname(const char*, size_t refs = 0);
       explicit collate_byname(const string&, size_t refs = 0);
     protected:
       ~collate_byname();
     };
 }
 ```
 Templates `time_get<charT, InputIterator>` and
 `time_put<charT, OutputIterator>` provide date and time formatting and
 parsing. All specifications of member functions for `time_put` and
 `time_get` in the subclauses of  [[category.time]] only apply to the
+specializations required in Tables  [[tab:locale.category.facets]] and
+[[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>
 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;
 ```
 ``` cpp
 iter_type get(iter_type s, iter_type end, ios_base& f, ios_base::iostate& err,
               tm* t, const char_type* fmt, const char_type* fmtend) const;
 ```
+*Preconditions:* \[`fmt`, `fmtend`) is a valid range.
 *Effects:* The function starts by evaluating `err = ios_base::goodbit`.
 It then enters a loop, reading zero or more characters from `s` at each
 iteration. Unless otherwise specified below, the loop terminates when
 the first of the following conditions holds:
 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;
 ```
 *Effects:* Reads characters starting at `s` until it has extracted those
 `struct tm` members and remaining format characters used by
 `time_put<>::put` to produce one of the following formats, or until it
 encounters an error. The format depends on the value returned by
+`date_order()` as shown in [[locale.time.get.dogetdate]].
+**Table: `do_get_date` effects** <a id="locale.time.get.dogetdate">[locale.time.get.dogetdate]</a>
 | `date_order()` | Format     |
 | -------------- | ---------- |
 | `no_order`     | `"%m%d%y"` |
 | `dmy`          | `"%d%m%y"` |
 ``` cpp
 iter_type do_get(iter_type s, iter_type end, ios_base& f,
                  ios_base::iostate& err, tm* t, char format, char modifier) const;
 ```
+*Preconditions:* `t` points to an object.
 *Effects:* The function starts by evaluating `err = ios_base::goodbit`.
 It then reads characters starting at `s` until it encounters an error,
 or until it has extracted and assigned those `struct tm` members, and
 any remaining format characters, corresponding to a conversion directive
 members are unspecified and may be outside their valid range.
 *Remarks:* It is unspecified whether multiple calls to `do_get()` with
 the address of the same `struct tm` object will update the current
 contents of the object or simply overwrite its members. Portable
+programs should zero out the object before invoking the function.
 *Returns:* An iterator pointing immediately beyond the last character
 recognized as possibly part of a valid input sequence for the given
 `format` and `modifier`.
       using dateorder = time_base::dateorder;
       using iter_type = InputIterator;
       explicit time_get_byname(const char*, size_t refs = 0);
       explicit time_get_byname(const string&, size_t refs = 0);
     protected:
       ~time_get_byname();
     };
 }
 ```
                                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,
 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;
 ```
 #### 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> {
     public:
       using char_type = charT;
       using iter_type = OutputIterator;
       explicit time_put_byname(const char*, size_t refs = 0);
       explicit time_put_byname(const string&, size_t refs = 0);
     protected:
       ~time_put_byname();
     };
 }
 ```
 These templates handle monetary formats. A template parameter indicates
 whether local or international monetary formats are to be used.
 All specifications of member functions for `money_put` and `money_get`
 in the subclauses of  [[category.monetary]] only apply to the
+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>
                                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,
+                 ios_base::iostate& err, string_type& digits) const;
 ```
 *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
 `(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*]
 element in the format pattern, no white space is consumed. Otherwise,
 where `money_base::space` appears in any of the initial elements of the
 format pattern, at least one white space character is required. Where
 `money_base::none` appears in any of the initial elements of the format
 pattern, white space is allowed but not required. If
+`(str.flags() & str.showbase)` is `false`, the currency symbol is
+optional and is consumed only if other characters are needed to complete
+the format; otherwise, the currency symbol is required.
 If the first character (if any) in the string `pos` returned by
 `mp.positive_sign()` or the string `neg` returned by
 `mp.negative_sign()` is recognized in the position indicated by `sign`
 in the format pattern, it is consumed and any remaining characters in
                                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,
 ```
 The `moneypunct<>` facet defines monetary formatting parameters used by
 `money_get<>` and `money_put<>`. A monetary format is a sequence of four
 components, specified by a `pattern` value `p`, such that the `part`
+value `static_cast<part>(p.field[i])` determines the `i`ᵗʰ component of
 the format[^21] In the `field` member of a `pattern` object, each value
 `symbol`, `sign`, `value`, and either `space` or `none` appears exactly
 once. The value `none`, if present, is not first; the value `space`, if
 present, is neither first nor last.
 after all other format components. Where `value` appears, the absolute
 numeric monetary value is required.
 The format of the numeric monetary value is a decimal number:
+``` bnf
+value:
+    units fractionalₒₚₜ
     decimal-point digits
 ```
+``` bnf
+fractional:
+    decimal-point digitsₒₚₜ
+```
 if `frac_digits()` returns a positive value, or
+``` bnf
+value:
+    units
 ```
+otherwise. The symbol indicates the character returned by
+`decimal_point()`. The other symbols are defined as follows:
+``` bnf
+units:
+ digits
+    digits thousands-sep units
 ```
+``` bnf
+digits:
+    adigit digitsₒₚₜ
+```
+In the syntax specification, the symbol is any of the values
+`ct.widen(c)` for `c` in the range `'0'` through `'9'` (inclusive) and
 `ct` is a reference of type `const ctype<charT>&` obtained as described
+in the definitions of `money_get<>` and `money_put<>`. The symbol is the
+character returned by `thousands_sep()`. The space character used is the
+value `ct.widen(' ')`. White space characters are those characters `c`
+for which `ci.is(space, c)` returns `true`. The number of digits
+required after the decimal point (if any) is exactly the value returned
+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;
 ```
 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;
 ```
 ``` 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;[^25] `do_negative_sign()` returns the string to
 use to indicate a negative value.
 ``` cpp
 int do_frac_digits() const;
 ```
 *Returns:* The number of digits after the decimal radix separator, if
+any.[^26]
 ``` cpp
 pattern do_pos_format() const;
 pattern do_neg_format() const;
 ```
 *Returns:* The specializations required in
+[[locale.spec]][[locale.category]], namely
+- `moneypunct<char>`,
+- `moneypunct<wchar_t>`,
+- `moneypunct<char, true>`, and
+- `moneypunct<wchar_t, true>`,
+return an object of type `pattern` initialized to
+`{ symbol, sign, none, value }`.[^27]
 #### Class template `moneypunct_byname` <a id="locale.moneypunct.byname">[[locale.moneypunct.byname]]</a>
 ``` cpp
 namespace std {
       using pattern     = money_base::pattern;
       using string_type = basic_string<charT>;
       explicit moneypunct_byname(const char*, size_t refs = 0);
       explicit moneypunct_byname(const string&, size_t refs = 0);
     protected:
       ~moneypunct_byname();
     };
 }
 ```
       using char_type   = charT;
       using string_type = basic_string<charT>;
       explicit messages(size_t refs = 0);
+      catalog open(const string& fn, const locale&) const;
       string_type get(catalog c, int set, int msgid,
                        const string_type& dfault) const;
       void close(catalog c) const;
       static locale::id id;
     protected:
       ~messages();
+      virtual catalog do_open(const string&, const locale&) const;
       virtual string_type do_get(catalog, int set, int msgid,
                                  const string_type& dfault) const;
       virtual void do_close(catalog) const;
     };
 }
 ```
 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;
 ```
 *Returns:* `do_open(name, loc)`.
 ``` cpp
 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;
 ```
 *Returns:* A value that may be passed to `get()` to retrieve a message
 from the message catalog identified by the string `name` according to an
 *implementation-defined* mapping. The result can be used until it is
 ``` cpp
 string_type do_get(catalog cat, int set, int msgid, const string_type& dfault) const;
 ```
+*Preconditions:* `cat` is a catalog obtained from `open()` and not yet
 closed.
 *Returns:* A message identified by arguments `set`, `msgid`, and
 `dfault`, according to an *implementation-defined* mapping. If no such
 message can be found, returns `dfault`.
 ``` cpp
 void do_close(catalog cat) const;
 ```
+*Preconditions:* `cat` is a catalog obtained from `open()` and not yet
 closed.
 *Effects:* Releases unspecified resources associated with `cat`.
 *Remarks:* The limit on such resources, if any, is
       using catalog     = messages_base::catalog;
       using string_type = basic_string<charT>;
       explicit messages_byname(const char*, size_t refs = 0);
       explicit messages_byname(const string&, size_t refs = 0);
     protected:
       ~messages_byname();
     };
 }
 ```
 ## C library locales <a id="c.locales">[[c.locales]]</a>
 ### Header `<clocale>` synopsis <a id="clocale.syn">[[clocale.syn]]</a>
 ``` cpp
 ```
 The contents and meaning of the header `<clocale>` are the same as the C
 standard library header `<locale.h>`.
+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]].
+See also: ISO C 7.11
+**Table: Potential `setlocale` data races** <a id="setlocale.data.races">[setlocale.data.races]</a>
 |           |            |             |              |            |
 | --------- | ---------- | ----------- | ------------ | ---------- |
 | `fprintf` | `isprint`  | `iswdigit`  | `localeconv` | `tolower`  |
 | `fscanf`  | `ispunct`  | `iswgraph`  | `mblen`      | `toupper`  |
 [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.category]: #locale.category
+[locale.category.facets]: #locale.category.facets
 [locale.codecvt]: #locale.codecvt
 [locale.codecvt.byname]: #locale.codecvt.byname
+[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.members]: #locale.collate.members
 [locale.collate.virtuals]: #locale.collate.virtuals
 [locale.nm.put]: #locale.nm.put
 [locale.num.get]: #locale.num.get
 [locale.numpunct]: #locale.numpunct
 [locale.numpunct.byname]: #locale.numpunct.byname
 [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.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 `struct 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 char argument 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.
     vendors do.
 [^18]: Interpretation of the `modifier` argument is
     implementation-defined, but should follow POSIX conventions.
+[^19]: Implementations should refer to other standards such as POSIX for
+    these definitions.
 [^20]: The semantics here are different from `ct.narrow`.
 [^21]: An array of `char`, rather than an array of `part`, is specified
     for `pattern::field` purely for efficiency.
 [^23]: In common U.S. locales this is `’,’`.
 [^24]: To specify grouping by 3s, the value is `"\003"` *not* `"3"`.
+[^25]: This is usually the empty string.
+[^26]: In common U.S. locales, this is 2.
+[^27]: Note that the international symbol returned by `do_curr_symbol()`
     usually contains a space, itself; for example, `"USD "`.

Diff to HTML by rtfpessoa