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

Files changed (1) hide show

tmp/tmp1q38pd_y/{from.md → to.md} +196 -142

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

@@ -1,33 +1,32 @@
 ### Conforming implementations <a id="conforming">[[conforming]]</a>
 #### Overview <a id="conforming.overview">[[conforming.overview]]</a>
-This section describes the constraints upon, and latitude of,
-implementations of the C++standard library.
 An implementation’s use of headers is discussed in  [[res.on.headers]],
 its use of macros in  [[res.on.macro.definitions]], non-member functions
 in  [[global.functions]], member functions in  [[member.functions]],
 data race avoidance in  [[res.on.data.races]], access specifiers in
 [[protection.within.classes]], class derivation in  [[derivation]], and
 exceptions in  [[res.on.exception.handling]].
 #### Headers <a id="res.on.headers">[[res.on.headers]]</a>
-A C++header may include other C++headers. A C++header shall provide the
-declarations and definitions that appear in its synopsis. A C++header
-shown in its synopsis as including other C++headers shall provide the
-declarations and definitions that appear in the synopses of those other
-headers.
 Certain types and macros are defined in more than one header. Every such
 entity shall be defined such that any header that defines it may be
-included after any other header that also defines it (
-[[basic.def.odr]]).
-The C standard library headers ([[depr.c.headers]]) shall include only
 their corresponding C++ standard library header, as described in
 [[headers]].
 #### Restrictions on macro definitions <a id="res.on.macro.definitions">[[res.on.macro.definitions]]</a>
@@ -40,31 +39,30 @@ suitable for use in `#if` preprocessing directives, unless explicitly
 stated otherwise.
 #### Non-member functions <a id="global.functions">[[global.functions]]</a>
 It is unspecified whether any non-member functions in the C++ standard
-library are defined as `inline` ([[dcl.inline]]).
-A call to a non-member function signature described in Clauses
-[[language.support]] through  [[thread]] and Annex  [[depr]] shall
-behave as if the implementation declared no additional non-member
-function signatures.[^26]
 An implementation shall not declare a non-member function signature with
 additional default arguments.
 Unless otherwise specified, calls made by functions in the standard
 library to non-operator, non-member functions do not use functions from
