Use cxxdraft-htmlgen macros more.

source/concepts.tex

@@ -495,7 +495,7 @@
 template<class T>
   concept @\deflibconcept{unsigned_integral}@ = @\libconcept{integral}@<T> && !@\libconcept{signed_integral}@<T>;
 template<class T>
-  concept @\deflibconcept{floating_point}@ = @\libglobalref{is_floating_point_v}@<T>;
+  concept @\deflibconcept{floating_point}@ = is_floating_point_v<T>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -747,7 +747,7 @@
 \begin{itemdescr}
 \pnum
 \begin{note}
-Unlike the \oldconcept{Destructible} requirements~(\tref{cpp17.destructible}), this
+Unlike the \oldconceptref{Destructible} requirements~(\tref{cpp17.destructible}), this
 concept forbids destructors that are potentially throwing, even if a particular
 invocation of the destructor does not actually throw.
 \end{note}

source/diagnostics.tex

@@ -834,9 +834,9 @@
 
   // \ref{syserr}, system error support
   template<class T>
-    constexpr bool @\libglobal{is_error_code_enum_v}@ = is_error_code_enum<T>::value;
+    constexpr bool @\libglobal{is_error_code_enum_v}@ = @\libglobalref{is_error_code_enum}@<T>::value;
   template<class T>
-    constexpr bool is_error_condition_enum_v = is_error_condition_enum<T>::value;
+    constexpr bool @\libglobal{is_error_condition_enum_v}@ = @\libglobalref{is_error_condition_enum}@<T>::value;
 }
 \end{codeblock}
 
@@ -847,9 +847,9 @@
 exposes the \libheader{cerrno} macros is unspecified.
 
 \pnum
-The \tcode{is_error_code_enum} and \tcode{is_error_condition_enum} templates may be
+The \libglobalref{is_error_code_enum} and \libglobalref{is_error_condition_enum} templates may be
 specialized for program-defined types to indicate that such types are eligible
-for \tcode{class error_code} and \tcode{class error_condition} implicit
+for \tcode{class \libglobalref{error_code}} and \tcode{class \libglobalref{error_condition}} implicit
 conversions, respectively.
 
 \rSec2[syserr.errcat]{Class \tcode{error_category}}
@@ -874,8 +874,6 @@
 \indexlibraryglobal{error_category}%
 \indexlibraryctor{error_category}%
 \indexlibrarydtor{error_category}%
-\indexlibraryglobal{generic_category}%
-\indexlibraryglobal{system_category}%
 \begin{codeblock}
 namespace std {
   class error_category {
@@ -894,8 +892,8 @@
     strong_ordering operator<=>(const error_category& rhs) const noexcept;
   };
 
-  const error_category& generic_category() noexcept;
-  const error_category& system_category() noexcept;
+  const error_category& @\libglobal{generic_category}@() noexcept;
+  const error_category& @\libglobal{system_category}@() noexcept;
 }
 \end{codeblock}
 
@@ -1166,7 +1164,7 @@
 \begin{itemdescr}
 \pnum
 \constraints
-\tcode{is_error_code_enum_v<ErrorCodeEnum>} is \tcode{true}.
+\tcode{\libglobalref{is_error_code_enum_v}<ErrorCodeEnum>} is \tcode{true}.
 
 \pnum
 \effects
@@ -1199,7 +1197,7 @@
 \begin{itemdescr}
 \pnum
 \constraints
-\tcode{is_error_code_enum_v<ErrorCodeEnum>} is \tcode{true}.
+\tcode{\libglobalref{is_error_code_enum_v}<ErrorCodeEnum>} is \tcode{true}.
 
 \pnum
 \effects

source/exec.tex

@@ -31,25 +31,25 @@
 \capsep
 core &
   provide core execution functionality, and connection between core components &
-  e.g., \tcode{connect}, \tcode{start} \\
+  e.g., \libglobalref{connect}, \libglobalref{start} \\
 completion functions &
   called by senders to announce the completion of the work (success, error, or cancellation) &
-  \tcode{set_value}, \tcode{set_error}, \tcode{set_stopped} \\
+  \libglobalref{set_value}, \libglobalref{set_error}, \libglobalref{set_stopped} \\
 senders &
   allow the specialization of the provided sender algorithms &
   \begin{itemize}
