From f3db092612e8fbb339a8f3d9cb982e71aa32eb2a Mon Sep 17 00:00:00 2001

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

Date: Wed, 5 Dec 2018 01:09:09 +0100

Subject: [PATCH 01/14] Use \range where appropriate.

---

source/algorithms.tex | 6 +++---

source/regex.tex | 2 +-

source/strings.tex | 8 ++++----

3 files changed, 8 insertions(+), 8 deletions(-)

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

index 58377c00..ba4f2c9f 100644

--- a/source/algorithms.tex

+++ b/source/algorithms.tex

@@ -7412,7 +7412,7 @@ The elements \tcode{e} of \range{first}{last}

are partitioned with respect to the expressions

\tcode{bool(invoke(comp, invoke(proj, e), value))} and

\tcode{!bool(invoke(comp, value, invoke(proj, e)))}.

-Also, for all elements \tcode{e} of \tcode{[first, last)},

+Also, for all elements \tcode{e} of \range{first}{last},

\tcode{bool(comp(e, value))} implies \tcode{!bool(comp(\brk{}value, e))}

for the overloads in namespace \tcode{std}.

@@ -7479,7 +7479,7 @@ The elements \tcode{e} of \range{first}{last}

are partitioned with respect to the expressions

\tcode{bool(invoke(comp, invoke(proj, e), value))} and

\tcode{!bool(invoke(comp, value, invoke(proj, e)))}.

-Also, for all elements \tcode{e} of \tcode{[first, last)},

+Also, for all elements \tcode{e} of \range{first}{last},

\tcode{bool(comp(e, value))} implies \tcode{!bool(comp(\brk{}value, e))}

for the overloads in namespace \tcode{std}.

@@ -10665,7 +10665,7 @@ move assigns from \tcode{val} to \tcode{acc}.

\pnum

For the overloads with an \tcode{ExecutionPolicy} and a non-empty range,

performs \tcode{*result = *first}.

-Then, for every \tcode{d} in \tcode{[1, last - first - 1]},

+Then, for every \tcode{d} in \crange{1}{last - first - 1},

performs \tcode{*(result + d) = binary_op(*(first + d), *(first + (d - 1)))}.

\pnum

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

index bbec2e9f..2a24cf05 100644

--- a/source/regex.tex

+++ b/source/regex.tex

@@ -3430,7 +3430,7 @@ iterator then returns \tcode{*this}.

In all cases in which the call to \tcode{regex_search} returns \tcode{true},

\tcode{match.prefix().first} shall be equal to the previous value of

\tcode{match[0].second}, and for each index \tcode{i} in the half-open range

-\tcode{[0, match.size())} for which \tcode{match[i].matched} is \tcode{true},

+\range{0}{match.size()} for which \tcode{match[i].matched} is \tcode{true},

\tcode{match.position(i)}

shall return \tcode{distance(begin, match[i].\brk{}first)}.

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

index 4493b5d4..a8239514 100644

--- a/source/strings.tex

+++ b/source/strings.tex

@@ -153,19 +153,19 @@ the smallest \tcode{i} such that \tcode{X::eq(p[i],charT())} is \tcode{true}. &

the smallest \tcode{q} in \tcode{[p,p+n)} such that

\tcode{X::eq(*q,c)} is \tcode{true}, \tcode{nullptr} otherwise. & linear \\ \rowsep

\tcode{X::move(s,p,n)} & \tcode{X::char_type*} &

-for each \tcode{i} in \tcode{[0,n)}, performs \tcode{X::assign(s[i],p[i])}.

-Copies correctly even where the ranges \tcode{[p,p+n)} and \tcode{[s,s+n)} overlap.\br \returns \tcode{s}. & linear \\ \rowsep

+for each \tcode{i} in \range{0}{n}, performs \tcode{X::assign(s[i],p[i])}.

+Copies correctly even where the ranges \range{p}{p+n} and \range{s}{s+n} overlap.\br \returns \tcode{s}. & linear \\ \rowsep

\tcode{X::copy(s,p,n)} & \tcode{X::char_type*} &

\expects

The ranges \range{p}{p+n} and \range{s}{s+n} do not overlap.\par

\returns

\tcode{s}.\br

for each \tcode{i} in

-\tcode{[0,n)}, performs \tcode{X::assign(s[i],p[i])}. & linear \\ \rowsep

+\range{0}{n}, performs \tcode{X::assign(s[i],p[i])}. & linear \\ \rowsep

\tcode{X::assign(r,d)} & (not used) &

assigns \tcode{r=d}. & constant \\ \rowsep

\tcode{X::assign\-(s,n,c)} & \tcode{X::char_type*} &