-another namespace which are found through *argument-dependent name
-lookup* ([[basic.lookup.argdep]]).
 [*Note 1*:
 The phrase “unless otherwise specified” applies to cases such as the
-swappable with requirements ([[swappable.requirements]]). The exception
 for overloaded operators allows argument-dependent lookup in cases like
-that of `ostream_iterator::operator=` ([[ostream.iterator.ops]]):
 *Effects:*
 ``` cpp
 *out_stream << value;
@@ -76,75 +74,90 @@ return *this;
 — *end note*]
 #### Member functions <a id="member.functions">[[member.functions]]</a>
 It is unspecified whether any member functions in the C++ standard
-library are defined as `inline` ([[dcl.inline]]).
 For a non-virtual member function described in the C++ standard library,
 an implementation may declare a different set of member function
 signatures, provided that any call to the member function that would
 select an overload from the set of declarations described in this
-International Standard behaves as if that overload were selected.
 [*Note 1*: For instance, an implementation may add parameters with
 default values, or replace a member function with default arguments with
 two or more member functions with equivalent behavior, or add additional
 signatures for a member function name. — *end note*]
 #### Constexpr functions and constructors <a id="constexpr.functions">[[constexpr.functions]]</a>
-This International Standard explicitly requires that certain standard
-library functions are `constexpr` ([[dcl.constexpr]]). An
-implementation shall not declare any standard library function signature
-as `constexpr` except for those where it is explicitly required. Within
-any header that provides any non-defining declarations of constexpr
-functions or constructors an implementation shall provide corresponding
-definitions.
 #### Requirements for stable algorithms <a id="algorithm.stable">[[algorithm.stable]]</a>
 When the requirements for an algorithm state that it is “stable” without
 further elaboration, it means:
-- For the *sort* algorithms the relative order of equivalent elements is
   preserved.
-- For the *remove* and *copy* algorithms the relative order of the
- elements that are not removed is preserved.
-- For the *merge* algorithms, for equivalent elements in the original
- two ranges, the elements from the first range (preserving their
- original order) precede the elements from the second range (preserving
- their original order).
 #### Reentrancy <a id="reentrancy">[[reentrancy]]</a>
-Except where explicitly specified in this International Standard, it is
 *implementation-defined* which functions in the C++ standard library may
 be recursively reentered.
 #### Data race avoidance <a id="res.on.data.races">[[res.on.data.races]]</a>
-This section specifies requirements that implementations shall meet to
-prevent data races ([[intro.multithread]]). Every standard library
 function shall meet each requirement unless otherwise specified.
 Implementations may prevent data races in cases other than those
 specified below.
 A C++ standard library function shall not directly or indirectly access
-objects ([[intro.multithread]]) accessible by threads other than the
 current thread unless the objects are accessed directly or indirectly
 via the function’s arguments, including `this`.
 A C++ standard library function shall not directly or indirectly modify
-objects ([[intro.multithread]]) accessible by threads other than the
 current thread unless the objects are accessed directly or indirectly
 via the function’s non-const arguments, including `this`.
-[*Note 1*: This means, for example, that implementations can’t use a
-static object for internal purposes without synchronization because it
-could cause a data race even in programs that do not explicitly share
-objects between threads. — *end note*]
 A C++ standard library function shall not access objects indirectly
 accessible via its arguments or via elements of its container arguments
 except by invoking functions required by its specification on those
 container elements.
@@ -161,31 +174,31 @@ Implementations may share their own internal objects between threads if
 the objects are not visible to users and are protected against data
 races.
 Unless otherwise specified, C++ standard library functions shall perform
 all operations solely within the current thread if those operations have
-effects that are visible ([[intro.multithread]]) to users.
 [*Note 3*: This allows implementations to parallelize operations if
 there are no visible side effects. — *end note*]
 #### Protection within classes <a id="protection.within.classes">[[protection.within.classes]]</a>
 It is unspecified whether any function signature or class described in
-Clauses  [[language.support]] through  [[thread]] and Annex  [[depr]] is
-a `friend` of another class in the C++standard library.
 #### Derived classes <a id="derivation">[[derivation]]</a>
-An implementation may derive any class in the C++standard library from a
-class with a name reserved to the implementation.
 Certain classes defined in the C++ standard library are required to be
-derived from other classes in the C++standard library. An implementation
-may derive such a class directly from the required base or indirectly
-through a hierarchy of base classes with names reserved to the
-implementation.
 In any case:
 - Every base class described as `virtual` shall be virtual;
 - Every base class not specified as `virtual` shall not be virtual;
@@ -205,13 +218,13 @@ type.
 Functions from the C standard library shall not throw exceptions [^28]
 except when such a function calls a program-supplied function that
 throws an exception.[^29]
-Destructor operations defined in the C++standard library shall not throw
-exceptions. Every destructor in the C++standard library shall behave as
-if it had a non-throwing exception specification.
 Functions defined in the C++ standard library that do not have a
 *Throws:* paragraph but do have a potentially-throwing exception
 specification may throw *implementation-defined* exceptions. [^30]
 Implementations should report errors by throwing exceptions of or
@@ -223,157 +236,189 @@ non-virtual function by adding a non-throwing exception specification.
 #### Restrictions on storage of pointers <a id="res.on.pointer.storage">[[res.on.pointer.storage]]</a>
 Objects constructed by the standard library that may hold a
 user-supplied pointer value or an integer of type `std::intptr_t` shall
-store such values in a traceable pointer location (
-[[basic.stc.dynamic.safety]]).
 [*Note 1*: Other libraries are strongly encouraged to do the same,
 since not doing so may result in accidental use of pointers that are not
 safely derived. Libraries that store pointers outside the user’s address
 space should make it appear that they are stored and retrieved from a
 traceable pointer location. — *end note*]
 #### Value of error codes <a id="value.error.codes">[[value.error.codes]]</a>
 Certain functions in the C++ standard library report errors via a
-`std::error_code` ([[syserr.errcode.overview]]) object. That object’s
 `category()` member shall return `std::system_category()` for errors
 originating from the operating system, or a reference to an
 *implementation-defined* `error_category` object for errors originating
 elsewhere. The implementation shall define the possible values of
 `value()` for each of these error categories.
 [*Example 1*: For operating systems that are based on POSIX,
-implementations are encouraged to define the `std::system_category()`
-values as identical to the POSIX `errno` values, with additional values
-as defined by the operating system’s documentation. Implementations for
-operating systems that are not based on POSIX are encouraged to define
-values identical to the operating system’s values. For errors that do
-not originate from the operating system, the implementation may provide
-enums for the associated values. — *end example*]
 #### Moved-from state of library types <a id="lib.types.movedfrom">[[lib.types.movedfrom]]</a>
-Objects of types defined in the C++standard library may be moved from (
-[[class.copy]]). Move operations may be explicitly specified or
 implicitly generated. Unless otherwise specified, such moved-from
 objects shall be placed in a valid but unspecified state.
 <!-- Link reference definitions -->
 [alg.c.library]: algorithms.md#alg.c.library
 [alg.sorting]: algorithms.md#alg.sorting
 [algorithm.stable]: #algorithm.stable
 [algorithms]: algorithms.md#algorithms
 [algorithms.requirements]: algorithms.md#algorithms.requirements
-[alloc.errors]: language.md#alloc.errors
 [allocator.requirements]: #allocator.requirements
 [allocator.requirements.completeness]: #allocator.requirements.completeness
 [allocator.traits]: utilities.md#allocator.traits
 [alt.headers]: #alt.headers
 [atomics]: atomics.md#atomics
-[bad.alloc]: language.md#bad.alloc
 [basic.def.odr]: basic.md#basic.def.odr
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.life]: basic.md#basic.life
 [basic.link]: basic.md#basic.link
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [basic.scope.namespace]: basic.md#basic.scope.namespace
 [basic.start]: basic.md#basic.start
 [basic.stc.dynamic]: basic.md#basic.stc.dynamic
 [basic.stc.dynamic.safety]: basic.md#basic.stc.dynamic.safety
 [basic.types]: basic.md#basic.types
 [bitmask.types]: #bitmask.types
 [byte.strings]: #byte.strings
-[c.locales]: localization.md#c.locales
-[c.strings]: strings.md#c.strings
 [character.seq]: #character.seq
-[class.conv.ctor]: special.md#class.conv.ctor
-[class.copy]: special.md#class.copy
-[class.ctor]: special.md#class.ctor
-[class.dtor]: special.md#class.dtor
 [class.mem]: class.md#class.mem
 [class.mfct]: class.md#class.mfct
 [class.this]: class.md#class.this
 [class.virtual]: class.md#class.virtual
 [compliance]: #compliance
 [conforming]: #conforming
 [conforming.overview]: #conforming.overview
 [constexpr.functions]: #constexpr.functions
 [constraints]: #constraints
 [constraints.overview]: #constraints.overview
 [container.requirements]: containers.md#container.requirements
 [containers]: containers.md#containers
 [contents]: #contents
-[conv]: conv.md#conv
 [conventions]: #conventions
 [cpp.include]: cpp.md#cpp.include
-[cstdint]: language.md#cstdint
 [dcl.array]: dcl.md#dcl.array
 [dcl.attr]: dcl.md#dcl.attr
 [dcl.constexpr]: dcl.md#dcl.constexpr
 [dcl.fct.default]: dcl.md#dcl.fct.default
 [dcl.init]: dcl.md#dcl.init
 [dcl.init.list]: dcl.md#dcl.init.list
 [dcl.inline]: dcl.md#dcl.inline
 [dcl.link]: dcl.md#dcl.link
 [definitions]: #definitions
 [depr]: future.md#depr
 [depr.c.headers]: future.md#depr.c.headers
-[depr.cstdalign.syn]: future.md#depr.cstdalign.syn
-[depr.cstdbool.syn]: future.md#depr.cstdbool.syn
 [derivation]: #derivation
 [derived.classes]: #derived.classes
 [description]: #description
 [diagnostics]: diagnostics.md#diagnostics
 [enumerated.types]: #enumerated.types
 [except]: except.md#except
 [expos.only.types]: #expos.only.types
 [expr.cond]: expr.md#expr.cond
 [expr.const]: expr.md#expr.const
 [expr.delete]: expr.md#expr.delete
 [expr.eq]: expr.md#expr.eq
 [expr.new]: expr.md#expr.new
 [expr.rel]: expr.md#expr.rel
 [extern.names]: #extern.names
 [extern.types]: #extern.types
 [function.objects]: utilities.md#function.objects
 [functions.within.classes]: #functions.within.classes
 [global.functions]: #global.functions
 [handler.functions]: #handler.functions
 [hash.requirements]: #hash.requirements
 [headers]: #headers
 [input.output]: input.md#input.output
 [intro.compliance]: intro.md#intro.compliance
 [intro.defs]: intro.md#intro.defs
-[intro.multithread]: intro.md#intro.multithread
 [intro.refs]: intro.md#intro.refs
 [iterator.requirements]: iterators.md#iterator.requirements
-[iterator.requirements.general]: iterators.md#iterator.requirements.general
 [iterators]: iterators.md#iterators
-[language.support]: language.md#language.support
-[lex]: lex.md#lex
 [lex.phases]: lex.md#lex.phases
 [lib.types.movedfrom]: #lib.types.movedfrom
 [library]: #library
 [library.c]: #library.c
 [library.general]: #library.general
 [locales]: localization.md#locales
 [localization]: localization.md#localization
 [macro.names]: #macro.names
 [member.functions]: #member.functions
 [meta]: utilities.md#meta
 [multibyte.strings]: #multibyte.strings
 [namespace.constraints]: #namespace.constraints
 [namespace.def]: dcl.md#namespace.def
 [namespace.future]: #namespace.future
 [namespace.posix]: #namespace.posix
 [namespace.std]: #namespace.std
 [namespace.udecl]: dcl.md#namespace.udecl
-[new.delete]: language.md#new.delete
-[new.handler]: language.md#new.handler
 [nullablepointer.requirements]: #nullablepointer.requirements
 [numeric.requirements]: numerics.md#numeric.requirements
 [numerics]: numerics.md#numerics
 [objects.within.classes]: #objects.within.classes
 [organization]: #organization
@@ -381,71 +426,73 @@ objects shall be placed in a valid but unspecified state.
 [over.literal]: over.md#over.literal
 [over.match]: over.md#over.match
 [over.oper]: over.md#over.oper
 [protection.within.classes]: #protection.within.classes
 [random.access.iterators]: iterators.md#random.access.iterators
 [re]: re.md#re
 [reentrancy]: #reentrancy
 [replacement.functions]: #replacement.functions
 [requirements]: #requirements
 [res.on.arguments]: #res.on.arguments
 [res.on.data.races]: #res.on.data.races
 [res.on.exception.handling]: #res.on.exception.handling
 [res.on.functions]: #res.on.functions
 [res.on.headers]: #res.on.headers
 [res.on.macro.definitions]: #res.on.macro.definitions
 [res.on.objects]: #res.on.objects
 [res.on.pointer.storage]: #res.on.pointer.storage
-[res.on.required]: #res.on.required
 [reserved.names]: #reserved.names
 [std.exceptions]: diagnostics.md#std.exceptions
 [stream.types]: input.md#stream.types
 [strings]: strings.md#strings
 [structure]: #structure
 [structure.elements]: #structure.elements
 [structure.requirements]: #structure.requirements
 [structure.see.also]: #structure.see.also
 [structure.specifications]: #structure.specifications
 [structure.summary]: #structure.summary
-[support.dynamic]: language.md#support.dynamic
-[support.exception]: language.md#support.exception
-[support.initlist]: language.md#support.initlist
-[support.limits]: language.md#support.limits
-[support.rtti]: language.md#support.rtti
-[support.runtime]: language.md#support.runtime
-[support.start.term]: language.md#support.start.term
-[support.types]: language.md#support.types
 [swappable.requirements]: #swappable.requirements
 [syserr]: diagnostics.md#syserr
 [syserr.errcode.overview]: diagnostics.md#syserr.errcode.overview
-[tab:c.annex.k.names]: #tab:c.annex.k.names
-[tab:copyassignable]: #tab:copyassignable
-[tab:cpp.c.headers]: #tab:cpp.c.headers
-[tab:cpp.headers.freestanding]: #tab:cpp.headers.freestanding
-[tab:cpp.library.headers]: #tab:cpp.library.headers
-[tab:desc.var.def]: #tab:desc.var.def
-[tab:destructible]: #tab:destructible
-[tab:equalitycomparable]: #tab:equalitycomparable
-[tab:hash]: #tab:hash
-[tab:identifiers.special]: lex.md#tab:identifiers.special
-[tab:library.categories]: #tab:library.categories
-[tab:moveassignable]: #tab:moveassignable
-[tab:nullablepointer]: #tab:nullablepointer
-[tab:utilities.allocator.requirements]: #tab:utilities.allocator.requirements
 [temp.deduct.call]: temp.md#temp.deduct.call
 [template.bitset]: utilities.md#template.bitset
-[terminate.handler]: language.md#terminate.handler
 [thread]: thread.md#thread
 [type.descriptions]: #type.descriptions
 [type.descriptions.general]: #type.descriptions.general
 [using]: #using
 [using.headers]: #using.headers
 [using.linkage]: #using.linkage
 [using.overview]: #using.overview
 [usrlit.suffix]: #usrlit.suffix
 [utilities]: utilities.md#utilities
-[utility]: utilities.md#utility
 [utility.arg.requirements]: #utility.arg.requirements
 [utility.requirements]: #utility.requirements
 [value.error.codes]: #value.error.codes
 [zombie.names]: #zombie.names
@@ -458,60 +505,60 @@ objects shall be placed in a valid but unspecified state.
 [^3]: To save space, items that do not apply to a class are omitted. For
     example, if a class does not specify any comparison functions, there
     will be no “Comparison functions” subclause.
-[^4]: To save space, items that do not apply to a function are omitted.
-    For example, if a function does not specify any further
- preconditions, there will be no *Requires:* paragraph.
 [^5]: This simplifies the presentation of complexity requirements in
     some cases.
 [^6]: Examples from  [[utility.requirements]] include:
- `EqualityComparable`, `LessThanComparable`, `CopyConstructible`.
-    Examples from  [[iterator.requirements]] include: `InputIterator`,
- `ForwardIterator`.
-[^7]: Such as an integer type, with constant integer values (
-    [[basic.fundamental]]).
-[^8]: declared in `<clocale>` ([[c.locales]]).
 [^9]: Many of the objects manipulated by function signatures declared in
-    `<cstring>` ([[c.strings]]) are character sequences or NTBSs. The
- size of some of these character sequences is limited by a length
- value, maintained separately from the character sequence.
-[^10]: A string literal, such as `"abc"`, is a static NTBS.
 [^11]: An NTBS that contains characters only from the basic execution
     character set is also an NTMBS. Each multibyte character then
     consists of a single byte.
-[^12]: The C standard library headers (Annex  [[depr.c.headers]]) also
- define names within the global namespace, while the C++headers for C
-    library facilities ([[headers]]) may also define names within the
     global namespace.
 [^13]: This gives implementers freedom to use inline namespaces to
     support multiple configurations of the library.
 [^14]: A header is not necessarily a source file, nor are the sequences
     delimited by `<` and `>` in header names necessarily valid source
-    file names ([[cpp.include]]).
 [^15]: It is intentional that there is no C++ header for any of these C
     headers: `<stdatomic.h>`, `<stdnoreturn.h>`, `<threads.h>`.
 [^16]: This disallows the practice, allowed in C, of providing a masking
     macro in addition to the function prototype. The only way to achieve
     equivalent inline behavior in C++ is to provide a definition as an
     extern inline function.
-[^17]: In particular, including the standard header `<iso646.h>` or
- `<ciso646>` has no effect.
 [^18]: The `".h"` headers dump all their names into the global
     namespace, whereas the newer forms keep their names in namespace
     `std`. Therefore, the newer forms are the preferred forms for all
     uses except for C++ programs which are intended to be strictly
@@ -523,43 +570,50 @@ objects shall be placed in a valid but unspecified state.
     from the C standard library is by including the header that declares
     it, notwithstanding the latitude granted in 7.1.4 of the C Standard.
 [^21]: Any library code that instantiates other library templates must
     be prepared to work adequately with any user-supplied specialization
-    that meets the minimum requirements of this International Standard.
-[^22]: The list of such reserved names includes `errno`, declared or
     defined in `<cerrno>`.
-[^23]: The list of such reserved function signatures with external
     linkage includes `setjmp(jmp_buf)`, declared or defined in
     `<csetjmp>`, and `va_end(va_list)`, declared or defined in
     `<cstdarg>`.
-[^24]: The function signatures declared in `<cuchar>`, `<cwchar>`, and
     `<cwctype>` are always reserved, notwithstanding the restrictions
     imposed in subclause 4.5.1 of Amendment 1 to the C Standard for
     these headers.
-[^25]: These types are `clock_t`, `div_t`, `FILE`, `fpos_t`, `lconv`,
-    `ldiv_t`, `mbstate_t`, `ptrdiff_t`, `sig_atomic_t`, `size_t`,
-    `time_t`, `tm`, `va_list`, `wctrans_t`, `wctype_t`, and `wint_t`.
 [^26]: A valid C++ program always calls the expected library non-member
     function. An implementation may also define additional non-member
     functions that would otherwise not be called by a valid C++ program.
 [^27]: There is an implicit exception to this rule for types that are
-    described as synonyms for basic integral types, such as `size_t` (
-    [[support.types]]) and `streamoff` ([[stream.types]]).
 [^28]: That is, the C library functions can all be treated as if they
     are marked `noexcept`. This allows implementations to make
     performance optimizations based on the absence of exceptions at
     runtime.
-[^29]: The functions `qsort()` and `bsearch()` ([[alg.c.library]]) meet
     this condition.
 [^30]: In particular, they can report a failure to allocate storage by
     throwing an exception of type `bad_alloc`, or a class derived from
-    `bad_alloc` ([[bad.alloc]]).

 ### Conforming implementations <a id="conforming">[[conforming]]</a>
 #### Overview <a id="conforming.overview">[[conforming.overview]]</a>
+Subclause [[conforming]] describes the constraints upon, and latitude
+of, implementations of the C++ standard library.
 An implementation’s use of headers is discussed in  [[res.on.headers]],
 its use of macros in  [[res.on.macro.definitions]], non-member functions
 in  [[global.functions]], member functions in  [[member.functions]],
 data race avoidance in  [[res.on.data.races]], access specifiers in
 [[protection.within.classes]], class derivation in  [[derivation]], and
 exceptions in  [[res.on.exception.handling]].
 #### Headers <a id="res.on.headers">[[res.on.headers]]</a>
+A C++ header may include other C++ headers. A C++ header shall provide
+the declarations and definitions that appear in its synopsis. A C++
+header shown in its synopsis as including other C++ headers shall
+provide the declarations and definitions that appear in the synopses of
+those other headers.
 Certain types and macros are defined in more than one header. Every such
 entity shall be defined such that any header that defines it may be
+included after any other header that also defines it [[basic.def.odr]].
+The C standard library headers [[depr.c.headers]] shall include only
 their corresponding C++ standard library header, as described in
 [[headers]].
 #### Restrictions on macro definitions <a id="res.on.macro.definitions">[[res.on.macro.definitions]]</a>
 stated otherwise.
 #### Non-member functions <a id="global.functions">[[global.functions]]</a>
 It is unspecified whether any non-member functions in the C++ standard
+library are defined as inline [[dcl.inline]].
+A call to a non-member function signature described in [[support]]
+through [[thread]] and [[depr]] shall behave as if the implementation
+declared no additional non-member function signatures.[^26]
 An implementation shall not declare a non-member function signature with
 additional default arguments.
 Unless otherwise specified, calls made by functions in the standard
 library to non-operator, non-member functions do not use functions from
+another namespace which are found through argument-dependent name lookup
+[[basic.lookup.argdep]].
 [*Note 1*:
 The phrase “unless otherwise specified” applies to cases such as the
+swappable with requirements [[swappable.requirements]]. The exception
 for overloaded operators allows argument-dependent lookup in cases like
+that of `ostream_iterator::operator=` [[ostream.iterator.ops]]:
 *Effects:*
 ``` cpp
 *out_stream << value;
 — *end note*]
 #### Member functions <a id="member.functions">[[member.functions]]</a>
 It is unspecified whether any member functions in the C++ standard
