From 08ed392990847876aab16d8c1ea3852cb36f35d8 Mon Sep 17 00:00:00 2001

From: Eelis van der Weegen <eelis@eelis.net>

Date: Mon, 23 Jan 2017 06:58:26 +0100

Subject: [PATCH 01/10] Reduce excessive indentation of comments. Helps layout

on smaller (e.g. half-screen) window sizes.

---

source/basic.tex | 26 +++++++++++++-------------

source/expressions.tex | 2 +-

2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/source/basic.tex b/source/basic.tex

index c1f58de6..c3113a07 100644

--- a/source/basic.tex

+++ b/source/basic.tex

@@ -342,7 +342,7 @@ Given

#include <string>

struct C {

- std::string s; // \tcode{std::string} is the standard library class\iref{string.classes}

+ std::string s; // \tcode{std::string} is the standard library class\iref{string.classes}

};

int main() {

@@ -2652,23 +2652,23 @@ namespace AB {

void h()

{

- AB::g(); // \tcode{g} is declared directly in \tcode{AB}, therefore \tcode{S} is $\{ \tcode{AB::g()} \}$ and \tcode{AB::g()} is chosen

+ AB::g(); // \tcode{g} is declared directly in \tcode{AB}, therefore \tcode{S} is $\{ \tcode{AB::g()} \}$ and \tcode{AB::g()} is chosen

- AB::f(1); // \tcode{f} is not declared directly in \tcode{AB} so the rules are applied recursively to \tcode{A} and \tcode{B};

- // namespace \tcode{Y} is not searched and \tcode{Y::f(float)} is not considered;

- // \tcode{S} is $\{ \tcode{A::f(int)}, \tcode{B::f(char)} \}$ and overload resolution chooses \tcode{A::f(int)}

+ AB::f(1); // \tcode{f} is not declared directly in \tcode{AB} so the rules are applied recursively to \tcode{A} and \tcode{B};

+ // namespace \tcode{Y} is not searched and \tcode{Y::f(float)} is not considered;

+ // \tcode{S} is $\{ \tcode{A::f(int)}, \tcode{B::f(char)} \}$ and overload resolution chooses \tcode{A::f(int)}

- AB::f('c'); // as above but resolution chooses \tcode{B::f(char)}

+ AB::f('c'); // as above but resolution chooses \tcode{B::f(char)}

- AB::x++; // \tcode{x} is not declared directly in \tcode{AB}, and is not declared in \tcode{A} or \tcode{B}, so the rules

- // are applied recursively to \tcode{Y} and \tcode{Z}, \tcode{S} is $\{ \}$ so the program is ill-formed

+ AB::x++; // \tcode{x} is not declared directly in \tcode{AB}, and is not declared in \tcode{A} or \tcode{B}, so the rules

+ // are applied recursively to \tcode{Y} and \tcode{Z}, \tcode{S} is $\{ \}$ so the program is ill-formed

- AB::i++; // \tcode{i} is not declared directly in \tcode{AB} so the rules are applied recursively to \tcode{A} and \tcode{B},

- // \tcode{S} is $\{ \tcode{A::i}, \tcode{B::i} \}$ so the use is ambiguous and the program is ill-formed

+ AB::i++; // \tcode{i} is not declared directly in \tcode{AB} so the rules are applied recursively to \tcode{A} and \tcode{B},

+ // \tcode{S} is $\{ \tcode{A::i}, \tcode{B::i} \}$ so the use is ambiguous and the program is ill-formed

- AB::h(16.8); // \tcode{h} is not declared directly in \tcode{AB} and not declared directly in \tcode{A} or \tcode{B} so the rules

- // are applied recursively to \tcode{Y} and \tcode{Z}, \tcode{S} is $\{ \tcode{Y::h(int)}, \tcode{Z::h(double)} \}$ and

- // overload resolution chooses \tcode{Z::h(double)}

+ AB::h(16.8); // \tcode{h} is not declared directly in \tcode{AB} and not declared directly in \tcode{A} or \tcode{B} so the rules

+ // are applied recursively to \tcode{Y} and \tcode{Z}, \tcode{S} is $\{ \tcode{Y::h(int)}, \tcode{Z::h(double)} \}$ and

+ // overload resolution chooses \tcode{Z::h(double)}

}

\end{codeblock}

\end{example}

diff --git a/source/expressions.tex b/source/expressions.tex

index eec3be90..0ea2a413 100644

--- a/source/expressions.tex

+++ b/source/expressions.tex

@@ -2938,7 +2938,7 @@ struct s2 {

}

auto g() {

return [] {

- return [*this] { }; // error: \tcode{*this} not captured by outer \grammarterm{lambda-expression}

+ return [*this] { }; // error: \tcode{*this} not captured by outer \grammarterm{lambda-expression}

}();

}

};

--

2.43.0

From cb8c607df8916d9e7e48773bfa6ae0e6ffbd8ac0 Mon Sep 17 00:00:00 2001

From: Eelis van der Weegen <eelis@eelis.net>

Date: Wed, 1 Feb 2017 03:24:29 +0100

Subject: [PATCH 02/10] Use new link macros.

---

source/algorithms.tex | 4 +-

source/basic.tex | 93 +++++++-------

source/classes.tex | 22 ++--

source/compatibility.tex | 4 +-

source/concepts.tex | 12 +-

source/containers.tex | 48 ++++----

source/declarations.tex | 57 +++++----

source/diagnostics.tex | 6 +-

source/exceptions.tex | 34 +++---

source/expressions.tex | 258 ++++++++++++++++++++-------------------

source/future.tex | 10 +-

source/intro.tex | 19 +--

source/iostreams.tex | 74 +++++------

source/iterators.tex | 6 +-

source/lex.tex | 6 +-

source/lib-intro.tex | 69 +++++------

source/limits.tex | 2 +-

source/numerics.tex | 55 ++++-----

source/overloading.tex | 64 +++++-----

source/preprocessor.tex | 12 +-

source/statements.tex | 30 ++---

source/strings.tex | 8 +-

source/support.tex | 86 ++++++-------

source/templates.tex | 114 ++++++++---------

source/threads.tex | 35 +++---

source/time.tex | 10 +-

source/utilities.tex | 20 +--

27 files changed, 573 insertions(+), 585 deletions(-)

diff --git a/source/algorithms.tex b/source/algorithms.tex

index 8b2f530d..cd4ba8fb 100644

--- a/source/algorithms.tex

+++ b/source/algorithms.tex

@@ -5,7 +5,7 @@

\pnum

This Clause describes components that \Cpp{} programs may use to perform

-algorithmic operations on containers\iref{containers} and other sequences.

+algorithmic operations on \link{containers}{containers} and other sequences.

\pnum

The following subclauses describe components for

@@ -10225,7 +10225,7 @@ In either case, twice as many projections as comparisons.

\pnum

\remarks

-Stable\iref{algorithm.stable}.

+\link{Stable}{algorithm.stable}.

\end{itemdescr}

\begin{itemdecl}

diff --git a/source/basic.tex b/source/basic.tex

index c3113a07..e820717d 100644

--- a/source/basic.tex

+++ b/source/basic.tex

@@ -180,7 +180,7 @@ or the \tcode{*\keyword{this}} object\iref{expr.prim.this}.

\indextext{linkage}%

A name used in more than one translation unit can potentially

refer to the same entity in these translation units depending on the

-linkage\iref{basic.link} of the name specified in each

+\link{linkage}{basic.link} of the name specified in each

translation unit.

\rSec1[basic.def]{Declarations and definitions}

@@ -205,7 +205,7 @@ A declaration can also have effects including:

\item a static assertion\iref{dcl.pre},

\item controlling template instantiation\iref{temp.explicit},

\item guiding template argument deduction for constructors\iref{temp.deduct.guide},

-\item use of attributes\iref{dcl.attr}, and

+\item use of \link{attributes}{dcl.attr}, and

\item nothing (in the case of an \grammarterm{empty-declaration}).

\end{itemize}

\end{note}

@@ -334,7 +334,7 @@ In some circumstances, \Cpp{} implementations implicitly define the

default constructor\iref{class.default.ctor},

copy constructor, move constructor\iref{class.copy.ctor},

copy assignment operator, move assignment operator\iref{class.copy.assign},

-or destructor\iref{class.dtor} member functions.

+or \link{destructor}{class.dtor} member functions.

\end{note}

\begin{example}

Given

@@ -419,7 +419,7 @@ defined as follows:

an \grammarterm{id-expression}\iref{expr.prim.id} or

a \grammarterm{splice-expression}\iref{expr.prim.splice}, the set

contains only $E$.

-\item If $E$ is a subscripting operation\iref{expr.sub} with

+\item If $E$ is a \link{subscripting}{expr.sub} operation with

an array operand, the set contains the potential results of that operand.

\item If $E$ is a class member access

expression\iref{expr.ref} of the form

@@ -430,16 +430,15 @@ the set contains the potential results of $E_1$.

\item If $E$ is a class member access expression

naming a static data member,

the set contains the \grammarterm{id-expression} designating the data member.

-\item If $E$ is a pointer-to-member

-expression\iref{expr.mptr.oper} of the form

+\item If $E$ is a \link{pointer-to-member expression}{expr.mptr.oper} of the form

$E_1$ \tcode{.*} $E_2$,

the set contains the potential results of $E_1$.

\item If $E$ has the form \tcode{($E_1$)}, the set contains the

potential results of $E_1$.

-\item If $E$ is a glvalue conditional

-expression\iref{expr.cond}, the set is the union of the sets of

+\item If $E$ is a glvalue \link{conditional expression}{expr.cond},

+the set is the union of the sets of

potential results of the second and third operands.

-\item If $E$ is a comma expression\iref{expr.comma}, the set

+\item If $E$ is a \link{comma expression}{expr.comma}, the set

contains the potential results of the right operand.

\item Otherwise, the set is empty.

\end{itemize}

@@ -601,8 +600,8 @@ implicitly-defined

copy assignment or move assignment function for another class as specified

in~\ref{class.copy.assign}.

A constructor for a class is odr-used as specified

-in~\ref{dcl.init}. A destructor for a class is odr-used if it is potentially

-invoked\iref{class.dtor}.

+in~\ref{dcl.init}. A destructor for a class is odr-used if it is

+\deflink{potentially invoked}{class.dtor}.

\pnum

A local entity\iref{basic.pre}

@@ -674,7 +673,7 @@ void h() {

\pnum

Every program shall contain at least one definition of every

function or variable that is odr-used in that program

-outside of a discarded statement\iref{stmt.if}; no diagnostic required.

+outside of a \deflink{discarded statement}{stmt.if}; no diagnostic required.

The definition can appear explicitly in the program, it can be found in

the standard or a user-defined library, or (when appropriate) it is

implicitly defined (see~\ref{class.default.ctor}, \ref{class.copy.ctor},

@@ -722,9 +721,9 @@ The rules for declarations and expressions

describe in which contexts complete class types are required. A class

type \tcode{T} must be complete if

\begin{itemize}

-\item an object of type \tcode{T} is defined\iref{basic.def}, or

-\item a non-static class data member of type \tcode{T} is

-declared\iref{class.mem}, or

+\item an object of type \tcode{T} is \link{defined}{basic.def}, or

+\item a non-static class \deflink{data member}{class.mem} of

+type \tcode{T} is declared, or

\item \tcode{T} is used as the allocated type or array element type in a

\grammarterm{new-expression}\iref{expr.new}, or

\item an lvalue-to-rvalue conversion is applied to

@@ -744,7 +743,7 @@ a \keyword{static_cast}\iref{expr.static.cast}, or

\keyword{sizeof} operator\iref{expr.sizeof} is applied to an operand of

type \tcode{T}, or

\item a function with a return type or argument type of type \tcode{T}

-is defined\iref{basic.def} or called\iref{expr.call}, or

+is defined\iref{basic.def} or \link{called}{expr.call}, or

\item a class with a base class of type \tcode{T} is

defined\iref{class.derived}, or

\item an lvalue of type \tcode{T} is assigned to\iref{expr.assign}, or

@@ -2945,7 +2944,7 @@ are attached to the same module.

\indextext{linkage!\idxcode{inline} and}%

\indextext{\idxcode{inline}!linkage of}%

The name of an entity

-that belongs to a namespace scope\iref{basic.scope.namespace}

+that belongs to a \link{namespace scope}{basic.scope.namespace}

has internal linkage if it is the name of

\begin{itemize}

\item

@@ -2986,7 +2985,7 @@ typedef declaration in which the class has the typedef name for linkage

purposes\iref{dcl.typedef}; or

\item

\indextext{enumeration!linkage of}%

-a named enumeration\iref{dcl.enum}, or an unnamed enumeration defined

+a named \link{enumeration}{dcl.enum}, or an unnamed enumeration defined

in a typedef declaration in which the enumeration has the typedef name

for linkage purposes\iref{dcl.typedef}; or

\item an unnamed enumeration

@@ -3062,7 +3061,7 @@ the declaration at line \#3 still redeclares \#1 and receives internal linkage.

\pnum

\indextext{linkage!no}%

Names not covered by these rules have no linkage. Moreover, except as

-noted, a name declared at block scope\iref{basic.scope.block} has no

+noted, a name declared at \deflinkx{block scope}{scope!block}{basic.scope.block} has no

linkage.

\pnum

@@ -3421,8 +3420,8 @@ features of the language, such as references and virtual functions, might

involve additional memory locations that are not accessible to programs but are

managed by the implementation.

\end{note}

-Two or more threads of

-execution\iref{intro.multithread} can access separate memory

+Two or more \deflinkx{threads of

+execution}{thread of execution}{intro.multithread} can access separate memory

locations without interfering with each other.

\pnum

@@ -3466,15 +3465,15 @@ bit-fields \tcode{b} and \tcode{c} cannot be concurrently modified, but

The constructs in a \Cpp{} program create, destroy, refer to, access, and

manipulate objects.

An \defn{object} is created

-by a definition\iref{basic.def},

+by a \link{definition}{basic.def},

by a \grammarterm{new-expression}\iref{expr.new},

by an operation that implicitly creates objects (see below),

-when implicitly changing the active member of a union\iref{class.union},

+when implicitly changing the active member of a \link{union}{class.union},

or

when a temporary object is created\iref{conv.rval,class.temporary}.

An object occupies a region of storage

in its period of construction\iref{class.cdtor},

-throughout its lifetime\iref{basic.life},

+throughout its \link{lifetime}{basic.life},

and

in its period of destruction\iref{class.cdtor}.

\begin{note}

@@ -3608,7 +3607,7 @@ A \defn{potentially-overlapping subobject} is either:

\begin{itemize}

\item a base class subobject, or

\item a non-static data member

-declared with the \tcode{no_unique_address} attribute\iref{dcl.attr.nouniqueaddr}.

+declared with the \link{\tcode{no_unique_address}}{dcl.attr.nouniqueaddr} attribute.

\end{itemize}

\pnum

@@ -3629,7 +3628,7 @@ Otherwise, the circumstances under which the object has zero size

are \impldef{which non-standard-layout objects

containing no data are considered empty}.

\indextext{most derived object!bit-field}%

-Unless it is a bit-field\iref{class.bit},

+Unless it is a \link{bit-field}{class.bit},

an object with nonzero size

shall occupy one or more bytes of storage,

including every byte that is occupied in full or in part

@@ -4269,16 +4268,16 @@ the result of the evaluation is that erroneous value:

is produced by the evaluation of:

\begin{itemize}

\item

- the second or third operand of a conditional expression\iref{expr.cond},

+ the second or third operand of a \link{conditional expression}{expr.cond},

\item

- the right operand of a comma expression\iref{expr.comma},

+ the right operand of a \link{comma expression}{expr.comma},

\item

the operand of a cast or conversion\iref{conv.integral,

expr.type.conv,expr.static.cast,expr.cast}

to an unsigned ordinary character type

or \tcode{std::byte} type\iref{cstddef.syn}, or

\item

- a discarded-value expression\iref{expr.context},

+ a \deflink{discarded-value expression}{expr.context},

\end{itemize}

then the result of the operation is an indeterminate value or

that erroneous value, respectively.

@@ -4469,8 +4468,8 @@ specified in~\ref{class.copy.elision}.

\indextext{storage duration!dynamic|(}

\pnum

-Objects can be created dynamically during program

-execution\iref{intro.execution}, using

+Objects can be created dynamically during \link{program

+execution}{intro.execution}, using

\indextext{\idxcode{new}}%

\grammarterm{new-expression}{s}\iref{expr.new}, and destroyed using

\indextext{\idxcode{delete}}%

@@ -4634,9 +4633,9 @@ that would match a handler\iref{except.handle} of type

\tcode{std::bad_alloc}\iref{bad.alloc}.

\pnum

-A global allocation function is only called as the result of a new

-expression\iref{expr.new}, or called directly using the function call

-syntax\iref{expr.call}, or called indirectly to allocate storage for

+A global allocation function is only called as the result of a \link{new

+expression}{expr.new}, or called directly using the \link{function call}{expr.call}

+syntax, or called indirectly to allocate storage for

a coroutine state\iref{dcl.fct.def.coroutine},

or called indirectly through calls to the

functions in the \Cpp{} standard library.

@@ -5161,9 +5160,9 @@ shall be destroyed before

impose requirements on implementations regarding the representation

of types.

There are two kinds of types: fundamental types and compound types.

-Types describe objects\iref{intro.object},

-references\iref{dcl.ref},

-or functions\iref{dcl.fct}.

+Types describe \link{objects}{intro.object},

+\link{references}{dcl.ref},

+or \link{functions}{dcl.fct}.

\end{note}

\pnum

@@ -5337,7 +5336,7 @@ Arithmetic types\iref{basic.fundamental}, enumeration types,

pointer types, pointer-to-member types\iref{basic.compound},

\tcode{std::meta::\brk{}info}, \tcode{std::nullptr_t},

and

-cv-qualified\iref{basic.type.qualifier} versions of these

+\link{cv-qualified}{basic.type.qualifier} versions of these

types are collectively called

\defnadjx{scalar}{types}{type}.

\label{term.trivially.copyable.type}%

@@ -5362,7 +5361,7 @@ A type is a \defnadj{literal}{type} if it is:

\item a scalar type; or

\item a reference type; or

\item an array of literal type; or

-\item a possibly cv-qualified class type\iref{class} that

+\item a possibly cv-qualified \link{class type}{class} that

has all of the following properties:

\begin{itemize}

\item it has a constexpr destructor\iref{dcl.constexpr},

@@ -5396,8 +5395,8 @@ will be usable in a constant expression.

Two types \cvqual{cv1} \tcode{T1} and \cvqual{cv2} \tcode{T2} are

\defnadjx{layout-compatible}{types}{type}

if \tcode{T1} and \tcode{T2} are the same type,

-layout-compatible enumerations\iref{dcl.enum}, or

-layout-compatible standard-layout class types\iref{class.mem}.

+\deflinkx{layout-compatible enumerations}{layout-compatible!enumeration}{dcl.enum}, or

+\deflinkx{layout-compatible standard-layout class types}{layout-compatible!class}{class.mem}.

\pnum

A type is \defn{consteval-only} if it is

@@ -5971,7 +5970,7 @@ ordinary pointers to objects or functions.

which identify members of a given

type within objects of a given class, \ref{dcl.mptr}.

Pointers to data members and pointers to member functions are collectively

-called \term{pointer-to-member} types.

+called \defn{pointer-to-member} types.

\end{itemize}

\pnum

@@ -6049,7 +6048,7 @@ layout-compatible types shall

have the same value representation and alignment

requirements\iref{basic.align}.

\begin{note}

-Pointers to over-aligned types\iref{basic.align} have no special

+Pointers to \deflinkx{over-aligned types}{type!over-aligned}{basic.align} have no special

representation, but their range of valid values is restricted by the extended

alignment requirement.

\end{note}

@@ -6386,8 +6385,8 @@ the definition of the usual arithmetic conversions\iref{expr.arith.conv}.

\indextext{program execution|(}

\pnum

-An instance of each object with automatic storage

-duration\iref{basic.stc.auto} is associated with each entry into its

+An instance of each object with \link{automatic storage

+duration}{basic.stc.auto} is associated with each entry into its

block. Such an object exists and retains its last-stored value during

the execution of the block and while the block is suspended (by a call

of a function, suspension of a coroutine\iref{expr.await}, or receipt of a signal).

@@ -6432,7 +6431,7 @@ if $E$ is a \grammarterm{lambda-expression}\iref{expr.prim.lambda},

the initialization of the entities captured by copy and

the constituent expressions of the \grammarterm{initializer} of the \grammarterm{init-capture}{s},

\item

-if $E$ is a function call\iref{expr.call} or implicitly invokes a function,

+if $E$ is a \link{function call}{expr.call} or implicitly invokes a function,

the constituent expressions of each default argument\iref{dcl.fct.default}

used in the call, and

\item

@@ -6463,7 +6462,7 @@ are not subexpressions of a nested unevaluated operand\iref{term.unevaluated.ope

A \defn{full-expression} is

\begin{itemize}

\item

-an unevaluated operand\iref{expr.context},

+an \deflink{unevaluated operand}{expr.context},

\item

a \grammarterm{constant-expression}\iref{expr.const.core},

\item

diff --git a/source/classes.tex b/source/classes.tex

index 6cd80b27..b1db5350 100644

--- a/source/classes.tex

+++ b/source/classes.tex

@@ -188,10 +188,10 @@ A class \tcode{S} is a \defnadj{standard-layout}{class} if it:

\item has no non-static data members of type non-standard-layout class

(or array of such types) or reference,

-\item has no virtual functions\iref{class.virtual} and no

-virtual base classes\iref{class.mi},

+\item has no \link{virtual functions}{class.virtual} and no

+\link{virtual base classes}{class.mi},

-\item has the same access control\iref{class.access}

+\item has the same \link{access control}{class.access}

for all non-static data members,

\item has no non-standard-layout base classes,

@@ -574,7 +574,7 @@ if it is

\end{itemize}

For any other \grammarterm{member-declaration},

each declared entity

-that is not an unnamed bit-field\iref{class.bit}

+that is not an \deflinkx{unnamed bit-field}{bit-field!unnamed}{class.bit}

is a member of the class,

and each such \grammarterm{member-declaration}

shall either

@@ -593,7 +593,7 @@ Nested types are classes\iref{class.name,class.nest} and

enumerations\iref{dcl.enum} declared in the class and arbitrary types

declared as members by use of a typedef declaration\iref{dcl.typedef}

or \grammarterm{alias-declaration}.

-The enumerators of an unscoped enumeration\iref{dcl.enum} defined in the class

+The enumerators of an \link{unscoped enumeration}{dcl.enum} defined in the class

are members of the class.

\pnum

@@ -739,9 +739,9 @@ shall contain a \grammarterm{type-specifier} that is not a \grammarterm{cv-quali

The

\grammarterm{member-declarator-list} can be omitted only after a

\grammarterm{class-specifier} or an \grammarterm{enum-specifier} or in a

-friend declaration\iref{class.friend}. A

+\link{friend declaration}{class.friend}. A

\grammarterm{pure-specifier} shall be used only in the declaration of a

-virtual function\iref{class.virtual}

+\link{virtual function}{class.virtual}

that is not a friend declaration.

\pnum

@@ -844,7 +844,7 @@ unscoped enumeration type; and

\pnum

In addition, if class \tcode{T} has a user-declared

-constructor\iref{class.ctor}, every non-static data member of class

+\link{constructor}{class.ctor}, every non-static data member of class

\tcode{T} shall have a name different from \tcode{T}.

\pnum

@@ -894,7 +894,7 @@ non-static data members (in any order) have layout-compatible

types\iref{term.layout.compatible.type}.

\pnum

-In a standard-layout union with an active member\iref{class.union}

+In a standard-layout union with an \deflinkx{active member}{active!union member}{class.union}

of struct type \tcode{T1}, it is permitted to read a non-static

data member \tcode{m} of another union member of struct type \tcode{T2}

provided \tcode{m} is part of the common initial sequence of \tcode{T1} and \tcode{T2};

@@ -2236,7 +2236,7 @@ by a \grammarterm{new-expression}\iref{expr.new}; the context of the invocation

An array of class type contains several subobjects for each of which

the destructor is invoked.

\end{note}

-A destructor can also be invoked explicitly. A destructor is \term{potentially invoked}

+A destructor can also be invoked explicitly. A destructor is \defn{potentially invoked}

if it is invoked or as specified in~\ref{expr.new},

\ref{stmt.return}, \ref{dcl.init.aggr},

\ref{class.base.init}, and~\ref{except.throw}.

@@ -6344,7 +6344,7 @@ associated with a \grammarterm{try-block} (if there is one),

the copy-initialization of the exception object can be omitted by

constructing $o$ directly into the exception object;

-\item in a coroutine\iref{dcl.fct.def.coroutine}, a copy of a coroutine parameter

+\item in a \link{coroutine}{dcl.fct.def.coroutine}, a copy of a coroutine parameter

can be omitted and references to that copy replaced with references to the

corresponding parameter if the meaning of the program will be unchanged except for

the execution of a constructor and destructor for the parameter copy object;

diff --git a/source/compatibility.tex b/source/compatibility.tex

index e3512400..cdca4c22 100644

--- a/source/compatibility.tex

+++ b/source/compatibility.tex

@@ -1981,8 +1981,8 @@ deallocation functions\iref{expr.new}.

A conditional expression with a throw expression as its second or third

operand keeps the type and value category of the other operand.

\rationale

-Formerly mandated conversions (lvalue-to-rvalue\iref{conv.lval},

-array-to-pointer\iref{conv.array}, and function-to-pointer\iref{conv.func}

+Formerly mandated conversions (\link{lvalue-to-rvalue}{conv.lval},

+\link{array-to-pointer}{conv.array}, and \link{function-to-pointer}{conv.func}

standard conversions), especially the creation of the temporary due to

lvalue-to-rvalue conversion, were considered gratuitous and surprising.

\effect

diff --git a/source/concepts.tex b/source/concepts.tex

index d1e15a6e..42828a4b 100644

--- a/source/concepts.tex

+++ b/source/concepts.tex

@@ -300,7 +300,7 @@ classifications, and fundamental type properties.

\begin{itemdecl}

template<class T, class U>

- concept @\defexposconcept{same-as-impl}@ = is_same_v<T, U>; // \expos

+ concept @\defexposconcept{same-as-impl}@ = @\libglobalref{is_same_v}@<T, U>; // \expos

template<class T, class U>

concept @\deflibconcept{same_as}@ = @\exposconcept{same-as-impl}@<T, U> && @\exposconcept{same-as-impl}@<U, T>;

@@ -493,13 +493,13 @@ Users can customize the behavior of \libconcept{common_with} by specializing the

\begin{itemdecl}

template<class T>

- concept @\deflibconcept{integral}@ = is_integral_v<T>;

+ concept @\deflibconcept{integral}@ = @\libglobalref{is_integral_v}@<T>;

template<class T>

- concept @\deflibconcept{signed_integral}@ = @\libconcept{integral}@<T> && is_signed_v<T>;

+ concept @\deflibconcept{signed_integral}@ = @\libconcept{integral}@<T> && @\libglobalref{is_signed_v}@<T>;

template<class T>

concept @\deflibconcept{unsigned_integral}@ = @\libconcept{integral}@<T> && !@\libconcept{signed_integral}@<T>;

template<class T>

- concept @\deflibconcept{floating_point}@ = is_floating_point_v<T>;

+ concept @\deflibconcept{floating_point}@ = @\libglobalref{is_floating_point_v}@<T>;

\end{itemdecl}

\begin{itemdescr}

@@ -748,7 +748,7 @@ types.

\begin{itemdecl}

template<class T>

- concept @\deflibconcept{destructible}@ = is_nothrow_destructible_v<T>;

+ concept @\deflibconcept{destructible}@ = @\libglobalref{is_nothrow_destructible_v}@<T>;

\end{itemdecl}

\begin{itemdescr}

@@ -768,7 +768,7 @@ variable of a given type with a particular set of argument types.

\begin{itemdecl}

template<class T, class... Args>

- concept @\deflibconcept{constructible_from}@ = @\libconcept{destructible}@<T> && is_constructible_v<T, Args...>;

+ concept @\deflibconcept{constructible_from}@ = @\libconcept{destructible}@<T> && @\libglobalref{is_constructible_v}@<T, Args...>;

\end{itemdecl}

\rSec2[concept.default.init]{Concept \cname{default_initializable}}

diff --git a/source/containers.tex b/source/containers.tex

index 8b043683..fe9418c0 100644

--- a/source/containers.tex

+++ b/source/containers.tex

@@ -6143,14 +6143,14 @@ namespace std {

\indextext{\idxcode{array}!contiguous storage}%

The header \libheader{array} defines a class template for storing fixed-size

sequences of objects.

-An \tcode{array} is a contiguous container\iref{container.reqmts}.

+An \tcode{array} is a \deflinkx{contiguous container}{container!contiguous}{container.reqmts}.

An instance of \tcode{array<T, N>} stores \tcode{N} elements of type \tcode{T},

so that \tcode{size() == N} is an invariant.

\pnum

\indextext{\idxcode{array}!initialization}%

\indextext{\idxcode{array}!as aggregate}%

-An \tcode{array} is an aggregate\iref{dcl.init.aggr} that can be

+An \tcode{array} is an \deflink{aggregate}{dcl.init.aggr} that can be

list-initialized with up

to \tcode{N} elements whose types are convertible to \tcode{T}.

@@ -6161,8 +6161,8 @@ of a container\iref{container.reqmts} and

of a reversible container\iref{container.rev.reqmts},

except that a default

constructed \tcode{array} object is not empty if $\tcode{N} > 0$.

-An \tcode{array} meets some of the requirements of a sequence

-container\iref{sequence.reqmts}.

+An \tcode{array} meets some of the requirements of a

+\link{sequence container}{sequence.reqmts}.

Descriptions are provided here

only for operations on \tcode{array} that are not described in

one of these tables and

@@ -6172,7 +6172,7 @@ for operations where there is additional semantic information.

\tcode{array<T, N>} is a structural type\iref{term.structural.type} if

\tcode{T} is a structural type.

Two values \tcode{a1} and \tcode{a2} of type \tcode{array<T, N>}

-are template-argument-equivalent\iref{temp.type} if and only if

+are \deflink{template-argument-equivalent}{temp.type} if and only if

each pair of corresponding elements in \tcode{a1} and \tcode{a2}

are template-argument-equivalent.

@@ -6497,7 +6497,7 @@ namespace std {

A

\indexlibraryglobal{deque}%

\tcode{deque}

-is a sequence container that supports random access iterators\iref{random.access.iterators}.

+is a sequence container that supports \link{random access iterators}{random.access.iterators}.

In addition, it supports constant time insert and erase operations at the beginning or the end;

insert and erase in the middle take linear time.

That is, a deque is especially optimized for pushing and popping elements at the beginning and end.

@@ -7162,7 +7162,7 @@ namespace std {

\pnum

An incomplete type \tcode{T} may be used when instantiating \tcode{forward_list}

if the allocator meets the

-allocator completeness requirements\iref{allocator.requirements.completeness}.

+\link{allocator completeness requirements}{allocator.requirements.completeness}.

\tcode{T} shall be complete before any member of the resulting specialization

of \tcode{forward_list} is referenced.

@@ -7746,7 +7746,7 @@ predicate.

\pnum

\remarks

-Stable\iref{algorithm.stable}.

+\link{Stable}{algorithm.stable}.

\end{itemdescr}

\indexlibrarymember{unique}{forward_list}%

@@ -7851,7 +7851,7 @@ Approximately $N \log N$ comparisons, where $N$ is \tcode{distance(begin(), end(

\pnum

\remarks

-Stable\iref{algorithm.stable}.

+\link{Stable}{algorithm.stable}.

\end{itemdescr}

\indexlibrarymember{reverse}{forward_list}%

@@ -9087,7 +9087,7 @@ A

is a sequence container that supports

bidirectional iterators and allows constant time insert and erase

operations anywhere within the sequence, with storage management handled

-automatically. Unlike vectors\iref{vector} and deques\iref{deque},

+automatically. Unlike \link{vectors}{vector} and \link{deques}{deque},

fast random access to list elements is not supported, but many

algorithms only need sequential access anyway.

@@ -9263,7 +9263,7 @@ namespace std {

\pnum

An incomplete type \tcode{T} may be used when instantiating \tcode{list}

if the allocator meets the

-allocator completeness requirements\iref{allocator.requirements.completeness}.

+\link{allocator completeness requirements}{allocator.requirements.completeness}.

\tcode{T} shall be complete before any member of the resulting specialization

of \tcode{list} is referenced.

@@ -9676,7 +9676,7 @@ applications of the corresponding predicate.

\pnum

\remarks

-Stable\iref{algorithm.stable}.

+\link{Stable}{algorithm.stable}.

\end{itemdescr}

\indexlibrarymember{unique}{list}%

@@ -9799,7 +9799,7 @@ comparisons, where $N$ is \tcode{size()}.

\pnum

\remarks

-Stable\iref{algorithm.stable}.

+\link{Stable}{algorithm.stable}.

\end{itemdescr}

\rSec3[list.erasure]{Erasure}

@@ -9907,7 +9907,7 @@ of an allocator-aware container\iref{container.alloc.reqmts},

of a sequence container, including most of the optional sequence container

requirements\iref{sequence.reqmts},

and, for an element type other than \tcode{bool},

-of a contiguous container\iref{container.reqmts}.

+of a \deflinkx{contiguous container}{container!contiguous}{container.reqmts}.

The exceptions are the

\tcode{push_front}, \tcode{prepend_range}, \tcode{pop_front}, and \tcode{emplace_front} member functions, which are not

provided. Descriptions are provided here only for operations on \tcode{vector}

@@ -10045,7 +10045,7 @@ namespace std {

\pnum

An incomplete type \tcode{T} may be used when instantiating \tcode{vector}

if the allocator meets the

-allocator completeness requirements\iref{allocator.requirements.completeness}.

+\link{allocator completeness requirements}{allocator.requirements.completeness}.

\tcode{T} shall be complete before any member of the resulting specialization

of \tcode{vector} is referenced.

@@ -10641,7 +10641,7 @@ Unless described below, all operations have the same requirements and

semantics as the \tcode{vector} primary template, except that operations

dealing with the \tcode{bool} value type map to bit values in the

container storage and

-\tcode{allocator_traits::construct}\iref{allocator.traits.members}

+\libmemberrefx{allocator_traits::construct}{allocator_traits}{construct}

is not used to construct these values.

\pnum

@@ -15779,9 +15779,9 @@ and

can be used to instantiate

\tcode{queue}.

In particular,

-\tcode{list}\iref{list}

+\link{\tcode{list}}{list}

and

-\tcode{deque}\iref{deque}

+\link{\tcode{deque}}{deque}

can be used.

\begin{codeblock}

@@ -16136,15 +16136,15 @@ and

can be used to instantiate

\tcode{priority_queue}.

In particular,

-\tcode{vector}\iref{vector}

+\link{\tcode{vector}}{vector}

and

-\tcode{deque}\iref{deque}

+\link{\tcode{deque}}{deque}

can be used.

Instantiating

\tcode{priority_queue}

also involves supplying a function or function object for making

priority comparisons; the library assumes that the function or function

-object defines a strict weak ordering\iref{alg.sorting}.

+object defines a \link{strict weak ordering}{alg.sorting}.

\begin{codeblock}

namespace std {

@@ -16692,10 +16692,10 @@ and

can be used to instantiate

\tcode{stack}.

In particular,

-\tcode{vector}\iref{vector},

-\tcode{list}\iref{list}

+\link{\tcode{vector}}{vector},

+\link{\tcode{list}}{list}

and

-\tcode{deque}\iref{deque}

+\link{\tcode{deque}}{deque}

can be used.

\rSec3[stack.defn]{Definition}

diff --git a/source/declarations.tex b/source/declarations.tex

index 627360a2..cea5493a 100644

--- a/source/declarations.tex

+++ b/source/declarations.tex

@@ -547,7 +547,7 @@ in explicit specializations and explicit instantiations, respectively.

\begin{note}

A variable declared without a \grammarterm{storage-class-specifier}

at block scope or declared as a function parameter

-has automatic storage duration by default\iref{basic.stc.auto}.

+has \deflinkx{automatic storage duration}{storage duration!automatic}{basic.stc.auto} by default.

\end{note}

\pnum

@@ -815,10 +815,10 @@ an alias template or a type template template parameter.

A \grammarterm{simple-template-id} that names a class template specialization

is a \grammarterm{class-name}\iref{class.name}.

If a \grammarterm{typedef-name} is used to identify the subject of an

-\grammarterm{elaborated-type-specifier}\iref{dcl.type.elab}, a class

-definition\iref{class}, a constructor

-declaration\iref{class.ctor}, or a destructor

-declaration\iref{class.dtor}, the program is ill-formed.

+\grammarterm{elaborated-type-specifier}\iref{dcl.type.elab}, a \link{class

+definition}{class}, a \link{constructor

+declaration}{class.ctor}, or a \link{destructor

+declaration}{class.dtor}, the program is ill-formed.

\end{note}

\begin{example}

\begin{codeblock}

@@ -1151,7 +1151,7 @@ If an inline function or variable that is attached to a named module

is declared in a definition domain,

it shall be defined in that domain.

\begin{note}

-A constexpr function\iref{dcl.constexpr} is implicitly inline.

+A \deflinkx{constexpr function}{specifier!\idxcode{constexpr}!function}{dcl.constexpr} is implicitly inline.

In the global module, a function defined within a class definition

is implicitly inline\iref{class.mfct,class.friend}.

\end{note}

@@ -1290,7 +1290,7 @@ the object referenced is a non-const object and can be modified through

some other access path.

\begin{note}

Cv-qualifiers are supported by the type system so that they cannot be

-subverted without casting\iref{expr.const.cast}.

+subverted without \link{casting}{expr.const.cast}.

\end{note}

\pnum

@@ -1734,8 +1734,7 @@ is \tcode{T\&}, where \tcode{T} is the type of $E$;

\item otherwise, \tcode{decltype($E$)} is the type of $E$.

\end{itemize}

-The operand of the \keyword{decltype} specifier is an unevaluated

-operand\iref{term.unevaluated.operand}.

+The operand of the \keyword{decltype} specifier is an \deflink{unevaluated operand}{expr.context}.

\begin{example}

\begin{codeblock}

@@ -1934,7 +1933,7 @@ explicitly allowed in \ref{dcl.spec.auto} is ill-formed.

If the \grammarterm{init-declarator-list} contains more than one

\grammarterm{init-declarator}, they shall all form declarations of

variables. The type of each declared variable is determined

-by placeholder type deduction\iref{dcl.type.auto.deduct},

+by \deflink{placeholder type deduction}{dcl.type.auto.deduct},

and if the type that replaces the placeholder type is not the

same in each deduction, the program is ill-formed.

@@ -2076,7 +2075,7 @@ A function declared with a return type that uses a placeholder type shall not

be a coroutine\iref{dcl.fct.def.coroutine}.

\pnum

-An explicit instantiation declaration\iref{temp.explicit} does not cause the

+An \link{explicit instantiation declaration}{temp.explicit} does not cause the

instantiation of an entity declared using a placeholder type, but it also does

not prevent that entity from being instantiated as needed to determine its

type.

@@ -2291,7 +2290,7 @@ in the \grammarterm{type-specifier-seq}

in the \grammarterm{new-type-id} or \grammarterm{type-id}

of a \grammarterm{new-expression}\iref{expr.new},

as the \grammarterm{simple-type-specifier}

-in an explicit type conversion (functional notation)\iref{expr.type.conv},

+in an \link{explicit type conversion (functional notation)}{expr.type.conv},

or

as the \grammarterm{type-specifier} in the \grammarterm{parameter-declaration}

of a \grammarterm{template-parameter}\iref{temp.param}.

@@ -4501,7 +4500,7 @@ int a;

int f(int a, int b = a); // error: parameter \tcode{a} used as default argument

typedef int I;

int g(float I, int b = I(2)); // error: parameter \tcode{I} found

-int h(int a, int b = sizeof(a)); // OK, unevaluated operand\iref{term.unevaluated.operand}

+int h(int a, int b = sizeof(a)); // OK, \deflink{unevaluated operand}{expr.context}

\end{codeblock}

\end{example}

A non-static member shall not be designated in a default argument unless

@@ -6226,15 +6225,15 @@ This requires a conversion

function\iref{class.conv.fct} returning a reference type.

\end{footnote}

(this conversion is selected by enumerating the applicable conversion

-functions\iref{over.match.ref} and choosing the best one through overload

-resolution\iref{over.match}),

+functions\iref{over.match.ref} and choosing the best one through \link{overload

+resolution}{over.match}),

\end{itemize}

then the reference binds to the initializer expression lvalue in the

first case and to the lvalue result of the conversion

in the second case (or, in either case, to the appropriate base class subobject of the object).

\begin{note}

-The usual lvalue-to-rvalue\iref{conv.lval}, array-to-pointer\iref{conv.array},

-and function-to-pointer\iref{conv.func} standard

+The usual \link{lvalue-to-rvalue}{conv.lval}, \link{array-to-pointer}{conv.array},

+and \link{function-to-pointer}{conv.func} standard

conversions are not needed, and therefore are suppressed, when such

direct bindings to lvalues are done.

\end{note}

@@ -7747,7 +7746,7 @@ the initializer is

where \tcode{get} undergoes argument-dependent lookup\iref{basic.lookup.argdep}.

In either case, \tcode{get<i>} is interpreted as a \grammarterm{template-id}.

\begin{note}

-Ordinary unqualified lookup\iref{basic.lookup.unqual} is not performed.

+Ordinary \link{unqualified lookup}{basic.lookup.unqual} is not performed.

\end{note}

In either case, \exposid{e} is an lvalue if the type of the entity \exposid{e}

is an lvalue reference and an xvalue otherwise.

@@ -7898,7 +7897,7 @@ is not looked up and is introduced by

the \grammarterm{enum-specifier} or \grammarterm{opaque-enum-declaration}.

If the \grammarterm{enum-head-name} of an \grammarterm{opaque-enum-declaration} contains

a \grammarterm{nested-name-specifier},

-the declaration shall be an explicit specialization\iref{temp.expl.spec}.

+the declaration shall be an \link{explicit specialization}{temp.expl.spec}.

\pnum

\indextext{constant!enumeration}%

@@ -8063,7 +8062,7 @@ if they have the same underlying type.

\pnum

The value of an enumerator or an object of an unscoped enumeration type is

-converted to an integer by integral promotion\iref{conv.prom}.

+converted to an integer by \deflinkx{integral promotion}{integral promotion}{conv.prom}.

\begin{example}

\begin{codeblock}

enum color { red, yellow, green=20, blue };

@@ -8346,7 +8345,7 @@ appertains to the namespace being defined or extended.

Members of an inline namespace can be used in most respects as though they were members

of the innermost enclosing namespace. Specifically, the inline namespace and its enclosing

namespace are both added to the set of associated namespaces used in

-argument-dependent lookup\iref{basic.lookup.argdep} whenever one of them is,

+\link{argument-dependent lookup}{basic.lookup.argdep} whenever one of them is,

and a \grammarterm{using-directive}\iref{namespace.udir} that names the inline

namespace is implicitly inserted into the enclosing namespace as for an unnamed

namespace\iref{namespace.unnamed}. Furthermore, each

@@ -9179,7 +9178,7 @@ different language linkages are distinct types even if they are

otherwise identical.

\pnum

-Linkage\iref{basic.link} between \Cpp{} and non-\Cpp{} code fragments can

+\link{Linkage}{basic.link} between \Cpp{} and non-\Cpp{} code fragments can

be achieved using a \grammarterm{linkage-specification}:

\indextext{\idxgram{linkage-specification}}%

@@ -9509,18 +9508,18 @@ For each individual attribute, the form of the

\pnum

In an \grammarterm{attribute-list}, an ellipsis may appear only if that

\grammarterm{attribute}'s specification permits it. An \grammarterm{attribute} followed

-by an ellipsis is a pack expansion\iref{temp.variadic}.

+by an ellipsis is a \deflink{pack expansion}{temp.variadic}.

An \grammarterm{attribute-specifier} that contains

an \grammarterm{attribute-list} with no \grammarterm{attribute}s

has no effect.

The order in which the \grammarterm{attribute-token}{s} appear in an

\grammarterm{attribute-list} is not significant. If a

-keyword\iref{lex.key}

-or an alternative token\iref{lex.digraph} that satisfies the syntactic requirements

+\link{keyword}{lex.key}

+or an \link{alternative token}{lex.digraph} that satisfies the syntactic requirements

of an \grammarterm{identifier}\iref{lex.name} is

contained in

-an \grammarterm{attribute-token}, it is considered an identifier. No name

-lookup\iref{basic.lookup} is performed on any of the identifiers contained in an

+an \grammarterm{attribute-token}, it is considered an identifier. No

+\link{name lookup}{basic.lookup} is performed on any of the identifiers contained in an

\grammarterm{attribute-token}. The \grammarterm{attribute-token} determines additional

requirements on the \grammarterm{attribute-argument-clause} (if any).

@@ -9638,7 +9637,7 @@ declaration, the program is ill-formed.

\pnum

An \grammarterm{alignment-specifier} of the form

\tcode{alignas(} \grammarterm{type-id} \tcode{)} has the same

-effect as \tcode{alignas(\brk{}alignof(} \grammarterm{type-id}~\tcode{))}\iref{expr.alignof}.

+effect as \tcode{alignas(\brk{}\link{alignof}{expr.alignof}(} \grammarterm{type-id}~\tcode{))}.

\pnum

The alignment requirement of an entity is the strictest nonzero alignment

@@ -9818,7 +9817,7 @@ unless the implementation can issue such diagnostic messages.

\pnum

The \grammarterm{attribute-token} \tcode{fallthrough}

-may be applied to a null statement\iref{stmt.expr};

+may be applied to a \deflinkx{null statement}{statement!null}{stmt.expr};

such a statement is a \defnadj{fallthrough}{statement}.

No \grammarterm{attribute-argument-clause} shall be present.

A fallthrough statement may only appear within

diff --git a/source/diagnostics.tex b/source/diagnostics.tex

index d842475b..eee2454e 100644

--- a/source/diagnostics.tex

+++ b/source/diagnostics.tex

@@ -508,13 +508,13 @@ the current state of \tcode{NDEBUG} each time that

\pnum

An expression \tcode{assert(E)}

-is a constant subexpression\iref{defns.const.subexpr}, if

+is a \link{constant subexpression}{defns.const.subexpr}, if

\begin{itemize}

\item

\tcode{NDEBUG} is defined at the point where \tcode{assert}

is last defined or redefined, or

\item

-\tcode{E} contextually converted to \tcode{bool}\iref{conv}

+\tcode{E} \deflinkx{contextually converted to \tcode{bool}}{conversion!contextual to \tcode{bool}}{conv}

is a constant subexpression that evaluates to the value \tcode{true}.

\end{itemize}

@@ -1529,7 +1529,7 @@ application program interfaces.

\pnum

\begin{note}

If an error represents an out-of-memory condition, implementations are