-  \item sender factories (e.g., \tcode{schedule}, \tcode{just}, \tcode{read_env})
-  \item sender adaptors (e.g., \tcode{continues_on}, \tcode{then}, \tcode{let_value})
-  \item sender consumers (e.g., \tcode{sync_wait})
+  \item sender factories (e.g., \libglobalref{schedule}, \libglobalref{just}, \libglobalref{read_env})
+  \item sender adaptors (e.g., \libglobalref{continues_on}, \libglobalref{then}, \libglobalref{let_value})
+  \item sender consumers (e.g., \libglobalref{sync_wait})
   \end{itemize}
     \\
 queries &
   allow querying different properties of objects &
   \begin{itemize}
-  \item general queries (e.g., \tcode{get_allocator}, \tcode{get_stop_token})
-  \item environment queries (e.g., \tcode{get_scheduler}, \tcode{get_delegation_scheduler})
-  \item scheduler queries (e.g., \tcode{get_forward_progress_guarantee})
-  \item sender attribute queries (e.g., \tcode{get_completion_scheduler})
+  \item general queries (e.g., \libglobalref{get_allocator}, \libglobalref{get_stop_token})
+  \item environment queries (e.g., \tcode{get_scheduler}, \libglobalref{get_delegation_scheduler})
+  \item scheduler queries (e.g., \libglobalref{get_forward_progress_guarantee})
+  \item sender attribute queries (e.g., \libglobalref{get_completion_scheduler})
   \end{itemize}
     \\
 \end{floattable}

source/future.tex

@@ -322,7 +322,7 @@
 
 \pnum
 \remarks
-\tcode{is_pod<T>} is a \oldconcept{UnaryTypeTrait}\iref{meta.rqmts}
+\tcode{is_pod<T>} is a \oldconceptref{UnaryTypeTrait}\iref{meta.rqmts}
 with a base characteristic of \tcode{true_type}
 if \tcode{T} is a POD type,
 and \tcode{false_type} otherwise.
@@ -506,7 +506,7 @@
 If the expression \tcode{TS::value} is well-formed
 when treated as an \deflink{unevaluated operand}{expr.context},
 then specializations of each of the two templates meet
-the \oldconcept{TransformationTrait} requirements with a base characteristic of
+the \oldconceptref{TransformationTrait} requirements with a base characteristic of
 \tcode{integral_constant<size_t, TS::value>}.
 Otherwise, they have no member \tcode{value}.
 
@@ -534,7 +534,7 @@
 Let \tcode{TE} denote \tcode{tuple_element_t<I, T>}
 of the cv-unqualified type \tcode{T}.
 Then specializations of each of the two templates meet
-the \oldconcept{TransformationTrait} requirements
+the \oldconceptref{TransformationTrait} requirements
 with a member typedef \tcode{type} that names the following type:
 \begin{itemize}
 \item for the first specialization, \tcode{add_volatile_t<TE>}, and
@@ -574,7 +574,7 @@
 Let \tcode{VS} denote \tcode{variant_size<T>}
 of the cv-unqualified type \tcode{T}.
 Then specializations of each of the two templates meet
-the \oldconcept{UnaryTypeTrait} requirements
+the \oldconceptref{UnaryTypeTrait} requirements
 with a base characteristic of \tcode{integral_constant<size_t, VS::value>}.
 \end{itemdescr}
 
@@ -588,7 +588,7 @@
 Let \tcode{VA} denote \tcode{variant_alternative<I, T>}
 of the cv-unqualified type \tcode{T}.
 Then specializations of each of the two templates meet
-the \oldconcept{TransformationTrait} requirements
+the \oldconceptref{TransformationTrait} requirements
 with a member typedef \tcode{type} that names the following type:
 \begin{itemize}
 \item for the first specialization, \tcode{add_volatile_t<VA::type>}, and

source/iostreams.tex

@@ -1681,22 +1681,22 @@
 It holds a state object
 whose type is equal to the template parameter \tcode{stateT}.
 Type \tcode{stateT} shall meet
-the \oldconcept{DefaultConstructible} (\tref{cpp17.defaultconstructible}),
-\oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}),
-\oldconcept{CopyAssignable} (\tref{cpp17.copyassignable}), and
-\oldconcept{Destructible} (\tref{cpp17.destructible}) requirements.
+the \oldconceptref{DefaultConstructible} (\tref{cpp17.defaultconstructible}),
+\oldconceptref{CopyConstructible} (\tref{cpp17.copyconstructible}),
+\oldconceptref{CopyAssignable} (\tref{cpp17.copyassignable}), and
+\oldconceptref{Destructible} (\tref{cpp17.destructible}) requirements.
 If \tcode{is_trivially_copy_constructible_v<stateT>} is \tcode{true},
 then \tcode{fpos<stateT>} has a trivial copy constructor.
 If \tcode{is_trivially_copy_assignable_v<stateT>} is \tcode{true},
 then \tcode{fpos<stateT>} has a trivial copy assignment operator.
 If \tcode{is_trivially_destructible_v<stateT>} is \tcode{true},
 then \tcode{fpos<stateT>} has a trivial destructor.
 All specializations of \tcode{fpos} meet
