[std] Extend \iref to accept a list of cross-references

Author: jensmaurer

source/algorithms.tex

@@ -3333,7 +3333,7 @@
 \pnum
 \mandates
 The type \tcode{Size} is convertible
-to an integral type~(\ref{conv.integral}, \ref{class.conv}).
+to an integral type\iref{conv.integral,class.conv}.
 
 \pnum
 \expects
@@ -3373,7 +3373,7 @@
 \pnum
 \mandates
 The type \tcode{Size} is convertible
-to an integral type~(\ref{conv.integral}, \ref{class.conv}).
+to an integral type\iref{conv.integral,class.conv}.
 
 \pnum
 \expects
@@ -4245,7 +4245,7 @@
 \pnum
 \mandates
 The type \tcode{Size}
-is convertible to an integral type~(\ref{conv.integral}, \ref{class.conv}).
+is convertible to an integral type\iref{conv.integral,class.conv}.
 
 \pnum
 \returns
@@ -4485,7 +4485,7 @@
 \pnum
 \mandates
 The type \tcode{Size} is convertible
-to an integral type~(\ref{conv.integral}, \ref{class.conv}).
+to an integral type\iref{conv.integral,class.conv}.
 
 \pnum
 \effects
@@ -5226,7 +5226,7 @@
 The expression \tcode{value}
 is writable\iref{iterator.requirements.general} to the output iterator.
 The type \tcode{Size} is convertible
-to an integral type~(\ref{conv.integral}, \ref{class.conv}).
+to an integral type\iref{conv.integral,class.conv}.
 
 \pnum
 \effects
@@ -5280,7 +5280,7 @@
 \pnum
 \mandates
 \tcode{Size} is convertible
-to an integral type~(\ref{conv.integral}, \ref{class.conv}).
+to an integral type\iref{conv.integral,class.conv}.
 
 \pnum
 \effects

source/basic.tex

@@ -50,7 +50,7 @@
 \item
 \grammarterm{declaration},
 \grammarterm{block-declaration}, or
-\grammarterm{member-declaration} (\ref{dcl.pre}, \ref{class.mem}),
+\grammarterm{member-declaration}\iref{dcl.pre,class.mem},
 \item
 \grammarterm{init-declarator}\iref{dcl.decl},
 \item
@@ -178,7 +178,7 @@
 \item
 \indextext{declaration!static member@\tcode{static} member}%
 it declares a non-inline static data member in a class
-definition~(\ref{class.mem}, \ref{class.static}),
+definition\iref{class.mem,class.static},
 \item
 it declares a static data member outside a class definition
 and the variable was defined within the class with the \keyword{constexpr}
@@ -404,7 +404,7 @@
 \item
   A function is named by an expression or conversion
   if it is the selected member
-  of an overload set~(\ref{basic.lookup}, \ref{over.match}, \ref{over.over})
+  of an overload set\iref{basic.lookup,over.match,over.over}
   in an overload resolution performed
   as part of forming that expression or conversion,
   unless it is a pure virtual function and either
@@ -413,7 +413,7 @@
   the expression forms a pointer to member\iref{expr.unary.op}.
   \begin{note}
 This covers
-  taking the address of functions~(\ref{conv.func}, \ref{expr.unary.op}),
+  taking the address of functions\iref{conv.func,expr.unary.op},
   calls to named functions\iref{expr.call},
   operator overloading\iref{over},
   user-defined conversions\iref{class.conv.fct},
@@ -597,8 +597,8 @@
 a glvalue referring
 to an object of type \tcode{T}\iref{conv.lval}, or
 \item an expression is converted (either implicitly or explicitly) to
