[intro.defs] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpl_xn_1yb/{from.md → to.md} +142 -124

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

@@ -1,71 +1,68 @@
 # Terms and definitions <a id="intro.defs">[[intro.defs]]</a>
 For the purposes of this document, the terms and definitions given in
-ISO/IEC 2382, the terms, definitions, and symbols given in ISO
-80000-2:2009, and the following apply.
 ISO and IEC maintain terminology databases for use in standardization at
 the following addresses:
 - ISO Online browsing platform: available at <https://www.iso.org/obp>
 - IEC Electropedia: available at <https://www.electropedia.org/>
-Terms that are used only in a small portion of this document are defined
-where they are used and italicized where they are defined.
 #### 1 access <a id="defns.access">[[defns.access]]</a>
 ⟨execution-time action⟩ read or modify the value of an object
-[*Note 1 to entry*: Only glvalues of scalar type can be used to access
-objects. Reads of scalar objects are described in [[conv.lval]] and
-modifications of scalar objects are described in [[expr.ass]],
-[[expr.post.incr]], and [[expr.pre.incr]]. Attempts to read or modify an
-object of class type typically invoke a constructor [[class.ctor]] or
-assignment operator [[class.copy.assign]]; such invocations do not
-themselves constitute accesses, although they may involve accesses of
-scalar subobjects. — *end note*]
-#### 2 arbitrary-positional stream <a id="defns.arbitrary.stream">[[defns.arbitrary.stream]]</a>
-⟨library⟩ stream that can seek to any integral position within the
-length of the stream
-[*Note 1 to entry*: Every arbitrary-positional stream is also a
-repositional stream [[defns.repositional.stream]]. — *end note*]
-#### 3 argument <a id="defns.argument">[[defns.argument]]</a>
-⟨function call expression⟩ expression in the comma-separated list
-bounded by the parentheses
-#### 4 argument <a id="defns.argument.macro">[[defns.argument.macro]]</a>
 ⟨function-like macro⟩ sequence of preprocessing tokens in the
 comma-separated list bounded by the parentheses
-#### 5 argument <a id="defns.argument.throw">[[defns.argument.throw]]</a>
 ⟨throw expression⟩ operand of `throw`
-#### 6 argument <a id="defns.argument.templ">[[defns.argument.templ]]</a>
 ⟨template instantiation⟩ *constant-expression*, *type-id*, or
 *id-expression* in the comma-separated list bounded by the angle
 brackets
-#### 7 block <a id="defns.block">[[defns.block]]</a>
 ⟨execution⟩ wait for some condition (other than for the implementation
 to execute the execution steps of the thread of execution) to be
 satisfied before continuing execution past the blocking operation
-#### 8 block <a id="defns.block.stmt">[[defns.block.stmt]]</a>
 ⟨statement⟩ compound statement
 #### 9 character <a id="defns.character">[[defns.character]]</a>
 ⟨library⟩ object which, when treated sequentially, can represent text
 [*Note 1 to entry*: The term does not mean only `char`, `char8_t`,
@@ -74,147 +71,154 @@ any value that can be represented by a type that provides the
 definitions specified in [[strings]], [[localization]],
 [[input.output]], or  [[re]]. — *end note*]
 #### 10 character container type <a id="defns.character.container">[[defns.character.container]]</a>
-⟨library⟩ class or a type used to represent a character
 [*Note 1 to entry*: It is used for one of the template parameters of
-the string, iostream, and regular expression class
-templates. — *end note*]
 #### 11 collating element <a id="defns.regex.collating.element">[[defns.regex.collating.element]]</a>
-sequence of one or more characters within the current locale that
-collate as if they were a single character
 #### 12 component <a id="defns.component">[[defns.component]]</a>
-⟨library⟩ group of library entities directly related as members,
-parameters, or return types
 [*Note 1 to entry*: For example, the class template `basic_string` and
 the non-member function templates that operate on strings are referred
-to as the *string component*. — *end note*]
 #### 13 conditionally-supported <a id="defns.cond.supp">[[defns.cond.supp]]</a>
 program construct that an implementation is not required to support
 [*Note 1 to entry*: Each implementation documents all
 conditionally-supported constructs that it does not
 support. — *end note*]