-for each \tcode{i} in \tcode{[0,n)}, performs

+for each \tcode{i} in \range{0}{n}, performs

\tcode{X::assign(s[i],c)}.\br

\returns

\tcode{s}. & linear \\ \rowsep

--

2.34.1

From 4dabead15e93f1501a86c31f1f2121e0f7c19370 Mon Sep 17 00:00:00 2001

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

Date: Wed, 1 Feb 2017 03:39:27 +0100

Subject: [PATCH 02/14] Make references more precise.

---

source/statements.tex | 2 +-

1 file changed, 1 insertion(+), 1 deletion(-)

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

index 2b6bde2f..bdeb0c4f 100644

--- a/source/statements.tex

+++ b/source/statements.tex

@@ -1147,7 +1147,7 @@ to determine whether this is the case. This resolves the meaning

of many examples.

\begin{example}

Assuming \tcode{T} is a

-\grammarterm{simple-type-specifier}\iref{dcl.type},

+\grammarterm{simple-type-specifier}\iref{dcl.type.simple},

\begin{codeblock}

T(a)->m = 7; // expression-statement

--

2.34.1

From 28e8802821eca8f917a48bd3aa1527a7950b4652 Mon Sep 17 00:00:00 2001

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

Date: Sat, 7 Jan 2017 01:59:05 +0100

Subject: [PATCH 03/14] [rand.req.eng] Omit superfluous dollar-math wrapping

inside \bigoh. [rejected upstream: 1340]

---

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

1 file changed, 7 insertions(+), 7 deletions(-)

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

index e0803699..76dc0a27 100644

--- a/source/numerics.tex

+++ b/source/numerics.tex

@@ -1927,19 +1927,19 @@ according to \ref{strings} and \ref{input.output}.

with the same initial state

as all other default-constructed engines

of type \tcode{E}.

- & \bigoh{$\text{size of state}$}

+ & \bigoh{\text{size of state}}

\\ \rowsep

\tcode{E(x)}

&

& Creates an engine

that compares equal to \tcode{x}.

- & \bigoh{$\text{size of state}$}

+ & \bigoh{\text{size of state}}

\\ \rowsep

\tcode{E(s)}%

&

& Creates an engine

with initial state determined by \tcode{s}.

- & \bigoh{$\text{size of state}$}

+ & \bigoh{\text{size of state}}

\\ \rowsep

\tcode{E(q)}%

\begin{footnote}

@@ -2014,12 +2014,12 @@ according to \ref{strings} and \ref{input.output}.

returns \tcode{true}

if $S_x = S_y$;

else returns \tcode{false}.

- & \bigoh{$\text{size of state}$}

+ & \bigoh{\text{size of state}}

\\ \rowsep

\tcode{x != y}%

& \tcode{bool}

& \tcode{!(x == y)}.

- & \bigoh{$\text{size of state}$}

+ & \bigoh{\text{size of state}}

\\ \rowsep

\tcode{os << x}%

& reference to the type of \tcode{os}

@@ -2034,7 +2034,7 @@ according to \ref{strings} and \ref{input.output}.

by one or more space characters.

\ensures The \tcode{os.}\textit{fmtflags} and fill character are unchanged.

- & \bigoh{$\text{size of state}$}

+ & \bigoh{\text{size of state}}

\\ \rowsep

\tcode{is >> v}%

& reference to the type of \tcode{is}

@@ -2064,7 +2064,7 @@ according to \ref{strings} and \ref{input.output}.

were respectively the same as those of \tcode{is}.

\ensures The \tcode{is.}\textit{fmtflags} are unchanged.

- & \bigoh{$\text{size of state}$}

+ & \bigoh{\text{size of state}}

\\

\end{libreqtab4d}

--

2.34.1

From c8f2b318f549c976363e3d4ff0be8c0ff7f14fb4 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 04/14] 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 f33d0dc6..66254000 100644

--- a/source/basic.tex

+++ b/source/basic.tex

@@ -282,7 +282,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() {

@@ -2457,23 +2457,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 683b3013..b31b832f 100644

--- a/source/expressions.tex

+++ b/source/expressions.tex

@@ -2565,7 +2565,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.34.1

From f1917310e92b512b6d181cfdba25bec7a7058ad9 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 05/14] Use new link macros.

---

source/algorithms.tex | 6 +-

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

source/classes.tex | 24 ++--

source/compatibility.tex | 4 +-

source/concepts.tex | 12 +-

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

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

source/diagnostics.tex | 6 +-

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

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

source/future.tex | 10 +-

source/intro.tex | 19 +--

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

source/iterators.tex | 8 +-

source/lex.tex | 14 +-

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