-the \oldconcept{DefaultConstructible},
-\oldconcept{CopyConstructible},
-\oldconcept{CopyAssignable},
-\oldconcept{Destructible},
-and \oldconcept{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements.
+the \oldconceptref{DefaultConstructible},
+\oldconceptref{CopyConstructible},
+\oldconceptref{CopyAssignable},
+\oldconceptref{Destructible},
+and \oldconceptref{EqualityComparable} (\tref{cpp17.equalitycomparable}) requirements.
 In addition, the expressions shown in \tref{fpos.operations}
 are valid and have the indicated semantics.
 In that table,
@@ -12940,7 +12940,7 @@
 
 \pnum
 \tcode{Allocator} shall meet
-the \oldconcept{Allocator} requirements\iref{allocator.requirements.general}.
+the \oldconceptref{Allocator} requirements\iref{allocator.requirements.general}.
 
 \pnum
 \begin{example}
@@ -13233,7 +13233,7 @@
 
 \pnum
 Template parameters named \tcode{InputIterator} shall meet the
-\oldconcept{InputIterator} requirements\iref{input.iterators} and shall
+\oldconceptref{InputIterator} requirements\iref{input.iterators} and shall
 have a value type that is one of the encoded character types.
 
 \pnum
@@ -13247,7 +13247,7 @@
 
 \pnum
 Template parameters named \tcode{Allocator} shall meet
-the \oldconcept{Allocator} requirements\iref{allocator.requirements.general}.
+the \oldconceptref{Allocator} requirements\iref{allocator.requirements.general}.
 
 \rSec2[fs.filesystem.syn]{Header \tcode{<filesystem>} synopsis}
 
@@ -14060,7 +14060,7 @@
 \item \tcode{basic_string_view<EcharT, traits>}. A function
   argument \tcode{const Source\&} \tcode{source} shall have an
   effective range \range{source.begin()}{source.end()}.
-\item A type meeting the \oldconcept{InputIterator} requirements that iterates over a NTCTS\@.
+\item A type meeting the \oldconceptref{InputIterator} requirements that iterates over a NTCTS\@.
   The value type shall be an encoded character type. A function argument
   \tcode{const Source\&} \tcode{source} shall have an effective range
   \range{source}{end} where \tcode{end} is the first
@@ -16540,7 +16540,7 @@
 
 \pnum
 \tcode{directory_iterator} meets the
-\oldconcept{InputIterator} requirements\iref{input.iterators}.
+\oldconceptref{InputIterator} requirements\iref{input.iterators}.
 
 \pnum
 If an iterator of type \tcode{directory_iterator} reports an error or

source/lib-intro.tex

@@ -1770,7 +1770,7 @@
 }\\
 \end{oldconcepttable}
 
-\begin{oldconcepttable}{CopyConstructible}{ (in addition to \oldconcept{MoveConstructible})}{cpp17.copyconstructible}
+\begin{oldconcepttable}{CopyConstructible}{ (in addition to \oldconceptref{MoveConstructible})}{cpp17.copyconstructible}
 {p{1in}p{4.15in}}
 \topline
 \hdstyle{Expression}          &   \hdstyle{Post-condition}  \\ \capsep
@@ -1797,7 +1797,7 @@
 }\\
 \end{oldconcepttable}
 
-\begin{oldconcepttable}{CopyAssignable}{ (in addition to \oldconcept{MoveAssignable})}{cpp17.copyassignable}
+\begin{oldconcepttable}{CopyAssignable}{ (in addition to \oldconceptref{MoveAssignable})}{cpp17.copyassignable}
 {p{1in}p{1in}p{1in}p{1.9in}}
 \topline
 \hdstyle{Expression} & \hdstyle{Return type} & \hdstyle{Return value} & \hdstyle{Post-condition} \\ \capsep
@@ -1811,7 +1811,7 @@
 \tcode{u.\~T()} &   All resources owned by \tcode{u} are reclaimed, no exception is propagated. \\ \rowsep
 \multicolumn{2}{|l|}{
   \begin{tailnote}
-  Array types and non-object types are not \oldconcept{Destructible}.
+  Array types and non-object types are not \oldconceptref{Destructible}.
   \end{tailnote}
 } \\
 \end{oldconcepttable}