-type \tcode{T} (\ref{conv}, \ref{expr.type.conv},
-\ref{expr.dynamic.cast}, \ref{expr.static.cast}, \ref{expr.cast}), or
+type \tcode{T}\iref{conv,expr.type.conv,
+expr.dynamic.cast,expr.static.cast,expr.cast}, or
 \item an expression that is not a null pointer constant, and has type
 other than \cv{}~\tcode{\keyword{void}*}, is converted to the type pointer to \tcode{T}
 or reference to \tcode{T} using a standard conversion\iref{conv},
@@ -690,7 +690,7 @@
 is subject to the requirements described in this paragraph (recursively).
 
 \item If \tcode{D} is a class with an implicitly-declared
-constructor (\ref{class.default.ctor}, \ref{class.copy.ctor}),
+constructor\iref{class.default.ctor,class.copy.ctor},
 it is as if the constructor was
 implicitly defined in every translation unit where it is odr-used, and the
 implicit definition in every translation unit shall call the same
@@ -1190,7 +1190,7 @@
 Each
 \begin{itemize}
 \item
-selection or iteration statement (\ref{stmt.select}, \ref{stmt.iter}),
+selection or iteration statement\iref{stmt.select,stmt.iter},
 \item
 substatement of such a statement,
 \item
@@ -1400,7 +1400,7 @@
 if the declarations found by name lookup do not all denote the same entity,
 \indextext{lookup!ambiguous}%
 they are \defn{ambiguous} and the program is ill-formed.
-Overload resolution~(\ref{over.match}, \ref{over.over})
+Overload resolution\iref{over.match,over.over}
 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
@@ -1698,7 +1698,7 @@
 \begin{note}
 Even if the result of name lookup is unambiguous, use of a name found in
 multiple subobjects might still be
-ambiguous~(\ref{conv.mem}, \ref{expr.ref}, \ref{class.access.base}).
+ambiguous\iref{conv.mem,expr.ref,class.access.base}.
 \end{note}
 \begin{example}
 \begin{codeblock}
@@ -2025,7 +2025,7 @@
 have the same innermost enclosing non-inline namespace scope as
 a declaration of an associated entity attached to \tcode{M}\iref{basic.link}.
 \end{itemize}
-If the lookup is for a dependent name (\ref{temp.dep}, \ref{temp.dep.candidate}),
+If the lookup is for a dependent name\iref{temp.dep,temp.dep.candidate},
 the above lookup is also performed
 from each point in the instantiation context\iref{module.context} of the lookup,
 additionally ignoring any declaration that
@@ -2703,7 +2703,7 @@
 \pnum
 Two declarations of entities declare the same entity
 if, considering declarations of unnamed types to introduce their names
-for linkage purposes, if any (\ref{dcl.typedef}, \ref{dcl.enum}),
+for linkage purposes, if any\iref{dcl.typedef,dcl.enum},
 they correspond\iref{basic.scope.scope},
 have the same target scope that is not a function or template parameter scope,
 and either
@@ -2716,8 +2716,8 @@
 they both declare names with external linkage.
 \end{itemize}
 \begin{note}
-There are other circumstances in which declarations declare the same entity
-(\ref{dcl.link}, \ref{temp.type}, \ref{temp.spec.partial}).
+There are other circumstances in which declarations declare the same entity%
+\iref{dcl.link,temp.type,temp.spec.partial}.
 \end{note}
 
 \pnum
@@ -3072,7 +3072,7 @@
 by an operation that implicitly creates objects (see below),
 when implicitly changing the active member of a union\iref{class.union},
 or
-when a temporary object is created~(\ref{conv.rval}, \ref{class.temporary}).
+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},
@@ -3327,8 +3327,8 @@
 implicitly creates objects in the returned region of storage and
 returns a pointer to a suitable created object.
 \begin{note}
-Some functions in the \Cpp{} standard library implicitly create objects
-(\ref{allocator.traits.members}, \ref{c.malloc}, \ref{cstring.syn}, \ref{bit.cast}).
+Some functions in the \Cpp{} standard library implicitly create objects%
+\iref{allocator.traits.members,c.malloc,cstring.syn,bit.cast}.
 \end{note}
 \indextext{object model|)}
 