-#### 14 constant subexpression <a id="defns.const.subexpr">[[defns.const.subexpr]]</a>
 expression whose evaluation as subexpression of a
 *conditional-expression* `CE` would not prevent `CE` from being a core
 constant expression
-#### 15 deadlock <a id="defns.deadlock">[[defns.deadlock]]</a>
 ⟨library⟩ situation wherein one or more threads are unable to continue
-execution because each is blocked waiting for one or more of the others
-to satisfy some condition
-#### 16 default behavior <a id="defns.default.behavior.impl">[[defns.default.behavior.impl]]</a>
 ⟨library implementation⟩ specific behavior provided by the
-implementation, within the scope of the required behavior
-#### 17 diagnostic message <a id="defns.diagnostic">[[defns.diagnostic]]</a>
 message belonging to an *implementation-defined* subset of the
 implementation’s output messages
-#### 18 direct-non-list-initialization <a id="defns.direct.non.list.init">[[defns.direct.non.list.init]]</a>
-direct-initialization that is not list-initialization
 #### 19 dynamic type <a id="defns.dynamic.type">[[defns.dynamic.type]]</a>
 ⟨glvalue⟩ type of the most derived object to which the glvalue refers
-[*Example 1*: If a pointer [[dcl.ptr]] `p` whose static type is
-“pointer to class `B`” is pointing to an object of class `D`, derived
-from `B` [[class.derived]], the dynamic type of the expression `*p` is
-“`D`”. References [[dcl.ref]] are treated similarly. — *end example*]
 #### 20 dynamic type <a id="defns.dynamic.type.prvalue">[[defns.dynamic.type.prvalue]]</a>
-⟨prvalue⟩ static type of the prvalue expression
-#### 21 expression-equivalent <a id="defns.expression.equivalent">[[defns.expression.equivalent]]</a>
 ⟨library⟩ expressions that all have the same effects, either are all
 potentially-throwing or are all not potentially-throwing, and either are
-all constant subexpressions or are all not constant subexpressions
 [*Example 1*: For a value `x` of type `int` and a function `f` that
 accepts integer arguments, the expressions `f(x + 2)`, `f(2 + x)`, and
 `f(1 + x + 1)` are expression-equivalent. — *end example*]
-#### 22 finite state machine <a id="defns.regex.finite.state.machine">[[defns.regex.finite.state.machine]]</a>
 ⟨regular expression⟩ unspecified data structure that is used to
-represent a regular expression, and which permits efficient matches
-against the regular expression to be obtained
-#### 23 format specifier <a id="defns.regex.format.specifier">[[defns.regex.format.specifier]]</a>
-⟨regular expression⟩ sequence of one or more characters that is to be
-replaced with some part of a regular expression match
-#### 24 handler function <a id="defns.handler">[[defns.handler]]</a>
 ⟨library⟩ non-reserved function whose definition may be provided by a
 C++ program
 [*Note 1 to entry*: A C++ program may designate a handler function at
 various points in its execution by supplying a pointer to the function
 when calling any of the library functions that install handler functions
-[[support]]. — *end note*]
-#### 25 ill-formed program <a id="defns.ill.formed">[[defns.ill.formed]]</a>
 program that is not well-formed [[defns.well.formed]]
-#### 26 implementation-defined behavior <a id="defns.impl.defined">[[defns.impl.defined]]</a>
-behavior, for a well-formed program construct and correct data, that
-depends on the implementation and that each implementation documents
-#### 27 implementation-defined strict total order over pointers <a id="defns.order.ptr">[[defns.order.ptr]]</a>
 ⟨library⟩ *implementation-defined* strict total ordering over all
 pointer values such that the ordering is consistent with the partial
-order imposed by the builtin operators `<`, `>`, `<=`, `>=`, and `<=>`
-#### 28 implementation limits <a id="defns.impl.limits">[[defns.impl.limits]]</a>
-restrictions imposed upon programs by the implementation
-#### 29 iostream class templates <a id="defns.iostream.templates">[[defns.iostream.templates]]</a>
-⟨library⟩ templates that are declared in header `<iosfwd>` and take two
-template arguments
-[*Note 1 to entry*: The arguments are named `charT` and `traits`. The
-argument `charT` is a character container class, and the argument
-`traits` is a class which defines additional characteristics and
-functions of the character type represented by `charT` necessary to
-implement the iostream class templates. — *end note*]
 #### 30 locale-specific behavior <a id="defns.locale.specific">[[defns.locale.specific]]</a>
 behavior that depends on local conventions of nationality, culture, and
 language that each implementation documents
 #### 31 matched <a id="defns.regex.matched">[[defns.regex.matched]]</a>
 ⟨regular expression⟩ condition when a sequence of zero or more
