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

Files changed (1) hide show

tmp/tmp25k5dld8/{from.md → to.md} +242 -272

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

@@ -103,10 +103,12 @@ encapsulate and manipulate the information peculiar to a locale.[^1]
 ## Locales <a id="locales">[[locales]]</a>
 ### Class `locale` <a id="locale">[[locale]]</a>
 ``` cpp
 namespace std {
   class locale {
   public:
     // types
@@ -157,11 +159,11 @@ locale’s set of facets.
 Access to the facets of a `locale` is via two function templates,
 `use_facet<>` and `has_facet<>`.
 [*Example 1*:
-An iostream `operator<<` might be implemented as: [^2]
 ``` cpp
 template<class charT, class traits>
 basic_ostream<charT, traits>&
 operator<< (basic_ostream<charT, traits>& s, Date d) {
@@ -170,11 +172,11 @@ operator<< (basic_ostream<charT, traits>& s, Date d) {
     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;
 }
 ```
@@ -191,12 +193,15 @@ installed in a locale, and used identically as may standard facets.
 All locale semantics are accessed via `use_facet<>` and `has_facet<>`,
 except that:
 - A member operator template
-  `operator()(const basic_string<C, T, A>&, const basic_string<{}C, T, A>&)`
- 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]].)
@@ -245,14 +250,12 @@ that the expression
 is `true`, and represents the union of all categories. Further, the
 expression `(X | Y)`, where `X` and `Y` each represent a single
 category, represents the union of the two categories.
-`locale`
-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>
@@ -369,11 +372,11 @@ facet) when the last `locale` object containing the facet is destroyed;
 for `refs == 1`, the implementation never destroys the facet.
 Constructors of all facets defined in this Clause take such an argument
 and pass it along to their `facet` base class constructor. All
 one-argument constructors defined in this Clause are *explicit*,
-preventing their participation in automatic conversions.
 For some standard facets a standard “…`_byname`” class, derived from it,
 implements the virtual function semantics equivalent to that facet of
 the locale constructed by `locale(const char*)` with the same name. Each
 such facet provides a constructor that takes a `const char*` argument,
@@ -440,51 +443,59 @@ any *implementation-defined* values.
 ``` cpp
 explicit locale(const string& std_name);
 ```
-*Effects:* The same as `locale(std_name.c_str())`.
 ``` cpp
-locale(const locale& other, const char* std_name, category);
 ```
 *Effects:* Constructs a locale as a copy of `other` except for the
 facets identified by the `category` argument, which instead implement
 the same semantics as `locale(std_name)`.
-*Throws:* `runtime_error` if the argument is not valid, or is null.
 *Remarks:* The locale has a name if and only if `other` has a name.
 ``` cpp
-locale(const locale& other, const string& std_name, category cat);
 ```
-*Effects:* The same as `locale(other, std_name.c_str(), cat)`.
 ``` cpp
 template<class Facet> locale(const locale& other, Facet* f);
 ```
 *Effects:* Constructs a locale incorporating all facets from the first
 argument except that of type `Facet`, and installs the second argument
 as the remaining facet. If `f` is null, the resulting object is a copy
 of `other`.
-*Remarks:* The resulting locale has no name.
 ``` cpp
 locale(const locale& other, const locale& one, category cats);
 ```
 *Effects:* Constructs a locale incorporating all facets from the first
 argument except those that implement `cats`, which are instead
 incorporated from the second argument.
-*Remarks:* The resulting locale has a name if and only if the first two
-arguments have names.
 ``` cpp
 const locale& operator=(const locale& other) noexcept;
 ```
@@ -530,25 +541,25 @@ template<class charT, class traits, class Allocator>
                   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(),
-                                         s2.data(), s2.data() + s2.size()) < 0
-```
 [*Example 1*:
 A vector of strings `v` can be collated according to collation rules in
-locale `loc` simply by ([[alg.sort]], [[vector]]):
 ``` cpp
 std::sort(v.begin(), v.end(), loc);
 ```
@@ -569,18 +580,18 @@ 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
 static const locale& classic();
 ```
 The `"C"` locale.
@@ -640,13 +651,11 @@ use_facet<ctype<charT>>(loc).is(ctype_base::F, c)
 ```
 where `F` is the `ctype_base::mask` value corresponding to that function
 [[category.ctype]].[^4]
-#### Conversions <a id="conversions">[[conversions]]</a>
-##### Character conversions <a id="conversions.character">[[conversions.character]]</a>
 ``` cpp
 template<class charT> charT toupper(charT c, const locale& loc);
 ```
@@ -658,10 +667,12 @@ template<class charT> charT tolower(charT c, const locale& loc);
 *Returns:* `use_facet<ctype<charT>>(loc).tolower(c)`.
 ## Standard `locale` categories <a id="locale.categories">[[locale.categories]]</a>
 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
@@ -674,15 +685,17 @@ The `put()` members make no provision for error reporting. (Any failures
 of the OutputIterator argument can be extracted from the returned
 iterator.) The `get()` members take an `ios_base::iostate&` argument
 whose value they ignore, but set to `ios_base::failbit` in case of a
 parse error.
-Within this clause it is unspecified whether one virtual function calls
-another virtual function.
 ### The `ctype` category <a id="category.ctype">[[category.ctype]]</a>
 ``` cpp
 namespace std {
   class ctype_base {
   public:
     using mask = see below;
@@ -706,10 +719,12 @@ namespace std {
 The type `mask` is a bitmask type [[bitmask.types]].
 #### Class template `ctype` <a id="locale.ctype">[[locale.ctype]]</a>
 ``` cpp
 namespace std {
   template<class charT>
     class ctype : public locale::facet, public ctype_base {
     public:
@@ -879,12 +894,14 @@ charT        do_widen(char c) const;
 const char*  do_widen(const char* low, const char* high, charT* dest) const;
 ```
 *Effects:* Applies the simplest reasonable transformation from a `char`
 value or sequence of `char` values to the corresponding `charT` value or
-values.[^5] The only characters for which unique transformations are
-required are those in the basic source character set [[lex.charset]].
 For any named `ctype` category with a `ctype<charT>` facet `ctc` and
 valid `ctype_base::mask` value `M`,
 `(ctc.is(M, c) || !is(M, do_widen(c)) )` is `true`.[^6]
@@ -901,12 +918,12 @@ const charT* do_narrow(const charT* low, const charT* high, char dfault, char* d
 *Effects:* Applies the simplest reasonable transformation from a `charT`
 value or sequence of `charT` values to the corresponding `char` value or
 values.
-For any character `c` in the basic source character set [[lex.charset]]
-the transformation is such that
 ``` cpp
 do_widen(do_narrow(c, 0)) == c
 ```
@@ -944,10 +961,12 @@ namespace std {
 }
 ```
 #### `ctype<char>` specialization <a id="facet.ctype.special">[[facet.ctype.special]]</a>
 ``` cpp
 namespace std {
   template<>
     class ctype<char> : public locale::facet, public ctype_base {
     public:
@@ -991,12 +1010,14 @@ namespace std {
     };
 }
 ```
 A specialization `ctype<char>` is provided so that the member functions
-on type `char` can be implemented inline.[^7] The
-*implementation-defined* value of member `table_size` is at least 256.
 ##### Destructor <a id="facet.ctype.char.dtor">[[facet.ctype.char.dtor]]</a>
 ``` cpp
 ~ctype();
@@ -1120,10 +1141,12 @@ virtual const char* do_narrow(const char* low, const char* high,
 These functions are described identically as those members of the same
 name in the `ctype` class template [[locale.ctype.members]].
 #### Class template `codecvt` <a id="locale.codecvt">[[locale.codecvt]]</a>
 ``` cpp
 namespace std {
   class codecvt_base {
   public:
     enum result { ok, partial, error, noconv };
@@ -1192,19 +1215,19 @@ mapped between.
 The specializations required in [[locale.category.facets]]
 [[locale.category]] convert the implementation-defined native character
 set. `codecvt<char, char, mbstate_t>` implements a degenerate
 conversion; it does not convert at all. The specialization
 `codecvt<char16_t, char8_t, mbstate_t>` converts between the UTF-16 and
-UTF-8 encoding forms, and the specialization `codecvt`
-`<char32_t, char8_t, mbstate_t>` converts between the UTF-32 and UTF-8
-encoding forms. `codecvt<wchar_t, char, mbstate_t>` converts between the
-native character sets for ordinary and wide characters. Specializations
-on `mbstate_t` perform conversion between encodings known to the library
-implementer. Other encodings can be converted by specializing on a
-program-defined `stateT` type. Objects of type `stateT` can contain any
-state that is useful to communicate to or from the specialized `do_in`
-or `do_out` members.
 ##### Members <a id="locale.codecvt.members">[[locale.codecvt.members]]</a>
 ``` cpp
 result out(
@@ -1317,44 +1340,45 @@ shall also return `ok`.[^8]
 [*Note 1*: As a result of operations on `state`, it can return `ok` or
 `partial` and set `from_next == from` and
 `to_next != to`. — *end note*]
-*Remarks:* Its operations on `state` are unspecified.
-[*Note 2*: This argument can be used, for example, to maintain shift
-state, to specify conversion options (such as count only), or to
-identify a cache of seek offsets. — *end note*]
 *Returns:* An enumeration value, as summarized in
 [[locale.codecvt.inout]].
 **Table: `do_in/do_out` result values** <a id="locale.codecvt.inout">[locale.codecvt.inout]</a>
 | Value     | Meaning                                                                                          |
 | --------- | ------------------------------------------------------------------------------------------------ |
 | `ok`      | completed the conversion                                                                         |
 | `partial` | not all source characters converted                                                              |
-| `error`   | encountered a character in {[}`from`, `from_end`{)} that it could not convert                    |
 | `noconv`  | `internT` and `externT` are the same type, and input sequence is identical to converted sequence |
 A return value of `partial`, if `(from_next == from_end)`, indicates
 that either the destination sequence has not absorbed all the available
 destination elements, or that additional source elements are needed
 before another destination element can be produced.
 ``` cpp
 result do_unshift(stateT& state, externT* to, externT* to_end, externT*& to_next) const;
 ```
 *Preconditions:* `(to <= to_end)` is well-defined and `true`; `state` is
 initialized, if at the beginning of a sequence, or else is equal to the
 result of converting the preceding characters in the sequence.
 *Effects:* Places characters starting at `to` that should be appended to
 terminate a sequence when the current `stateT` is given by `state`.[^9]
 Stores no more than `(to_end - to)` destination elements, and leaves the
 `to_next` pointer pointing one beyond the last element successfully
 stored.
 *Returns:* An enumeration value, as summarized in
@@ -1430,10 +1454,12 @@ namespace std {
 }
 ```
 ### The numeric category <a id="category.numeric">[[category.numeric]]</a>
 The classes `num_get<>` and `num_put<>` handle numeric formatting and
 parsing. Virtual functions are provided for several numeric types.
 Implementations may (but are not required to) delegate extraction of
 smaller types to extractors for larger types.[^11]
@@ -1448,14 +1474,16 @@ specifications [[locale.categories]], and to its imbued locale for the
 `numpunct<>` facet to identify all numeric punctuation preferences, and
 also for the `ctype<>` facet to perform character classification.
 Extractor and inserter members of the standard iostreams use `num_get<>`
 and `num_put<>` member functions for formatting and parsing numeric
-values ([[istream.formatted.reqmts]], [[ostream.formatted.reqmts]]).
 #### Class template `num_get` <a id="locale.num.get">[[locale.num.get]]</a>
 ``` cpp
 namespace std {
   template<class charT, class InputIterator = istreambuf_iterator<charT>>
     class num_get : public locale::facet {
     public:
@@ -1586,129 +1614,27 @@ The details of this operation occur in three stages
   determined in stage 1.
 - Stage 3: Store results
 The details of the stages are presented below.
-- **Stage 1:**
-The function initializes local variables via
-``` cpp
-fmtflags flags = str.flags();
-fmtflags basefield = (flags & ios_base::basefield);
-fmtflags uppercase = (flags & ios_base::uppercase);
-fmtflags boolalpha = (flags & ios_base::boolalpha);
-```
-For conversion to an integral type, the function determines the integral
-conversion specifier as indicated in [[facet.num.get.int]]. The
-table is ordered. That is, the first line whose condition is true
-applies.
-**Table: Integer conversions** <a id="facet.num.get.int">[facet.num.get.int]</a>
-| State                    | `stdio` equivalent |
-| ------------------------ | ------------------ |
-| `basefield == oct`       | `%o`               |
-| `basefield == hex`       | `%X`               |
-| `basefield == 0`         | `%i` `signed` integral type | `%d` |
-| `unsigned` integral type | `%u`               |
-For conversions to a floating-point type the specifier is `%g`.
-For conversions to `void*` the specifier is `%p`.
-A length modifier is added to the conversion specification, if needed,
-as indicated in [[facet.num.get.length]].
-**Table: Length modifier** <a id="facet.num.get.length">[facet.num.get.length]</a>
-| Type                 | Length modifier |
-| -------------------- | --------------- |
-| `short`              | `h`             |
-| `unsigned short`     | `h`             |
-| `long`               | `l`             |
-| `unsigned long`      | `l`             |
-| `long long`          | `ll`            |
-| `unsigned long long` | `ll`            |
-| `double`             | `l`             |
-| `long double`        | `L`             |
-- **Stage 2:**
-If `in == end` then stage 2 terminates. Otherwise a `charT` is taken
-from `in` and local variables are initialized as if by
-``` cpp
-char_type ct = *in;
-char c = src[find(atoms, atoms + sizeof(src) - 1, ct) - atoms];
-if (ct == use_facet<numpunct<charT>>(loc).decimal_point())
-c = '.';
-bool discard =
-  ct == use_facet<numpunct<charT>>(loc).thousands_sep()
-  && use_facet<numpunct<charT>>(loc).grouping().length() != 0;
-```
-where the values `src` and `atoms` are defined as if by:
-``` cpp
-static const char src[] = "0123456789abcdefxABCDEFX+-";
-char_type atoms[sizeof(src)];
-use_facet<ctype<charT>>(loc).widen(src, src + sizeof(src), atoms);
-```
-for this value of `loc`.
-If `discard` is `true`, then if `’.’` has not yet been accumulated, then
-the position of the character is remembered, but the character is
-otherwise ignored. Otherwise, if `’.’` has already been accumulated, the
-character is discarded and Stage 2 terminates. If it is not discarded,
-then a check is made to determine if `c` is allowed as the next
-character of an input field of the conversion specifier returned by
-Stage 1. If so, it is accumulated.
-If the character is either discarded or accumulated then `in` is
-advanced by `++in` and processing returns to the beginning of stage 2.
-- **Stage 3:**
-The sequence of `char`s accumulated in stage 2 (the field) is converted
-to a numeric value by the rules of one of the functions declared in the
-header `<cstdlib>`:
-- For a signed integer value, the function `strtoll`.
-- For an unsigned integer value, the function `strtoull`.
-- For a `float` value, the function `strtof`.
-- For a `double` value, the function `strtod`.
-- For a `long double` value, the function `strtold`.
-The numeric value to be stored can be one of:
-- zero, if the conversion function does not convert the entire field.
-- the most positive (or negative) representable value, if the field to
-  be converted to a signed integer type represents a value too large
-  positive (or negative) to be represented in `val`.
-- the most positive representable value, if the field to be converted to
-  an unsigned integer type represents a value that cannot be represented
-  in `val`.
-- the converted value, otherwise.
-The resultant numeric value is stored in `val`. If the conversion
-function does not convert the entire field, or if the field represents a
-value outside the range of representable values, `ios_base::failbit` is
-assigned to `err`.
 Digit grouping is checked. That is, the positions of discarded
-separators is examined for consistency with
 `use_facet<numpunct<charT>>(loc).grouping()`. If they are not consistent
 then `ios_base::failbit` is assigned to `err`.
 In any case, if stage 2 processing was terminated by the test for
 `in == end` then `err |= ios_base::eofbit` is performed.
@@ -1741,11 +1667,11 @@ character successfully matched. If `val` is set, then `err` is set to
 `str.goodbit`; or to `str.eofbit` if, when seeking another character to
 match, it is found that `(in == end)`. If `val` is not set, then `err`
 is set to `str.failbit`; or to `(str.failbit|str.eofbit)` if the reason
 for the failure was that `(in == end)`.
-[*Example 1*: For targets `true`: `"a"` and `false`: `"abb"`, the input
 sequence `"a"` yields `val == true` and `err == str.eofbit`; the input
 sequence `"abc"` yields `err = str.failbit`, with `in` ending at the
 `’c’` element. For targets `true`: `"1"` and `false`: `"0"`, the input
 sequence `"1"` yields `val == true` and `err == str.goodbit`. For empty
 targets `("")`, any input sequence yields
@@ -1753,10 +1679,12 @@ targets `("")`, any input sequence yields
 *Returns:* `in`.
 #### Class template `num_put` <a id="locale.nm.put">[[locale.nm.put]]</a>
 ``` cpp
 namespace std {
   template<class charT, class OutputIterator = ostreambuf_iterator<charT>>
     class num_put : public locale::facet {
     public:
@@ -1956,24 +1884,25 @@ const numpunct<charT>& punct = use_facet<numpunct<charT>>(loc);
 ```
 For arithmetic types, `punct.thousands_sep()` characters are inserted
 into the sequence as determined by the value returned by
 `punct.do_grouping()` using the method described
-in [[facet.numpunct.virtuals]]
-Decimal point characters(.) are replaced by `punct.decimal_point()`
 - **Stage 3:**
 A local variable is initialized as
 ``` cpp
 fmtflags adjustfield = (flags & (ios_base::adjustfield));
 ```
-The location of any padding[^12] is determined according to
-[[facet.num.put.fill]].
 **Table: Fill padding** <a id="facet.num.put.fill">[facet.num.put.fill]</a>
 | State                                                                          | Location           |
 | ------------------------------------------------------------------------------ | ------------------ |
@@ -2018,10 +1947,12 @@ and returns `out`.
 ### The numeric punctuation facet <a id="facet.numpunct">[[facet.numpunct]]</a>
 #### Class template `numpunct` <a id="locale.numpunct">[[locale.numpunct]]</a>
 ``` cpp
 namespace std {
   template<class charT>
     class numpunct : public locale::facet {
     public:
@@ -2047,14 +1978,12 @@ namespace std {
       virtual string_type  do_falsename()     const;            // for bool
     };
 }
 ```
-`numpunct<>`
-specifies numeric punctuation. The specializations required in
-[[locale.category.facets]] [[locale.category]], namely
 `numpunct<{}wchar_t>` and `numpunct<char>`, provide classic `"C"`
 numeric formats, i.e., they contain information equivalent to that
 contained in the `"C"` locale or their wide character counterparts as if
 obtained by a call to `widen`.
@@ -2159,14 +2088,15 @@ required specializations return `’,’` or `L’,’`.
 ``` cpp
 string do_grouping() const;
 ```
 *Returns:* A `string` `vec` used as a vector of integer values, in which
-each element `vec[i]` represents the number of digits[^13] in the group
-at position `i`, starting with position 0 as the rightmost group. If
-`vec.size() <= i`, the number is the same as group `(i - 1)`; if
-`(i < 0 || vec[i] <= 0 || vec[i] == CHAR_MAX)`, the size of the digit
 group is unlimited.
 The required specializations return the empty string, indicating no
 grouping.
@@ -2203,10 +2133,12 @@ namespace std {
 ### The collate category <a id="category.collate">[[category.collate]]</a>
 #### Class template `collate` <a id="locale.collate">[[locale.collate]]</a>
 ``` cpp
 namespace std {
   template<class charT>
     class collate : public locale::facet {
     public:
@@ -2236,11 +2168,11 @@ The class `collate<charT>` provides features for use in the collation
 (comparison) and hashing of strings. A locale member function template,
 `operator()`, uses the collate facet to allow a locale to act directly
 as the predicate argument for standard algorithms [[algorithms]] and
 containers operating on strings. The specializations required in
 [[locale.category.facets]] [[locale.category]], namely `collate<char>`
-and `collate<wchar_t>`, apply lexicographic ordering
 [[alg.lex.comparison]].
 Each function compares a string of characters `*p` in the range \[`low`,
 `high`).
@@ -2293,13 +2225,13 @@ long do_hash(const charT* low, const charT* high) const;
 *Returns:* An integer value equal to the result of calling `hash()` on
 any other string for which `do_compare()` returns 0 (equal) when passed
 the two strings.
-[*Note 1*: The probability that the result equals that for another
-string which does not compare equal should be very small, approaching
-`(1.0/numeric_limits<unsigned long>::max())`. — *end note*]
 #### Class template `collate_byname` <a id="locale.collate.byname">[[locale.collate.byname]]</a>
 ``` cpp
 namespace std {
@@ -2317,10 +2249,12 @@ namespace std {
 }
 ```
 ### The time category <a id="category.time">[[category.time]]</a>
 Templates `time_get<charT, InputIterator>` and
 `time_put<charT, OutputIterator>` provide date and time formatting and
 parsing. All specifications of member functions for `time_put` and
 `time_get` in the subclauses of  [[category.time]] only apply to the
 specializations required in Tables  [[tab:locale.category.facets]] and
@@ -2329,10 +2263,12 @@ specializations required in Tables  [[tab:locale.category.facets]] and
 [[locale.categories]], and the `ctype<>` facet, to determine formatting
 details.
 #### Class template `time_get` <a id="locale.time.get">[[locale.time.get]]</a>
 ``` cpp
 namespace std {
   class time_base {
   public:
     enum dateorder { no_order, dmy, mdy, ymd, ydm };
@@ -2382,19 +2318,17 @@ namespace std {
                                ios_base::iostate& err, tm* t, char format, char modifier) const;
     };
 }
 ```
-`time_get`
-is used to parse a character sequence, extracting components of a time
-or date into a `struct tm` object. Each `get` member parses a format as
-produced by a corresponding format specifier to `time_put<>::put`. If
 the sequence being parsed matches the correct format, the corresponding
-members of the `struct tm` argument are set to the values used to
-produce the sequence; otherwise either an error is reported or
-unspecified values are assigned.[^15]
 If the end iterator is reached during parsing by any of the `get()`
 member functions, the member sets `ios_base::eofbit` in `err`.
 ##### Members <a id="locale.time.get.members">[[locale.time.get.members]]</a>
@@ -2460,12 +2394,12 @@ the first of the following conditions holds:
 - The expression `s == end` evaluates to `true`, in which case the
   function evaluates `err = ios_base::eofbit | ios_base::failbit`.
 - The next element of `fmt` is equal to `’%’`, optionally followed by a
   modifier character, followed by a conversion specifier character,
   `format`, together forming a conversion specification valid for the
- ISO/IEC 9945 function `strptime`. If the number of elements in the
- range \[`fmt`, `fmtend`) is not sufficient to unambiguously determine
   whether the conversion specification is complete and valid, the
   function evaluates `err = ios_base::failbit`. Otherwise, the function
   evaluates `s = do_get(s, end, f, err, t, format, modifier)`, where the
   value of `modifier` is `’\0’` when the optional modifier is absent
   from the conversion specification. If `err == ios_base::goodbit` holds
@@ -2496,37 +2430,38 @@ so. — *end note*]
 dateorder do_date_order() const;
 ```
 *Returns:* An enumeration value indicating the preferred order of
 components for those date formats that are composed of day, month, and
-year.[^16] Returns `no_order` if the date format specified by `’x’`
-contains other variable components (e.g., Julian day, week number, week
-day).
 ``` cpp
 iter_type do_get_time(iter_type s, iter_type end, ios_base& str,
                       ios_base::iostate& err, tm* t) const;
 ```
 *Effects:* Reads characters starting at `s` until it has extracted those
-`struct tm` members, and remaining format characters, used by
-`time_put<>::put` to produce the format specified by `"%H:%M:%S"`, or
-until it encounters an error or end of sequence.
 *Returns:* An iterator pointing immediately beyond the last character
 recognized as possibly part of a valid time.
 ``` cpp
 iter_type do_get_date(iter_type s, iter_type end, ios_base& str,
                       ios_base::iostate& err, tm* t) const;
 ```
 *Effects:* Reads characters starting at `s` until it has extracted those
-`struct tm` members and remaining format characters used by
-`time_put<>::put` to produce one of the following formats, or until it
-encounters an error. The format depends on the value returned by
-`date_order()` as shown in [[locale.time.get.dogetdate]].
 **Table: `do_get_date` effects** <a id="locale.time.get.dogetdate">[locale.time.get.dogetdate]</a>
 | `date_order()` | Format     |
 | -------------- | ---------- |
@@ -2550,13 +2485,13 @@ iter_type do_get_monthname(iter_type s, iter_type end, ios_base& str,
                            ios_base::iostate& err, tm* t) const;
 ```
 *Effects:* Reads characters starting at `s` until it has extracted the
 (perhaps abbreviated) name of a weekday or month. If it finds an
-abbreviation that is followed by characters that could match a full
-name, it continues reading until it matches the full name or fails. It
-sets the appropriate `struct tm` member accordingly.
 *Returns:* An iterator pointing immediately beyond the last character
 recognized as part of a valid name.
 ``` cpp
@@ -2579,36 +2514,36 @@ iter_type do_get(iter_type s, iter_type end, ios_base& f,
 *Preconditions:* `t` points to an object.
 *Effects:* The function starts by evaluating `err = ios_base::goodbit`.
 It then reads characters starting at `s` until it encounters an error,
-or until it has extracted and assigned those `struct tm` members, and
-any remaining format characters, corresponding to a conversion directive
-appropriate for the ISO/IEC 9945 function `strptime`, formed by
-concatenating `’%’`, the `modifier` character, when non-NUL, and the
-`format` character. When the concatenation fails to yield a complete
-valid directive the function leaves the object pointed to by `t`
-unchanged and evaluates `err |= ios_base::failbit`. When `s == end`
-evaluates to `true` after reading a character the function evaluates
 `err |= ios_base::eofbit`.
-For complex conversion directives such as `%c`, `%x`, or `%X`, or
-directives that involve the optional modifiers `E` or `O`, when the
-function is unable to unambiguously determine some or all `struct tm`
-members from the input sequence \[`s`, `end`), it evaluates
-`err |= ios_base::eofbit`. In such cases the values of those `struct tm`
 members are unspecified and may be outside their valid range.
-*Remarks:* It is unspecified whether multiple calls to `do_get()` with
-the address of the same `struct tm` object will update the current
-contents of the object or simply overwrite its members. Portable
-programs should zero out the object before invoking the function.
 *Returns:* An iterator pointing immediately beyond the last character
 recognized as possibly part of a valid input sequence for the given
 `format` and `modifier`.
 #### Class template `time_get_byname` <a id="locale.time.get.byname">[[locale.time.get.byname]]</a>
 ``` cpp
 namespace std {
   template<class charT, class InputIterator = istreambuf_iterator<charT>>
@@ -2671,18 +2606,20 @@ call to `do_put`; thus, format elements and other characters are
 interleaved in the output in the order in which they appear in the
 pattern. Format sequences are identified by converting each character
 `c` to a `char` value as if by `ct.narrow(c, 0)`, where `ct` is a
 reference to `ctype<charT>` obtained from `str.getloc()`. The first
 character of each sequence is equal to `’%’`, followed by an optional
-modifier character `mod`[^17] and a format specifier character `spec` as
-defined for the function `strftime`. If no modifier character is
-present, `mod` is zero. For each valid format sequence identified, calls
 `do_put(s, str, fill, t, spec, mod)`.
 The second form calls `do_put(s, str, fill, t, format, modifier)`.
-[*Note 1*: The `fill` argument may be used in the
 implementation-defined formats or by derivations. A space character is a
 reasonable default for this argument. — *end note*]
 *Returns:* An iterator pointing immediately after the last character
 produced.
@@ -2696,21 +2633,29 @@ iter_type do_put(iter_type s, ios_base&, char_type fill, const tm* t,
 *Effects:* Formats the contents of the parameter `t` into characters
 placed on the output sequence `s`. Formatting is controlled by the
 parameters `format` and `modifier`, interpreted identically as the
 format specifiers in the string argument to the standard library
-function `strftime()`[^18], except that the sequence of characters
-produced for those specifiers that are described as depending on the C
-locale are instead *implementation-defined*.[^19]
 *Returns:* An iterator pointing immediately after the last character
 produced.
-[*Note 2*: The `fill` argument may be used in the
 implementation-defined formats or by derivations. A space character is a
 reasonable default for this argument. — *end note*]
 #### Class template `time_put_byname` <a id="locale.time.put.byname">[[locale.time.put.byname]]</a>
 ``` cpp
 namespace std {
   template<class charT, class OutputIterator = ostreambuf_iterator<charT>>
@@ -2728,10 +2673,12 @@ namespace std {
 }
 ```
 ### The monetary category <a id="category.monetary">[[category.monetary]]</a>
 These templates handle monetary formats. A template parameter indicates
 whether local or international monetary formats are to be used.
 All specifications of member functions for `money_put` and `money_get`
 in the subclauses of  [[category.monetary]] only apply to the
@@ -2848,11 +2795,11 @@ the result is given a positive sign.
 Digits in the numeric monetary component are extracted and placed in
 `digits`, or into a character buffer `buf1` for conversion to produce a
 value for `units`, in the order in which they appear, preceded by a
 minus sign if and only if the result is negative. The value `units` is
-produced as if by[^20]
 ``` cpp
 for (int i = 0; i < n; ++i)
   buf2[i] = src[find(atoms, atoms+sizeof(src), buf1[i]) - atoms];
 buf2[n] = 0;
@@ -2939,10 +2886,13 @@ minus sign) in `digits` or `buf2`. In `digits`, only the optional
 leading minus sign and the immediately subsequent digit characters (as
 classified according to `ct`) are used; any trailing characters
 (including digits appearing after a non-digit character) are ignored.
 Calls `str.width(0)`.
 *Remarks:* The currency symbol is generated if and only if
 `(str.flags() & str.showbase)` is nonzero. If the number of characters
 generated for the specified format is less than the value returned by
 `str.width()` on entry to the function, then copies of `fill` are
 inserted as necessary to pad to the specified width. For the value `af`
@@ -2954,15 +2904,14 @@ before the other characters.
 [*Note 1*: It is possible, with some combinations of format patterns
 and flag values, to produce output that cannot be parsed using
 `num_get<>::get`. — *end note*]
-*Returns:* An iterator pointing immediately after the last character
-produced.
 #### Class template `moneypunct` <a id="locale.moneypunct">[[locale.moneypunct]]</a>
 ``` cpp
 namespace std {
   class money_base {
   public:
     enum part { none, space, symbol, sign, value };
@@ -3007,14 +2956,16 @@ namespace std {
 The `moneypunct<>` facet defines monetary formatting parameters used by
 `money_get<>` and `money_put<>`. A monetary format is a sequence of four
 components, specified by a `pattern` value `p`, such that the `part`
 value `static_cast<part>(p.field[i])` determines the `i`ᵗʰ component of
-the format[^21] In the `field` member of a `pattern` object, each value
-`symbol`, `sign`, `value`, and either `space` or `none` appears exactly
-once. The value `none`, if present, is not first; the value `space`, if
-present, is neither first nor last.
 Where `none` or `space` appears, whitespace is permitted in the format,
 except where `none` appears at the end, in which case no whitespace is
 permitted. The value `space` indicates that at least one space is
 required at that position. Where `symbol` appears, the sequence of
@@ -3096,25 +3047,25 @@ corresponding virtual member function `do_F()`.
 ``` cpp
 charT do_decimal_point() const;
 ```
 *Returns:* The radix separator to use in case `do_frac_digits()` is
-greater than zero.[^22]
 ``` cpp
 charT do_thousands_sep() const;
 ```
 *Returns:* The digit group separator to use in case `do_grouping()`
-specifies a digit grouping pattern.[^23]
 ``` cpp
 string do_grouping() const;
 ```
 *Returns:* A pattern defined identically as, but not necessarily equal
-to, the result of `numpunct<charT>::do_grouping()`.[^24]
 ``` cpp
 string_type do_curr_symbol() const;
 ```
@@ -3128,19 +3079,21 @@ specified by ISO 4217 followed by a space. — *end note*]
 string_type do_positive_sign() const;
 string_type do_negative_sign() const;
 ```
 *Returns:* `do_positive_sign()` returns the string to use to indicate a
-positive monetary value;[^25] `do_negative_sign()` returns the string to
-use to indicate a negative value.
 ``` cpp
 int do_frac_digits() const;
 ```
 *Returns:* The number of digits after the decimal radix separator, if
-any.[^26]
 ``` cpp
 pattern do_pos_format() const;
 pattern do_neg_format() const;
 ```
@@ -3152,11 +3105,11 @@ pattern do_neg_format() const;
 - `moneypunct<wchar_t>`,
 - `moneypunct<char, true>`, and
 - `moneypunct<wchar_t, true>`,
 return an object of type `pattern` initialized to
-`{ symbol, sign, none, value }`.[^27]
 #### Class template `moneypunct_byname` <a id="locale.moneypunct.byname">[[locale.moneypunct.byname]]</a>
 ``` cpp
 namespace std {
@@ -3175,15 +3128,19 @@ namespace std {
 }
 ```
 ### The message retrieval category <a id="category.messages">[[category.messages]]</a>
 Class `messages<charT>` implements retrieval of strings from message
 catalogs.
 #### Class template `messages` <a id="locale.messages">[[locale.messages]]</a>
 ``` cpp
 namespace std {
   class messages_base {
   public:
     using catalog = unspecified signed integer type;
@@ -3317,10 +3274,12 @@ 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 [[setlocale.data.races]].
 See also: ISO C 7.11
@@ -3349,23 +3308,29 @@ See also: ISO C 7.11
 [bitmask.types]: library.md#bitmask.types
 [c.files]: input.md#c.files
 [c.locales]: #c.locales
 [category.collate]: #category.collate
 [category.ctype]: #category.ctype
 [category.messages]: #category.messages
 [category.monetary]: #category.monetary
 [category.numeric]: #category.numeric
 [category.time]: #category.time
 [classification]: #classification
 [clocale.syn]: #clocale.syn
-[conversions]: #conversions
 [conversions.character]: #conversions.character
 [facet.ctype.char.dtor]: #facet.ctype.char.dtor
 [facet.ctype.char.members]: #facet.ctype.char.members
 [facet.ctype.char.statics]: #facet.ctype.char.statics
 [facet.ctype.char.virtuals]: #facet.ctype.char.virtuals
 [facet.ctype.special]: #facet.ctype.special
 [facet.num.get.members]: #facet.num.get.members
 [facet.num.get.virtuals]: #facet.num.get.virtuals
 [facet.num.put.members]: #facet.num.put.members
 [facet.num.put.virtuals]: #facet.num.put.virtuals
 [facet.numpunct]: #facet.numpunct
@@ -3377,57 +3342,68 @@ See also: ISO C 7.11
 [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.cons]: #locale.cons
 [locale.convenience]: #locale.convenience
 [locale.ctype]: #locale.ctype
 [locale.ctype.byname]: #locale.ctype.byname
 [locale.ctype.members]: #locale.ctype.members
 [locale.ctype.virtuals]: #locale.ctype.virtuals
 [locale.facet]: #locale.facet
 [locale.global.templates]: #locale.global.templates
 [locale.id]: #locale.id
 [locale.members]: #locale.members
 [locale.messages]: #locale.messages
 [locale.messages.byname]: #locale.messages.byname
 [locale.messages.members]: #locale.messages.members
 [locale.messages.virtuals]: #locale.messages.virtuals
 [locale.money.get]: #locale.money.get
 [locale.money.get.members]: #locale.money.get.members
 [locale.money.get.virtuals]: #locale.money.get.virtuals
 [locale.money.put]: #locale.money.put
 [locale.money.put.members]: #locale.money.put.members
 [locale.money.put.virtuals]: #locale.money.put.virtuals
 [locale.moneypunct]: #locale.moneypunct
 [locale.moneypunct.byname]: #locale.moneypunct.byname
 [locale.moneypunct.members]: #locale.moneypunct.members
 [locale.moneypunct.virtuals]: #locale.moneypunct.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
@@ -3443,12 +3419,12 @@ See also: ISO C 7.11
 [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
@@ -3456,11 +3432,11 @@ See also: ISO C 7.11
     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.
@@ -3469,20 +3445,20 @@ See also: ISO C 7.11
     provided. The specialization is specified in the standard, and not
     left as an implementation detail, because it affects the derivation
     interface for `ctype<char>`.
 [^8]: Informally, this means that `basic_filebuf` assumes that the
-    mappings from internal to external characters is 1 to N: a `codecvt`
-    facet that is used by `basic_filebuf` must be able to translate
     characters one internal character at a time.
 [^9]: Typically these will be characters to return the state to
     `stateT()`.
 [^10]: If `encoding()` yields `-1`, then more than `max_length()`
-    `externT` elements may be consumed when producing a single `internT`
-    character, and additional `externT` elements may appear at the end
     of a sequence after those that yield the final `internT` character.
 [^11]: Parsing `"-1"` correctly into, e.g., an `unsigned short` requires
     that the corresponding member `get()` at least extract the sign
     before delegating.
@@ -3501,33 +3477,27 @@ See also: ISO C 7.11
     parsing of user-entered dates and times, but machine-generated
     formats can be parsed reliably. This allows parsers to be aggressive
     about interpreting user variations on standard formats.
 [^16]: This function is intended as a convenience only, for common
-    formats, and may return `no_order` in valid locales.
 [^17]: Although the C programming language defines no modifiers, most
     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.
-[^22]: In common U.S. locales this is `’.’`.
-[^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 "`.

 ## Locales <a id="locales">[[locales]]</a>
 ### Class `locale` <a id="locale">[[locale]]</a>
+#### General <a id="locale.general">[[locale.general]]</a>
 ``` cpp
 namespace std {
   class locale {
   public:
     // types
 Access to the facets of a `locale` is via two function templates,
 `use_facet<>` and `has_facet<>`.
 [*Example 1*:
+An iostream `operator<<` can be implemented as:[^2]
 ``` cpp
 template<class charT, class traits>
 basic_ostream<charT, traits>&
 operator<< (basic_ostream<charT, traits>& s, Date d) {
     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);     // can throw
   }
   return s;
 }
 ```
 All locale semantics are accessed via `use_facet<>` and `has_facet<>`,
 except that:
 - A member operator template
+  ``` cpp
+ operator()(const basic_string<C, T, A>&, const basic_string<C, T, A>&)
+  ```
+  is provided so that a locale can 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]].)
 is `true`, and represents the union of all categories. Further, the
 expression `(X | Y)`, where `X` and `Y` each represent a single
 category, represents the union of the two categories.
+`locale` 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>
 for `refs == 1`, the implementation never destroys the facet.
 Constructors of all facets defined in this Clause take such an argument
 and pass it along to their `facet` base class constructor. All
 one-argument constructors defined in this Clause are *explicit*,
+preventing their participation in implicit conversions.
 For some standard facets a standard “…`_byname`” class, derived from it,
 implements the virtual function semantics equivalent to that facet of
 the locale constructed by `locale(const char*)` with the same name. Each
 such facet provides a constructor that takes a `const char*` argument,
 ``` cpp
 explicit locale(const string& std_name);
 ```
+*Effects:* Equivalent to `locale(std_name.c_str())`.
 ``` cpp
+locale(const locale& other, const char* std_name, category cats);
 ```
+*Preconditions:* `cats` is a valid `category` value [[locale.category]].
 *Effects:* Constructs a locale as a copy of `other` except for the
 facets identified by the `category` argument, which instead implement
 the same semantics as `locale(std_name)`.
+*Throws:* `runtime_error` if the second argument is not valid, or is
+null.
 *Remarks:* The locale has a name if and only if `other` has a name.
 ``` cpp
+locale(const locale& other, const string& std_name, category cats);
 ```
+*Effects:* Equivalent to `locale(other, std_name.c_str(), cats)`.
 ``` cpp
 template<class Facet> locale(const locale& other, Facet* f);
 ```
 *Effects:* Constructs a locale incorporating all facets from the first
 argument except that of type `Facet`, and installs the second argument
 as the remaining facet. If `f` is null, the resulting object is a copy
 of `other`.
+*Remarks:* If `f` is null, the resulting locale has the same name as
+`other`. Otherwise, the resulting locale has no name.
 ``` cpp
 locale(const locale& other, const locale& one, category cats);
 ```
+*Preconditions:* `cats` is a valid `category` value.
 *Effects:* Constructs a locale incorporating all facets from the first
 argument except those that implement `cats`, which are instead
 incorporated from the second argument.
+*Remarks:* If `cats` is equal to `locale::none`, the resulting locale
+has a name if and only if the first argument has a name. Otherwise, the
+resulting locale has a name if and only if the first two arguments both
+have names.
 ``` cpp
 const locale& operator=(const locale& other) noexcept;
 ```
                   const basic_string<charT, traits, Allocator>& s2) const;
 ```
 *Effects:* Compares two strings according to the `collate<charT>` facet.
+*Returns:*
+``` cpp
+use_facet<collate<charT>>(*this).compare(s1.data(), s1.data() + s1.size(),
+                                         s2.data(), s2.data() + s2.size()) < 0
+```
 *Remarks:* This member operator template (and therefore `locale` itself)
 meets the requirements for a comparator predicate template
 argument [[algorithms]] applied to strings.
 [*Example 1*:
 A vector of strings `v` can be collated according to collation rules in
+locale `loc` simply by [[alg.sort]], [[vector]]:
 ``` cpp
 std::sort(v.begin(), v.end(), loc);
 ```
 ```
 otherwise, the effect on the C locale, if any, is
 *implementation-defined*.
+*Returns:* The previous value of `locale()`.
 *Remarks:* No library function other than `locale::global()` affects the
 value returned by `locale()`.
 [*Note 1*: See  [[c.locales]] for data race considerations when
 `setlocale` is invoked. — *end note*]
 ``` cpp
 static const locale& classic();
 ```
 The `"C"` locale.
 ```
 where `F` is the `ctype_base::mask` value corresponding to that function
 [[category.ctype]].[^4]
+#### Character conversions <a id="conversions.character">[[conversions.character]]</a>
 ``` cpp
 template<class charT> charT toupper(charT c, const locale& loc);
 ```
 *Returns:* `use_facet<ctype<charT>>(loc).tolower(c)`.
 ## Standard `locale` categories <a id="locale.categories">[[locale.categories]]</a>
+### General <a id="locale.categories.general">[[locale.categories.general]]</a>
 Each of the standard categories includes a family of facets. Some of
 these implement formatting or parsing of a datum, for use by standard or
 users’ iostream operators `<<` and `>>`, as members `put()` and `get()`,
 respectively. Each such member function takes an `ios_base&` argument
 whose members `flags()`, `precision()`, and `width()`, specify the
 of the OutputIterator argument can be extracted from the returned
 iterator.) The `get()` members take an `ios_base::iostate&` argument
 whose value they ignore, but set to `ios_base::failbit` in case of a
 parse error.
+Within subclause [[locale.categories]] it is unspecified whether one
+virtual function calls another virtual function.
 ### The `ctype` category <a id="category.ctype">[[category.ctype]]</a>
+#### General <a id="category.ctype.general">[[category.ctype.general]]</a>
 ``` cpp
 namespace std {
   class ctype_base {
   public:
     using mask = see below;
 The type `mask` is a bitmask type [[bitmask.types]].
 #### Class template `ctype` <a id="locale.ctype">[[locale.ctype]]</a>
+##### General <a id="locale.ctype.general">[[locale.ctype.general]]</a>
 ``` cpp
 namespace std {
   template<class charT>
     class ctype : public locale::facet, public ctype_base {
     public:
 const char*  do_widen(const char* low, const char* high, charT* dest) const;
 ```
 *Effects:* Applies the simplest reasonable transformation from a `char`
 value or sequence of `char` values to the corresponding `charT` value or
+values.[^5]
+The only characters for which unique transformations are required are
+those in the basic character set [[lex.charset]].
 For any named `ctype` category with a `ctype<charT>` facet `ctc` and
 valid `ctype_base::mask` value `M`,
 `(ctc.is(M, c) || !is(M, do_widen(c)) )` is `true`.[^6]
 *Effects:* Applies the simplest reasonable transformation from a `charT`
 value or sequence of `charT` values to the corresponding `char` value or
 values.
+For any character `c` in the basic character set [[lex.charset]] the
+transformation is such that
 ``` cpp
 do_widen(do_narrow(c, 0)) == c
 ```
 }
 ```
 #### `ctype<char>` specialization <a id="facet.ctype.special">[[facet.ctype.special]]</a>
+##### General <a id="facet.ctype.special.general">[[facet.ctype.special.general]]</a>
 ``` cpp
 namespace std {
   template<>
     class ctype<char> : public locale::facet, public ctype_base {
     public:
     };
 }
 ```
 A specialization `ctype<char>` is provided so that the member functions
+on type `char` can be implemented inline.[^7]
+The *implementation-defined* value of member `table_size` is at least
+256.
 ##### Destructor <a id="facet.ctype.char.dtor">[[facet.ctype.char.dtor]]</a>
 ``` cpp
 ~ctype();
 These functions are described identically as those members of the same
 name in the `ctype` class template [[locale.ctype.members]].
 #### Class template `codecvt` <a id="locale.codecvt">[[locale.codecvt]]</a>
+##### General <a id="locale.codecvt.general">[[locale.codecvt.general]]</a>
 ``` cpp
 namespace std {
   class codecvt_base {
   public:
     enum result { ok, partial, error, noconv };
 The specializations required in [[locale.category.facets]]
 [[locale.category]] convert the implementation-defined native character
 set. `codecvt<char, char, mbstate_t>` implements a degenerate
 conversion; it does not convert at all. The specialization
 `codecvt<char16_t, char8_t, mbstate_t>` converts between the UTF-16 and
+UTF-8 encoding forms, and the specialization
+`codecvt<char32_t, char8_t, mbstate_t>` converts between the UTF-32 and
+UTF-8 encoding forms. `codecvt<wchar_t, char, mbstate_t>` converts
+between the native character sets for ordinary and wide characters.
+Specializations on `mbstate_t` perform conversion between encodings
+known to the library implementer. Other encodings can be converted by
+specializing on a program-defined `stateT` type. Objects of type
+`stateT` can contain any state that is useful to communicate to or from
+the specialized `do_in` or `do_out` members.
 ##### Members <a id="locale.codecvt.members">[[locale.codecvt.members]]</a>
 ``` cpp
 result out(
 [*Note 1*: As a result of operations on `state`, it can return `ok` or
 `partial` and set `from_next == from` and
 `to_next != to`. — *end note*]
 *Returns:* An enumeration value, as summarized in
 [[locale.codecvt.inout]].
 **Table: `do_in/do_out` result values** <a id="locale.codecvt.inout">[locale.codecvt.inout]</a>
 | Value     | Meaning                                                                                          |
 | --------- | ------------------------------------------------------------------------------------------------ |
 | `ok`      | completed the conversion                                                                         |
 | `partial` | not all source characters converted                                                              |
+| `error`   | encountered a character in {[}`from`, `from_end`{)} that cannot be converted                     |
 | `noconv`  | `internT` and `externT` are the same type, and input sequence is identical to converted sequence |
 A return value of `partial`, if `(from_next == from_end)`, indicates
 that either the destination sequence has not absorbed all the available
 destination elements, or that additional source elements are needed
 before another destination element can be produced.
+*Remarks:* Its operations on `state` are unspecified.
+[*Note 2*: This argument can be used, for example, to maintain shift
+state, to specify conversion options (such as count only), or to
+identify a cache of seek offsets. — *end note*]
 ``` cpp
 result do_unshift(stateT& state, externT* to, externT* to_end, externT*& to_next) const;
 ```
 *Preconditions:* `(to <= to_end)` is well-defined and `true`; `state` is
 initialized, if at the beginning of a sequence, or else is equal to the
 result of converting the preceding characters in the sequence.
 *Effects:* Places characters starting at `to` that should be appended to
 terminate a sequence when the current `stateT` is given by `state`.[^9]
 Stores no more than `(to_end - to)` destination elements, and leaves the
 `to_next` pointer pointing one beyond the last element successfully
 stored.
 *Returns:* An enumeration value, as summarized in
 }
 ```
 ### The numeric category <a id="category.numeric">[[category.numeric]]</a>
+#### General <a id="category.numeric.general">[[category.numeric.general]]</a>
 The classes `num_get<>` and `num_put<>` handle numeric formatting and
 parsing. Virtual functions are provided for several numeric types.
 Implementations may (but are not required to) delegate extraction of
 smaller types to extractors for larger types.[^11]
 `numpunct<>` facet to identify all numeric punctuation preferences, and
 also for the `ctype<>` facet to perform character classification.
 Extractor and inserter members of the standard iostreams use `num_get<>`
 and `num_put<>` member functions for formatting and parsing numeric
+values [[istream.formatted.reqmts]], [[ostream.formatted.reqmts]].
 #### Class template `num_get` <a id="locale.num.get">[[locale.num.get]]</a>
+##### General <a id="locale.num.get.general">[[locale.num.get.general]]</a>
 ``` cpp
 namespace std {
   template<class charT, class InputIterator = istreambuf_iterator<charT>>
     class num_get : public locale::facet {
     public:
   determined in stage 1.
 - Stage 3: Store results
 The details of the stages are presented below.
+[*Example 1*:
+Given an input sequence of `"0x1a.bp+07p"`,
+- if the conversion specifier returned by Stage 1 is `%d`, `"0"` is
+  accumulated;
+- if the conversion specifier returned by Stage 1 is `%i`, `"0x1a"` are
+  accumulated;
+- if the conversion specifier returned by Stage 1 is `%g`,
+ `"0x1a.bp+07"` are accumulated.
+In all cases, the remainder is left in the input.
+— *end example*]
 Digit grouping is checked. That is, the positions of discarded
+separators are examined for consistency with
 `use_facet<numpunct<charT>>(loc).grouping()`. If they are not consistent
 then `ios_base::failbit` is assigned to `err`.
 In any case, if stage 2 processing was terminated by the test for
 `in == end` then `err |= ios_base::eofbit` is performed.
 `str.goodbit`; or to `str.eofbit` if, when seeking another character to
 match, it is found that `(in == end)`. If `val` is not set, then `err`
 is set to `str.failbit`; or to `(str.failbit|str.eofbit)` if the reason
 for the failure was that `(in == end)`.
+[*Example 2*: For targets `true`: `"a"` and `false`: `"abb"`, the input
 sequence `"a"` yields `val == true` and `err == str.eofbit`; the input
 sequence `"abc"` yields `err = str.failbit`, with `in` ending at the
 `’c’` element. For targets `true`: `"1"` and `false`: `"0"`, the input
 sequence `"1"` yields `val == true` and `err == str.goodbit`. For empty
 targets `("")`, any input sequence yields
 *Returns:* `in`.
 #### Class template `num_put` <a id="locale.nm.put">[[locale.nm.put]]</a>
+##### General <a id="locale.nm.put.general">[[locale.nm.put.general]]</a>
 ``` cpp
 namespace std {
   template<class charT, class OutputIterator = ostreambuf_iterator<charT>>
     class num_put : public locale::facet {
     public:
 ```
 For arithmetic types, `punct.thousands_sep()` characters are inserted
 into the sequence as determined by the value returned by
 `punct.do_grouping()` using the method described
+in [[facet.numpunct.virtuals]].
+Decimal point characters(.) are replaced by `punct.decimal_point()`.
 - **Stage 3:**
 A local variable is initialized as
 ``` cpp
 fmtflags adjustfield = (flags & (ios_base::adjustfield));
 ```
+The location of any padding[^12]
+is determined according to [[facet.num.put.fill]].
 **Table: Fill padding** <a id="facet.num.put.fill">[facet.num.put.fill]</a>
 | State                                                                          | Location           |
 | ------------------------------------------------------------------------------ | ------------------ |
 ### The numeric punctuation facet <a id="facet.numpunct">[[facet.numpunct]]</a>
 #### Class template `numpunct` <a id="locale.numpunct">[[locale.numpunct]]</a>
+##### General <a id="locale.numpunct.general">[[locale.numpunct.general]]</a>
 ``` cpp
 namespace std {
   template<class charT>
     class numpunct : public locale::facet {
     public:
       virtual string_type  do_falsename()     const;            // for bool
     };
 }
 ```
+`numpunct<>` specifies numeric punctuation. The specializations required
+in [[locale.category.facets]] [[locale.category]], namely
 `numpunct<{}wchar_t>` and `numpunct<char>`, provide classic `"C"`
 numeric formats, i.e., they contain information equivalent to that
 contained in the `"C"` locale or their wide character counterparts as if
 obtained by a call to `widen`.
 ``` cpp
 string do_grouping() const;
 ```
 *Returns:* A `string` `vec` used as a vector of integer values, in which
+each element `vec[i]` represents the number of digits[^13]
+in the group at position `i`, starting with position 0 as the rightmost
+group. If `vec.size() <= i`, the number is the same as group `(i - 1)`;
+if `(i < 0 || vec[i] <= 0 || vec[i] == CHAR_MAX)`, the size of the digit
 group is unlimited.
 The required specializations return the empty string, indicating no
 grouping.
 ### The collate category <a id="category.collate">[[category.collate]]</a>
 #### Class template `collate` <a id="locale.collate">[[locale.collate]]</a>
+##### General <a id="locale.collate.general">[[locale.collate.general]]</a>
 ``` cpp
 namespace std {
   template<class charT>
     class collate : public locale::facet {
     public:
 (comparison) and hashing of strings. A locale member function template,
 `operator()`, uses the collate facet to allow a locale to act directly
 as the predicate argument for standard algorithms [[algorithms]] and
 containers operating on strings. The specializations required in
 [[locale.category.facets]] [[locale.category]], namely `collate<char>`
+and `collate<wchar_t>`, apply lexicographical ordering
 [[alg.lex.comparison]].
 Each function compares a string of characters `*p` in the range \[`low`,
 `high`).
 *Returns:* An integer value equal to the result of calling `hash()` on
 any other string for which `do_compare()` returns 0 (equal) when passed
 the two strings.
+*Recommended practice:* The probability that the result equals that for
+another string which does not compare equal should be very small,
+approaching `(1.0/numeric_limits<unsigned long>::max())`.
 #### Class template `collate_byname` <a id="locale.collate.byname">[[locale.collate.byname]]</a>
 ``` cpp
 namespace std {
 }
 ```
 ### The time category <a id="category.time">[[category.time]]</a>
+#### General <a id="category.time.general">[[category.time.general]]</a>
 Templates `time_get<charT, InputIterator>` and
 `time_put<charT, OutputIterator>` provide date and time formatting and
 parsing. All specifications of member functions for `time_put` and
 `time_get` in the subclauses of  [[category.time]] only apply to the
 specializations required in Tables  [[tab:locale.category.facets]] and
 [[locale.categories]], and the `ctype<>` facet, to determine formatting
 details.
 #### Class template `time_get` <a id="locale.time.get">[[locale.time.get]]</a>
+##### General <a id="locale.time.get.general">[[locale.time.get.general]]</a>
 ``` cpp
 namespace std {
   class time_base {
   public:
     enum dateorder { no_order, dmy, mdy, ymd, ydm };
                                ios_base::iostate& err, tm* t, char format, char modifier) const;
     };
 }
 ```
+`time_get` is used to parse a character sequence, extracting components
+of a time or date into a `tm` object. Each `get` member parses a format
+as produced by a corresponding format specifier to `time_put<>::put`. If
 the sequence being parsed matches the correct format, the corresponding
+members of the `tm` argument are set to the values used to produce the
+sequence; otherwise either an error is reported or unspecified values
+are assigned.[^15]
 If the end iterator is reached during parsing by any of the `get()`
 member functions, the member sets `ios_base::eofbit` in `err`.
 ##### Members <a id="locale.time.get.members">[[locale.time.get.members]]</a>
 - The expression `s == end` evaluates to `true`, in which case the
   function evaluates `err = ios_base::eofbit | ios_base::failbit`.
 - The next element of `fmt` is equal to `’%’`, optionally followed by a
   modifier character, followed by a conversion specifier character,
   `format`, together forming a conversion specification valid for the
+ POSIX function `strptime`. If the number of elements in the range
+  \[`fmt`, `fmtend`) is not sufficient to unambiguously determine
   whether the conversion specification is complete and valid, the
   function evaluates `err = ios_base::failbit`. Otherwise, the function
   evaluates `s = do_get(s, end, f, err, t, format, modifier)`, where the
   value of `modifier` is `’\0’` when the optional modifier is absent
   from the conversion specification. If `err == ios_base::goodbit` holds
 dateorder do_date_order() const;
 ```
 *Returns:* An enumeration value indicating the preferred order of
 components for those date formats that are composed of day, month, and
+year.[^16]
+Returns `no_order` if the date format specified by `’x’` contains other
+variable components (e.g., Julian day, week number, week day).
 ``` cpp
 iter_type do_get_time(iter_type s, iter_type end, ios_base& str,
                       ios_base::iostate& err, tm* t) const;
 ```
 *Effects:* Reads characters starting at `s` until it has extracted those
+`tm` members, and remaining format characters, used by `time_put<>::put`
+to produce the format specified by `"%H:%M:%S"`, or until it encounters
+an error or end of sequence.
 *Returns:* An iterator pointing immediately beyond the last character
 recognized as possibly part of a valid time.
 ``` cpp
 iter_type do_get_date(iter_type s, iter_type end, ios_base& str,
                       ios_base::iostate& err, tm* t) const;
 ```
 *Effects:* Reads characters starting at `s` until it has extracted those
+`tm` members and remaining format characters used by `time_put<>::put`
+to produce one of the following formats, or until it encounters an
+error. The format depends on the value returned by `date_order()` as
+shown in [[locale.time.get.dogetdate]].
 **Table: `do_get_date` effects** <a id="locale.time.get.dogetdate">[locale.time.get.dogetdate]</a>
 | `date_order()` | Format     |
 | -------------- | ---------- |
                            ios_base::iostate& err, tm* t) const;
 ```
 *Effects:* Reads characters starting at `s` until it has extracted the
 (perhaps abbreviated) name of a weekday or month. If it finds an
+abbreviation that is followed by characters that can match a full name,
+it continues reading until it matches the full name or fails. It sets
+the appropriate `tm` member accordingly.
 *Returns:* An iterator pointing immediately beyond the last character
 recognized as part of a valid name.
 ``` cpp
 *Preconditions:* `t` points to an object.
 *Effects:* The function starts by evaluating `err = ios_base::goodbit`.
 It then reads characters starting at `s` until it encounters an error,
+or until it has extracted and assigned those `tm` members, and any
+remaining format characters, corresponding to a conversion specification
+appropriate for the POSIX function `strptime`, formed by concatenating
+`’%’`, the `modifier` character, when non-NUL, and the `format`
+character. When the concatenation fails to yield a complete valid
+directive the function leaves the object pointed to by `t` unchanged and
+evaluates `err |= ios_base::failbit`. When `s == end` evaluates to
+`true` after reading a character the function evaluates
 `err |= ios_base::eofbit`.
+For complex conversion specifications such as `%c`, `%x`, or `%X`, or
+conversion specifications that involve the optional modifiers `E` or
+`O`, when the function is unable to unambiguously determine some or all
+`tm` members from the input sequence \[`s`, `end`), it evaluates
+`err |= ios_base::eofbit`. In such cases the values of those `tm`
 members are unspecified and may be outside their valid range.
 *Returns:* An iterator pointing immediately beyond the last character
 recognized as possibly part of a valid input sequence for the given
 `format` and `modifier`.
+*Remarks:* It is unspecified whether multiple calls to `do_get()` with
+the address of the same `tm` object will update the current contents of
+the object or simply overwrite its members. Portable programs should
+zero out the object before invoking the function.
 #### Class template `time_get_byname` <a id="locale.time.get.byname">[[locale.time.get.byname]]</a>
 ``` cpp
 namespace std {
   template<class charT, class InputIterator = istreambuf_iterator<charT>>
 interleaved in the output in the order in which they appear in the
 pattern. Format sequences are identified by converting each character
 `c` to a `char` value as if by `ct.narrow(c, 0)`, where `ct` is a
 reference to `ctype<charT>` obtained from `str.getloc()`. The first
 character of each sequence is equal to `’%’`, followed by an optional
+modifier character `mod`[^17]
+and a format specifier character `spec` as defined for the function
+`strftime`. If no modifier character is present, `mod` is zero. For each
+valid format sequence identified, calls
 `do_put(s, str, fill, t, spec, mod)`.
 The second form calls `do_put(s, str, fill, t, format, modifier)`.
+[*Note 1*: The `fill` argument can be used in the
 implementation-defined formats or by derivations. A space character is a
 reasonable default for this argument. — *end note*]
 *Returns:* An iterator pointing immediately after the last character
 produced.
 *Effects:* Formats the contents of the parameter `t` into characters
 placed on the output sequence `s`. Formatting is controlled by the
 parameters `format` and `modifier`, interpreted identically as the
 format specifiers in the string argument to the standard library
+function `strftime()`, except that the sequence of characters produced
+for those specifiers that are described as depending on the C locale are
+instead *implementation-defined*.
+[*Note 2*: Interpretation of the `modifier` argument is
+implementation-defined. — *end note*]
 *Returns:* An iterator pointing immediately after the last character
 produced.
+[*Note 3*: The `fill` argument can be used in the
 implementation-defined formats or by derivations. A space character is a
 reasonable default for this argument. — *end note*]
+*Recommended practice:* Interpretation of the `modifier` should follow
+POSIX conventions. Implementations should refer to other standards such
+as POSIX for a specification of the character sequences produced for
+those specifiers described as depending on the C locale.
 #### Class template `time_put_byname` <a id="locale.time.put.byname">[[locale.time.put.byname]]</a>
 ``` cpp
 namespace std {
   template<class charT, class OutputIterator = ostreambuf_iterator<charT>>
 }
 ```
 ### The monetary category <a id="category.monetary">[[category.monetary]]</a>
+#### General <a id="category.monetary.general">[[category.monetary.general]]</a>
 These templates handle monetary formats. A template parameter indicates
 whether local or international monetary formats are to be used.
 All specifications of member functions for `money_put` and `money_get`
 in the subclauses of  [[category.monetary]] only apply to the
 Digits in the numeric monetary component are extracted and placed in
 `digits`, or into a character buffer `buf1` for conversion to produce a
 value for `units`, in the order in which they appear, preceded by a
 minus sign if and only if the result is negative. The value `units` is
+produced as if by[^18]
 ``` cpp
 for (int i = 0; i < n; ++i)
   buf2[i] = src[find(atoms, atoms+sizeof(src), buf1[i]) - atoms];
 buf2[n] = 0;
 leading minus sign and the immediately subsequent digit characters (as
 classified according to `ct`) are used; any trailing characters
 (including digits appearing after a non-digit character) are ignored.
 Calls `str.width(0)`.
+*Returns:* An iterator pointing immediately after the last character
+produced.
 *Remarks:* The currency symbol is generated if and only if
 `(str.flags() & str.showbase)` is nonzero. If the number of characters
 generated for the specified format is less than the value returned by
 `str.width()` on entry to the function, then copies of `fill` are
 inserted as necessary to pad to the specified width. For the value `af`
 [*Note 1*: It is possible, with some combinations of format patterns
 and flag values, to produce output that cannot be parsed using
 `num_get<>::get`. — *end note*]
 #### Class template `moneypunct` <a id="locale.moneypunct">[[locale.moneypunct]]</a>
+##### General <a id="locale.moneypunct.general">[[locale.moneypunct.general]]</a>
 ``` cpp
 namespace std {
   class money_base {
   public:
     enum part { none, space, symbol, sign, value };
 The `moneypunct<>` facet defines monetary formatting parameters used by
 `money_get<>` and `money_put<>`. A monetary format is a sequence of four
 components, specified by a `pattern` value `p`, such that the `part`
 value `static_cast<part>(p.field[i])` determines the `i`ᵗʰ component of
+the format[^19]
+In the `field` member of a `pattern` object, each value `symbol`,
+`sign`, `value`, and either `space` or `none` appears exactly once. The
+value `none`, if present, is not first; the value `space`, if present,
+is neither first nor last.
 Where `none` or `space` appears, whitespace is permitted in the format,
 except where `none` appears at the end, in which case no whitespace is
 permitted. The value `space` indicates that at least one space is
 required at that position. Where `symbol` appears, the sequence of
 ``` cpp
 charT do_decimal_point() const;
 ```
 *Returns:* The radix separator to use in case `do_frac_digits()` is
+greater than zero.[^20]
 ``` cpp
 charT do_thousands_sep() const;
 ```
 *Returns:* The digit group separator to use in case `do_grouping()`
+specifies a digit grouping pattern.[^21]
 ``` cpp
 string do_grouping() const;
 ```
 *Returns:* A pattern defined identically as, but not necessarily equal
+to, the result of `numpunct<charT>::do_grouping()`.[^22]
 ``` cpp
 string_type do_curr_symbol() const;
 ```
 string_type do_positive_sign() const;
 string_type do_negative_sign() const;
 ```
 *Returns:* `do_positive_sign()` returns the string to use to indicate a
+positive monetary value;[^23]
+`do_negative_sign()` returns the string to use to indicate a negative
+value.
 ``` cpp
 int do_frac_digits() const;
 ```
 *Returns:* The number of digits after the decimal radix separator, if
+any.[^24]
 ``` cpp
 pattern do_pos_format() const;
 pattern do_neg_format() const;
 ```
 - `moneypunct<wchar_t>`,
 - `moneypunct<char, true>`, and
 - `moneypunct<wchar_t, true>`,
 return an object of type `pattern` initialized to
+`{ symbol, sign, none, value }`.[^25]
 #### Class template `moneypunct_byname` <a id="locale.moneypunct.byname">[[locale.moneypunct.byname]]</a>
 ``` cpp
 namespace std {
 }
 ```
 ### The message retrieval category <a id="category.messages">[[category.messages]]</a>
+#### General <a id="category.messages.general">[[category.messages.general]]</a>
 Class `messages<charT>` implements retrieval of strings from message
 catalogs.
 #### Class template `messages` <a id="locale.messages">[[locale.messages]]</a>
+##### General <a id="locale.messages.general">[[locale.messages.general]]</a>
 ``` cpp
 namespace std {
   class messages_base {
   public:
     using catalog = unspecified signed integer type;
 ```
 The contents and meaning of the header `<clocale>` are the same as the C
 standard library header `<locale.h>`.
+### Data races <a id="clocale.data.races">[[clocale.data.races]]</a>
 Calls to the function `setlocale` may introduce a data race
 [[res.on.data.races]] with other calls to `setlocale` or with calls to
 the functions listed in [[setlocale.data.races]].
 See also: ISO C 7.11
 [bitmask.types]: library.md#bitmask.types
 [c.files]: input.md#c.files
 [c.locales]: #c.locales
 [category.collate]: #category.collate
 [category.ctype]: #category.ctype
+[category.ctype.general]: #category.ctype.general
 [category.messages]: #category.messages
+[category.messages.general]: #category.messages.general
 [category.monetary]: #category.monetary
+[category.monetary.general]: #category.monetary.general
 [category.numeric]: #category.numeric
+[category.numeric.general]: #category.numeric.general
 [category.time]: #category.time
+[category.time.general]: #category.time.general
 [classification]: #classification
+[clocale.data.races]: #clocale.data.races
 [clocale.syn]: #clocale.syn
 [conversions.character]: #conversions.character
 [facet.ctype.char.dtor]: #facet.ctype.char.dtor
 [facet.ctype.char.members]: #facet.ctype.char.members
 [facet.ctype.char.statics]: #facet.ctype.char.statics
 [facet.ctype.char.virtuals]: #facet.ctype.char.virtuals
 [facet.ctype.special]: #facet.ctype.special
+[facet.ctype.special.general]: #facet.ctype.special.general
 [facet.num.get.members]: #facet.num.get.members
 [facet.num.get.virtuals]: #facet.num.get.virtuals
 [facet.num.put.members]: #facet.num.put.members
 [facet.num.put.virtuals]: #facet.num.put.virtuals
 [facet.numpunct]: #facet.numpunct
 [istream.formatted.reqmts]: input.md#istream.formatted.reqmts
 [iterator.requirements]: iterators.md#iterator.requirements
 [lex.charset]: lex.md#lex.charset
 [locale]: #locale
 [locale.categories]: #locale.categories
+[locale.categories.general]: #locale.categories.general
 [locale.category]: #locale.category
 [locale.category.facets]: #locale.category.facets
 [locale.codecvt]: #locale.codecvt
 [locale.codecvt.byname]: #locale.codecvt.byname
+[locale.codecvt.general]: #locale.codecvt.general
 [locale.codecvt.inout]: #locale.codecvt.inout
 [locale.codecvt.members]: #locale.codecvt.members
 [locale.codecvt.unshift]: #locale.codecvt.unshift
 [locale.codecvt.virtuals]: #locale.codecvt.virtuals
 [locale.collate]: #locale.collate
 [locale.collate.byname]: #locale.collate.byname
+[locale.collate.general]: #locale.collate.general
 [locale.collate.members]: #locale.collate.members
 [locale.collate.virtuals]: #locale.collate.virtuals
 [locale.cons]: #locale.cons
 [locale.convenience]: #locale.convenience
 [locale.ctype]: #locale.ctype
 [locale.ctype.byname]: #locale.ctype.byname
+[locale.ctype.general]: #locale.ctype.general
 [locale.ctype.members]: #locale.ctype.members
 [locale.ctype.virtuals]: #locale.ctype.virtuals
 [locale.facet]: #locale.facet
+[locale.general]: #locale.general
 [locale.global.templates]: #locale.global.templates
 [locale.id]: #locale.id
 [locale.members]: #locale.members
 [locale.messages]: #locale.messages
 [locale.messages.byname]: #locale.messages.byname
+[locale.messages.general]: #locale.messages.general
 [locale.messages.members]: #locale.messages.members
 [locale.messages.virtuals]: #locale.messages.virtuals
 [locale.money.get]: #locale.money.get
 [locale.money.get.members]: #locale.money.get.members
 [locale.money.get.virtuals]: #locale.money.get.virtuals
 [locale.money.put]: #locale.money.put
 [locale.money.put.members]: #locale.money.put.members
 [locale.money.put.virtuals]: #locale.money.put.virtuals
 [locale.moneypunct]: #locale.moneypunct
 [locale.moneypunct.byname]: #locale.moneypunct.byname
+[locale.moneypunct.general]: #locale.moneypunct.general
 [locale.moneypunct.members]: #locale.moneypunct.members
 [locale.moneypunct.virtuals]: #locale.moneypunct.virtuals
 [locale.nm.put]: #locale.nm.put
+[locale.nm.put.general]: #locale.nm.put.general
 [locale.num.get]: #locale.num.get
+[locale.num.get.general]: #locale.num.get.general
 [locale.numpunct]: #locale.numpunct
 [locale.numpunct.byname]: #locale.numpunct.byname
+[locale.numpunct.general]: #locale.numpunct.general
 [locale.operators]: #locale.operators
 [locale.spec]: #locale.spec
 [locale.statics]: #locale.statics
 [locale.syn]: #locale.syn
 [locale.time.get]: #locale.time.get
 [locale.time.get.byname]: #locale.time.get.byname
 [locale.time.get.dogetdate]: #locale.time.get.dogetdate
+[locale.time.get.general]: #locale.time.get.general
 [locale.time.get.members]: #locale.time.get.members
 [locale.time.get.virtuals]: #locale.time.get.virtuals
 [locale.time.put]: #locale.time.put
 [locale.time.put.byname]: #locale.time.put.byname
 [locale.time.put.members]: #locale.time.put.members
 [setlocale.data.races]: #setlocale.data.races
 [tab:locale.category.facets]: #tab:locale.category.facets
 [tab:locale.spec]: #tab:locale.spec
 [vector]: containers.md#vector
+[^1]: In this subclause, the type name `tm` is an incomplete type that
+    is defined in `<ctime>`.
 [^2]: Note that in the call to `put`, the stream is implicitly converted
     to an `ostreambuf_iterator<charT, traits>`.
 [^3]: This is a complete list of requirements; there are no other
     constructor, assignment, default constructor, destructor, etc.
 [^4]: When used in a loop, it is faster to cache the `ctype<>` facet and
     use it directly, or use the vector form of `ctype<>::is`.
+[^5]: The parameter `c` of `do_widen` is intended to accept values
     derived from *character-literal*s for conversion to the locale’s
     encoding.
 [^6]: In other words, the transformed character is not a member of any
     character classification that `c` is not also a member of.
     provided. The specialization is specified in the standard, and not
     left as an implementation detail, because it affects the derivation
     interface for `ctype<char>`.
 [^8]: Informally, this means that `basic_filebuf` assumes that the
+    mappings from internal to external characters is 1 to N: that a
+ `codecvt` facet that is used by `basic_filebuf` can translate
     characters one internal character at a time.
 [^9]: Typically these will be characters to return the state to
     `stateT()`.
 [^10]: If `encoding()` yields `-1`, then more than `max_length()`
+    `externT` elements can be consumed when producing a single `internT`
+    character, and additional `externT` elements can appear at the end
     of a sequence after those that yield the final `internT` character.
 [^11]: Parsing `"-1"` correctly into, e.g., an `unsigned short` requires
     that the corresponding member `get()` at least extract the sign
     before delegating.
     parsing of user-entered dates and times, but machine-generated
     formats can be parsed reliably. This allows parsers to be aggressive
     about interpreting user variations on standard formats.
 [^16]: This function is intended as a convenience only, for common
+    formats, and can return `no_order` in valid locales.
 [^17]: Although the C programming language defines no modifiers, most
     vendors do.
+[^18]: The semantics here are different from `ct.narrow`.
+[^19]: An array of `char`, rather than an array of `part`, is specified
     for `pattern::field` purely for efficiency.
+[^20]: In common U.S. locales this is `’.’`.
+[^21]: In common U.S. locales this is `’,’`.
+[^22]: To specify grouping by 3s, the value is `"\003"` *not* `"3"`.
+[^23]: This is usually the empty string.
+[^24]: In common U.S. locales, this is 2.
+[^25]: Note that the international symbol returned by `do_curr_symbol()`
     usually contains a space, itself; for example, `"USD "`.

Diff to HTML by rtfpessoa