source/limits.tex | 2 +-

source/locales.tex | 32 ++---

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

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

source/preprocessor.tex | 14 +-

source/regex.tex | 53 +++----

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

source/strings.tex | 10 +-

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

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

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

source/time.tex | 10 +-

source/utilities.tex | 45 +++---

29 files changed, 705 insertions(+), 748 deletions(-)

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

index ba4f2c9f..3e080a4e 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

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

\pnum

\remarks

-Stable\iref{algorithm.stable}.

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

\end{itemdescr}

\begin{itemdecl}

@@ -11561,7 +11561,7 @@ namespace ranges {

\pnum

\constraints

The expression \tcode{::new (declval<void*>()) T(declval<Args>()...)}

-is well-formed when treated as an unevaluated operand\iref{term.unevaluated.operand}.

+is well-formed when treated as an \deflink{unevaluated operand}{expr.context}.

\pnum

\effects

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

index 66254000..9b9c5cc8 100644

--- a/source/basic.tex

+++ b/source/basic.tex

@@ -97,8 +97,8 @@ an object. The variable's name, if any, denotes the reference or object.

\pnum

A \defnadj{local}{entity} is a variable with

-automatic storage duration\iref{basic.stc.auto},

-a structured binding\iref{dcl.struct.bind}

+\link{automatic storage duration}{basic.stc.auto},

+a \link{structured binding}{dcl.struct.bind}

whose corresponding variable is such an entity,

or the \tcode{*\keyword{this}} object\iref{expr.prim.this}.

@@ -126,7 +126,7 @@ the same literal suffix identifier.

\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}

@@ -135,7 +135,7 @@ translation unit.

\indextext{declaration!definition versus}%

\indextext{declaration}%

\indextext{declaration!name}%

-A declaration\iref{dcl.dcl} may (re)introduce

+A \link{declaration}{dcl.dcl} may (re)introduce

one or more names and/or entities into a translation

unit.

If so, the

@@ -148,7 +148,7 @@ A declaration may 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}

@@ -232,7 +232,7 @@ that defines a function, a class, a variable, or a static data member,

\item it is

an explicit instantiation declaration\iref{temp.explicit}, or

\item it is

-an explicit specialization\iref{temp.expl.spec} whose

+an \link{explicit specialization}{temp.expl.spec} whose

\grammarterm{declaration} is not a definition.

\end{itemize}

A declaration is said to be a \defn{definition} of each entity that it defines.

@@ -274,7 +274,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

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

\item If $E$ is an

\grammarterm{id-expression}\iref{expr.prim.id}, 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

@@ -368,16 +368,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}

@@ -492,12 +491,12 @@ 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}

-is \defn{odr-usable} in a scope\iref{basic.scope.scope} if:

+A \deflinkx{local entity}{entity!local}{basic.pre}

+is \defn{odr-usable} in a \link{scope}{basic.scope.scope} if:

\begin{itemize}

\item either the local entity is not \tcode{*\keyword{this}}, or

an enclosing class or non-lambda function parameter scope exists and,

@@ -561,7 +560,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},

@@ -609,9 +608,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

@@ -631,10 +630,10 @@ 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.ass}, or

+\item an lvalue of type \tcode{T} is \link{assigned to}{expr.ass}, or

\item the type \tcode{T} is the subject of an

\keyword{alignof} expression\iref{expr.alignof}, or

\item an \grammarterm{exception-declaration} has type \tcode{T}, reference to

@@ -677,7 +676,7 @@ template specialization\iref{temp.over}, except that a name can refer to

a non-volatile const object with internal or no linkage if the object

\begin{itemize}

\item has the same literal type in all definitions of \tcode{D},

-\item is initialized with a constant expression\iref{expr.const},

+\item is initialized with a \link{constant expression}{expr.const},

\item is not odr-used in any definition of \tcode{D}, and

\item has the same value in all definitions of \tcode{D},

\end{itemize}

@@ -2652,7 +2651,7 @@ only namespace names are considered.%

\pnum

\indextext{program}%

-A \defn{program} consists of one or more translation units\iref{lex.separate}

+A \defn{program} consists of one or more \deflinkx{translation units}{translation unit}{lex.separate}

linked together. A translation unit consists

of a sequence of declarations.

@@ -2675,7 +2674,7 @@ from other scopes of the same translation unit.

\item When a name has \defnx{module linkage}{linkage!module},

the entity it denotes

-can be referred to by names from other scopes of the same module unit\iref{module.unit} or

+can be referred to by names from other scopes of the same \deflink{module unit}{module.unit} or

from scopes of other module units of that same module.

\item When a name has \defnadj{internal}{linkage},