-characters correspond to a sequence of characters defined by the pattern
 #### 32 modifier function <a id="defns.modifier">[[defns.modifier]]</a>
 ⟨library⟩ class member function other than a constructor, assignment
 operator, or destructor that alters the state of an object of the class
@@ -234,12 +238,13 @@ of the same type
 invocation of a library function that, as part of evaluating any
 expression `E`, prevents `E` from being a core constant expression
 #### 36 NTCTS <a id="defns.ntcts">[[defns.ntcts]]</a>
-⟨library⟩ sequence of values that have character type that precede the
-terminating null character type value `charT()`
 #### 37 observer function <a id="defns.observer">[[defns.observer]]</a>
 ⟨library⟩ class member function that accesses the state of an object of
 the class but does not alter that state
@@ -263,13 +268,13 @@ by the parentheses immediately following the macro name
 ⟨template⟩ member of a *template-parameter-list*
 #### 41 primary equivalence class <a id="defns.regex.primary.equivalence.class">[[defns.regex.primary.equivalence.class]]</a>
-⟨regular expression⟩ set of one or more characters which share the same
-primary sort key: that is the sort key weighting that depends only upon
-character shape, and not accents, case, or locale specific tailorings
 #### 42 program-defined specialization <a id="defns.prog.def.spec">[[defns.prog.def.spec]]</a>
 ⟨library⟩ explicit template specialization or partial specialization
 that is not part of the C++ standard library and not defined by the
@@ -278,11 +283,12 @@ implementation
 #### 43 program-defined type <a id="defns.prog.def.type">[[defns.prog.def.type]]</a>
 ⟨library⟩ non-closure class type or enumeration type that is not part of
 the C++ standard library and not defined by the implementation, or a
 closure type of a non-implementation-provided lambda expression, or an
-instantiation of a program-defined specialization
 [*Note 1 to entry*: Types defined by the implementation include
 extensions [[intro.compliance]] and internal types used by the
 library. — *end note*]
@@ -314,11 +320,12 @@ cv-qualifiers or a *ref-qualifier*, or a reference type
 [*Note 1 to entry*: The term describes a type to which a reference can
 be created, including reference types. — *end note*]
 #### 46 regular expression <a id="defns.regex.regular.expression">[[defns.regex.regular.expression]]</a>
-pattern that selects specific strings from a set of character strings
 #### 47 replacement function <a id="defns.replacement">[[defns.replacement]]</a>
 ⟨library⟩ non-reserved function whose definition is provided by a C++
 program
@@ -326,33 +333,37 @@ program
 [*Note 1 to entry*: Only one definition for such a function is in
 effect for the duration of the program’s execution, as the result of
 creating the program [[lex.phases]] and resolving the definitions of all
 translation units [[basic.link]]. — *end note*]
-#### 48 repositional stream <a id="defns.repositional.stream">[[defns.repositional.stream]]</a>
-⟨library⟩ stream that can seek to a position that was previously
-encountered
-#### 49 required behavior <a id="defns.required.behavior">[[defns.required.behavior]]</a>
-⟨library⟩ description of replacement function and handler function
-semantics applicable to both the behavior provided by the implementation
-and the behavior of any such function definition in the program
 [*Note 1 to entry*: If such a function defined in a C++ program fails
 to meet the required behavior when it executes, the behavior is
 undefined.  — *end note*]
-#### 50 reserved function <a id="defns.reserved.function">[[defns.reserved.function]]</a>
 ⟨library⟩ function, specified as part of the C++ standard library, that
 is defined by the implementation
 [*Note 1 to entry*: If a C++ program provides a definition for any
 reserved function, the results are undefined.  — *end note*]
 #### 51 signature <a id="defns.signature">[[defns.signature]]</a>
 ⟨function⟩ name, parameter-type-list, and enclosing namespace
 [*Note 1 to entry*: Signatures are used as a basis for name mangling
@@ -364,24 +375,26 @@ and linking. — *end note*]
 parameter-type-list, enclosing class, and trailing *requires-clause*
 #### 53 signature <a id="defns.signature.templ">[[defns.signature.templ]]</a>
 ⟨function template⟩ name, parameter-type-list, enclosing namespace,