@@ -3351,7 +3351,7 @@
 \end{itemize}
 except that if the object is a union member or subobject thereof,
 its lifetime only begins if that union member is the
-initialized member in the union~(\ref{dcl.init.aggr}, \ref{class.base.init}),
+initialized member in the union\iref{dcl.init.aggr,class.base.init},
 or as described in \ref{class.union} and \ref{class.copy.ctor},
 and except as described in \ref{allocator.members}.
 The lifetime of an object \placeholder{o} of type \tcode{T} ends when:
@@ -3639,8 +3639,8 @@
   \item
     the right operand of a comma expression\iref{expr.comma},
   \item
-    the operand of a cast or conversion~(\ref{conv.integral},
-    \ref{expr.type.conv}, \ref{expr.static.cast}, \ref{expr.cast})
+    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
@@ -3743,7 +3743,7 @@
 \end{itemize}
 have \defn{static storage duration}.
 The storage for these entities lasts for the duration of the
-program~(\ref{basic.start.static}, \ref{basic.start.term}).
+program\iref{basic.start.static,basic.start.term}.
 
 \pnum
 If a variable with static storage duration has initialization or a
@@ -4067,7 +4067,7 @@
 \rSec2[basic.align]{Alignment}
 
 \pnum
-Object types have \defnx{alignment requirements}{alignment requirement!implementation-defined}~(\ref{basic.fundamental}, \ref{basic.compound})
+Object types have \defnx{alignment requirements}{alignment requirement!implementation-defined}\iref{basic.fundamental,basic.compound}
 which place restrictions on the addresses at which an object of that type
 may be allocated. An \defn{alignment} is an \impldef{alignment}
 integer value representing the number of bytes between successive addresses
@@ -4195,16 +4195,16 @@
 Temporary objects are materialized:
 \begin{itemize}
 \item
-when binding a reference to a prvalue~(\ref{dcl.init.ref}, \ref{expr.type.conv},
-\ref{expr.dynamic.cast}, \ref{expr.static.cast}, \ref{expr.const.cast}, \ref{expr.cast}),
+when binding a reference to a prvalue\iref{dcl.init.ref,expr.type.conv,
+expr.dynamic.cast,expr.static.cast,expr.const.cast,expr.cast},
 \item
-when performing member access on a class prvalue~(\ref{expr.ref}, \ref{expr.mptr.oper}),
+when performing member access on a class prvalue\iref{expr.ref,expr.mptr.oper},
 \item
-when performing an array-to-pointer conversion or subscripting on an array prvalue~(\ref{conv.array}, \ref{expr.sub}),
+when performing an array-to-pointer conversion or subscripting on an array prvalue\iref{conv.array,expr.sub},
 \item
 when initializing an object of type \tcode{std::initializer_list<T>} from a \grammarterm{braced-init-list}\iref{dcl.init.list},
 \item
-for certain unevaluated operands~(\ref{expr.typeid}, \ref{expr.sizeof}), and
+for certain unevaluated operands\iref{expr.typeid,expr.sizeof}, and
 \item
 when a prvalue that has type other than \cv{}~\keyword{void} appears as a discarded-value expression\iref{expr.context}.
 \end{itemize}
@@ -4279,7 +4279,7 @@
 \indextext{temporary!destructor for}%
 \indextext{temporary!destruction of}%
 When an implementation introduces a temporary object of a class that has a
-non-trivial constructor~(\ref{class.default.ctor}, \ref{class.copy.ctor}),
+non-trivial constructor\iref{class.default.ctor,class.copy.ctor},
 it shall ensure that a constructor is called for the temporary object.
 Similarly, the destructor shall be called for a temporary with a non-trivial
 destructor\iref{class.dtor}.