+library are defined as inline [[dcl.inline]].
 For a non-virtual member function described in the C++ standard library,
 an implementation may declare a different set of member function
 signatures, provided that any call to the member function that would
 select an overload from the set of declarations described in this
+document behaves as if that overload were selected.
 [*Note 1*: For instance, an implementation may add parameters with
 default values, or replace a member function with default arguments with
 two or more member functions with equivalent behavior, or add additional
 signatures for a member function name. — *end note*]
+#### Friend functions <a id="hidden.friends">[[hidden.friends]]</a>
+Whenever this document specifies a friend declaration of a function or
+function template within a class or class template definition, that
+declaration shall be the only declaration of that function or function
+template provided by an implementation.
+[*Note 1*: In particular, an implementation is not allowed to provide
+an additional declaration of that function or function template at
+namespace scope. — *end note*]
+[*Note 2*: Such a friend function or function template declaration is
+known as a hidden friend, as it is visible neither to ordinary
+unqualified lookup [[basic.lookup.unqual]] nor to qualified lookup
+[[basic.lookup.qual]]. — *end note*]
 #### Constexpr functions and constructors <a id="constexpr.functions">[[constexpr.functions]]</a>
+This document explicitly requires that certain standard library
+functions are `constexpr` [[dcl.constexpr]]. An implementation shall not
+declare any standard library function signature as `constexpr` except
+for those where it is explicitly required. Within any header that
+provides any non-defining declarations of constexpr functions or
+constructors an implementation shall provide corresponding definitions.
 #### Requirements for stable algorithms <a id="algorithm.stable">[[algorithm.stable]]</a>
 When the requirements for an algorithm state that it is “stable” without
 further elaboration, it means:
+- For the sort algorithms the relative order of equivalent elements is
   preserved.
+- For the remove and copy algorithms the relative order of the elements
+  that are not removed is preserved.
+- For the merge algorithms, for equivalent elements in the original two
+  ranges, the elements from the first range (preserving their original
+  order) precede the elements from the second range (preserving their
+  original order).
 #### Reentrancy <a id="reentrancy">[[reentrancy]]</a>
+Except where explicitly specified in this document, it is
 *implementation-defined* which functions in the C++ standard library may
 be recursively reentered.
 #### Data race avoidance <a id="res.on.data.races">[[res.on.data.races]]</a>
+This subclause specifies requirements that implementations shall meet to
+prevent data races [[intro.multithread]]. Every standard library
 function shall meet each requirement unless otherwise specified.
 Implementations may prevent data races in cases other than those
 specified below.
 A C++ standard library function shall not directly or indirectly access
+objects [[intro.multithread]] accessible by threads other than the
 current thread unless the objects are accessed directly or indirectly
 via the function’s arguments, including `this`.
 A C++ standard library function shall not directly or indirectly modify
+objects [[intro.multithread]] accessible by threads other than the
 current thread unless the objects are accessed directly or indirectly
 via the function’s non-const arguments, including `this`.
+[*Note 1*: This means, for example, that implementations can’t use an
+object with static storage duration for internal purposes without
+synchronization because it could cause a data race even in programs that
+do not explicitly share objects between threads. — *end note*]
 A C++ standard library function shall not access objects indirectly
 accessible via its arguments or via elements of its container arguments
 except by invoking functions required by its specification on those
 container elements.
 the objects are not visible to users and are protected against data
 races.
 Unless otherwise specified, C++ standard library functions shall perform
 all operations solely within the current thread if those operations have
