[everywhere] Fix (\ref{..}) at start of line to be \iref on prior line.

Author: zygoloid

source/basic.tex

@@ -115,8 +115,8 @@
 \tcode{extern} specifier\iref{dcl.stc} or a
 \grammarterm{linkage-specification}\footnote{Appearing inside the braced-enclosed
 \grammarterm{declaration-seq} in a \grammarterm{linkage-specification} does
-not affect whether a declaration is a definition.}
-(\ref{dcl.link}) and neither an \grammarterm{initializer} nor a
+not affect whether a declaration is a definition.}\iref{dcl.link}
+and neither an \grammarterm{initializer} nor a
 \grammarterm{function-body},
 \item
 \indextext{declaration!static member@\tcode{static} member}%
@@ -401,8 +401,8 @@
 \ref{expr.dynamic.cast}, \ref{expr.static.cast}, \ref{expr.cast}), or
 \item an expression that is not a null pointer constant, and has type
 other than \cv{}~\tcode{void*}, is converted to the type pointer to \tcode{T}
-or reference to \tcode{T} using a standard conversion
-(\ref{conv}), a \tcode{dynamic_cast}\iref{expr.dynamic.cast} or
+or reference to \tcode{T} using a standard conversion\iref{conv},
+a \tcode{dynamic_cast}\iref{expr.dynamic.cast} or
 a \tcode{static_cast}\iref{expr.static.cast}, or
 \item a class member access operator is applied to an expression of type
 \tcode{T}\iref{expr.ref}, or
@@ -422,11 +422,11 @@
 \end{note}
 
 \pnum
-There can be more than one definition of a class type
-(\ref{class}), enumeration type\iref{dcl.enum}, inline function
+There can be more than one definition of a class type\iref{class},
+enumeration type\iref{dcl.enum}, inline function
 with external linkage\iref{dcl.inline}, inline variable with external
-linkage\iref{dcl.inline}, class template
-(\ref{temp}), non-static function template\iref{temp.fct},
+linkage\iref{dcl.inline}, class template\iref{temp},
+non-static function template\iref{temp.fct},
 concept\iref{temp.concept},
 static data member of a class template\iref{temp.static}, member
 function of a class template\iref{temp.mem.func}, or template
@@ -640,8 +640,8 @@
 \pnum
 The point of declaration for a class or class template first declared by a
 \grammarterm{class-specifier} is immediately after the \grammarterm{identifier} or
-\grammarterm{simple-template-id} (if any) in its \grammarterm{class-head}
-(\ref{class}). The point of declaration for an enumeration is
+\grammarterm{simple-template-id} (if any) in its \grammarterm{class-head}\iref{class}.
+The point of declaration for an enumeration is
 immediately after the \grammarterm{identifier} (if any) in either its
 \grammarterm{enum-specifier}\iref{dcl.enum} or its first
 \grammarterm{opaque-enum-declaration}\iref{dcl.enum}, whichever comes first.
@@ -945,8 +945,8 @@
 \pnum
 The name of a class member shall only be used as follows:
 \begin{itemize}
-\item in the scope of its class (as described above) or a class derived
-(\ref{class.derived}) from its class,
+\item in the scope of its class (as described above) or a class derived\iref{class.derived}
+from its class,
 \item after the \tcode{.} operator applied to an expression of the type
 of its class\iref{expr.ref} or a class derived from its class,
 \item after the \tcode{->} operator applied to a pointer to an object of
@@ -1101,8 +1101,8 @@
 in the latter case,
 the declarations are said to form a set of overloaded
 functions\iref{over.load}. Overload resolution\iref{over.match}
-takes place after name lookup has succeeded. The access rules
-(\ref{class.access}) are considered only once name lookup and
+takes place after name lookup has succeeded. The access rules\iref{class.access}
+are considered only once name lookup and
 function overload resolution (if applicable) have succeeded. Only after
 name lookup, function overload resolution (if applicable) and access
 checking have succeeded are the attributes introduced by the name's
@@ -1428,8 +1428,8 @@
 \end{example}
 
 \pnum
-A name used in the handler for a \grammarterm{function-try-block}
-(\ref{except}) is looked up as if the name was used in the
+A name used in the handler for a \grammarterm{function-try-block}\iref{except}
+is looked up as if the name was used in the
 outermost block of the function definition. In particular, the function
 parameter names shall not be redeclared in the
 \grammarterm{exception-declaration} nor in the outermost block of a handler
@@ -2199,8 +2199,8 @@
 
 \pnum
 \indextext{program}%
-A \defn{program} consists of one or more \defnx{translation units}{translation unit}
-(\ref{lex}) linked together. A translation unit consists
+A \defn{program} consists of one or more \defnx{translation units}{translation unit}\iref{lex}
+linked together. A translation unit consists
 of a sequence of declarations.
 
 \begin{bnf}