-return type, signature of the *template-head*, and trailing
-*requires-clause* (if any)
 #### 54 signature <a id="defns.signature.templ.friend">[[defns.signature.templ.friend]]</a>
 ⟨friend function template with constraint involving enclosing template parameters⟩
-name, parameter-type-list, return type, enclosing class, signature of
-the *template-head*, and trailing *requires-clause* (if any)
 #### 55 signature <a id="defns.signature.spec">[[defns.signature.spec]]</a>
-⟨function template specialization⟩ signature of the template of which it
-is a specialization and its template arguments (whether explicitly
-specified or deduced)
 #### 56 signature <a id="defns.signature.member">[[defns.signature.member]]</a>
 ⟨class member function⟩ name, parameter-type-list, class of which the
 function is a member, cv-qualifiers (if any), *ref-qualifier* (if any),
@@ -389,23 +402,26 @@ and trailing *requires-clause* (if any)
 #### 57 signature <a id="defns.signature.member.templ">[[defns.signature.member.templ]]</a>
 ⟨class member function template⟩ name, parameter-type-list, class of
 which the function is a member, cv-qualifiers (if any), *ref-qualifier*
-(if any), return type (if any), signature of the *template-head*, and
-trailing *requires-clause* (if any)
 #### 58 signature <a id="defns.signature.member.spec">[[defns.signature.member.spec]]</a>
-⟨class member function template specialization⟩ signature of the member
-function template of which it is a specialization and its template
-arguments (whether explicitly specified or deduced)
 #### 59 signature <a id="defns.signature.template.head">[[defns.signature.template.head]]</a>
-⟨*template-head*⟩ template parameter list, excluding template parameter
-names and default arguments, and *requires-clause* (if any)
 #### 60 stable algorithm <a id="defns.stable">[[defns.stable]]</a>
 ⟨library⟩ algorithm that preserves, as appropriate to the particular
 algorithm, the order of elements
@@ -422,45 +438,47 @@ considering execution semantics
 the form of the program in which the expression appears, and does not
 change while the program is executing. — *end note*]
 #### 62 sub-expression <a id="defns.regex.subexpression">[[defns.regex.subexpression]]</a>
-⟨regular expression⟩ subset of a regular expression that has been marked
-by parentheses
 #### 63 traits class <a id="defns.traits">[[defns.traits]]</a>
 ⟨library⟩ class that encapsulates a set of types and functions necessary
 for class templates and function templates to manipulate objects of
 types for which they are instantiated
 #### 64 unblock <a id="defns.unblock">[[defns.unblock]]</a>
-satisfy a condition that one or more blocked threads of execution are
-waiting for
 #### 65 undefined behavior <a id="defns.undefined">[[defns.undefined]]</a>
 behavior for which this document imposes no requirements
 [*Note 1 to entry*: Undefined behavior may be expected when this
 document omits any explicit definition of behavior or when a program
-uses an erroneous construct or erroneous data. Permissible undefined
 behavior ranges from ignoring the situation completely with
 unpredictable results, to behaving during translation or program
 execution in a documented manner characteristic of the environment (with
-or without the issuance of a diagnostic message), to terminating a
 translation or execution (with the issuance of a diagnostic message).
-Many erroneous program constructs do not engender undefined behavior;
 they are required to be diagnosed. Evaluation of a constant expression
 [[expr.const]] never exhibits behavior explicitly specified as undefined
-in [[intro]] through [[cpp]]. — *end note*]
 #### 66 unspecified behavior <a id="defns.unspecified">[[defns.unspecified]]</a>
-behavior, for a well-formed program construct and correct data, that
-depends on the implementation
 [*Note 1 to entry*: The implementation is not required to document
 which behavior occurs. The range of possible behaviors is usually
 delineated by this document. — *end note*]

 # Terms and definitions <a id="intro.defs">[[intro.defs]]</a>
 For the purposes of this document, the terms and definitions given in