+effects that are visible [[intro.multithread]] to users.
 [*Note 3*: This allows implementations to parallelize operations if
 there are no visible side effects. — *end note*]
 #### Protection within classes <a id="protection.within.classes">[[protection.within.classes]]</a>
 It is unspecified whether any function signature or class described in
+[[support]] through [[thread]] and [[depr]] is a friend of another class
+in the C++ standard library.
 #### Derived classes <a id="derivation">[[derivation]]</a>
+An implementation may derive any class in the C++ standard library from
+a class with a name reserved to the implementation.
 Certain classes defined in the C++ standard library are required to be
+derived from other classes in the C++ standard library. An
+implementation may derive such a class directly from the required base
+or indirectly through a hierarchy of base classes with names reserved to
+the implementation.
 In any case:
 - Every base class described as `virtual` shall be virtual;
 - Every base class not specified as `virtual` shall not be virtual;
 Functions from the C standard library shall not throw exceptions [^28]
 except when such a function calls a program-supplied function that
 throws an exception.[^29]
+Destructor operations defined in the C++ standard library shall not
+throw exceptions. Every destructor in the C++ standard library shall
+behave as if it had a non-throwing exception specification.
 Functions defined in the C++ standard library that do not have a
 *Throws:* paragraph but do have a potentially-throwing exception
 specification may throw *implementation-defined* exceptions. [^30]
 Implementations should report errors by throwing exceptions of or
 #### Restrictions on storage of pointers <a id="res.on.pointer.storage">[[res.on.pointer.storage]]</a>
 Objects constructed by the standard library that may hold a
 user-supplied pointer value or an integer of type `std::intptr_t` shall