@@ -2695,7 +2694,7 @@ cannot be referred to by names from other scopes.

\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

@@ -2736,7 +2735,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

@@ -2794,7 +2793,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

@@ -3120,8 +3119,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

@@ -3165,15 +3164,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}

@@ -3303,7 +3302,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

@@ -3324,7 +3323,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

@@ -3793,16 +3792,16 @@ the result of the evaluation is the value so produced but is not erroneous:

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 errorneous value, respectively.

@@ -3987,8 +3986,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}}%

@@ -4157,19 +4156,19 @@ 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.

\begin{note}

In particular, a

global allocation function is not called to allocate storage for objects

-with static storage duration\iref{basic.stc.static}, for objects or references

-with thread storage duration\iref{basic.stc.thread}, for objects of

-type \tcode{std::type_info}\iref{expr.typeid}, or for an

-exception object\iref{except.throw}.

+with \link{static storage duration}{basic.stc.static}, for objects or references

+with \link{thread storage duration}{basic.stc.thread}, for objects of

+type \link{\tcode{std::type_info}}{expr.typeid}, or for an

+\link{exception object}{except.throw}.

\end{note}

\rSec4[basic.stc.dynamic.deallocation]{Deallocation functions}

@@ -4256,7 +4255,7 @@ may be allocated. An \defn{alignment} is an \impldef{alignment}

integer value representing the number of bytes between successive addresses

at which a given object can be allocated. An object type imposes an alignment

requirement on every object of that type; stricter alignment can be requested

-using the alignment specifier\iref{dcl.align}.

+using the \link{alignment specifier}{dcl.align}.

Attempting to create an object\iref{intro.object} in storage that

does not meet the alignment requirements of the object's type

is undefined behavior.

@@ -4732,9 +4731,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

@@ -4908,7 +4907,7 @@ Arithmetic types\iref{basic.fundamental}, enumeration types,

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

\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}%

@@ -4938,7 +4937,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},

@@ -4972,8 +4971,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}.

\rSec2[basic.fundamental]{Fundamental types}

@@ -5418,7 +5417,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

@@ -5496,7 +5495,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}

@@ -5802,8 +5801,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).

@@ -5848,7 +5847,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, or

\item

@@ -5879,7 +5878,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},

\item

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

index c9da3494..198e5e13 100644

--- a/source/classes.tex

+++ b/source/classes.tex

@@ -187,10 +187,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,

@@ -564,7 +564,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

@@ -579,7 +579,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

@@ -594,7 +594,7 @@ Any other data member or member function is a \defnadj{non-static}{member}

\defnadj{non-static}{member function}\iref{class.mfct.non.static}, respectively).

\begin{note}

A non-static data member of non-reference

-type is a member subobject of a class object\iref{intro.object}.

+type is a \deflink{member subobject}{intro.object} of a class object.

\end{note}

\pnum

@@ -713,9 +713,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

@@ -818,7 +818,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

@@ -868,7 +868,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};

@@ -2143,7 +2143,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}.

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

the copy/move operation can be omitted by

constructing the object 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 e3ff4860..f95de013 100644

--- a/source/compatibility.tex

+++ b/source/compatibility.tex

@@ -1749,8 +1749,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 0508cb54..36b784d9 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 c2d11138..011a901e 100644

--- a/source/containers.tex

+++ b/source/containers.tex

@@ -6186,14 +6186,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}.

@@ -6204,8 +6204,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

@@ -6215,13 +6215,13 @@ 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.

\pnum

The types \tcode{iterator} and \tcode{const_iterator} meet

-the constexpr iterator requirements\iref{iterator.requirements.general}.

+the \deflinkx{constexpr iterator}{iterator!constexpr}{iterator.requirements.general} requirements.

\indexlibraryglobal{array}%

\indexlibrarymember{array}{begin}%

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

\pnum

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

\indextext{requirements!container}%

-The conditions for an aggregate\iref{dcl.init.aggr} shall be

+The conditions for an \deflink{aggregate}{dcl.init.aggr} shall be

met. Class \tcode{array} relies on the implicitly-declared special

member functions\iref{class.default.ctor,class.dtor,class.copy.ctor} to

conform to the container requirements table in~\ref{container.requirements}.

@@ -6509,7 +6509,7 @@ where indexing is zero-based.

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.

@@ -7124,7 +7124,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.

@@ -7704,7 +7704,7 @@ predicate.

\pnum

\remarks

-Stable\iref{algorithm.stable}.

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

\end{itemdescr}

\indexlibrarymember{unique}{forward_list}%

@@ -7809,7 +7809,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}%

@@ -7867,7 +7867,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.

@@ -8036,7 +8036,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.

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