+ISO/IEC 2382, ISO 80000-2:2019, and the following apply.
 ISO and IEC maintain terminology databases for use in standardization at
 the following addresses:
 - ISO Online browsing platform: available at <https://www.iso.org/obp>
 - IEC Electropedia: available at <https://www.electropedia.org/>
 #### 1 access <a id="defns.access">[[defns.access]]</a>
 ⟨execution-time action⟩ read or modify the value of an object
+[*Note 1 to entry*: Only glvalues of scalar type
+[[basic.types.general]] can be used to access objects. Reads of scalar
+objects are described in [[conv.lval]] and modifications of scalar
+objects are described in [[expr.assign]], [[expr.post.incr]], and
+[[expr.pre.incr]]. Attempts to read or modify an object of class type
+typically invoke a constructor [[class.ctor]] or assignment operator
+[[class.copy.assign]]; such invocations do not themselves constitute
+accesses, although they may involve accesses of scalar
+subobjects. — *end note*]
+#### 2 argument <a id="defns.argument">[[defns.argument]]</a>
+⟨function call expression⟩ expression or *braced-init-list* in the
+comma-separated list bounded by the parentheses
+#### 3 argument <a id="defns.argument.macro">[[defns.argument.macro]]</a>
 ⟨function-like macro⟩ sequence of preprocessing tokens in the
 comma-separated list bounded by the parentheses
+#### 4 argument <a id="defns.argument.throw">[[defns.argument.throw]]</a>
 ⟨throw expression⟩ operand of `throw`
+#### 5 argument <a id="defns.argument.templ">[[defns.argument.templ]]</a>
 ⟨template instantiation⟩ *constant-expression*, *type-id*, or
 *id-expression* in the comma-separated list bounded by the angle
 brackets
+#### 6 block <a id="defns.block">[[defns.block]]</a>
 ⟨execution⟩ wait for some condition (other than for the implementation
 to execute the execution steps of the thread of execution) to be
 satisfied before continuing execution past the blocking operation
+#### 7 block <a id="defns.block.stmt">[[defns.block.stmt]]</a>
 ⟨statement⟩ compound statement
+#### 8 C standard library <a id="defns.c.lib">[[defns.c.lib]]</a>
+library described in ISO/IEC 9899:2018 (C), Clause 7
+[*Note 1 to entry*: With the qualifications noted in [[support]]
+through [[exec]] and in [[diff.library]], the C standard library is a
+subset of the C++ standard library. — *end note*]
 #### 9 character <a id="defns.character">[[defns.character]]</a>
 ⟨library⟩ object which, when treated sequentially, can represent text
 [*Note 1 to entry*: The term does not mean only `char`, `char8_t`,
 definitions specified in [[strings]], [[localization]],
 [[input.output]], or  [[re]]. — *end note*]
 #### 10 character container type <a id="defns.character.container">[[defns.character.container]]</a>
+⟨library⟩ class or a type used to represent a
+\termref{defns.character}{character}
 [*Note 1 to entry*: It is used for one of the template parameters of
+`char_traits` and the class templates which use that, such as the
+string, iostream, and regular expression class templates. — *end note*]
 #### 11 collating element <a id="defns.regex.collating.element">[[defns.regex.collating.element]]</a>
+sequence of one or more within the current locale that collate as if
+they were a single character
 #### 12 component <a id="defns.component">[[defns.component]]</a>
+⟨library⟩ group of library entities directly related as members, , or
+return types
 [*Note 1 to entry*: For example, the class template `basic_string` and
 the non-member function templates that operate on strings are referred
+to as the string component. — *end note*]
 #### 13 conditionally-supported <a id="defns.cond.supp">[[defns.cond.supp]]</a>
 program construct that an implementation is not required to support
 [*Note 1 to entry*: Each implementation documents all
 conditionally-supported constructs that it does not
 support. — *end note*]
+#### 14 constant evaluation <a id="defns.const.eval">[[defns.const.eval]]</a>
+evaluation that is performed as part of evaluating an expression as a
+core constant expression [[expr.const]]
+#### 15 constant subexpression <a id="defns.const.subexpr">[[defns.const.subexpr]]</a>
 expression whose evaluation as subexpression of a
 *conditional-expression* `CE` would not prevent `CE` from being a core
 constant expression