+store such values in a traceable pointer location
+[[basic.stc.dynamic.safety]].
 [*Note 1*: Other libraries are strongly encouraged to do the same,
 since not doing so may result in accidental use of pointers that are not
 safely derived. Libraries that store pointers outside the user’s address
 space should make it appear that they are stored and retrieved from a
 traceable pointer location. — *end note*]
 #### Value of error codes <a id="value.error.codes">[[value.error.codes]]</a>
 Certain functions in the C++ standard library report errors via a
+`std::error_code` [[syserr.errcode.overview]] object. That object’s
 `category()` member shall return `std::system_category()` for errors
 originating from the operating system, or a reference to an
 *implementation-defined* `error_category` object for errors originating
 elsewhere. The implementation shall define the possible values of
 `value()` for each of these error categories.
 [*Example 1*: For operating systems that are based on POSIX,
+implementations should define the `std::system_category()` values as
+identical to the POSIX `errno` values, with additional values as defined
+by the operating system’s documentation. Implementations for operating
+systems that are not based on POSIX should define values identical to
+the operating system’s values. For errors that do not originate from the
+operating system, the implementation may provide enums for the
+associated values. — *end example*]
 #### Moved-from state of library types <a id="lib.types.movedfrom">[[lib.types.movedfrom]]</a>
+Objects of types defined in the C++ standard library may be moved from
+[[class.copy.ctor]]. Move operations may be explicitly specified or
 implicitly generated. Unless otherwise specified, such moved-from
 objects shall be placed in a valid but unspecified state.
 <!-- Link reference definitions -->
 [alg.c.library]: algorithms.md#alg.c.library
 [alg.sorting]: algorithms.md#alg.sorting
 [algorithm.stable]: #algorithm.stable
 [algorithms]: algorithms.md#algorithms
 [algorithms.requirements]: algorithms.md#algorithms.requirements
+[alloc.errors]: support.md#alloc.errors
+[allocator.req.var]: #allocator.req.var
 [allocator.requirements]: #allocator.requirements
 [allocator.requirements.completeness]: #allocator.requirements.completeness
 [allocator.traits]: utilities.md#allocator.traits
 [alt.headers]: #alt.headers
 [atomics]: atomics.md#atomics
+[atomics.alias]: atomics.md#atomics.alias
+[atomics.lockfree]: atomics.md#atomics.lockfree
+[bad.alloc]: support.md#bad.alloc
 [basic.def.odr]: basic.md#basic.def.odr
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.life]: basic.md#basic.life
 [basic.link]: basic.md#basic.link
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
+[basic.lookup.qual]: basic.md#basic.lookup.qual
+[basic.lookup.unqual]: basic.md#basic.lookup.unqual
 [basic.scope.namespace]: basic.md#basic.scope.namespace
 [basic.start]: basic.md#basic.start
 [basic.stc.dynamic]: basic.md#basic.stc.dynamic
 [basic.stc.dynamic.safety]: basic.md#basic.stc.dynamic.safety
 [basic.types]: basic.md#basic.types
+[bit]: numerics.md#bit
 [bitmask.types]: #bitmask.types
 [byte.strings]: #byte.strings
+[c.annex.k.names]: #c.annex.k.names
 [character.seq]: #character.seq
+[class.copy.assign]: class.md#class.copy.assign
+[class.copy.ctor]: class.md#class.copy.ctor
+[class.dtor]: class.md#class.dtor
 [class.mem]: class.md#class.mem
 [class.mfct]: class.md#class.mfct
 [class.this]: class.md#class.this
 [class.virtual]: class.md#class.virtual
+[cmp]: support.md#cmp
 [compliance]: #compliance
+[concept.destructible]: concepts.md#concept.destructible
+[concept.invocable]: concepts.md#concept.invocable
+[concept.totallyordered]: concepts.md#concept.totallyordered
+[concepts]: concepts.md#concepts
+[concepts.equality]: concepts.md#concepts.equality
+[concepts.object]: concepts.md#concepts.object
 [conforming]: #conforming
 [conforming.overview]: #conforming.overview
 [constexpr.functions]: #constexpr.functions
 [constraints]: #constraints
 [constraints.overview]: #constraints.overview
 [container.requirements]: containers.md#container.requirements
 [containers]: containers.md#containers
 [contents]: #contents
+[conv]: expr.md#conv
+[conv.func]: expr.md#conv.func
 [conventions]: #conventions
 [cpp.include]: cpp.md#cpp.include