@@ -3971,8 +3971,8 @@
 \end{itemize}
 
 \item
-\defnx{classes}{class} containing a sequence of objects of various types
-(\ref{class}), a set of types, enumerations and functions for
+\defnx{classes}{class} containing a sequence of objects of various types\iref{class},
+a set of types, enumerations and functions for
 manipulating these objects\iref{class.mfct}, and a set of restrictions
 on the access to these entities\iref{class.access};
 

source/classes.tex

@@ -80,8 +80,8 @@
 
 \pnum
 If a class is marked with the \grammarterm{class-virt-specifier} \tcode{final} and it appears
-as a \grammarterm{class-or-decltype} in a \grammarterm{base-clause}
-(\ref{class.derived}), the program is ill-formed. Whenever a
+as a \grammarterm{class-or-decltype} in a \grammarterm{base-clause}\iref{class.derived},
+the program is ill-formed. Whenever a
 \grammarterm{class-key} is followed by a \grammarterm{class-head-name}, the
 \grammarterm{identifier} \tcode{final}, and a colon or left brace, \tcode{final} is
 interpreted as a \grammarterm{class-virt-specifier}. \begin{example}
@@ -928,8 +928,8 @@
 
 \pnum
 A non-static member function may be called for an object of
-its class type, or for an object of a class derived
-(\ref{class.derived}) from its class type, using the class member
+its class type, or for an object of a class derived\iref{class.derived}
+from its class type, using the class member
 access syntax~(\ref{expr.ref}, \ref{over.match.call}). A non-static
 member function may also be called directly using the function call
 syntax~(\ref{expr.call}, \ref{over.match.call}) from within
@@ -1181,8 +1181,8 @@
 
 
 \pnum
-Static members obey the usual class member access rules
-(\ref{class.access}). When used in the declaration of a class
+Static members obey the usual class member access rules\iref{class.access}.
+When used in the declaration of a class
 member, the \tcode{static} specifier shall only be used in the member
 declarations that appear within the \grammarterm{member-specification} of
 the class definition.

source/conversions.tex

@@ -518,8 +518,8 @@
 \pnum
 A prvalue of type ``pointer to \cvqual{cv} \tcode{D}'', where \tcode{D}
 is a class type, can be converted to a prvalue of type ``pointer to
-\cvqual{cv} \tcode{B}'', where \tcode{B} is a base class
-(\ref{class.derived}) of \tcode{D}. If \tcode{B} is an
+\cvqual{cv} \tcode{B}'', where \tcode{B} is a base class\iref{class.derived}
+of \tcode{D}. If \tcode{B} is an
 inaccessible\iref{class.access} or
 ambiguous\iref{class.member.lookup} base class of \tcode{D}, a program
 that necessitates this conversion is ill-formed. The result of the
@@ -548,8 +548,8 @@
 A prvalue of type ``pointer to member of \tcode{B} of type \cvqual{cv}
 \tcode{T}'', where \tcode{B} is a class type, can be converted to
 a prvalue of type ``pointer to member of \tcode{D} of type \cvqual{cv}
-\tcode{T}'', where \tcode{D} is a derived class
-(\ref{class.derived}) of \tcode{B}. If \tcode{B} is an
+\tcode{T}'', where \tcode{D} is a derived class\iref{class.derived}
+of \tcode{B}. If \tcode{B} is an
 inaccessible\iref{class.access},
 ambiguous\iref{class.member.lookup}, or virtual\iref{class.mi} base
 class of \tcode{D}, or a base class of a virtual base class of

source/declarations.tex

@@ -1524,10 +1524,10 @@
 \grammarterm{elaborated-type-specifier}, the \tcode{enum} keyword
 shall be
 used to refer to an enumeration\iref{dcl.enum}, the \tcode{union}
-\grammarterm{class-key} shall be used to refer to a union
-(\ref{class}), and either the \tcode{class} or \tcode{struct}
-\grammarterm{class-key} shall be used to refer to a class
-(\ref{class}) declared using the \tcode{class} or \tcode{struct}
+\grammarterm{class-key} shall be used to refer to a union\iref{class},
+and either the \tcode{class} or \tcode{struct}
+\grammarterm{class-key} shall be used to refer to a class\iref{class}
+declared using the \tcode{class} or \tcode{struct}
 \grammarterm{class-key}. \begin{example}
 
 \begin{codeblock}

source/declarators.tex

@@ -282,8 +282,7 @@
 
 \pnum
 A type can also be named (often more easily) by using a