+#### 16 deadlock <a id="defns.deadlock">[[defns.deadlock]]</a>
 ⟨library⟩ situation wherein one or more threads are unable to continue
+execution because each is waiting for one or more of the others to
+satisfy some condition
+#### 17 default behavior <a id="defns.default.behavior.impl">[[defns.default.behavior.impl]]</a>
 ⟨library implementation⟩ specific behavior provided by the
+implementation, within the scope of the
+\termref{defns.required.behavior}{required behavior}
+#### 18 diagnostic message <a id="defns.diagnostic">[[defns.diagnostic]]</a>
 message belonging to an *implementation-defined* subset of the
 implementation’s output messages
 #### 19 dynamic type <a id="defns.dynamic.type">[[defns.dynamic.type]]</a>
 ⟨glvalue⟩ type of the most derived object to which the glvalue refers
+[*Example 1*: If a pointer [[dcl.ptr]] `p` whose type is “pointer to
+class `B`” is pointing to a base class subobject of class `B`, whose
+most derived object is of class `D`, derived from `B` [[class.derived]],
+the dynamic type of the expression `*p` is “`D`”. References [[dcl.ref]]
+are treated similarly. — *end example*]
 #### 20 dynamic type <a id="defns.dynamic.type.prvalue">[[defns.dynamic.type.prvalue]]</a>
+⟨prvalue⟩ \termref{defns.static.type}{static type} of the prvalue
+expression
+#### 21 erroneous behavior <a id="defns.erroneous">[[defns.erroneous]]</a>
+well-defined behavior that the implementation is recommended to diagnose
+[*Note 1 to entry*: Erroneous behavior is always the consequence of
+incorrect program code. Implementations are allowed, but not required,
+to diagnose it [[intro.compliance.general]]. Evaluation of a constant
+expression [[expr.const]] never exhibits behavior specified as erroneous
+in [[intro]] through [[\lastcorechapter]]. — *end note*]
+#### 22 expression-equivalent <a id="defns.expression.equivalent">[[defns.expression.equivalent]]</a>
 ⟨library⟩ expressions that all have the same effects, either are all
 potentially-throwing or are all not potentially-throwing, and either are
+all or are all not constant subexpressions
 [*Example 1*: For a value `x` of type `int` and a function `f` that
 accepts integer arguments, the expressions `f(x + 2)`, `f(2 + x)`, and
 `f(1 + x + 1)` are expression-equivalent. — *end example*]
+#### 23 finite state machine <a id="defns.regex.finite.state.machine">[[defns.regex.finite.state.machine]]</a>
 ⟨regular expression⟩ unspecified data structure that is used to
+represent a
+\termref{defns.regex.regular.expression}{regular expression}, and which
+permits efficient matches against the regular expression to be obtained
+#### 24 format specifier <a id="defns.regex.format.specifier">[[defns.regex.format.specifier]]</a>
+⟨regular expression⟩ sequence of one or more that is expected to be
+replaced with some part of a
+\termref{defns.regex.regular.expression}{regular expression} match
+#### 25 handler function <a id="defns.handler">[[defns.handler]]</a>
 ⟨library⟩ non-reserved function whose definition may be provided by a
 C++ program
 [*Note 1 to entry*: A C++ program may designate a handler function at
 various points in its execution by supplying a pointer to the function
 when calling any of the library functions that install handler functions
+(see [[support]]). — *end note*]
+#### 26 ill-formed program <a id="defns.ill.formed">[[defns.ill.formed]]</a>
 program that is not well-formed [[defns.well.formed]]
+#### 27 implementation-defined behavior <a id="defns.impl.defined">[[defns.impl.defined]]</a>
+behavior, for a \termref{defns.well.formed}{well-formed program}
+construct and correct data, that depends on the implementation and that
+each implementation documents
+#### 28 implementation-defined strict total order over pointers <a id="defns.order.ptr">[[defns.order.ptr]]</a>
 ⟨library⟩ *implementation-defined* strict total ordering over all
 pointer values such that the ordering is consistent with the partial
