Use new link macros.

Author: Eelis

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
@@ -8106,7 +8106,7 @@
 
 \pnum
 \remarks
-Stable\iref{algorithm.stable}.
+\link{Stable}{algorithm.stable}.
 \end{itemdescr}
 
 \begin{itemdecl}

source/basic.tex

@@ -97,8 +97,8 @@
 
 \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}.
 
@@ -128,7 +128,7 @@
 \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}
@@ -137,7 +137,7 @@
 \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
@@ -150,7 +150,7 @@
 \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}
 
@@ -234,7 +234,7 @@
 \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.
@@ -276,7 +276,7 @@
 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
@@ -360,7 +360,7 @@
 \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
@@ -370,16 +370,15 @@
 \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}
@@ -529,8 +528,8 @@
 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}
@@ -601,7 +600,7 @@
 \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},
@@ -649,9 +648,9 @@
 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
@@ -671,10 +670,10 @@
 \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
@@ -717,7 +716,7 @@
 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}
@@ -2691,7 +2690,7 @@
 
 \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.
 
@@ -2724,7 +2723,7 @@
 \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
@@ -2765,7 +2764,7 @@
 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
@@ -2841,7 +2840,7 @@
 \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
@@ -3163,8 +3162,8 @@
 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
@@ -3208,15 +3207,15 @@
 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}
@@ -3346,7 +3345,7 @@
 \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
@@ -3367,7 +3366,7 @@
 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
@@ -3932,16 +3931,16 @@
   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.
@@ -4132,8 +4131,8 @@
 \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}}%
@@ -4302,19 +4301,19 @@
 \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}
@@ -4778,9 +4777,9 @@
 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
@@ -4954,7 +4953,7 @@
 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}%
@@ -4979,7 +4978,7 @@
 \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},
@@ -5013,8 +5012,8 @@
 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}
 
@@ -5462,7 +5461,7 @@
 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
@@ -5540,7 +5539,7 @@
 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}
@@ -5855,8 +5854,8 @@
 \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).
@@ -5901,7 +5900,7 @@
 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
@@ -5932,7 +5931,7 @@
 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