+[cpp.replace]: cpp.md#cpp.replace
+[cpp17.allocator]: #cpp17.allocator
+[cpp17.copyassignable]: #cpp17.copyassignable
+[cpp17.copyconstructible]: #cpp17.copyconstructible
+[cpp17.destructible]: #cpp17.destructible
+[cpp17.hash]: #cpp17.hash
+[cpp17.moveassignable]: #cpp17.moveassignable
+[cpp17.nullablepointer]: #cpp17.nullablepointer
+[cstdint]: support.md#cstdint
+[customization.point.object]: #customization.point.object
 [dcl.array]: dcl.md#dcl.array
 [dcl.attr]: dcl.md#dcl.attr
 [dcl.constexpr]: dcl.md#dcl.constexpr
 [dcl.fct.default]: dcl.md#dcl.fct.default
 [dcl.init]: dcl.md#dcl.init
 [dcl.init.list]: dcl.md#dcl.init.list
 [dcl.inline]: dcl.md#dcl.inline
 [dcl.link]: dcl.md#dcl.link
+[dcl.pre]: dcl.md#dcl.pre
 [definitions]: #definitions
 [depr]: future.md#depr
 [depr.c.headers]: future.md#depr.c.headers
 [derivation]: #derivation
 [derived.classes]: #derived.classes
 [description]: #description
 [diagnostics]: diagnostics.md#diagnostics
 [enumerated.types]: #enumerated.types
 [except]: except.md#except
+[except.spec]: except.md#except.spec
+[expos.only.func]: #expos.only.func
 [expos.only.types]: #expos.only.types
 [expr.cond]: expr.md#expr.cond
 [expr.const]: expr.md#expr.const
 [expr.delete]: expr.md#expr.delete
 [expr.eq]: expr.md#expr.eq
 [expr.new]: expr.md#expr.new
 [expr.rel]: expr.md#expr.rel
+[expr.spaceship]: expr.md#expr.spaceship
+[expr.unary.op]: expr.md#expr.unary.op
 [extern.names]: #extern.names
 [extern.types]: #extern.types
 [function.objects]: utilities.md#function.objects
 [functions.within.classes]: #functions.within.classes
 [global.functions]: #global.functions
 [handler.functions]: #handler.functions
 [hash.requirements]: #hash.requirements
 [headers]: #headers
+[headers.cpp]: #headers.cpp
+[headers.cpp.c]: #headers.cpp.c
+[headers.cpp.fs]: #headers.cpp.fs
+[hidden.friends]: #hidden.friends
 [input.output]: input.md#input.output
 [intro.compliance]: intro.md#intro.compliance
 [intro.defs]: intro.md#intro.defs
+[intro.execution]: basic.md#intro.execution
+[intro.multithread]: basic.md#intro.multithread
 [intro.refs]: intro.md#intro.refs
 [iterator.requirements]: iterators.md#iterator.requirements
 [iterators]: iterators.md#iterators
+[lex.name]: lex.md#lex.name
+[lex.name.special]: #lex.name.special
 [lex.phases]: lex.md#lex.phases
+[lex.separate]: lex.md#lex.separate
 [lib.types.movedfrom]: #lib.types.movedfrom
 [library]: #library
 [library.c]: #library.c
+[library.categories]: #library.categories
 [library.general]: #library.general
 [locales]: localization.md#locales
 [localization]: localization.md#localization
 [macro.names]: #macro.names
 [member.functions]: #member.functions
 [meta]: utilities.md#meta
+[module.import]: module.md#module.import
 [multibyte.strings]: #multibyte.strings
 [namespace.constraints]: #namespace.constraints
 [namespace.def]: dcl.md#namespace.def
 [namespace.future]: #namespace.future
 [namespace.posix]: #namespace.posix
 [namespace.std]: #namespace.std
 [namespace.udecl]: dcl.md#namespace.udecl
+[new.delete]: support.md#new.delete
+[new.handler]: support.md#new.handler
+[new.syn]: support.md#new.syn
 [nullablepointer.requirements]: #nullablepointer.requirements
 [numeric.requirements]: numerics.md#numeric.requirements
 [numerics]: numerics.md#numerics
 [objects.within.classes]: #objects.within.classes
 [organization]: #organization
 [over.literal]: over.md#over.literal
 [over.match]: over.md#over.match
 [over.oper]: over.md#over.oper
 [protection.within.classes]: #protection.within.classes
 [random.access.iterators]: iterators.md#random.access.iterators
+[ranges]: ranges.md#ranges
 [re]: re.md#re
 [reentrancy]: #reentrancy
 [replacement.functions]: #replacement.functions
 [requirements]: #requirements
 [res.on.arguments]: #res.on.arguments
 [res.on.data.races]: #res.on.data.races
 [res.on.exception.handling]: #res.on.exception.handling
+[res.on.expects]: #res.on.expects
 [res.on.functions]: #res.on.functions
 [res.on.headers]: #res.on.headers
 [res.on.macro.definitions]: #res.on.macro.definitions
 [res.on.objects]: #res.on.objects
 [res.on.pointer.storage]: #res.on.pointer.storage
+[res.on.requirements]: #res.on.requirements
 [reserved.names]: #reserved.names
+[specialized.addressof]: utilities.md#specialized.addressof
 [std.exceptions]: diagnostics.md#std.exceptions
+[stmt.return]: stmt.md#stmt.return
 [stream.types]: input.md#stream.types
 [strings]: strings.md#strings
 [structure]: #structure
 [structure.elements]: #structure.elements
 [structure.requirements]: #structure.requirements
 [structure.see.also]: #structure.see.also
 [structure.specifications]: #structure.specifications
 [structure.summary]: #structure.summary
+[support]: support.md#support
+[support.coroutine]: support.md#support.coroutine
+[support.dynamic]: support.md#support.dynamic
+[support.exception]: support.md#support.exception
+[support.initlist]: support.md#support.initlist
+[support.limits]: support.md#support.limits
+[support.rtti]: support.md#support.rtti
+[support.runtime]: support.md#support.runtime
+[support.srcloc]: support.md#support.srcloc
+[support.start.term]: support.md#support.start.term
+[support.types]: support.md#support.types
 [swappable.requirements]: #swappable.requirements
 [syserr]: diagnostics.md#syserr
 [syserr.errcode.overview]: diagnostics.md#syserr.errcode.overview