@@ -1890,7 +1890,7 @@
                                                 // for rvalues and lvalues
 }
 
-// Preconditions: \tcode{T} meets the \oldconcept{Swappable} requirements.
+// Preconditions: \tcode{T} meets the \oldconceptref{Swappable} requirements.
 template<class T>
 void lv_swap(T& t1, T& t2) {
   using std::swap;
@@ -1927,9 +1927,9 @@
 A \oldconcept{NullablePointer} type is a pointer-like type that supports null values.
 A type \tcode{P} meets the \oldconcept{\-Nullable\-Pointer} requirements if
 \begin{itemize}
-\item \tcode{P} meets the \oldconcept{EqualityComparable},
-\oldconcept{DefaultConstructible}, \oldconcept{CopyConstructible}, \oldconcept{\-Copy\-Assign\-able},
-\oldconcept{Swappable}, and \oldconcept{Destructible} requirements,
+\item \tcode{P} meets the \oldconceptref{EqualityComparable},
+\oldconceptref{DefaultConstructible}, \oldconceptref{CopyConstructible}, \oldconcept{\-Copy\-Assign\-able},
+\oldconceptref{Swappable}, and \oldconceptref{Destructible} requirements,
 
 \item the expressions shown in \tref{cpp17.nullablepointer} are
 valid and have the indicated semantics, and
@@ -2005,8 +2005,8 @@
 A type \tcode{H} meets the \defnoldconcept{Hash} requirements if
 \begin{itemize}
 \item it is a function object type\iref{function.objects},
-\item it meets the \oldconcept{CopyConstructible} (\tref{cpp17.copyconstructible}) and
-  \oldconcept{Destructible} (\tref{cpp17.destructible}) requirements, and
+\item it meets the \oldconceptref{CopyConstructible} (\tref{cpp17.copyconstructible}) and
+  \oldconceptref{Destructible} (\tref{cpp17.destructible}) requirements, and
 \item the expressions shown in \tref{cpp17.hash}
 are valid and have the indicated semantics.
 \end{itemize}
@@ -2690,7 +2690,7 @@
 \tcode{true_type} only if an allocator of type \tcode{X} should be copied
 when the client container is copy-assigned;
 if so, \tcode{X} shall meet
-the \oldconcept{CopyAssignable} requirements (\tref{cpp17.copyassignable}) and
+the \oldconceptref{CopyAssignable} requirements (\tref{cpp17.copyassignable}) and
 the copy operation shall not throw exceptions.
 
 \pnum
@@ -2712,7 +2712,7 @@
 \tcode{true_type} only if an allocator of type \tcode{X} should be moved
 when the client container is move-assigned;
 if so, \tcode{X} shall meet
-the \oldconcept{MoveAssignable} requirements (\tref{cpp17.moveassignable}) and
+the \oldconceptref{MoveAssignable} requirements (\tref{cpp17.moveassignable}) and
 the move operation shall not throw exceptions.
 
 \pnum
@@ -2734,7 +2734,7 @@
 \tcode{true_type} only if an allocator of type \tcode{X} should be swapped
 when the client container is swapped;
 if so,
-\tcode{X} shall meet the \oldconcept{Swappable} requirements\iref{swappable.requirements} and
+\tcode{X} shall meet the \oldconceptref{Swappable} requirements\iref{swappable.requirements} and
 the \tcode{swap} operation shall not throw exceptions.
 
 \pnum
@@ -2764,15 +2764,15 @@
 
 \pnum
 An allocator type \tcode{X} shall meet the
-\oldconcept{CopyConstructible} requirements (\tref{cpp17.copyconstructible}).
+\oldconceptref{CopyConstructible} requirements (\tref{cpp17.copyconstructible}).
 The \tcode{XX::pointer}, \tcode{XX::const_pointer}, \tcode{XX::void_pointer}, and
 \tcode{XX::const_void_pointer} types shall meet the
 \oldconcept{Nullable\-Pointer} requirements (\tref{cpp17.nullablepointer}).
 No constructor,
 comparison operator function, copy operation, move operation, or swap operation on
 these pointer types shall exit via an exception. \tcode{XX::pointer} and \tcode{XX::const_pointer} shall also
 meet the requirements for
-a \oldconcept{RandomAccessIterator}\iref{random.access.iterators} and
+a \oldconceptref{RandomAccessIterator}\iref{random.access.iterators} and
 the additional requirement that, when \tcode{p} and \tcode{(p + n)} are
 dereferenceable pointer values for some integral value \tcode{n},
 \begin{codeblock}