@@ -4305,7 +4305,7 @@
 The first context is when a default constructor is called to initialize
 an element of an array with no corresponding initializer\iref{dcl.init}.
 The second context is when a copy constructor is called to copy an element of
-an array while the entire array is copied~(\ref{expr.prim.lambda.capture}, \ref{class.copy.ctor}).
+an array while the entire array is copied\iref{expr.prim.lambda.capture,class.copy.ctor}.
 In either case, if the constructor has one or more default arguments,
 the destruction of every temporary created in a default argument is
 sequenced before the construction of the next array element, if any.
@@ -4371,7 +4371,7 @@
 \end{codeblock}
 \end{example}
 \begin{note}
-An explicit type conversion~(\ref{expr.type.conv}, \ref{expr.cast})
+An explicit type conversion\iref{expr.type.conv,expr.cast}
 is interpreted as
 a sequence of elementary casts,
 covered above.
@@ -4430,7 +4430,7 @@
 completion of their construction.
 In addition, the destruction of temporaries bound to references shall
 take into account the ordering of destruction of objects with static, thread, or
-automatic storage duration~(\ref{basic.stc.static}, \ref{basic.stc.thread}, \ref{basic.stc.auto});
+automatic storage duration\iref{basic.stc.static,basic.stc.thread,basic.stc.auto};
 that is, if
 \tcode{obj1}
 is an object with the same storage duration as the temporary and
@@ -5021,8 +5021,8 @@
 is an incomplete type that cannot be completed; such a type has
 an empty set of values. It is used as the return
 type for functions that do not return a value. Any expression can be
-explicitly converted to type \cv{}~\keyword{void}~(\ref{expr.type.conv},
-\ref{expr.static.cast}, \ref{expr.cast}).
+explicitly converted to type
+\cv{}~\keyword{void}\iref{expr.type.conv,expr.static.cast,expr.cast}.
 An expression of type \cv{}~\keyword{void} shall
 be used only as an expression statement\iref{stmt.expr}, as an operand
 of a comma expression\iref{expr.comma}, as a second or third operand
@@ -5035,7 +5035,7 @@
 \pnum
 A value of type \tcode{std::nullptr_t} is a null pointer
 constant\iref{conv.ptr}. Such values participate in the pointer and the
-pointer-to-member conversions~(\ref{conv.ptr}, \ref{conv.mem}).
+pointer-to-member conversions\iref{conv.ptr,conv.mem}.
 \tcode{\keyword{sizeof}(std::nullptr_t)} shall be equal to \tcode{\keyword{sizeof}(\keyword{void}*)}.
 
 \pnum
@@ -5165,7 +5165,7 @@
 see \ref{basic.stc}.
 \end{note}
 For purposes of pointer arithmetic\iref{expr.add}
-and comparison~(\ref{expr.rel}, \ref{expr.eq}),
+and comparison\iref{expr.rel,expr.eq},
 a pointer past the end of the last element of
 an array \tcode{x} of $n$ elements
 is considered to be equivalent to
@@ -6325,7 +6325,7 @@
 \indextext{program!startup|(}%
 A program shall contain exactly one function called \tcode{main}
 that belongs to the global scope.
-Executing a program starts a main thread of execution~(\ref{intro.multithread}, \ref{thread.threads})
+Executing a program starts a main thread of execution\iref{intro.multithread,thread.threads}
 in which the \tcode{main} function is invoked.
 \indextext{implementation!freestanding}%
 It is \impldef{defining \tcode{main} in freestanding environment}
@@ -6576,7 +6576,7 @@
 A non-block variable with static storage duration
 having initialization
 with side effects is initialized in this case,
-even if it is not itself odr-used~(\ref{term.odr.use}, \ref{basic.stc.static}).
+even if it is not itself odr-used\iref{term.odr.use,basic.stc.static}.
 \end{footnote}
 It is \impldef{threads and program points at which deferred dynamic initialization is performed}
 in which threads and at which points in the program such deferred dynamic initialization occurs.