+[tab:allocator.req.var]: #tab:allocator.req.var
+[tab:cpp17.allocator]: #tab:cpp17.allocator
+[tab:cpp17.destructible]: #tab:cpp17.destructible
+[tab:cpp17.equalitycomparable]: #tab:cpp17.equalitycomparable
+[temp]: temp.md#temp
+[temp.concept]: temp.md#temp.concept
+[temp.constr.decl]: temp.md#temp.constr.decl
+[temp.constr.order]: temp.md#temp.constr.order
 [temp.deduct.call]: temp.md#temp.deduct.call
+[temp.func.order]: temp.md#temp.func.order
 [template.bitset]: utilities.md#template.bitset
+[terminate.handler]: support.md#terminate.handler
 [thread]: thread.md#thread
+[time]: time.md#time
 [type.descriptions]: #type.descriptions
 [type.descriptions.general]: #type.descriptions.general
 [using]: #using
 [using.headers]: #using.headers
 [using.linkage]: #using.linkage
 [using.overview]: #using.overview
 [usrlit.suffix]: #usrlit.suffix
 [utilities]: utilities.md#utilities
 [utility.arg.requirements]: #utility.arg.requirements
 [utility.requirements]: #utility.requirements
 [value.error.codes]: #value.error.codes
 [zombie.names]: #zombie.names
 [^3]: To save space, items that do not apply to a class are omitted. For
     example, if a class does not specify any comparison functions, there
     will be no “Comparison functions” subclause.
+[^4]: To save space, elements that do not apply to a function are
+ omitted. For example, if a function specifies no preconditions,
+    there will be no *Preconditions:* element.
 [^5]: This simplifies the presentation of complexity requirements in
     some cases.
 [^6]: Examples from  [[utility.requirements]] include:
+ *Cpp17EqualityComparable*, *Cpp17LessThanComparable*,
+ *Cpp17CopyConstructible*. Examples from  [[iterator.requirements]]
+ include: *Cpp17InputIterator*, *Cpp17ForwardIterator*.
+[^7]: Such as an integer type, with constant integer values
+    [[basic.fundamental]].
+[^8]: declared in `<clocale>`.
 [^9]: Many of the objects manipulated by function signatures declared in
+    `<cstring>` are character sequences or NTBSs. The size of some of
+    these character sequences is limited by a length value, maintained
+    separately from the character sequence.
+[^10]: A *string-literal*, such as `"abc"`, is a static NTBS.
 [^11]: An NTBS that contains characters only from the basic execution
     character set is also an NTMBS. Each multibyte character then
     consists of a single byte.
+[^12]: The C standard library headers [[depr.c.headers]] also define
+    names within the global namespace, while the C++ headers for C
+    library facilities [[headers]] may also define names within the
     global namespace.
 [^13]: This gives implementers freedom to use inline namespaces to
     support multiple configurations of the library.
 [^14]: A header is not necessarily a source file, nor are the sequences
     delimited by `<` and `>` in header names necessarily valid source
+    file names [[cpp.include]].
 [^15]: It is intentional that there is no C++ header for any of these C
     headers: `<stdatomic.h>`, `<stdnoreturn.h>`, `<threads.h>`.
 [^16]: This disallows the practice, allowed in C, of providing a masking
     macro in addition to the function prototype. The only way to achieve
     equivalent inline behavior in C++ is to provide a definition as an
     extern inline function.
+[^17]: In particular, including the standard header `<iso646.h>` has no
+    effect.
 [^18]: The `".h"` headers dump all their names into the global
     namespace, whereas the newer forms keep their names in namespace
     `std`. Therefore, the newer forms are the preferred forms for all
     uses except for C++ programs which are intended to be strictly
     from the C standard library is by including the header that declares
     it, notwithstanding the latitude granted in 7.1.4 of the C Standard.
 [^21]: Any library code that instantiates other library templates must
     be prepared to work adequately with any user-supplied specialization
+    that meets the minimum requirements of this document.
+[^22]: Any library customization point must be prepared to work
+    adequately with any user-defined overload that meets the minimum
+    requirements of this document. Therefore an implementation may
+    elect, under the as-if rule [[intro.execution]], to provide any
+    customization point in the form of an instantiated function object
+    [[function.objects]] even though the customization point’s
+    specification is in the form of a function template. The template
+    parameters of each such function object and the function parameters
+    and return type of the object’s `operator()` must match those of the
+    corresponding customization point’s specification.
+[^23]: The list of such reserved names includes `errno`, declared or
     defined in `<cerrno>`.
+[^24]: The list of such reserved function signatures with external
     linkage includes `setjmp(jmp_buf)`, declared or defined in
     `<csetjmp>`, and `va_end(va_list)`, declared or defined in
     `<cstdarg>`.
+[^25]: The function signatures declared in `<cuchar>`, `<cwchar>`, and
     `<cwctype>` are always reserved, notwithstanding the restrictions
     imposed in subclause 4.5.1 of Amendment 1 to the C Standard for
     these headers.
 [^26]: A valid C++ program always calls the expected library non-member
     function. An implementation may also define additional non-member
     functions that would otherwise not be called by a valid C++ program.
 [^27]: There is an implicit exception to this rule for types that are
+    described as synonyms for basic integral types, such as `size_t`
+    [[support.types]] and `streamoff` [[stream.types]].
 [^28]: That is, the C library functions can all be treated as if they
     are marked `noexcept`. This allows implementations to make
     performance optimizations based on the absence of exceptions at
     runtime.
+[^29]: The functions `qsort()` and `bsearch()` [[alg.c.library]] meet
     this condition.
 [^30]: In particular, they can report a failure to allocate storage by
     throwing an exception of type `bad_alloc`, or a class derived from
+    `bad_alloc` [[bad.alloc]].

Diff to HTML by rtfpessoa