+order imposed by the built-in operators `<`, `>`, `<=`, `>=`, and `<=>`
+#### 29 implementation limit <a id="defns.impl.limits">[[defns.impl.limits]]</a>
+restriction imposed upon programs by the implementation
 #### 30 locale-specific behavior <a id="defns.locale.specific">[[defns.locale.specific]]</a>
 behavior that depends on local conventions of nationality, culture, and
 language that each implementation documents
 #### 31 matched <a id="defns.regex.matched">[[defns.regex.matched]]</a>
 ⟨regular expression⟩ condition when a sequence of zero or more
+correspond to a sequence of characters defined by the pattern
 #### 32 modifier function <a id="defns.modifier">[[defns.modifier]]</a>
 ⟨library⟩ class member function other than a constructor, assignment
 operator, or destructor that alters the state of an object of the class
 invocation of a library function that, as part of evaluating any
 expression `E`, prevents `E` from being a core constant expression
 #### 36 NTCTS <a id="defns.ntcts">[[defns.ntcts]]</a>
+⟨library⟩ sequence of values that have
+\termref{defns.character}{character} type that precede the terminating
+null character type value `charT()`
 #### 37 observer function <a id="defns.observer">[[defns.observer]]</a>
 ⟨library⟩ class member function that accesses the state of an object of
 the class but does not alter that state
 ⟨template⟩ member of a *template-parameter-list*
 #### 41 primary equivalence class <a id="defns.regex.primary.equivalence.class">[[defns.regex.primary.equivalence.class]]</a>
+⟨regular expression⟩ set of one or more which share the same primary
+sort key: that is the sort key weighting that depends only upon
+character shape, and not accents, case, or locale-specific tailorings
 #### 42 program-defined specialization <a id="defns.prog.def.spec">[[defns.prog.def.spec]]</a>
 ⟨library⟩ explicit template specialization or partial specialization
 that is not part of the C++ standard library and not defined by the
 #### 43 program-defined type <a id="defns.prog.def.type">[[defns.prog.def.type]]</a>
 ⟨library⟩ non-closure class type or enumeration type that is not part of
 the C++ standard library and not defined by the implementation, or a
 closure type of a non-implementation-provided lambda expression, or an
+instantiation of a
+\termref{defns.prog.def.spec}{program-defined specialization}
 [*Note 1 to entry*: Types defined by the implementation include
 extensions [[intro.compliance]] and internal types used by the
 library. — *end note*]
 [*Note 1 to entry*: The term describes a type to which a reference can
 be created, including reference types. — *end note*]
 #### 46 regular expression <a id="defns.regex.regular.expression">[[defns.regex.regular.expression]]</a>
+pattern that selects specific strings from a set of
+\termref{defns.character}{character} strings
 #### 47 replacement function <a id="defns.replacement">[[defns.replacement]]</a>
 ⟨library⟩ non-reserved function whose definition is provided by a C++
 program
 [*Note 1 to entry*: Only one definition for such a function is in
 effect for the duration of the program’s execution, as the result of
 creating the program [[lex.phases]] and resolving the definitions of all
 translation units [[basic.link]]. — *end note*]
+#### 48 required behavior <a id="defns.required.behavior">[[defns.required.behavior]]</a>
+⟨library⟩ description of
+\termref{defns.replacement}{replacement function} and
+\termref{defns.handler}{handler function} semantics applicable to both
+the behavior provided by the implementation and the behavior of any such
+function definition in the program
 [*Note 1 to entry*: If such a function defined in a C++ program fails
 to meet the required behavior when it executes, the behavior is
 undefined.  — *end note*]
+#### 49 reserved function <a id="defns.reserved.function">[[defns.reserved.function]]</a>
 ⟨library⟩ function, specified as part of the C++ standard library, that
 is defined by the implementation
 [*Note 1 to entry*: If a C++ program provides a definition for any
 reserved function, the results are undefined.  — *end note*]