-\tcode{typedef}
-(\ref{dcl.typedef}).
+\tcode{typedef}\iref{dcl.typedef}.
 
 \rSec1[dcl.ambig.res]{Ambiguity resolution}%
 \indextext{ambiguity!declaration versus cast}%
@@ -495,8 +494,7 @@
 \tcode{int}
 \tcode{unsigned}
 determine the type
-``\tcode{unsigned int}''
-(\ref{dcl.type.simple}).
+``\tcode{unsigned int}''\iref{dcl.type.simple}.
 \end{example}
 
 \pnum
@@ -789,8 +787,7 @@
 no arrays of references, and no pointers to references.
 \indextext{initialization!reference}%
 The declaration of a reference shall contain an
-\grammarterm{initializer}
-(\ref{dcl.init.ref})
+\grammarterm{initializer}\iref{dcl.init.ref}
 except when the declaration contains an explicit
 \tcode{extern}
 specifier\iref{dcl.stc},
@@ -982,8 +979,8 @@
 a function type or an abstract class type.
 \indextext{declaration!array}%
 If the
-\grammarterm{constant-expression}
-(\ref{expr.const}) is present, it shall be a converted constant
+\grammarterm{constant-expression}\iref{expr.const}
+is present, it shall be a converted constant
 expression of type \tcode{std::size_t} and
 its value shall be greater than zero.
 The constant expression specifies the
@@ -1078,8 +1075,8 @@
 \indextext{array size!default}%
 of initial elements (say,
 \tcode{N})
-supplied
-(\ref{dcl.init.aggr}), and the type of the identifier of
+supplied\iref{dcl.init.aggr},
+and the type of the identifier of
 \tcode{D}
 is ``array of
 \tcode{N}
@@ -1522,8 +1519,7 @@
 
 declares a function taking three arguments of the specified types,
 and returning
-\tcode{int}
-(\ref{dcl.type}).
+\tcode{int}\iref{dcl.type}.
 \end{example}
 
 \pnum
@@ -1742,8 +1738,7 @@
 of a function declaration
 or \grammarterm{lambda-declarator}
 or in a
-\grammarterm{template-parameter}
-(\ref{temp.param});
+\grammarterm{template-parameter}\iref{temp.param};
 in the latter case, the \grammarterm{initializer-clause} shall be an
 \grammarterm{assignment-expression}.
 A default argument shall not be specified for a parameter pack.
@@ -1967,8 +1962,8 @@
 \end{codeblock}
 \end{example}
 When a declaration of a function is introduced by way of a
-\grammarterm{using-declaration}
-(\ref{namespace.udecl}), any default argument information associated
+\grammarterm{using-declaration}\iref{namespace.udecl},
+any default argument information associated
 with the declaration is made known as well.
 If the function is redeclared
 thereafter in the namespace with additional default arguments,
@@ -2888,8 +2883,8 @@
 Otherwise, if the source type
 is a (possibly cv-qualified) class type, conversion functions are
 considered.
-The applicable conversion functions are enumerated
-(\ref{over.match.conv}), and the best one is chosen through overload
+The applicable conversion functions are enumerated\iref{over.match.conv},
+and the best one is chosen through overload
 resolution\iref{over.match}.
 The user-defined conversion so selected
 is called to convert the initializer expression into the
@@ -3206,8 +3201,8 @@
 \begin{note}
 A default member initializer does not determine the bound for a member
 array of unknown bound.  Since the default member initializer is
-ignored if a suitable \grammarterm{mem-initializer} is present
-(\ref{class.base.init}), the default member initializer is not
+ignored if a suitable \grammarterm{mem-initializer} is present\iref{class.base.init},
+the default member initializer is not
 considered to initialize the array of unknown bound.
 \begin{example}
 \begin{codeblock}
@@ -3601,8 +3596,8 @@
 and function value return\iref{stmt.return} are initializations.
 
 \pnum
-The initializer can be omitted for a reference only in a parameter declaration
-(\ref{dcl.fct}), in the declaration of a function return type, in the declaration of
+The initializer can be omitted for a reference only in a parameter declaration\iref{dcl.fct},
+in the declaration of a function return type, in the declaration of
 a class member within its class definition\iref{class.mem}, and where the
 \tcode{extern}
 specifier is explicitly used.
@@ -3674,8 +3669,8 @@
 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
-(\ref{conv.array}), and function-to-pointer\iref{conv.func} standard
+The usual lvalue-to-rvalue\iref{conv.lval}, array-to-pointer\iref{conv.array},
+and function-to-pointer\iref{conv.func} standard
 conversions are not needed, and therefore are suppressed, when such
 direct bindings to lvalues are done.
 \end{note}

source/derived.tex

@@ -588,8 +588,8 @@
 name, parameter-type-list\iref{dcl.fct}, cv-qualification, and ref-qualifier
 (or absence of same) as
 \tcode{Base::vf} is declared, then \tcode{Derived::vf} is also virtual
-(whether or not it is so declared) and it \term{overrides}\footnote{A function with the same name but a different parameter list
-(\ref{over}) as a virtual function is not necessarily virtual and
+(whether or not it is so declared) and it \term{overrides}\footnote{A function with the same name but a different parameter list\iref{over}
+as a virtual function is not necessarily virtual and
 does not override. The use of the \tcode{virtual} specifier in the
 declaration of an overriding function is legal but redundant (has empty
 semantics). Access control\iref{class.access} is not considered in

source/expressions.tex

@@ -680,8 +680,8 @@
 \pnum
 A \grammarterm{lambda-expression} is a prvalue
 whose result object is called the \defn{closure object}. A
-\grammarterm{lambda-expression} shall not appear in an unevaluated operand
-(\ref{expr}), in a \grammarterm{template-argument},
+\grammarterm{lambda-expression} shall not appear in an unevaluated operand\iref{expr},
+in a \grammarterm{template-argument},
 in an \grammarterm{alias-declaration},
 in a typedef declaration, or in the declaration of a function or function
 template outside its function body and default arguments.
@@ -1836,8 +1836,8 @@
 \end{example}
 
 \pnum
-A local parameter shall only appear as an unevaluated operand
-(\ref{expr}) within the \grammarterm{constraint-expression}.
+A local parameter shall only appear as an unevaluated operand\iref{expr}
+within the \grammarterm{constraint-expression}.
 \begin{example}
 \begin{codeblock}
 template<typename T> concept C = requires (T a) {
@@ -2028,8 +2028,8 @@
 checked at the point of call in the calling function. If a constructor
 or destructor for a function parameter throws an exception, the search
 for a handler starts in the scope of the calling function; in
-particular, if the function called has a \grammarterm{function-try-block}
-(\ref{except}) with a handler that could handle the exception,
+particular, if the function called has a \grammarterm{function-try-block}\iref{except}
+with a handler that could handle the exception,
 this handler is not considered.
 \end{example}
 
@@ -2275,8 +2275,8 @@
 \grammarterm{id-expression} shall name a member of the class or of one of
 its base classes.
 \begin{note}
-Because the name of a class is inserted in its class scope
-(\ref{class}), the name of a class is also considered a nested
+Because the name of a class is inserted in its class scope\iref{class},
+the name of a class is also considered a nested
 member of that class.
 \end{note}
 \begin{note}
@@ -2785,8 +2785,8 @@
 \indextext{cast!derived class}%
 A prvalue of type ``pointer to \cvqual{cv1} \tcode{B}'', where \tcode{B}
 is a class type, can be converted to a prvalue of type ``pointer to
-\cvqual{cv2} \tcode{D}'', where \tcode{D} is a class derived
-(\ref{class.derived}) from \tcode{B},
+\cvqual{cv2} \tcode{D}'', where \tcode{D} is a class derived\iref{class.derived}
+from \tcode{B},
 if \cvqual{cv2} is the same cv-qualification as,
 or greater cv-qualification than, \cvqual{cv1}.
 If \tcode{B} is a virtual base class of \tcode{D} or
@@ -3279,8 +3279,8 @@
 \pnum
 \indextext{operator!logical negation}%
 The operand of the logical negation operator \tcode{!} is contextually
-converted to \tcode{bool}
-(\ref{conv}); its value is \tcode{true}
+converted to \tcode{bool}\iref{conv};
+its value is \tcode{true}
 if the converted operand is \tcode{false} and \tcode{false} otherwise.
 The type of the result is \tcode{bool}.
 
@@ -4000,8 +4000,8 @@
 empty square brackets can follow the \tcode{delete} keyword if the lambda expression is
 enclosed in parentheses.}
 The operand shall be of pointer to object type or of class type. If of
-class type, the operand is contextually implicitly converted
-(\ref{conv}) to a pointer to object
+class type, the operand is contextually implicitly converted\iref{conv}
+to a pointer to object
 type.\footnote{This implies that an object
 cannot be deleted using a pointer of type
 \tcode{void*} because \tcode{void} is not an object type.}
@@ -4746,8 +4746,8 @@
 pointer conversions\iref{conv.ptr},
 function pointer conversions\iref{conv.fctptr}, and
 qualification conversions\iref{conv.qual}
-are performed on both operands to bring them to their composite pointer type
-(\ref{expr}). Comparing pointers is defined as follows:
+are performed on both operands to bring them to their composite pointer type\iref{expr}.
+Comparing pointers is defined as follows:
 
 \begin{itemize}
 \item