+#### 50 runtime-undefined behavior <a id="defns.undefined.runtime">[[defns.undefined.runtime]]</a>
+behavior that is undefined except when it occurs during constant
+evaluation
+[*Note 1 to entry*: During constant evaluation, — *end note*]
 #### 51 signature <a id="defns.signature">[[defns.signature]]</a>
 ⟨function⟩ name, parameter-type-list, and enclosing namespace
 [*Note 1 to entry*: Signatures are used as a basis for name mangling
 parameter-type-list, enclosing class, and trailing *requires-clause*
 #### 53 signature <a id="defns.signature.templ">[[defns.signature.templ]]</a>
 ⟨function template⟩ name, parameter-type-list, enclosing namespace,
+return type, \termref{defns.signature.template.head}{signature} of the
+*template-head*, and trailing *requires-clause* (if any)
 #### 54 signature <a id="defns.signature.templ.friend">[[defns.signature.templ.friend]]</a>
 ⟨friend function template with constraint involving enclosing template parameters⟩
+name, parameter-type-list, return type, enclosing class,
+\termref{defns.signature.template.head}{signature} of the
+*template-head*, and trailing *requires-clause* (if any)
 #### 55 signature <a id="defns.signature.spec">[[defns.signature.spec]]</a>
+⟨function template specialization⟩
+\termref{defns.signature.templ}{signature} of the template of which it
+is a specialization and its template (whether explicitly specified or
+deduced)
 #### 56 signature <a id="defns.signature.member">[[defns.signature.member]]</a>
 ⟨class member function⟩ name, parameter-type-list, class of which the
 function is a member, cv-qualifiers (if any), *ref-qualifier* (if any),
 #### 57 signature <a id="defns.signature.member.templ">[[defns.signature.member.templ]]</a>
 ⟨class member function template⟩ name, parameter-type-list, class of
 which the function is a member, cv-qualifiers (if any), *ref-qualifier*
+(if any), return type (if any),
+\termref{defns.signature.template.head}{signature} of the
+*template-head*, and trailing *requires-clause* (if any)
 #### 58 signature <a id="defns.signature.member.spec">[[defns.signature.member.spec]]</a>
+⟨class member function template specialization⟩
+\termref{defns.signature.member.templ}{signature} of the member function
+template of which it is a specialization and its template arguments
+(whether explicitly specified or deduced)
 #### 59 signature <a id="defns.signature.template.head">[[defns.signature.template.head]]</a>
+⟨*template-head*⟩ template \termref{defns.parameter.templ}{parameter}
+list, excluding template parameter names and default , and
+*requires-clause* (if any)
 #### 60 stable algorithm <a id="defns.stable">[[defns.stable]]</a>
 ⟨library⟩ algorithm that preserves, as appropriate to the particular
 algorithm, the order of elements
 the form of the program in which the expression appears, and does not
 change while the program is executing. — *end note*]
 #### 62 sub-expression <a id="defns.regex.subexpression">[[defns.regex.subexpression]]</a>
+⟨regular expression⟩ subset of a
+\termref{defns.regex.regular.expression}{regular expression} that has
+been marked by parentheses
 #### 63 traits class <a id="defns.traits">[[defns.traits]]</a>
 ⟨library⟩ class that encapsulates a set of types and functions necessary
 for class templates and function templates to manipulate objects of
 types for which they are instantiated
 #### 64 unblock <a id="defns.unblock">[[defns.unblock]]</a>
+satisfy a condition that one or more \termref{defns.block}{blocked}
+threads of execution are waiting for
 #### 65 undefined behavior <a id="defns.undefined">[[defns.undefined]]</a>
 behavior for which this document imposes no requirements
 [*Note 1 to entry*: Undefined behavior may be expected when this
 document omits any explicit definition of behavior or when a program
+uses an incorrect construct or invalid data. Permissible undefined
 behavior ranges from ignoring the situation completely with
 unpredictable results, to behaving during translation or program
 execution in a documented manner characteristic of the environment (with
+or without the issuance of a
+\termref{defns.diagnostic}{diagnostic message}), to terminating a
 translation or execution (with the issuance of a diagnostic message).
+Many incorrect program constructs do not engender undefined behavior;
 they are required to be diagnosed. Evaluation of a constant expression
 [[expr.const]] never exhibits behavior explicitly specified as undefined
+in [[intro]] through [[\lastcorechapter]]. — *end note*]
 #### 66 unspecified behavior <a id="defns.unspecified">[[defns.unspecified]]</a>
+behavior, for a \termref{defns.well.formed}{well-formed program}
+construct and correct data, that depends on the implementation
 [*Note 1 to entry*: The implementation is not required to document
 which behavior occurs. The range of possible behaviors is usually
 delineated by this document. — *end note*]

Diff to HTML by rtfpessoa