n4950.patch

From acf9a8298f4562d59c2eef22d037365503bbbe68 Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Sun, 4 Oct 2020 05:12:13 +0200
Subject: [PATCH 01/21] Use \defnadj more.

---
 source/lex.tex        | 1 -
 source/basic.tex      | 3 +--
 source/statements.tex | 3 +--
 source/classes.tex    | 3 +--
 4 files changed, 3 insertions(+), 7 deletions(-)

diff --git a/source/lex.tex b/source/lex.tex
index a253a50b..5963cdcf 100644
--- a/source/lex.tex
+++ b/source/lex.tex
@@ -19,7 +19,6 @@ [lex]
 \indextext{pointer literal|see{literal, pointer}}
 \indextext{user-defined literal|see{literal, user-defined}}
 \indextext{file, source|see{source file}}
-\indextext{null character|see{character, null}}
 \indextext{null wide character|see{wide-character, null}}
 
 \rSec1[lex.separate]{Separate translation}
diff --git a/source/basic.tex b/source/basic.tex
index e7d171d6..521d42c5 100644
--- a/source/basic.tex
+++ b/source/basic.tex
@@ -3756,7 +3756,6 @@ [basic.stc.general]
 \rSec3[basic.stc.static]{Static storage duration}
 
 \pnum
-\indextext{storage duration!static}%
 All variables which
 \begin{itemize}
 \item
@@ -3766,7 +3765,7 @@ [basic.stc.static]
 are first declared with
 the \keyword{static} or \keyword{extern} keywords\iref{dcl.stc}
 \end{itemize}
-have \defn{static storage duration}.
+have \defnadj{static}{storage duration}.
 The storage for these entities lasts for the duration of the
 program\iref{basic.start.static,basic.start.term}.
 
diff --git a/source/statements.tex b/source/statements.tex
index aa9ae2bb..9eb08406 100644
--- a/source/statements.tex
+++ b/source/statements.tex
@@ -187,10 +187,9 @@ [stmt.expr]
 \indextext{side effects}%
 side effects from an expression statement
 are completed before the next statement is executed.
-\indextext{statement!null}%
 \indextext{statement!empty}%
 An expression statement with the expression missing is called
-a \defn{null statement}.
+a \defnadj{null}{statement}.
 \begin{note}
 Most statements are expression statements --- usually assignments or
 function calls. A null statement is useful to supply a null body to an
diff --git a/source/classes.tex b/source/classes.tex
index c1756861..0edcc6b7 100644
--- a/source/classes.tex
+++ b/source/classes.tex
@@ -2795,9 +2795,8 @@ [class.bit]
 \end{note}
 
 \pnum
-\indextext{bit-field!unnamed}%
 A declaration for a bit-field that omits the \grammarterm{identifier}
-declares an \defn{unnamed bit-field}. Unnamed bit-fields are not
+declares an \defnadj{unnamed}{bit-field}. Unnamed bit-fields are not
 members and cannot be initialized.
 An unnamed bit-field shall not be declared with a cv-qualified type.
 \begin{note}
-- 
2.25.1


From b7ec4c049d3aec43053ea949650e4e91c4cc209f Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Sun, 4 Oct 2020 04:26:58 +0200
Subject: [PATCH 02/21] [dcl.spec.auto] Add index entry for 'placeholder type'.

---
 source/declarations.tex | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/declarations.tex b/source/declarations.tex
index fed6acc5..f07b1396 100644
--- a/source/declarations.tex
+++ b/source/declarations.tex
@@ -1624,7 +1624,7 @@ [dcl.spec.auto.general]
 
 \pnum
 A \grammarterm{placeholder-type-specifier}
-designates a placeholder type that will be replaced later by deduction
+designates a \defnadj{placeholder}{type} that will be replaced later by deduction
 from an initializer.
 
 \pnum
-- 
2.25.1


From 97c6891bc95947ce1b94405bec76eda53acee858 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 03/21] Use \range where appropriate.

---
 source/strings.tex    | 8 ++++----
 source/algorithms.tex | 6 +++---
 source/regex.tex      | 2 +-
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/source/strings.tex b/source/strings.tex
index 66fc8b20..26c298f3 100644
--- a/source/strings.tex
+++ b/source/strings.tex
@@ -153,19 +153,19 @@ [char.traits.require]
 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
diff --git a/source/algorithms.tex b/source/algorithms.tex
index b6a4acd7..448ffe21 100644
--- a/source/algorithms.tex
+++ b/source/algorithms.tex
@@ -7322,7 +7322,7 @@ [equal.range]
 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}.
 
@@ -7386,7 +7386,7 @@ [binary.search]
 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}.
 
@@ -10559,7 +10559,7 @@ [adjacent.difference]
 \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 dcd432b3..6fc3b5a0 100644
--- a/source/regex.tex
+++ b/source/regex.tex
@@ -3426,7 +3426,7 @@ [re.regiter.incr]
 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)}.
 
-- 
2.25.1


From 6e0ba52d66283c83796baf10daf6f588b33dc625 Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Sun, 26 Feb 2017 14:24:19 +0100
Subject: [PATCH 04/21] [some.where] Replace \term with \placeholder.

---
 source/expressions.tex | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/expressions.tex b/source/expressions.tex
index 8026d159..c4beb4c0 100644
--- a/source/expressions.tex
+++ b/source/expressions.tex
@@ -3826,7 +3826,7 @@ [expr.typeid]
 \indextext{\idxcode{type_info}}%
 \indexlibraryglobal{type_info}%
 \keyword{const} \tcode{std::type_info}\iref{type.info} and dynamic type \keyword{const}
-\tcode{std::type_info} or \keyword{const} \term{name} where \term{name} is an
+\tcode{std::type_info} or \keyword{const} \placeholder{name} where \placeholder{name} is an
 \impldef{derived type for \tcode{typeid}} class publicly derived from
 \tcode{std::type_info} which preserves the behavior described
 in~\ref{type.info}.
-- 
2.25.1


From 5d1a6ea83a504f12729d7f2bc517d3fe47f9eee3 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 05/21] Make references more precise.

---
 source/statements.tex | 2 +-
 source/strings.tex    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/statements.tex b/source/statements.tex
index 9eb08406..d635f1a6 100644
--- a/source/statements.tex
+++ b/source/statements.tex
@@ -1092,7 +1092,7 @@ [stmt.ambig]
 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
diff --git a/source/strings.tex b/source/strings.tex
index 26c298f3..9adcd211 100644
--- a/source/strings.tex
+++ b/source/strings.tex
@@ -2725,7 +2725,7 @@ [string.cons]
 \begin{itemdescr}
 \pnum
 \effects
-Move assigns as a sequence container\iref{container.requirements},
+Move assigns as a sequence container\iref{sequence.reqmts},
 except that iterators, pointers and references may be invalidated.
 
 \pnum
-- 
2.25.1


From 1fbc6951f68fe063be355ee1050e3fc82f34c7a6 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 06/21] [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 785bb29f..9f2ebe47 100644
--- a/source/numerics.tex
+++ b/source/numerics.tex
@@ -1832,19 +1832,19 @@ [rand.req.eng]
     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}
@@ -1919,12 +1919,12 @@ [rand.req.eng]
     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}
@@ -1939,7 +1939,7 @@ [rand.req.eng]
     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}
@@ -1969,7 +1969,7 @@ [rand.req.eng]
     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.25.1


From b4c4aee5d9f0682b0c3ede28afdf0b0d8d3d4755 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 07/21] 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 521d42c5..969f9cd8 100644
--- a/source/basic.tex
+++ b/source/basic.tex
@@ -282,7 +282,7 @@ [basic.def]
 #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() {
@@ -2382,23 +2382,23 @@ [namespace.qual]
 
 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 c4beb4c0..c17a1d20 100644
--- a/source/expressions.tex
+++ b/source/expressions.tex
@@ -2482,7 +2482,7 @@ [expr.prim.lambda.capture]
   }
   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.25.1


From 8ee70e9ada56b1fc83189fa2cc64942b4d33a54a 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 08/21] Use new link macros.

---
 source/intro.tex         |  19 ++-
 source/lex.tex           |  16 +-
 source/basic.tex         | 129 +++++++-------
 source/expressions.tex   | 354 ++++++++++++++++++++-------------------
 source/statements.tex    |  32 ++--
 source/declarations.tex  |  69 ++++----
 source/classes.tex       |  28 ++--
 source/overloading.tex   |  70 ++++----
 source/templates.tex     | 143 ++++++++--------
 source/exceptions.tex    |  46 ++---
 source/preprocessor.tex  |  14 +-
 source/lib-intro.tex     |  79 ++++-----
 source/support.tex       | 109 ++++++------
 source/concepts.tex      |  12 +-
 source/diagnostics.tex   |   6 +-
 source/utilities.tex     |  45 +++--
 source/strings.tex       |  10 +-
 source/containers.tex    |  54 +++---
 source/iterators.tex     |   9 +-
 source/algorithms.tex    |   6 +-
 source/numerics.tex      |  60 ++++---
 source/time.tex          |  10 +-
 source/locales.tex       |  32 ++--
 source/iostreams.tex     |  74 ++++----
 source/regex.tex         |  53 +++---
 source/threads.tex       |  47 +++---
 source/limits.tex        |   2 +-
 source/compatibility.tex |   4 +-
 source/future.tex        |  10 +-
 29 files changed, 750 insertions(+), 792 deletions(-)

diff --git a/source/intro.tex b/source/intro.tex
index c247ada6..4203ff1f 100644
--- a/source/intro.tex
+++ b/source/intro.tex
@@ -126,8 +126,8 @@ [intro.defs]
 modifications of scalar objects are described in
 \ref{expr.ass}, \ref{expr.post.incr}, and \ref{expr.pre.incr}.
 Attempts to read or modify an object of class type
-typically invoke a constructor\iref{class.ctor}
-or assignment operator\iref{class.copy.assign};
+typically invoke a \deflink{constructor}{class.ctor}
+or \link{assignment operator}{class.copy.assign};
 such invocations do not themselves constitute accesses,
 although they may involve accesses of scalar subobjects.
 \end{defnote}
@@ -278,10 +278,11 @@ [intro.defs]
 glvalue refers
 
 \begin{example}
-If a pointer\iref{dcl.ptr} \tcode{p} whose static type is ``pointer to
-class \tcode{B}'' is pointing to an object of class \tcode{D}, derived
-from \tcode{B}\iref{class.derived}, the dynamic type of the
-expression \tcode{*p} is ``\tcode{D}''. References\iref{dcl.ref} are
+If a \link{pointer}{dcl.ptr} \tcode{p} whose static type is ``pointer to
+class \tcode{B}'' is pointing to an object of class \tcode{D},
+\link{derived}{class.derived}
+from \tcode{B}, the dynamic type of the
+expression \tcode{*p} is ``\tcode{D}''. \link{References}{dcl.ref} are
 treated similarly.
 \end{example}
 
@@ -338,7 +339,7 @@ [intro.defs]
 
 \indexdefn{program!ill-formed}%
 \definition{ill-formed program}{defns.ill.formed}
-program that is not well-formed\iref{defns.well.formed}
+program that is not \link{well-formed}{defns.well.formed}
 
 \indexdefn{behavior!implementation-defined}%
 \definition{implementation-defined behavior}{defns.impl.defined}
@@ -817,7 +818,7 @@ [intro.compliance.general]
 \indextext{conformance requirements!classes}%
 \indextext{conformance requirements!class templates}%
 For classes and class templates, the library Clauses specify partial
-definitions. Private members\iref{class.access} are not
+definitions. \link{Private members}{class.access} are not
 specified, but each implementation shall supply them to complete the
 definitions according to the description in the library Clauses.
 
@@ -834,7 +835,7 @@ [intro.compliance.general]
 
 \pnum
 The templates, classes, functions, and objects in the library have
-external linkage\iref{basic.link}. The implementation provides
+external \link{linkage}{basic.link}. The implementation provides
 definitions for standard library entities, as necessary, while combining
 translation units to form a complete \Cpp{}  program\iref{lex.phases}.%
 \indextext{conformance requirements!library|)}
diff --git a/source/lex.tex b/source/lex.tex
index 5963cdcf..a1ad8a34 100644
--- a/source/lex.tex
+++ b/source/lex.tex
@@ -28,10 +28,10 @@ [lex.separate]
 \indextext{compilation!separate|(}%
 The text of the program is kept in units called
 \defnx{source files}{source file} in this document.
-A source file together with all the headers\iref{headers}
-and source files included\iref{cpp.include} via the preprocessing
+A source file together with all the \link{headers}{headers}
+and source files \link{included}{cpp.include} via the preprocessing
 directive \tcode{\#include}, less any source lines skipped by any of the
-conditional inclusion\iref{cpp.cond} preprocessing directives, is
+\link{conditional inclusion}{cpp.cond} preprocessing directives, is
 called a \defnadj{preprocessing}{translation unit}.
 \begin{note}
 A \Cpp{} program need not all be translated at the same time.
@@ -46,8 +46,8 @@ [lex.separate]
 calls to functions whose identifiers have external or module linkage,
 manipulation of objects whose identifiers have external or module linkage, or
 manipulation of data files. Translation units can be separately
-translated and then later linked to produce an executable
-program\iref{basic.link}.
+translated and then later \link{linked}{basic.link} to produce an executable
+program.
 \end{note}
 \indextext{compilation!separate|)}
 
@@ -469,7 +469,7 @@ [lex.pptoken]
 \end{bnf}
 
 \pnum
-Each preprocessing token that is converted to a token\iref{lex.token}
+Each preprocessing token that is converted to a \link{token}{lex.token}
 shall have the lexical form of a keyword, an identifier, a literal,
 or an operator or punctuator.
 
@@ -1052,7 +1052,7 @@ [lex.operators]
 \end{bnf}
 
 Each \grammarterm{operator-or-punctuator} is converted to a single token
-in translation phase 7\iref{lex.phases}.%
+in \link{translation phase 7}{lex.phases}.%
 \indextext{punctuator|)}%
 \indextext{operator|)}
 
@@ -2226,7 +2226,7 @@ [lex.ext]
 \pnum
 If \placeholder{L} is a \grammarterm{user-defined-character-literal}, let \placeholder{ch} be the
 literal without its \grammarterm{ud-suffix}.
-\placeholder{S} shall contain a literal operator\iref{over.literal} whose only parameter has
+\placeholder{S} shall contain a \deflinkx{literal operator}{literal!operator}{over.literal} whose only parameter has
 the type of \placeholder{ch} and the
 literal \placeholder{L} is treated as a call
 of the form
diff --git a/source/basic.tex b/source/basic.tex
index 969f9cd8..ec3f3e3e 100644
--- a/source/basic.tex
+++ b/source/basic.tex
@@ -97,8 +97,8 @@ [basic.pre]
 
 \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 @@ [basic.pre]
 \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 @@ [basic.def]
 \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 @@ [basic.def]
 \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 @@ [basic.def]
 \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 @@ [basic.def]
 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 @@ [basic.def.odr]
 \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 @@ [basic.def.odr]
 \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 @@ [basic.def.odr]
 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,
@@ -540,7 +539,7 @@ [basic.def.odr]
 \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},
@@ -588,9 +587,9 @@ [basic.def.odr]
 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
@@ -610,10 +609,10 @@ [basic.def.odr]
 \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
@@ -656,7 +655,7 @@ [basic.def.odr]
 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}
@@ -2577,7 +2576,7 @@ [basic.link]
 
 \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.
 
@@ -2600,7 +2599,7 @@ [basic.link]
 
 \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},
@@ -2620,7 +2619,7 @@ [basic.link]
 \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
@@ -2661,7 +2660,7 @@ [basic.link]
 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
@@ -2719,7 +2718,7 @@ [basic.link]
 \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
@@ -3044,8 +3043,8 @@ [intro.memory]
 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
@@ -3089,15 +3088,15 @@ [intro.object]
 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}
@@ -3225,7 +3224,7 @@ [intro.object]
 \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
@@ -3246,7 +3245,7 @@ [intro.object]
 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
@@ -3660,16 +3659,16 @@ [basic.indet]
   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.
 \item
@@ -3728,8 +3727,8 @@ [basic.stc.general]
 \indextext{storage duration!automatic}%
 \indextext{storage duration!dynamic}%
 Static, thread, and automatic storage durations are associated with objects
-introduced by declarations\iref{basic.def} and implicitly created by
-the implementation\iref{class.temporary}. The dynamic storage duration
+introduced by declarations\iref{basic.def} and \link{implicitly created by
+the implementation}{class.temporary}. The dynamic storage duration
 is associated with objects created by a
 \grammarterm{new-expression}\iref{expr.new}.
 
@@ -3740,7 +3739,7 @@ [basic.stc.general]
 When the end of the duration of a region of storage is reached,
 the values of all pointers
 representing the address of any part of that region of storage
-become invalid pointer values\iref{basic.compound}.
+become \deflinkx{invalid pointer values}{value!invalid pointer}{basic.compound}.
 Indirection through an invalid pointer value and
 passing an invalid pointer value to a deallocation function
 have undefined behavior.
@@ -3832,8 +3831,8 @@ [basic.stc.dynamic.general]
 \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}}%
@@ -4002,19 +4001,19 @@ [basic.stc.dynamic.allocation]
 \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}
@@ -4101,7 +4100,7 @@ [basic.align]
 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}.
 
 \pnum
 A \defnadj{fundamental}{alignment} is represented by an alignment
@@ -4577,9 +4576,9 @@ [basic.types.general]
 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
@@ -4741,7 +4740,7 @@ [basic.types.general]
 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}%
@@ -4770,7 +4769,7 @@ [basic.types.general]
 \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},
@@ -4804,8 +4803,8 @@ [basic.types.general]
 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}
 
@@ -5233,7 +5232,7 @@ [basic.compound]
 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
@@ -5315,7 +5314,7 @@ [basic.compound]
 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}
@@ -5596,8 +5595,8 @@ [intro.execution]
 \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).
@@ -5642,7 +5641,7 @@ [intro.execution]
 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
@@ -5673,7 +5672,7 @@ [intro.execution]
 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/expressions.tex b/source/expressions.tex
index c17a1d20..efcea31f 100644
--- a/source/expressions.tex
+++ b/source/expressions.tex
@@ -33,14 +33,14 @@ [expr.pre]
 \indextext{operator!overloaded}%
 \begin{note}
 Operators can be overloaded, that is, given meaning when applied to
-expressions of class type\iref{class} or enumeration
-type\iref{dcl.enum}. Uses of overloaded operators are transformed into
+expressions of \link{class}{class} type or
+\link{enumeration}{dcl.enum} type. Uses of overloaded operators are transformed into
 function calls as described in~\ref{over.oper}. Overloaded operators
 obey the rules for syntax and evaluation order specified in \ref{expr.compound},
 but the requirements of operand type and value category are replaced
 by the rules for function call. Relations between operators, such as
-\tcode{++a} meaning \tcode{a+=1}, are not guaranteed for overloaded
-operators\iref{over.oper}.
+\tcode{++a} meaning \tcode{a+=1}, are not guaranteed for \link{overloaded
+operators}{over.oper}.
 \end{note}
 
 \pnum
@@ -212,7 +212,7 @@ [basic.lval]
 \begin{example}
 \begin{codeblock}
 struct A {
-  int m;
+int m;
 };
 A&& operator+(A, A);
 A&& f();
@@ -247,8 +247,8 @@ [basic.lval]
 \pnum
 Whenever a glvalue appears as an operand of an operator that
 expects a prvalue for that operand, the
-lvalue-to-rvalue\iref{conv.lval}, array-to-pointer\iref{conv.array},
-or function-to-pointer\iref{conv.func} standard conversions are
+\link{lvalue-to-rvalue}{conv.lval}, \link{array-to-pointer}{conv.array},
+or \link{function-to-pointer}{conv.func} standard conversions are
 applied to convert the expression to a prvalue.
 \begin{note}
 An attempt to bind an rvalue reference to an lvalue is not such a context; see~\ref{dcl.init.ref}.
@@ -268,7 +268,7 @@ [basic.lval]
 \pnum
 Whenever a prvalue appears as an operand of an operator that
 expects a glvalue for that operand, the
-temporary materialization conversion\iref{conv.rval} is
+\link{temporary materialization conversion}{conv.rval} is
 applied to convert the expression to an xvalue.
 
 \pnum
@@ -298,9 +298,9 @@ [basic.lval]
 \end{note}
 
 \pnum
-If a program attempts to access\iref{defns.access}
+If a program attempts to \link{access}{defns.access}
 the stored value of an object through a glvalue
-whose type is not similar\iref{conv.qual} to
+whose type is not \deflinkx{similar}{similar types}{conv.qual} to
 one of the following types the behavior is
 undefined:
 \begin{footnote}
@@ -442,31 +442,31 @@ [expr.context]
 In an unevaluated operand, a non-static class member can be
 named\iref{expr.prim.id} and naming of objects or functions does not, by
 itself, require that a definition be provided\iref{basic.def.odr}.
-An unevaluated operand is considered a full-expression\iref{intro.execution}.
+An unevaluated operand is considered a \deflink{full-expression}{intro.execution}.
 \end{note}
 
 \pnum
 In some contexts, an expression only appears for its side effects. Such an
 expression is called a \defn{discarded-value expression}.
-The array-to-pointer\iref{conv.array}
-and function-to-pointer\iref{conv.func} standard conversions are not
-applied. The lvalue-to-rvalue conversion\iref{conv.lval} is applied
+The \link{array-to-pointer}{conv.array}
+and \link{function-to-pointer}{conv.func} standard conversions are not
+applied. The \link{lvalue-to-rvalue}{conv.lval} conversion is applied
 if and only if
 the expression is a glvalue of volatile-qualified type and it is one of the
 following:
 
 \begin{itemize}
 \item \tcode{(} \grammarterm{expression} \tcode{)}, where
-  \grammarterm{expression} is one of these expressions,
+\grammarterm{expression} is one of these expressions,
 \item \grammarterm{id-expression}\iref{expr.prim.id},
-\item subscripting\iref{expr.sub},
-\item class member access\iref{expr.ref},
-\item indirection\iref{expr.unary.op},
-\item pointer-to-member operation\iref{expr.mptr.oper},
-\item conditional expression\iref{expr.cond} where both the second and the
-      third operands are one of these expressions, or
-\item comma expression\iref{expr.comma} where the right operand is one of
-      these expressions.
+\item \link{subscripting}{expr.sub},
+\item \link{class member access}{expr.ref},
+\item \deflink{indirection}{expr.unary.op},
+\item \link{pointer-to-member operation}{expr.mptr.oper},
+\item \link{conditional expression}{expr.cond} where both the second and the
+  third operands are one of these expressions, or
+\item \link{comma expression}{expr.comma} where the right operand is one of
+  these expressions.
 \end{itemize}
 
 \begin{note}
@@ -603,7 +603,7 @@ [conv.lval]
 \pnum
 \indextext{conversion!lvalue-to-rvalue}%
 \indextext{type!incomplete}%
-A glvalue\iref{basic.lval} of a non-function, non-array type \tcode{T}
+A \deflink{glvalue}{basic.lval} of a non-function, non-array type \tcode{T}
 can be converted to
 a prvalue.
 \begin{footnote}
@@ -628,18 +628,18 @@ [conv.lval]
 \begin{itemize}
 \item $E$ is not potentially evaluated, or
 \item the evaluation of $E$ results in the evaluation of a member
-      $E_\tcode{x}$ of the set of potential results of $E$, and $E_\tcode{x}$
-      names a variable \tcode{x} that is not odr-used by
-      $E_\tcode{x}$\iref{basic.def.odr},
+  $E_\tcode{x}$ of the set of potential results of $E$, and $E_\tcode{x}$
+  names a variable \tcode{x} that is not odr-used by
+  $E_\tcode{x}$\iref{basic.def.odr},
 \end{itemize}
 the value contained in the referenced object is not accessed.
 \begin{example}
 \begin{codeblock}
 struct S { int n; };
 auto f() {
-  S x { 1 };
-  constexpr S y { 2 };
-  return [&](bool b) { return (b ? y : x).n; };
+S x { 1 };
+constexpr S y { 2 };
+return [&](bool b) { return (b ? y : x).n; };
 }
 auto g = f();
 int m = g(false);   // undefined behavior: access of \tcode{x.n} outside its lifetime
@@ -793,11 +793,11 @@ [conv.qual]
 (as it is done on line \#2). For example,
 \begin{codeblock}
 int main() {
-  const char c = 'c';
-  char* pc;
-  const char** pcc = &pc;       // \#1: not allowed
-  *pcc = &c;
-  *pc = 'C';                    // \#2: modifies a const object
+const char c = 'c';
+char* pc;
+const char** pcc = &pc;       // \#1: not allowed
+*pcc = &c;
+*pc = 'C';                    // \#2: modifies a const object
 }
 \end{codeblock}
 \end{note}
@@ -1029,7 +1029,7 @@ [conv.mem]
 \indextext{conversion!pointer-to-member}%
 \indextext{null member pointer conversion|see{conversion, null member pointer}}%
 \indextext{constant!null pointer}%
-A null pointer constant\iref{conv.ptr} can be converted to a
+A \deflinkx{null pointer constant}{constant!null pointer}{conv.ptr} can be converted to a
 pointer-to-member
 type; the result is the \defnx{null member pointer value}{value!null member pointer}
 of that type and is distinguishable from any pointer to member not
@@ -1117,7 +1117,7 @@ [expr.arith.conv]
 which are defined as follows:
 
 \begin{itemize}
-\item If either operand is of scoped enumeration type\iref{dcl.enum}, no conversions
+\item If either operand is of \deflinkx{scoped enumeration type}{enumeration!scoped}{dcl.enum}, no conversions
 are performed; if the other operand does not have the same type, the expression is
 ill-formed.
 \item Otherwise, if either operand is of floating-point type,
@@ -1243,7 +1243,7 @@ [expr.prim.this]
 \begin{note}
 In a \grammarterm{trailing-return-type},
 the class being defined is not required to be complete
-for purposes of class member access\iref{expr.ref}.
+for purposes of \link{class member access}{expr.ref}.
 Class members declared later are not visible.
 \begin{example}
 \begin{codeblock}
@@ -1310,8 +1310,8 @@ [expr.prim.id.general]
 An \grammarterm{id-expression} is a restricted form of a
 \grammarterm{primary-expression}.
 \begin{note}
-An \grammarterm{id-expression} can appear after \tcode{.} and \tcode{->}
-operators\iref{expr.ref}.
+An \grammarterm{id-expression} can appear after
+\link{\tcode{.} and \tcode{->} operators}{expr.ref}.
 \end{note}
 
 \pnum
@@ -1343,7 +1343,7 @@ [expr.prim.id.general]
 An \grammarterm{id-expression} that denotes a non-static data member or
 implicit object member function of a class can only be used:
 \begin{itemize}
-\item as part of a class member access\iref{expr.ref} in which the
+\item as part of a \link{class member access}{expr.ref} in which the
 object expression
 refers to the member's class
 \begin{footnote}
@@ -1393,7 +1393,7 @@ [expr.prim.id.general]
 In the declaration of \tcode{p2},
 those constraints are required to be satisfied
 even though
-\tcode{f} is an unevaluated operand\iref{term.unevaluated.operand}.
+\tcode{f} is an \deflink{unevaluated operand}{expr.context}.
 \end{example}
 \end{note}
 
@@ -1492,7 +1492,7 @@ [expr.prim.id.unqual]
 \end{note}
 The expression is an xvalue if it is move-eligible (see below);
 an lvalue
-if the entity is a function, variable, structured binding\iref{dcl.struct.bind}, data member, or
+if the entity is a function, variable, \link{structured binding}{dcl.struct.bind}, data member, or
 template parameter object;
 and a prvalue otherwise\iref{basic.lval};
 it is a bit-field if the identifier designates a bit-field.
@@ -1760,8 +1760,8 @@ [expr.prim.lambda.general]
 A \grammarterm{lambda-expression} is a prvalue
 whose result object is called the \defn{closure object}.
 \begin{note}
-A closure object behaves like a function
-object\iref{function.objects}.
+A closure object behaves like a \link{function
+object}{function.objects}.
 \end{note}
 
 \pnum
@@ -1845,7 +1845,7 @@ [expr.prim.lambda.closure]
 types of a \grammarterm{lambda-declarator} do not affect these associated namespaces and
 classes.
 \end{note}
-The closure type is not an aggregate type\iref{dcl.init.aggr}.
+The closure type is not an \deflink{aggregate}{dcl.init.aggr} type.
 An implementation may define the closure type differently from what
 is described below provided this does not alter the observable behavior of the program
 other than by changing:
@@ -2033,7 +2033,7 @@ [expr.prim.lambda.closure]
 \grammarterm{lambda-capture}
 whose constraints (if any) are satisfied
 has a conversion function to pointer to
-function with \Cpp{} language linkage\iref{dcl.link} having
+function with \Cpp{} language \link{linkage}{dcl.link} having
 the same parameter and return types as the closure type's function call operator.
 The conversion is to ``pointer to \keyword{noexcept} function''
 if the function call operator
@@ -2140,8 +2140,8 @@ [expr.prim.lambda.closure]
 
 \pnum
 The conversion function or conversion function template is public,
-constexpr, non-virtual, non-explicit, const, and has a non-throwing exception
-specification\iref{except.spec}.
+constexpr, non-virtual, non-explicit, const, and has a non-throwing \link{exception
+specification}{except.spec}.
 \begin{example}
 \begin{codeblock}
 auto Fwd = [](int (*fp)(int), auto a) { return fp(a); };
@@ -2197,9 +2197,9 @@ [expr.prim.lambda.closure]
 
 \pnum
 A member of a closure type shall not be
-explicitly instantiated\iref{temp.explicit},
-explicitly specialized\iref{temp.expl.spec}, or
-named in a friend declaration\iref{class.friend}.
+\link{explicitly instantiated}{temp.explicit},
+\link{explicitly specialized}{temp.expl.spec}, or
+named in a \link{friend declaration}{class.friend}.
 
 \rSec3[expr.prim.lambda.capture]{Captures}%
 
@@ -2755,7 +2755,7 @@ [expr.prim.req.general]
 \pnum
 A \grammarterm{requires-expression} provides a concise way to express
 requirements on template arguments
-that can be checked by name lookup\iref{basic.lookup}
+that can be checked by \link{name lookup}{basic.lookup}
 or by checking properties of types and expressions.
 
 \begin{bnf}
@@ -2792,7 +2792,7 @@ [expr.prim.req.general]
 A \grammarterm{requires-expression} is a prvalue of type \tcode{bool}
 whose value is described below.
 Expressions appearing within a \grammarterm{requirement-body}
-are unevaluated operands\iref{term.unevaluated.operand}.
+are \deflinkx{unevaluated operands}{unevaluated operand}{expr.context}.
 
 \pnum
 \begin{example}
@@ -2879,7 +2879,7 @@ [expr.prim.req.simple]
 \begin{note}
 The enclosing \grammarterm{requires-expression} will evaluate to \keyword{false}
 if substitution of template arguments into the \grammarterm{expression} fails.
-The \grammarterm{expression} is an unevaluated operand\iref{term.unevaluated.operand}.
+The \grammarterm{expression} is an \deflink{unevaluated operand}{expr.context}.
 \end{note}
 \begin{example}
 \begin{codeblock}
@@ -3175,7 +3175,7 @@ [expr.call]
 If the selected
 function is non-virtual, or if the \grammarterm{id-expression} in the class
 member access expression is a \grammarterm{qualified-id}, that function is
-called. Otherwise, its final overrider\iref{class.virtual} in the dynamic type
+called. Otherwise, its \deflink{final overrider}{class.virtual} in the dynamic type
 of the object expression is called; such a call is referred to as a
 \defnx{virtual function call}{function!virtual function call}.
 \begin{note}
@@ -3188,8 +3188,8 @@ [expr.call]
 
 \pnum
 \begin{note}
-If a function or member function name is used, and name
-lookup\iref{basic.lookup} does not find a declaration of that name,
+If a function or member function name is used, and \link{name
+lookup}{basic.lookup} does not find a declaration of that name,
 the program is ill-formed. No function is implicitly declared by such a
 call.
 \end{note}
@@ -3246,7 +3246,7 @@ [expr.call]
 If the function is an implicit object member
 function, the \keyword{this} parameter of the function\iref{expr.prim.this}
 is initialized with a pointer to the object of the call, converted
-as if by an explicit type conversion\iref{expr.cast}.
+as if by an \link{explicit type conversion}{expr.cast}.
 \begin{note}
 There is no access or ambiguity checking on this conversion; the access
 checking and disambiguation are done as part of the (possibly implicit)
@@ -3355,10 +3355,10 @@ [expr.call]
 \pnum
 \indextext{declaration!ellipsis in function}%
 \indextext{parameter list!variable}%
-A function can be declared to accept fewer arguments (by declaring default
-arguments\iref{dcl.fct.default}) or more arguments (by using the ellipsis,
+A function can be declared to accept fewer arguments (by declaring \link{default
+arguments}{dcl.fct.default}) or more arguments (by using the ellipsis,
 \tcode{...}, or a function parameter pack\iref{dcl.fct}) than the number of
-parameters in the function definition\iref{dcl.fct.def}.
+parameters in the \link{function definition}{dcl.fct.def}.
 \begin{note}
 This implies that, except where the ellipsis (\tcode{...}) or a function
 parameter pack is used, a parameter is available for each argument.
@@ -3368,7 +3368,7 @@ [expr.call]
 \indextext{ellipsis!conversion sequence}%
 When there is no parameter for a given argument, the argument is passed
 in such a way that the receiving function can obtain the value of the
-argument by invoking \tcode{va_arg}\iref{support.runtime}.
+argument by invoking \libglobalref{va_arg}.
 \begin{note}
 This paragraph does not apply to arguments passed to a function parameter pack.
 Function parameter packs are expanded during template instantiation\iref{temp.variadic},
@@ -3376,8 +3376,8 @@ [expr.call]
 specialization is actually called.
 \end{note}
 The
-lvalue-to-rvalue\iref{conv.lval}, array-to-pointer\iref{conv.array},
-and function-to-pointer\iref{conv.func} standard conversions are
+\link{lvalue-to-rvalue}{conv.lval}, \link{array-to-pointer}{conv.array},
+and \link{function-to-pointer}{conv.func} standard conversions are
 performed on the argument expression.
 An argument that has type \cv{}~\tcode{std::nullptr_t} is converted
 to type \tcode{\keyword{void}*}\iref{conv.ptr}.
@@ -3392,16 +3392,16 @@ [expr.call]
 non-trivial destructor\iref{special},
 with no corresponding parameter, is conditionally-supported with
 \impldef{passing argument of class type through ellipsis} semantics. If the argument has
-integral or enumeration type that is subject to the integral
-promotions\iref{conv.prom}, or a floating-point type that is subject to the
-floating-point promotion\iref{conv.fpprom}, the value of the argument is converted to the
+integral or enumeration type that is subject to the \link{integral
+promotions}{conv.prom}, or a floating-point type that is subject to the
+\link{floating-point promotion}{conv.fpprom}, the value of the argument is converted to the
 promoted type before the call. These promotions are referred to as
 the \defnx{default argument promotions}{promotion!default argument promotion}.
 
 \pnum
 \indextext{function call!recursive}%
-Recursive calls are permitted, except to the \tcode{main}
-function\iref{basic.start.main}.
+Recursive calls are permitted, except to the \link{\tcode{main}
+function}{basic.start.main}.
 
 \pnum
 A function call is an lvalue
@@ -3417,8 +3417,8 @@ [expr.type.conv]
 \indextext{type conversion, explicit|see{casting}}%
 \indextext{conversion explicit type|see{casting}}%
 \indextext{casting}%
-A \grammarterm{simple-type-specifier}\iref{dcl.type.simple} or
-\grammarterm{typename-specifier}\iref{temp.res} followed
+A \link{\grammarterm{simple-type-specifier}}{dcl.type.simple} or
+\link{\grammarterm{typename-specifier}}{temp.res} followed
 by a parenthesized optional \grammarterm{expression-list} or
 by a \grammarterm{braced-init-list}
 (the initializer)
@@ -3429,7 +3429,7 @@ [expr.type.conv]
 for a deduced class type,
 it is replaced by the return type
 of the function selected by overload resolution
-for class template deduction\iref{over.match.class.deduct}
+for \link{class template deduction}{over.match.class.deduct}
 for the remainder of this subclause.
 Otherwise, if the type contains a placeholder type,
 it is replaced by the type
@@ -3451,8 +3451,7 @@ [expr.type.conv]
 \pnum
 If the initializer is a parenthesized single expression,
 the type conversion expression is equivalent
-to the corresponding cast
-expression\iref{expr.cast}.
+to the corresponding \link{cast expression}{expr.cast}.
 \indextext{type!incomplete}%
 Otherwise, if the type is \cv{}~\keyword{void}
 and the initializer is \tcode{()} or \tcode{\{\}}
@@ -3461,7 +3460,7 @@ [expr.type.conv]
 that performs no initialization.
 Otherwise,
 the expression is a prvalue of the specified type
-whose result object is direct-initialized\iref{dcl.init}
+whose result object is \deflinkx{direct-initialized}{direct-initialization}{dcl.init}
 with the initializer.
 If the initializer is a parenthesized optional \grammarterm{expression-list},
 the specified type shall not be an array type.
@@ -3744,8 +3743,8 @@ [expr.dynamic.cast]
 \end{example}
 
 \pnum
-Otherwise, \tcode{v} shall be a pointer to or a glvalue of a polymorphic
-type\iref{class.virtual}.
+Otherwise, \tcode{v} shall be a pointer to or a glvalue of a
+\deflinkx{polymorphic type}{class!polymorphic}{class.virtual}.
 
 \pnum
 If \tcode{v} is a null pointer value, the result is a null pointer value.
@@ -3779,9 +3778,9 @@ [expr.dynamic.cast]
 
 \pnum
 The value of a failed cast to pointer type is the null pointer value of
-the required result type. A failed cast to reference type throws
-an exception\iref{except.throw} of a type that would match a
-handler\iref{except.handle} of type \tcode{std::bad_cast}\iref{bad.cast}.
+the required result type. A failed cast to reference type \link{throws
+an exception}{except.throw} of a type that would match a
+\link{handler}{except.handle} of type \link{\tcode{std::bad_cast}}{bad.cast}.
 
 \indextext{\idxcode{bad_cast}}%
 \indexlibraryglobal{bad_cast}%
@@ -3869,13 +3868,13 @@ [expr.typeid]
 When \keyword{typeid} is applied to an expression other than a glvalue of
 a polymorphic class type, the result refers to a \tcode{std::type_info}
 object representing the static type of the expression.
-Lvalue-to-rvalue\iref{conv.lval}, array-to-pointer\iref{conv.array},
-and function-to-pointer\iref{conv.func} conversions are not applied to
+\link{Lvalue-to-rvalue}{conv.lval}, \link{array-to-pointer}{conv.array},
+and \link{function-to-pointer}{conv.func} conversions are not applied to
 the expression.
 If the expression is a prvalue,
-the temporary materialization conversion\iref{conv.rval}
+the \link{temporary materialization conversion}{conv.rval}
 is applied.
-The expression is an unevaluated operand\iref{term.unevaluated.operand}.
+The expression is an \deflink{unevaluated operand}{expr.context}.
 
 \pnum
 When \keyword{typeid} is applied to a \grammarterm{type-id}, the result
@@ -3939,7 +3938,7 @@ [expr.static.cast]
 \indextext{cast!reference}%
 An lvalue of type ``\cvqual{cv1} \tcode{B}'', where \tcode{B} is a class
 type, can be cast to type ``reference to \cvqual{cv2} \tcode{D}'', where
-\tcode{D} is a class derived\iref{class.derived} from \tcode{B},
+\tcode{D} is a class \link{derived}{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}
@@ -3970,7 +3969,7 @@ [expr.static.cast]
 reference to \tcode{T2}'' if \tcode{T2} is reference-compatible with
 \tcode{T1}\iref{dcl.init.ref}. If the value is not a bit-field,
 the result refers to the object or the specified base class subobject
-thereof; otherwise, the lvalue-to-rvalue conversion\iref{conv.lval}
+thereof; otherwise, the \link{lvalue-to-rvalue conversion}{conv.lval}
 is applied to the bit-field and the resulting prvalue is used as the
 operand of the \keyword{static_cast} for the remainder of this subclause.
 If \tcode{T2} is an inaccessible\iref{class.access} or
@@ -4018,8 +4017,8 @@ [expr.static.cast]
 as it is a prvalue of type \keyword{void}; see~\ref{basic.lval}.
 \end{note}
 \begin{note}
-However, if the value is in a temporary
-object\iref{class.temporary}, the destructor for that
+However, if the value is in a \link{temporary
+object}{class.temporary}, the destructor for that
 object is
 not executed until the usual time, and the value of the object is
 preserved for the purpose of executing the destructor.
@@ -4105,7 +4104,8 @@ [expr.static.cast]
 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 complete class derived\iref{class.derived}
+where \tcode{D} is a complete class
+\link{derived}{class.derived}
 from \tcode{B},
 if \cvqual{cv2} is the same cv-qualification as,
 or greater cv-qualification than, \cvqual{cv1}.
@@ -4126,7 +4126,7 @@ [expr.static.cast]
 \tcode{T}'' can be converted to a prvalue of type ``pointer to member of
 \tcode{B} of type \cvqual{cv2} \tcode{T}'', where
 \tcode{D} is a complete class type and
-\tcode{B} is a base class\iref{class.derived} of \tcode{D},
+\tcode{B} is a \link{base class}{class.derived} of \tcode{D},
 if \cvqual{cv2} is the same cv-qualification
 as, or greater cv-qualification than, \cvqual{cv1}.
 \begin{note}
@@ -4137,7 +4137,7 @@ [expr.static.cast]
 from ``pointer to member of \tcode{B} of type \tcode{T}''
 to ``pointer to member of \tcode{D} of type \tcode{T}''
 exists\iref{conv.mem}, the program is ill-formed.
-The null member pointer value\iref{conv.mem} is converted to the null
+The \deflinkx{null member pointer value}{value!null member pointer}{conv.mem} is converted to the null
 member pointer value of the destination type. If class \tcode{B}
 contains the original member, or is a base or derived class of the class
 containing the original member, the resulting pointer to member points
@@ -4160,7 +4160,7 @@ [expr.static.cast]
 then the resulting pointer value is unspecified.
 Otherwise, if the original pointer value points to an object \placeholder{a},
 and there is an object \placeholder{b} of type similar to \tcode{T}
-that is pointer-interconvertible\iref{basic.compound} with \placeholder{a},
+that is \deflink{pointer-interconvertible}{basic.compound} with \placeholder{a},
 the result is a pointer to \placeholder{b}.
 Otherwise, the pointer value is unchanged by the conversion.
 \begin{example}
@@ -4183,8 +4183,8 @@ [expr.reinterpret.cast]
 If \tcode{T} is an lvalue reference type or an rvalue reference to function type, the result is an lvalue;
 if \tcode{T} is an rvalue reference to object type, the result is an xvalue;
 otherwise, the result is a prvalue and the
-lvalue-to-rvalue\iref{conv.lval}, array-to-pointer\iref{conv.array},
-and function-to-pointer\iref{conv.func} standard conversions are
+\link{lvalue-to-rvalue}{conv.lval}, \link{array-to-pointer}{conv.array},
+and \link{function-to-pointer}{conv.func} standard conversions are
 performed on the expression \tcode{v}. Conversions that can be performed explicitly
 using \keyword{reinterpret_cast} are listed below. No other conversion can
 be performed explicitly using \keyword{reinterpret_cast}.
@@ -4353,8 +4353,8 @@ [expr.const.cast]
 lvalue;
 if \tcode{T} is an rvalue reference to object type, the result is an xvalue;
 otherwise, the result is a prvalue and the
-lvalue-to-rvalue\iref{conv.lval}, array-to-pointer\iref{conv.array},
-and function-to-pointer\iref{conv.func} standard conversions are
+\link{lvalue-to-rvalue}{conv.lval}, \link{array-to-pointer}{conv.array},
+and \link{function-to-pointer}{conv.func} standard conversions are
 performed on the expression \tcode{v}. Conversions that can be performed explicitly using
 \keyword{const_cast} are listed below. No other conversion shall be
 performed explicitly using \keyword{const_cast}.
@@ -4366,7 +4366,7 @@ [expr.const.cast]
 \end{note}
 
 \pnum
-For two similar types \tcode{T1} and \tcode{T2}\iref{conv.qual},
+For two \deflink{similar types}{conv.qual} \tcode{T1} and \tcode{T2},
 a prvalue of type \tcode{T1} may be explicitly
 converted to the type \tcode{T2} using a \keyword{const_cast}
 if, considering the qualification-decompositions of both types,
@@ -4402,7 +4402,7 @@ [expr.const.cast]
 
 The result of a reference \keyword{const_cast} refers
 to the original object if the operand is a glvalue and
-to the result of applying the temporary materialization conversion\iref{conv.rval} otherwise.
+to the result of applying the \link{temporary materialization conversion}{conv.rval} otherwise.
 
 \pnum
 A null pointer value\iref{basic.compound} is converted to the null pointer
@@ -4684,8 +4684,8 @@ [expr.pre.incr]
 The expression \tcode{++x} is equivalent to \tcode{x+=1}.
 \indextext{operator!\idxcode{+=}}%
 \begin{note}
-See the discussions of addition\iref{expr.add} and assignment
-operators\iref{expr.ass} for information on conversions.
+See the discussions of \link{addition}{expr.add} and \link{assignment
+operators}{expr.ass} for information on conversions.
 \end{note}
 
 \pnum
@@ -4900,7 +4900,7 @@ [expr.sizeof]
 The \keyword{sizeof} operator yields the number of bytes
 occupied by a non-potentially-overlapping object of the type
 of its operand. The operand is either an expression,
-which is an unevaluated operand\iref{term.unevaluated.operand}, or a parenthesized
+which is an \deflink{unevaluated operand}{expr.context}, or a parenthesized
 \grammarterm{type-id}.
 \indextext{type!incomplete}%
 The \keyword{sizeof} operator shall not be applied to an expression that
@@ -4955,7 +4955,7 @@ [expr.sizeof]
 function-to-pointer\iref{conv.func} standard conversions are not
 applied to the operand of \keyword{sizeof}.
 If the operand is a prvalue,
-the temporary materialization conversion\iref{conv.rval}
+the \link{temporary materialization conversion}{conv.rval}
 is applied.
 
 \pnum
@@ -5015,7 +5015,7 @@ [expr.unary.noexcept]
 \indextext{\idxcode{noexcept}}%
 \indextext{expression!\idxcode{noexcept}}%
 The \keyword{noexcept} operator determines whether the evaluation of its operand,
-which is an unevaluated operand\iref{term.unevaluated.operand}, can throw an
+which is an \deflink{unevaluated operand}{expr.context}, can throw an
 exception\iref{except.throw}.
 
 \begin{bnf}
@@ -5099,7 +5099,7 @@ [expr.new]
 \end{bnf}
 
 \pnum
-If a placeholder type\iref{dcl.spec.auto} appears in the
+If a \link{placeholder type}{dcl.spec.auto} appears in the
 \grammarterm{type-specifier-seq} of a \grammarterm{new-type-id} or
 \grammarterm{type-id} of a \grammarterm{new-expression},
 the allocated type is deduced as follows:
@@ -5216,7 +5216,7 @@ [expr.new]
 
 \item
 its value is such that the size of the allocated object would exceed the
-\impldef{maximum size of an allocated object} limit\iref{implimits}; or
+\impldef{maximum size of an allocated object} \link{limit}{implimits}; or
 
 \item
 the \grammarterm{new-initializer} is a \grammarterm{braced-init-list} and the
@@ -5241,7 +5241,7 @@ [expr.new]
 \item
 otherwise, the \grammarterm{new-expression} terminates by throwing an
 exception of a type that would match a handler\iref{except.handle} of type
-\tcode{std::bad_array_new_length}\iref{new.badlength}.
+\link{\tcode{std::bad_array_new_length}}{new.badlength}.
 \end{itemize}
 \end{itemize}
 When the value of the \grammarterm{expression} is zero, the allocation
@@ -5277,8 +5277,8 @@ [expr.new]
 A \grammarterm{new-expression} may obtain storage for the object by calling an
 allocation function\iref{basic.stc.dynamic.allocation}. If
 the \grammarterm{new-expression} terminates by throwing an exception, it
-may release storage by calling a deallocation
-function\iref{basic.stc.dynamic.deallocation}. If the allocated type
+may release storage by calling a \link{deallocation
+function}{basic.stc.dynamic.deallocation}. If the allocated type
 is a non-array type, the allocation function's name is
 \indextext{\idxcode{operator new}}%
 \indextext{\idxcode{operator delete}}%
@@ -5394,7 +5394,7 @@ [expr.new]
 result of the \grammarterm{new-expression} and the address returned by the
 allocation function shall be an integral multiple of the
 strictest fundamental
-alignment requirement\iref{basic.align} of any object type whose size
+\link{alignment requirement}{basic.align} of any object type whose size
 is no greater than the size of the array being created.
 \begin{note}
 \indextext{allocation!alignment storage}%
@@ -5485,7 +5485,7 @@ [expr.new]
 \pnum
 \begin{note}
 Unless an allocation function has a non-throwing
-exception specification\iref{except.spec},
+\link{exception specification}{except.spec},
 it indicates failure to allocate storage by throwing a
 \indextext{\idxcode{bad_alloc}}%
 \indexlibraryglobal{bad_alloc}%
@@ -5631,8 +5631,8 @@ [expr.delete]
 \pnum
 \indextext{expression!\idxcode{delete}}%
 \indextext{\idxcode{delete}}%
-The \grammarterm{delete-expression} operator destroys a most derived
-object\iref{intro.object} or array created by a
+The \grammarterm{delete-expression} operator destroys a
+\deflink{most derived object}{intro.object} or array created by a
 \grammarterm{new-expression}.
 
 \begin{bnf}
@@ -5653,7 +5653,7 @@ [expr.delete]
 if the \grammarterm{lambda-expression} is enclosed in parentheses.
 \end{footnote}
 The operand shall be of pointer to object type or of class type. If of
-class type, the operand is contextually implicitly converted\iref{conv}
+class type, the operand is \deflink{contextually implicitly converted}{conv}
 to a pointer to object
 type.
 \begin{footnote}
@@ -5743,8 +5743,8 @@ [expr.delete]
 \item
 If the allocation call for the \grammarterm{new-expression} for the object to
 be deleted was not omitted and the allocation was not extended\iref{expr.new}, the
-\grammarterm{delete-expression} shall call a deallocation
-function\iref{basic.stc.dynamic.deallocation}. The value returned from the
+\grammarterm{delete-expression} shall call a \link{deallocation
+function}{basic.stc.dynamic.deallocation}. The value returned from the
 allocation call of the \grammarterm{new-expression} shall be passed as the
 first argument to the deallocation function.
 
@@ -6092,8 +6092,8 @@ [expr.mptr.oper]
 whose second operand is a pointer to a data member is an lvalue if the first
 operand is an lvalue and an xvalue otherwise. The result of a \tcode{.*} expression whose
 second operand is a pointer to a member function is a prvalue.
-If the second operand is the null
-member pointer value\iref{conv.mem}, the behavior is undefined.
+If the second operand is the \deflinkx{null member pointer value}{value!null member pointer}{conv.mem},
+the behavior is undefined.
 
 \rSec2[expr.mul]{Multiplicative operators}%
 \indextext{expression!multiplicative operators}%
@@ -6122,7 +6122,7 @@ [expr.mul]
 \pnum
 The operands of \tcode{*} and \tcode{/} shall have arithmetic or unscoped
 enumeration type; the operands of \tcode{\%} shall have integral or unscoped
-enumeration type. The usual arithmetic conversions\iref{expr.arith.conv} are performed on the
+enumeration type. The \link{usual arithmetic conversions}{expr.arith.conv} are performed on the
 operands and determine the type of the result.
 
 \pnum
@@ -6150,7 +6150,7 @@ [expr.add]
 
 \pnum
 The additive operators \tcode{+} and \tcode{-} group left-to-right. The
-usual arithmetic conversions\iref{expr.arith.conv} are performed for operands of arithmetic or
+\link{usual arithmetic conversions}{expr.arith.conv} are performed for operands of arithmetic or
 enumeration type.
 
 \indextext{operator!addition}%
@@ -6253,7 +6253,7 @@ [expr.add]
 \pnum
 For addition or subtraction, if the expressions \tcode{P} or \tcode{Q} have
 type ``pointer to \cv{}~\tcode{T}'', where \tcode{T} and the array element type
-are not similar\iref{conv.qual}, the behavior is undefined.
+are not \deflinkx{similar}{similar types}{conv.qual}, the behavior is undefined.
 \begin{example}
 \begin{codeblock}
 int arr[5] = {1, 2, 3, 4, 5};
@@ -6343,12 +6343,12 @@ [expr.spaceship]
 If both operands have arithmetic types,
 or one operand has integral type and
 the other operand has unscoped enumeration type,
-the usual arithmetic conversions\iref{expr.arith.conv} are applied to the operands.
+the \link{usual arithmetic conversions}{expr.arith.conv} are applied to the operands.
 Then:
 
 \begin{itemize}
 \item
-If a narrowing conversion\iref{dcl.init.list} is required,
+If a \deflinkx{narrowing conversion}{conversion!narrowing}{dcl.init.list} is required,
 other than from an integral type to a floating-point type,
 the program is ill-formed.
 
@@ -6390,13 +6390,13 @@ [expr.spaceship]
 array-to-pointer conversions\iref{conv.array},
 pointer conversions\iref{conv.ptr},
 and
-qualification conversions\iref{conv.qual}
+\link{qualification conversions}{conv.qual}
 are performed on both operands
 to bring them to their composite pointer type\iref{expr.type}.
 After the conversions, the operands shall have the same type.
 \begin{note}
 If both of the operands are arrays,
-array-to-pointer conversions\iref{conv.array} are not applied.
+\link{array-to-pointer conversions}{conv.array} are not applied.
 \end{note}
 In this case,
 \tcode{p <=> q} is of type \tcode{std::strong_ordering} and
@@ -6481,11 +6481,11 @@ [expr.rel]
 \keyword{bool}.
 
 \pnum
-The usual arithmetic conversions\iref{expr.arith.conv} are performed on operands of arithmetic
-or enumeration type. If both operands are pointers, pointer
-conversions\iref{conv.ptr} and qualification conversions\iref{conv.qual}
+The \link{usual arithmetic conversions}{expr.arith.conv} are performed on operands of arithmetic
+or enumeration type. If both operands are pointers, \link{pointer
+conversions}{conv.ptr} and \link{qualification conversions}{conv.qual}
 are performed to bring
-them to their composite pointer type\iref{expr.type}.
+them to their \deflink{composite pointer type}{expr.type}.
 After conversions, the operands shall have the same type.
 
 \pnum
@@ -6570,10 +6570,10 @@ [expr.eq]
 \indextext{comparison!pointer}%
 \indextext{comparison!pointer to function}%
 If at least one of the operands is a pointer,
-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\iref{expr.type}.
+\link{pointer conversions}{conv.ptr},
+\link{function pointer conversions}{conv.fctptr}, and
+\link{qualification conversions}{conv.qual}
+are performed on both operands to bring them to their \deflink{composite pointer type}{expr.type}.
 Comparing pointers is defined as follows:
 
 \begin{itemize}
@@ -6590,7 +6590,8 @@ [expr.eq]
 \item
 Otherwise, if the pointers are both null, both point to the same
 \indextext{address}%
-function, or both represent the same address\iref{basic.compound},
+function, or both
+\deflinkx{represent the same address}{represents the address}{basic.compound},
 they compare equal.
 \item
 Otherwise, the pointers compare unequal.
@@ -6635,12 +6636,12 @@ [expr.eq]
 \end{example}
 
 \item
-If both refer to (possibly different) members of the same union\iref{class.union},
+If both refer to (possibly different) members of the same \link{union}{class.union},
 they compare equal.
 
 \item
 Otherwise, two pointers to members compare equal if they would refer to the same member of
-the same most derived object\iref{intro.object} or the same subobject if
+the same \deflink{most derived object}{intro.object} or the same subobject if
 indirection with a hypothetical object of the associated
 class type were performed, otherwise they compare unequal.
 \begin{example}
@@ -6866,7 +6867,7 @@ [expr.cond]
 either has (possibly cv-qualified) class type, or if both
 are glvalues of the same value category and the same type except for
 cv-qualification, an attempt is made to
-form an implicit conversion sequence\iref{over.best.ics} from
+form an \link{implicit conversion sequence}{over.best.ics} from
 each of those operands to the type of the other.
 \begin{note}
 Properties such as access, whether an operand is a bit-field, or whether
@@ -6903,9 +6904,9 @@ [expr.cond]
 
 \item otherwise, the target type is the type that \tcode{E2} would have
 after applying the
-lvalue-to-rvalue\iref{conv.lval},
-array-to-pointer\iref{conv.array}, and
-function-to-pointer\iref{conv.func}
+\link{lvalue-to-rvalue}{conv.lval},
+\link{array-to-pointer}{conv.array}, and
+\link{function-to-pointer}{conv.func}
 standard conversions.
 \end{itemize}
 \end{itemize}
@@ -6943,8 +6944,8 @@ [expr.cond]
 subclause.
 
 \pnum
-Lvalue-to-rvalue\iref{conv.lval}, array-to-pointer\iref{conv.array},
-and function-to-pointer\iref{conv.func} standard conversions are
+\link{Lvalue-to-rvalue}{conv.lval}, \link{array-to-pointer}{conv.array},
+and \link{function-to-pointer}{conv.func} standard conversions are
 performed on the second and third operands. After those conversions, one
 of the following shall hold:
 
@@ -6953,15 +6954,15 @@ [expr.cond]
 that type and the result object is initialized using the selected operand.
 
 \item The second and third operands have arithmetic or enumeration type;
-the usual arithmetic conversions\iref{expr.arith.conv} are performed to bring them to a common
+the \link{usual arithmetic conversions}{expr.arith.conv} are performed to bring them to a common
 type, and the result is of that type.
 
 \item One or both of the second and third operands have pointer type;
-pointer conversions\iref{conv.ptr},
-function pointer conversions\iref{conv.fctptr}, and
-qualification conversions\iref{conv.qual}
+\link{pointer conversions}{conv.ptr},
+\link{function pointer conversions}{conv.fctptr}, and
+\link{qualification conversions}{conv.qual}
 are performed to bring them to their
-composite pointer type\iref{expr.type}. The result is of the composite
+\deflink{composite pointer type}{expr.type}. The result is of the composite
 pointer type.
 
 \item One or both of the second and third operands have pointer-to-member type;
@@ -7046,8 +7047,8 @@ [expr.throw]
 A \grammarterm{throw-expression} is of type \keyword{void}.
 
 \pnum
-Evaluating a \grammarterm{throw-expression} with an operand throws an
-exception\iref{except.throw}; the type of the exception object is determined by removing
+Evaluating a \grammarterm{throw-expression} with an operand \link{throws an
+exception}{except.throw}; the type of the exception object is determined by removing
 any top-level \grammarterm{cv-qualifier}{s} from the static type of the
 operand and adjusting the type
 from ``array of \tcode{T}'' or function type \tcode{T}
@@ -7057,7 +7058,8 @@ [expr.throw]
 \indextext{exception handling!rethrow}%
 A
 \grammarterm{throw-expression}
-with no operand rethrows the currently handled exception\iref{except.handle}.
+with no operand rethrows the
+\deflinkx{currently handled exception}{exception handling!currently handled exception}{except.handle}.
 The exception is reactivated with the existing exception object;
 no new exception object is created.
 The exception is no longer considered to be caught.
@@ -7082,7 +7084,7 @@ [expr.throw]
 evaluating a
 \grammarterm{throw-expression}
 with no operand calls
-\tcode{std::\brk{}terminate()}\iref{except.terminate}.
+\link{\tcode{std::\brk{}terminate()}}{except.terminate}.
 
 \rSec2[expr.ass]{Assignment and compound assignment operators}%
 \indextext{expression!assignment and compound assignment}
@@ -7143,7 +7145,7 @@ [expr.ass]
 \pnum
 \indextext{assignment!conversion by}%
 If the right operand is an expression, it is implicitly
-converted\iref{conv} to the cv-unqualified type of the left
+\link{converted}{conv} to the cv-unqualified type of the left
 operand.
 
 \pnum
@@ -7157,7 +7159,7 @@ [expr.ass]
 An assignment whose left operand is of
 a volatile-qualified type is deprecated\iref{depr.volatile.type}
 unless the (possibly parenthesized) assignment is a discarded-value expression or
-an unevaluated operand\iref{term.unevaluated.operand}.
+an \deflink{unevaluated operand}{expr.context}.
 
 \pnum
 The behavior of an expression of the form \tcode{E1 \placeholder{op}= E2}
@@ -7224,7 +7226,7 @@ [expr.comma]
 
 A pair of expressions separated by a comma is evaluated left-to-right;
 the left expression is
-a discarded-value expression\iref{expr.prop}.
+a \deflink{discarded-value expression}{expr.prop}.
 The left expression is sequenced before
 the right expression\iref{intro.execution}.
 \indextext{operator!side effects and comma}%
@@ -7258,7 +7260,7 @@ [expr.const]
 requirements as detailed in this subclause; other contexts have different
 semantics depending on whether or not an expression satisfies these requirements.
 Expressions that satisfy these requirements,
-assuming that copy elision\iref{class.copy.elision} is not performed,
+assuming that \link{copy elision}{class.copy.elision} is not performed,
 are called
 \indexdefn{expression!constant}%
 \defnx{constant expressions}{constant expression}.
@@ -7311,8 +7313,8 @@ [expr.const]
 An object or reference is \defn{usable in constant expressions} if it is
 \begin{itemize}
 \item a variable that is usable in constant expressions, or
-\item a template parameter object\iref{temp.param}, or
-\item a string literal object\iref{lex.string}, or
+\item a \link{template parameter}{temp.param} object, or
+\item a \link{string literal}{lex.string} object, or
 \item a temporary object of non-volatile const-qualified literal type
   whose lifetime is extended\iref{class.temporary}
   to that of a variable that is usable in constant expressions, or
@@ -7386,7 +7388,7 @@ [expr.const]
 \end{footnote}
 
 \item
-an lvalue-to-rvalue conversion\iref{conv.lval} unless
+an \link{lvalue-to-rvalue conversion}{conv.lval} unless
 it is applied to
 \begin{itemize}
   \item
@@ -7405,7 +7407,7 @@ [expr.const]
 
 \item
 an lvalue-to-rvalue conversion that is applied to
-an object with an indeterminate value\iref{basic.indet};
+an object with an \deflinkx{indeterminate value}{value!indeterminate}{basic.indet};
 
 \item
 an invocation of an implicitly-defined copy/move constructor or
@@ -7702,7 +7704,7 @@ [expr.const]
 Such expressions can be
 used as bit-field lengths\iref{class.bit}, as enumerator
 initializers if the underlying type is not fixed\iref{dcl.enum},
-and as alignments\iref{dcl.align}.
+and as \link{alignments}{dcl.align}.
 \end{note}
 
 \pnum
@@ -7734,24 +7736,24 @@ [expr.const]
 implicit conversion sequence contains only
 \begin{itemize}
 \item user-defined conversions,
-\item lvalue-to-rvalue conversions\iref{conv.lval},
-\item array-to-pointer conversions\iref{conv.array},
-\item function-to-pointer conversions\iref{conv.func},
-\item qualification conversions\iref{conv.qual},
-\item integral promotions\iref{conv.prom},
-\item integral conversions\iref{conv.integral} other than narrowing conversions\iref{dcl.init.list},
-\item null pointer conversions\iref{conv.ptr} from \tcode{std::nullptr_t},
-\item null member pointer conversions\iref{conv.mem} from \tcode{std::nullptr_t}, and
-\item function pointer conversions\iref{conv.fctptr},
+\item \link{lvalue-to-rvalue conversions}{conv.lval},
+\item \link{array-to-pointer conversions}{conv.array},
+\item \link{function-to-pointer conversions}{conv.func},
+\item \link{qualification conversions}{conv.qual},
+\item \deflinkx{integral promotions}{integral promotion}{conv.prom},
+\item \link{integral conversions}{conv.integral} other than
+\deflinkx{narrowing conversions}{conversion!narrowing}{dcl.init.list},
+\item \deflinkx{null pointer conversions}{conversion!null pointer}{conv.ptr} from \tcode{std::nullptr_t},
+\item \deflinkx{null member pointer conversions}{conversion!null member pointer}{conv.mem} from \tcode{std::nullptr_t}, and
+\item \link{function pointer conversions}{conv.fctptr},
 \end{itemize}
 and where the reference binding (if any) binds directly.
 \begin{note}
 Such expressions can be used in \keyword{new}
 expressions\iref{expr.new}, as case expressions\iref{stmt.switch},
 as enumerator initializers if the underlying type is
-fixed\iref{dcl.enum}, as array bounds\iref{dcl.array}, and
-as non-type template
-arguments\iref{temp.arg}.
+\deflinkx{fixed}{type!underlying!fixed}{dcl.enum}, as \link{array}{dcl.array} bounds, and
+as non-type \link{template arguments}{temp.arg}.
 \end{note}
 \indextext{contextually converted constant expression of type \tcode{bool}|see{conversion, contextual}}%
 \indextext{conversion!contextual to constant expression of type \tcode{bool}}%
@@ -8001,7 +8003,7 @@ [expr.const]
 \end{itemize}
 \begin{note}
 A manifestly constant-evaluated expression
-is evaluated even in an unevaluated operand\iref{term.unevaluated.operand}.
+is evaluated even in an \deflink{unevaluated operand}{expr.context}.
 \end{note}
 
 \pnum
@@ -8013,7 +8015,7 @@ [expr.const]
 a manifestly constant-evaluated expression,
 
 \item
-a potentially-evaluated expression\iref{basic.def.odr},
+a \deflinkx{potentially-evaluated}{potentially evaluated}{basic.def.odr} expression,
 
 \item
 an immediate subexpression of a \grammarterm{braced-init-list},
@@ -8040,7 +8042,9 @@ [expr.const]
 if it is:
 \begin{itemize}
 \item
-a constexpr function that is named by an expression\iref{basic.def.odr}
+a constexpr function that
+\deflinkx{is named by}{function!named by expression or conversion}{basic.def.odr}
+an expression
 that is potentially constant evaluated, or
 
 \item
diff --git a/source/statements.tex b/source/statements.tex
index d635f1a6..29ee9f0b 100644
--- a/source/statements.tex
+++ b/source/statements.tex
@@ -98,7 +98,7 @@ [stmt.pre]
 The value of a \grammarterm{condition} that is an initialized declaration
 in a statement other than a \keyword{switch} statement is the value of the
 declared variable
-contextually converted to \tcode{bool}\iref{conv}.
+\deflinkx{contextually converted to \tcode{bool}}{conversion!contextual to \tcode{bool}}{conv}.
 If that
 conversion is ill-formed, the program is ill-formed.
 The value of a
@@ -182,7 +182,7 @@ [stmt.expr]
 \end{bnf}
 
 The expression is
-a discarded-value expression\iref{expr.context}.
+a \deflink{discarded-value expression}{expr.context}.
 All
 \indextext{side effects}%
 side effects from an expression statement
@@ -414,10 +414,10 @@ [stmt.switch]
 or the value of the \grammarterm{expression} otherwise.
 The value of the condition shall be of integral type, enumeration type, or class
 type. If of class type, the
-condition is contextually implicitly converted\iref{conv} to
+condition is \deflink{contextually implicitly converted}{conv} to
 an integral or enumeration type.
-If the (possibly converted) type is subject to integral
-promotions\iref{conv.prom}, the condition is converted
+If the (possibly converted) type is subject to \link{integral
+promotions}{conv.prom}, the condition is converted
 to the promoted type.
 Any
 statement within the \keyword{switch} statement can be labeled with one or
@@ -427,7 +427,7 @@ [stmt.switch]
 \keyword{case} constant-expression \terminal{:}
 \end{ncbnf}
 where the \grammarterm{constant-expression} shall be
-a converted constant expression\iref{expr.const} of the
+a converted \link{constant expression}{expr.const} of the
 adjusted type of the switch condition. No two of the case constants in
 the same switch shall have the same value after conversion.
 
@@ -526,7 +526,7 @@ [stmt.iter.general]
 \pnum
 \indextext{scope!\idxgram{iteration-statement}}%
 The substatement in an \grammarterm{iteration-statement} implicitly defines
-a block scope\iref{basic.scope} which is entered and exited each time
+a block \link{scope}{basic.scope} which is entered and exited each time
 through the loop.
 If the substatement in an \grammarterm{iteration-statement} is
 a single statement and not a \grammarterm{compound-statement},
@@ -594,7 +594,7 @@ [stmt.do]
 \indextext{statement!\idxcode{do}}
 
 \pnum
-The expression is contextually converted to \tcode{bool}\iref{conv};
+The expression is \deflinkx{contextually converted to \tcode{bool}}{conversion!contextual to \tcode{bool}}{conv};
 if that conversion is ill-formed, the program is ill-formed.
 
 \pnum
@@ -763,8 +763,8 @@ [stmt.jump.general]
 \indextext{local variable!destruction of}%
 \indextext{scope!destructor and exit from}%
 \begin{note}
-On exit from a scope (however accomplished), objects with automatic storage
-duration\iref{basic.stc.auto} that have been constructed in that scope are destroyed
+On exit from a scope (however accomplished), objects with \link{automatic storage
+duration}{basic.stc.auto} that have been constructed in that scope are destroyed
 in the reverse order of their construction.
 For temporaries, see~\ref{class.temporary}.
 However, the program can be terminated (by calling
@@ -864,7 +864,7 @@ [stmt.return]
 the \tcode{return} statement initializes the
 returned reference or prvalue result object
 of the (explicit or implicit) function call
-by copy-initialization\iref{dcl.init} from the operand.
+by \deflink{copy-initialization}{dcl.init} from the operand.
 \begin{note}
 A constructor or destructor does not have a return type.
 \end{note}
@@ -963,7 +963,7 @@ [stmt.goto]
 The \tcode{goto} statement unconditionally transfers control to the
 statement labeled by the identifier. The identifier shall be a
 \indextext{label}%
-label\iref{stmt.label} located in the current function.
+\link{label}{stmt.label} located in the current function.
 
 \rSec1[stmt.dcl]{Declaration statement}%
 \indextext{statement!declaration}
@@ -1032,8 +1032,8 @@ [stmt.dcl]
 \indextext{initialization!local \tcode{static}}%
 \indextext{initialization!local \tcode{thread_local}}%
 Dynamic initialization of a block variable with
-static storage duration\iref{basic.stc.static} or
-thread storage duration\iref{basic.stc.thread} is performed
+\link{static storage duration}{basic.stc.static} or
+\link{thread storage duration}{basic.stc.thread} is performed
 the first time control passes through its declaration; such a variable is
 considered initialized upon the completion of its initialization. If the
 initialization exits by throwing an exception, the initialization is not
@@ -1076,8 +1076,8 @@ [stmt.ambig]
 \pnum
 There is an ambiguity in the grammar involving
 \grammarterm{expression-statement}{s} and \grammarterm{declaration}{s}: An
-\grammarterm{expression-statement} with a function-style explicit type
-conversion\iref{expr.type.conv} as its leftmost subexpression can be
+\grammarterm{expression-statement} with a \link{function-style explicit type
+conversion}{expr.type.conv} as its leftmost subexpression can be
 indistinguishable from a \grammarterm{declaration} where the first
 \grammarterm{declarator} starts with a \tcode{(}. In those cases the
 \grammarterm{statement} is a \grammarterm{declaration}.
diff --git a/source/declarations.tex b/source/declarations.tex
index f07b1396..643c0676 100644
--- a/source/declarations.tex
+++ b/source/declarations.tex
@@ -417,7 +417,7 @@ [dcl.stc]
 \begin{note}
 A variable declared without a \grammarterm{storage-class-specifier}
 at block scope or declared as a function parameter
-has automatic storage duration by default\iref{basic.stc.auto}.
+has \deflinkx{automatic storage duration}{storage duration!automatic}{basic.stc.auto} by default.
 \end{note}
 
 \pnum
@@ -684,10 +684,10 @@ [dcl.typedef]
 A \grammarterm{simple-template-id} that names a class template specialization
 is a \grammarterm{class-name}\iref{class.name}.
 If a \grammarterm{typedef-name} is used to identify the subject of an
-\grammarterm{elaborated-type-specifier}\iref{dcl.type.elab}, a class
-definition\iref{class}, a constructor
-declaration\iref{class.ctor}, or a destructor
-declaration\iref{class.dtor}, the program is ill-formed.
+\grammarterm{elaborated-type-specifier}\iref{dcl.type.elab}, a \link{class
+definition}{class}, a \link{constructor
+declaration}{class.ctor}, or a \link{destructor
+declaration}{class.dtor}, the program is ill-formed.
 \end{note}
 \begin{example}
 \begin{codeblock}
@@ -1013,7 +1013,7 @@ [dcl.inline]
 is declared in a definition domain,
 it shall be defined in that domain.
 \begin{note}
-A constexpr function\iref{dcl.constexpr} is implicitly inline.
+A \deflinkx{constexpr function}{specifier!\idxcode{constexpr}!function}{dcl.constexpr} is implicitly inline.
 In the global module, a function defined within a class definition
 is implicitly inline\iref{class.mfct,class.friend}.
 \end{note}
@@ -1158,7 +1158,7 @@ [dcl.type.cv]
 some other access path.
 \begin{note}
 Cv-qualifiers are supported by the type system so that they cannot be
-subverted without casting\iref{expr.const.cast}.
+subverted without \link{casting}{expr.const.cast}.
 \end{note}
 
 \pnum
@@ -1540,8 +1540,7 @@ [dcl.type.decltype]
 \item otherwise, \tcode{decltype($E$)} is the type of $E$.
 \end{itemize}
 
-The operand of the \keyword{decltype} specifier is an unevaluated
-operand\iref{term.unevaluated.operand}.
+The operand of the \keyword{decltype} specifier is an \deflink{unevaluated operand}{expr.context}.
 
 \begin{example}
 \begin{codeblock}
@@ -1708,7 +1707,7 @@ [dcl.spec.auto.general]
 If the \grammarterm{init-declarator-list} contains more than one
 \grammarterm{init-declarator}, they shall all form declarations of
 variables. The type of each declared variable is determined
-by placeholder type deduction\iref{dcl.type.auto.deduct},
+by \deflink{placeholder type deduction}{dcl.type.auto.deduct},
 and if the type that replaces the placeholder type is not the
 same in each deduction, the program is ill-formed.
 
@@ -1836,7 +1835,7 @@ [dcl.spec.auto.general]
 be a coroutine\iref{dcl.fct.def.coroutine}.
 
 \pnum
-An explicit instantiation declaration\iref{temp.explicit} does not cause the
+An \link{explicit instantiation declaration}{temp.explicit} does not cause the
 instantiation of an entity declared using a placeholder type, but it also does
 not prevent that entity from being instantiated as needed to determine its
 type.
@@ -1948,7 +1947,7 @@ [dcl.type.auto.deduct]
 a new invented type template parameter \tcode{U} or,
 if the initialization is copy-list-initialization, with
 \tcode{std::initializer_list<U>}. Deduce a value for \tcode{U} using the rules
-of template argument deduction from a function call\iref{temp.deduct.call},
+of \link{template argument deduction from a function call}{temp.deduct.call},
 where \tcode{P} is a
 function template parameter type and
 the corresponding argument is $E$.
@@ -2047,7 +2046,7 @@ [dcl.type.class.deduct]
 in the \grammarterm{new-type-id} or \grammarterm{type-id}
 of a \grammarterm{new-expression}\iref{expr.new},
 as the \grammarterm{simple-type-specifier}
-in an explicit type conversion (functional notation)\iref{expr.type.conv},
+in an \link{explicit type conversion (functional notation)}{expr.type.conv},
 or
 as the \grammarterm{type-specifier} in the \grammarterm{parameter-declaration}
 of a \grammarterm{template-parameter}\iref{temp.param}.
@@ -4148,7 +4147,7 @@ [dcl.fct.default]
 int f(int a, int b = a);            // error: parameter \tcode{a} used as default argument
 typedef int I;
 int g(float I, int b = I(2));       // error: parameter \tcode{I} found
-int h(int a, int b = sizeof(a));    // OK, unevaluated operand\iref{term.unevaluated.operand}
+int h(int a, int b = sizeof(a));    // OK, \deflink{unevaluated operand}{expr.context}
 \end{codeblock}
 \end{example}
 A non-static member shall not appear in a default argument unless it appears as
@@ -5503,15 +5502,15 @@ [dcl.init.ref]
 function\iref{class.conv.fct} returning a reference type.
 \end{footnote}
 (this conversion is selected by enumerating the applicable conversion
-functions\iref{over.match.ref} and choosing the best one through overload
-resolution\iref{over.match}),
+functions\iref{over.match.ref} and choosing the best one through \link{overload
+resolution}{over.match}),
 \end{itemize}
 then the reference binds to the initializer expression lvalue in the
 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\iref{conv.array},
-and function-to-pointer\iref{conv.func} standard
+The usual \link{lvalue-to-rvalue}{conv.lval}, \link{array-to-pointer}{conv.array},
+and \link{function-to-pointer}{conv.func} standard
 conversions are not needed, and therefore are suppressed, when such
 direct bindings to lvalues are done.
 \end{note}
@@ -6828,7 +6827,7 @@ [dcl.struct.bind]
 where \tcode{get} undergoes argument-dependent lookup\iref{basic.lookup.argdep}.
 In either case, \tcode{get<i>} is interpreted as a \grammarterm{template-id}.
 \begin{note}
-Ordinary unqualified lookup\iref{basic.lookup.unqual} is not performed.
+Ordinary \link{unqualified lookup}{basic.lookup.unqual} is not performed.
 \end{note}
 In either case, \exposid{e} is an lvalue if the type of the entity \exposid{e}
 is an lvalue reference and an xvalue otherwise.
@@ -6973,7 +6972,7 @@ [dcl.enum]
 the \grammarterm{enum-specifier} or \grammarterm{opaque-enum-declaration}.
 If the \grammarterm{enum-head-name} of an \grammarterm{opaque-enum-declaration} contains
 a \grammarterm{nested-name-specifier},
-the declaration shall be an explicit specialization\iref{temp.expl.spec}.
+the declaration shall be an \link{explicit specialization}{temp.expl.spec}.
 
 \pnum
 \indextext{constant!enumeration}%
@@ -7056,8 +7055,9 @@ [dcl.enum]
 prior to the closing brace is the underlying
 type
 and the \grammarterm{constant-expression} in the \grammarterm{enumerator-definition}
-shall be a converted constant expression of the underlying
-type\iref{expr.const}.
+shall be a
+\deflinkx{converted constant expression}{expression!converted constant}{expr.const}
+of the underlying type.
 If the underlying
 type is not fixed,
 the type of each enumerator prior to the closing brace is determined as
@@ -7066,8 +7066,9 @@ [dcl.enum]
 \begin{itemize}
 \item If an
 initializer is specified for an enumerator, the
-\grammarterm{constant-expression} shall be an integral constant
-expression\iref{expr.const}. If the expression has
+\grammarterm{constant-expression} shall be an
+\deflinkx{integral constant expression}{expression!integral constant}{expr.const}.
+If the expression has
 unscoped enumeration type, the enumerator has the underlying type of that
 enumeration type, otherwise it has the same type as the expression.
 
@@ -7139,7 +7140,7 @@ [dcl.enum]
 
 \pnum
 The value of an enumerator or an object of an unscoped enumeration type is
-converted to an integer by integral promotion\iref{conv.prom}.
+converted to an integer by \deflinkx{integral promotion}{integral promotion}{conv.prom}.
 \begin{example}
 \begin{codeblock}
 enum color { red, yellow, green=20, blue };
@@ -7403,7 +7404,7 @@ [namespace.def.general]
 Members of an inline namespace can be used in most respects as though they were members
 of the innermost enclosing namespace. Specifically, the inline namespace and its enclosing
 namespace are both added to the set of associated namespaces used in
-argument-dependent lookup\iref{basic.lookup.argdep} whenever one of them is,
+\link{argument-dependent lookup}{basic.lookup.argdep} whenever one of them is,
 and a \grammarterm{using-directive}\iref{namespace.udir} that names the inline
 namespace is implicitly inserted into the enclosing namespace as for an unnamed
 namespace\iref{namespace.unnamed}. Furthermore, each
@@ -8177,7 +8178,7 @@ [dcl.link]
 otherwise identical.
 
 \pnum
-Linkage\iref{basic.link} between \Cpp{} and  non-\Cpp{} code fragments can
+\link{Linkage}{basic.link} between \Cpp{} and  non-\Cpp{} code fragments can
 be achieved using a \grammarterm{linkage-specification}:
 
 \indextext{\idxgram{linkage-specification}}%
@@ -8490,16 +8491,16 @@ [dcl.attr.grammar]
 \pnum
 In an \grammarterm{attribute-list}, an ellipsis may appear only if that
 \grammarterm{attribute}'s specification permits it. An \grammarterm{attribute} followed
-by an ellipsis is a pack expansion\iref{temp.variadic}.
+by an ellipsis is a \deflink{pack expansion}{temp.variadic}.
 An \grammarterm{attribute-specifier} that contains no \grammarterm{attribute}{s} has no
 effect. The order in which the \grammarterm{attribute-token}{s} appear in an
 \grammarterm{attribute-list} is not significant. If a
-keyword\iref{lex.key}
-or an alternative token\iref{lex.digraph} that satisfies the syntactic requirements
+\link{keyword}{lex.key}
+or an \link{alternative token}{lex.digraph} that satisfies the syntactic requirements
 of an \grammarterm{identifier}\iref{lex.name} is
 contained in
-an \grammarterm{attribute-token}, it is considered an identifier. No name
-lookup\iref{basic.lookup} is performed on any of the identifiers contained in an
+an \grammarterm{attribute-token}, it is considered an identifier. No
+\link{name lookup}{basic.lookup} is performed on any of the identifiers contained in an
 \grammarterm{attribute-token}. The \grammarterm{attribute-token} determines additional
 requirements on the \grammarterm{attribute-argument-clause} (if any).
 
@@ -8606,7 +8607,7 @@ [dcl.align]
 \pnum
 An \grammarterm{alignment-specifier} of the form
 \tcode{alignas(} \grammarterm{type-id} \tcode{)} has the same
-effect as \tcode{alignas(\brk{}alignof(} \grammarterm{type-id}~\tcode{))}\iref{expr.alignof}.
+effect as \tcode{alignas(\brk{}\link{alignof}{expr.alignof}(} \grammarterm{type-id}~\tcode{))}.
 
 \pnum
 The alignment requirement of an entity is the strictest nonzero alignment
@@ -8851,7 +8852,7 @@ [dcl.attr.fallthrough]
 
 \pnum
 The \grammarterm{attribute-token} \tcode{fallthrough}
-may be applied to a null statement\iref{stmt.expr};
+may be applied to a \deflinkx{null statement}{statement!null}{stmt.expr};
 \indextext{statement!fallthrough}
 such a statement is a fallthrough statement.
 No \grammarterm{attribute-argument-clause} shall be present.
diff --git a/source/classes.tex b/source/classes.tex
index 0edcc6b7..879881be 100644
--- a/source/classes.tex
+++ b/source/classes.tex
@@ -186,10 +186,10 @@ [class.prop]
 \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,
@@ -532,7 +532,7 @@ [class.mem.general]
 \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
@@ -547,7 +547,7 @@ [class.mem.general]
 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
@@ -562,7 +562,7 @@ [class.mem.general]
 \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
@@ -677,9 +677,9 @@ [class.mem.general]
 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
@@ -765,8 +765,8 @@ [class.mem.general]
 
 \item every member function of class \tcode{T};
 \begin{note}
-This restriction does not apply to constructors, which do not have
-names\iref{class.ctor}
+This restriction does not apply to \link{constructors}{class.ctor},
+which do not have names
 \end{note}%
 
 \item every member of class \tcode{T} that is itself a type;
@@ -782,7 +782,7 @@ [class.mem.general]
 
 \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
@@ -831,7 +831,7 @@ [class.mem.general]
 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};
@@ -2183,7 +2183,7 @@ [class.dtor]
 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}.
@@ -6244,7 +6244,7 @@ [class.copy.elision]
 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/overloading.tex b/source/overloading.tex
index d0698b19..91bd8dab 100644
--- a/source/overloading.tex
+++ b/source/overloading.tex
@@ -69,7 +69,7 @@ [over.match.general]
 contexts within the language:
 \begin{itemize}
 \item
-invocation of a function named in the function call syntax\iref{over.call.func};
+invocation of a function named in the \link{function call syntax}{over.call.func};
 \item
 invocation of a function call operator, a pointer-to-function
 conversion function, a reference-to-pointer-to-function conversion
@@ -83,14 +83,14 @@ [over.match.general]
 of a class object\iref{over.match.ctor};
 \item
 invocation of a user-defined conversion for
-copy-initialization\iref{dcl.init} of a class object\iref{over.match.copy};
+\deflink{copy-initialization}{dcl.init} of a class object\iref{over.match.copy};
 \item
 invocation of a conversion function for initialization of an object of a
 non-class type from an expression of class type\iref{over.match.conv}; and
 \item
 invocation of a conversion function for conversion
 in which a reference\iref{dcl.init.ref}
-will be directly bound\iref{over.match.ref}.
+will be \link{directly bound}{over.match.ref}.
 \end{itemize}
 
 Each of these contexts defines the set of candidate functions and
@@ -108,7 +108,7 @@ [over.match.general]
 viable functions\iref{over.match.viable}.
 \item
 Then the best viable function is selected based on the
-implicit conversion sequences\iref{over.best.ics} needed to
+\link{implicit conversion sequences}{over.best.ics} needed to
 match each argument to the corresponding parameter of each
 viable function.
 \end{itemize}
@@ -119,7 +119,7 @@ [over.match.general]
 Otherwise
 overload resolution fails and the invocation is ill-formed.
 When overload resolution succeeds,
-and the best viable function is not accessible\iref{class.access} in the context
+and the best viable function is not \link{accessible}{class.access} in the context
 in which it is used,
 the program is ill-formed.
 
@@ -233,7 +233,7 @@ [over.match.funcs.general]
 converted to the type of the implicit object parameter.
 \begin{note}
 The fact that such an argument is an rvalue does not
-affect the ranking of implicit conversion sequences\iref{over.ics.rank}.
+affect the \link{ranking}{over.ics.rank} of implicit conversion sequences.
 \end{note}
 
 \pnum
@@ -356,7 +356,7 @@ [over.match.call.general]
 \indextext{overloading!resolution!function call syntax|(}
 
 \pnum
-In a function call\iref{expr.call}
+In a \link{function call}{expr.call}
 \begin{ncsimplebnf}
 postfix-expression \terminal{(} \opt{expression-list} \terminal{)}
 \end{ncsimplebnf}
@@ -919,7 +919,7 @@ [over.match.oper]
 If a built-in candidate is selected by overload resolution, the
 operands of class type are converted to the types of the corresponding parameters
 of the selected operation function, except that the second standard conversion
-sequence of a user-defined conversion sequence\iref{over.ics.user} is not applied.
+sequence of a \link{user-defined conversion sequence}{over.ics.user} is not applied.
 Then the operator is treated as the corresponding
 built-in operator and interpreted according to \ref{expr.compound}.
 \begin{example}
@@ -1002,10 +1002,10 @@ [over.match.ctor]
 \indextext{overloading!resolution!initialization}
 
 \pnum
-When objects of class type are direct-initialized\iref{dcl.init},
+When objects of class type are \deflinkx{direct-initialized}{direct-initialization}{dcl.init},
 copy-initialized from an expression of the same or a
 derived class type\iref{dcl.init},
-or default-initialized\iref{dcl.init},
+or \deflinkx{default-initialized}{default-initialization}{dcl.init},
 overload resolution selects the constructor.
 For direct-initialization or default-initialization
 that is not in the context of copy-initialization, the
@@ -1043,7 +1043,7 @@ [over.match.copy]
 
 \begin{itemize}
 \item
-The converting constructors\iref{class.conv.ctor} of
+The \deflinkx{converting constructors}{constructor!converting}{class.conv.ctor} of
 \tcode{T}
 are candidate functions.
 \item
@@ -1684,7 +1684,7 @@ [over.match.viable]
 \tcode{F}
 to be a viable function, there shall exist for each
 argument an
-implicit conversion sequence\iref{over.best.ics} that
+\deflinkx{implicit conversion sequence}{conversion sequence!implicit}{over.best.ics} that
 converts that argument to the corresponding parameter of
 \tcode{F}.
 If the parameter has reference type, the implicit conversion sequence
@@ -1748,8 +1748,8 @@ [over.match.best.general]
 \end{example}
 or, if not that,
 
-\item the context is an initialization by conversion function for direct
-reference binding\iref{over.match.ref} of a reference to function type, the
+\item the context is an initialization by conversion function for \link{direct
+reference binding}{over.match.ref} of a reference to function type, the
 return type of \tcode{F1} is the same kind of reference (lvalue or rvalue)
 as the reference being initialized, and the return type of \tcode{F2} is not
 \begin{example}
@@ -1865,7 +1865,7 @@ [over.match.best.general]
 and \tcode{F2} is not, or, if not that,
 
 \item
-\tcode{F1} is the copy deduction candidate\iref{over.match.class.deduct}
+\tcode{F1} is the \deflink{copy deduction candidate}{over.match.class.deduct}
 and \tcode{F2} is not, or, if not that,
 
 \item
@@ -2010,7 +2010,7 @@ [over.best.ics.general]
 \begin{note}
 Other properties, such as the lifetime, storage class,
 alignment, accessibility of the argument, whether the argument is a bit-field,
-and whether a function is deleted\iref{dcl.fct.def.delete}, are ignored.
+and whether a function is \link{deleted}{dcl.fct.def.delete}, are ignored.
 So, although an implicit
 conversion sequence can be defined for a given argument-parameter
 pair, the conversion from the argument to the parameter might still
@@ -2023,11 +2023,11 @@ [over.best.ics.general]
 sequence is one of the following forms:
 \begin{itemize}
 \item
-a standard conversion sequence\iref{over.ics.scs},
+a \link{standard conversion sequence}{over.ics.scs},
 \item
-a user-defined conversion sequence\iref{over.ics.user}, or
+a \link{user-defined conversion sequence}{over.ics.user}, or
 \item
-an ellipsis conversion sequence\iref{over.ics.ellipsis}.
+an \link{ellipsis conversion sequence}{over.ics.ellipsis}.
 \end{itemize}
 
 \pnum
@@ -2208,10 +2208,10 @@ [over.ics.scs]
 also has an associated rank (Exact
 Match, Promotion, or Conversion).
 These are used
-to rank standard conversion sequences\iref{over.ics.rank}.
+to \link{rank standard conversion sequences}{over.ics.rank}.
 The rank of a conversion sequence is determined by considering the
-rank of each conversion in the sequence and the rank of any reference
-binding\iref{over.ics.ref}.
+rank of each conversion in the sequence and the rank of any \link{reference
+binding}{over.ics.ref}.
 If any of those has Conversion rank, the
 sequence has Conversion rank; otherwise, if any of those has Promotion rank,
 the sequence has Promotion rank; otherwise, the sequence has Exact
@@ -2248,7 +2248,7 @@ [over.ics.user]
 conversion sequence converts the source type to the type of the
 first parameter of that constructor.
 If the user-defined
-conversion is specified by a conversion function\iref{class.conv.fct}, the
+conversion is specified by a \link{conversion function}{class.conv.fct}, the
 initial standard conversion sequence
 converts the source type to the type of the
 object parameter of that conversion function.
@@ -2288,7 +2288,7 @@ [over.ics.ellipsis]
 \rSec4[over.ics.ref]{Reference binding}
 
 \pnum
-When a parameter of reference type binds directly\iref{dcl.init.ref} to an
+When a parameter of reference type \link{binds directly}{dcl.init.ref} to an
 argument expression, the implicit conversion sequence is the identity conversion,
 unless the argument expression has a type that is a derived class of the parameter
 type, in which case the implicit conversion sequence is a derived-to-base
@@ -2359,7 +2359,7 @@ [over.ics.ref]
 \rSec4[over.ics.list]{List-initialization sequence}
 
 \pnum
-When an argument is an initializer list\iref{dcl.init.list}, it is not an
+When an argument is an initializer list\iref{dcl.init.list}, it is not an % todo
 expression and special rules apply for converting it to a parameter type.
 
 \pnum
@@ -2600,13 +2600,13 @@ [over.ics.rank]
 (as defined in~\ref{over.best.ics})
 \begin{itemize}
 \item
-a standard conversion sequence\iref{over.ics.scs} is a better
+a \link{standard conversion sequence}{over.ics.scs} is a better
 conversion sequence than a user-defined conversion sequence
 or an ellipsis conversion sequence, and
 \item
-a user-defined conversion sequence\iref{over.ics.user} is a
-better conversion sequence than an ellipsis conversion
-sequence\iref{over.ics.ellipsis}.
+a \link{user-defined conversion sequence}{over.ics.user} is a
+better conversion sequence than an \link{ellipsis conversion
+sequence}{over.ics.ellipsis}.
 \end{itemize}
 
 \pnum
@@ -3010,11 +3010,11 @@ [over.over]
 \item
 an object or reference being initialized\iref{dcl.init,dcl.init.ref,dcl.init.list},
 \item
-the left side of an assignment\iref{expr.ass},
+the left side of an \link{assignment}{expr.ass},
 \item
 a parameter of a function\iref{expr.call},
 \item
-a parameter of a user-defined operator\iref{over.oper},
+a parameter of a \link{user-defined operator}{over.oper},
 \item
 the return value of a function, operator function, or conversion\iref{stmt.return},
 \item
@@ -3198,8 +3198,8 @@ [over.oper.general]
 and
 \tcode{[]}
 are formed from more than one token.
-The latter two operators are function call\iref{expr.call}
-and subscripting\iref{expr.sub}.
+The latter two operators are \link{function call}{expr.call}
+and \link{subscripting}{expr.sub}.
 \end{note}
 \indextext{operator!subscripting}%
 \indextext{operator!function call}%
@@ -3300,7 +3300,7 @@ [over.oper.general]
 
 \pnum
 \indextext{argument!overloaded operator and default}%
-An operator function cannot have default arguments\iref{dcl.fct.default},
+An operator function cannot have \link{default arguments}{dcl.fct.default},
 except where explicitly stated below.
 Operator
 functions cannot have more or fewer parameters than the
@@ -3636,7 +3636,7 @@ [over.built]
 In this subclause, the term
 \defn{promoted integral type}
 is used to refer to those cv-unqualified integral types which are preserved by
-integral promotion\iref{conv.prom} (including e.g.
+\link{integral promotion}{conv.prom} (including e.g.
 \tcode{int}
 and
 \tcode{long}
diff --git a/source/templates.tex b/source/templates.tex
index edac0e26..2ef7da3c 100644
--- a/source/templates.tex
+++ b/source/templates.tex
@@ -495,7 +495,7 @@ [temp.param]
 may be specified for any kind of
 \grammarterm{template-parameter}
 (type, non-type, template)
-that is not a template parameter pack\iref{temp.variadic}.
+that is not a \deflink{template parameter pack}{temp.variadic}.
 A default
 \grammarterm{template-argument}
 may be specified in a template declaration.
@@ -619,7 +619,7 @@ [temp.param]
 optional \grammarterm{identifier} or is a
 \grammarterm{parameter-declaration} that declares a
 pack\iref{dcl.fct}, then the \grammarterm{template-parameter}
-is a template parameter pack\iref{temp.variadic}.
+is a \deflink{template parameter pack}{temp.variadic}.
 A template parameter pack that is a \grammarterm{parameter-declaration} whose type
 contains one or more unexpanded packs is a pack expansion. Similarly,
 a template parameter pack that is a \grammarterm{type-parameter} with a
@@ -651,7 +651,7 @@ [temp.param]
 \rSec1[temp.names]{Names of template specializations}
 
 \pnum
-A template specialization\iref{temp.spec} can be referred to by a
+A \link{template specialization}{temp.spec} can be referred to by a
 \grammarterm{template-id}:
 
 \begin{bnf}
@@ -947,8 +947,8 @@ [temp.arg.general]
 shall match the type and form specified for the corresponding
 parameter declared by the template in its
 \grammarterm{template-parameter-list}.
-When the parameter declared by the template is a template
-parameter pack\iref{temp.variadic}, it will correspond to zero or more
+When the parameter declared by the template is a
+\deflink{template parameter pack}{temp.variadic}, it will correspond to zero or more
 \grammarterm{template-argument}{s}.
 \begin{example}
 \begin{codeblock}
@@ -1117,7 +1117,7 @@ [temp.arg.general]
 \pnum
 When a \grammarterm{simple-template-id} does not name a function,
 a default \grammarterm{template-argument} is
-implicitly instantiated\iref{temp.inst}
+\link{implicitly instantiated}{temp.inst}
 when the value of that default argument is needed.
 \begin{example}
 \begin{codeblock}
@@ -1129,7 +1129,7 @@ [temp.arg.general]
 
 \pnum
 A \grammarterm{template-argument} followed by an ellipsis is
-a pack expansion\iref{temp.variadic}.
+a \deflink{pack expansion}{temp.variadic}.
 
 \rSec2[temp.arg.type]{Template type arguments}
 
@@ -1414,8 +1414,8 @@ [temp.arg.template]
 the function template corresponding to \tcode{P}
 is at least as specialized as
 the function template corresponding to \tcode{A}
-according to the partial ordering rules
-for function templates\iref{temp.func.order}.
+according to the \link{partial ordering rules
+for function templates}{temp.func.order}.
 Given an invented class template \tcode{X}
 with the \grammarterm{template-head} of \tcode{A} (including default arguments
 and \grammarterm{requires-clause}, if any):
@@ -1465,14 +1465,14 @@ [temp.constr.constr.general]
 The operands of a logical operation are constraints.
 There are three different kinds of constraints:
 \begin{itemize}
-\item conjunctions\iref{temp.constr.op},
-\item disjunctions\iref{temp.constr.op}, and
-\item atomic constraints\iref{temp.constr.atomic}.
+\item \deflinkx{conjunctions}{conjunction}{temp.constr.op},
+\item \deflinkx{disjunctions}{disjunction}{temp.constr.op}, and
+\item \deflinkx{atomic constraints}{constraint!atomic}{temp.constr.atomic}.
 \end{itemize}
 
 \pnum
 In order for a constrained template to be instantiated\iref{temp.spec},
-its associated constraints\iref{temp.constr.decl}
+its \deflink{associated constraints}{temp.constr.decl}
 shall be satisfied as described in the following subclauses.
 \begin{note}
 Forming the name of a specialization of
@@ -1480,7 +1480,7 @@ [temp.constr.constr.general]
 a variable template, or
 an alias template\iref{temp.names}
 requires the satisfaction of its constraints.
-Overload resolution\iref{over.match.viable}
+\link{Overload resolution}{over.match.viable}
 requires the satisfaction of constraints
 on functions and function templates.
 \end{note}
@@ -1537,7 +1537,7 @@ [temp.constr.op]
 
 f('a'); // OK, calls \tcode{f(int)}
 \end{codeblock}
-In the satisfaction of the associated constraints\iref{temp.constr.decl}
+In the satisfaction of the \deflink{associated constraints}{temp.constr.decl}
 of \tcode{f}, the constraint \tcode{sizeof(char) > 1} is not satisfied;
 the second operand is not checked for satisfaction.
 \end{example}
@@ -1595,9 +1595,9 @@ [temp.constr.atomic]
 unsubstituted template parameters of the constrained entity),
 called the \defn{parameter mapping}\iref{temp.constr.decl}.
 \begin{note}
-Atomic constraints are formed by constraint normalization\iref{temp.constr.normal}.
-\tcode{E} is never a logical \logop{and} expression\iref{expr.log.and}
-nor a logical \logop{or} expression\iref{expr.log.or}.
+Atomic constraints are formed by \deflinkx{constraint normalization}{constraint!normalization}{temp.constr.normal}.
+\tcode{E} is never a \link{logical \logop{and} expression}{expr.log.and}
+nor a \link{logical \logop{or} expression}{expr.log.or}.
 \end{note}
 
 \pnum
@@ -1673,7 +1673,7 @@ [temp.constr.atomic]
 first substituted into its expression.
 If substitution results in an invalid type or expression,
 the constraint is not satisfied.
-Otherwise, the lvalue-to-rvalue conversion\iref{conv.lval}
+Otherwise, the \link{lvalue-to-rvalue conversion}{conv.lval}
 is performed if necessary,
 and \tcode{E} shall be a constant expression of type \tcode{bool}.
 The constraint is satisfied if and only if evaluation of \tcode{E}
@@ -1731,11 +1731,11 @@ [temp.constr.decl]
 the declaration has no associated constraints.
 
 \item Otherwise, if there is a single introduced \grammarterm{constraint-expression},
-the associated constraints are the normal form\iref{temp.constr.normal}
+the associated constraints are the \deflinkx{normal form}{normal form!constraint}{temp.constr.normal}
 of that expression.
 
-\item Otherwise, the associated constraints are the normal form of a logical
-\logop{and} expression\iref{expr.log.and} whose operands are in the
+\item Otherwise, the associated constraints are the normal form of a \link{logical
+\logop{and} expression}{expr.log.and} whose operands are in the
 following order:
 \begin{itemize}
 \item
@@ -1832,7 +1832,7 @@ [temp.constr.normal]
 
 \pnum
 The \defnx{normal form}{normal form!constraint} of an \grammarterm{expression} \tcode{E} is
-a constraint\iref{temp.constr.constr} that is defined as follows:
+a \deflink{constraint}{temp.constr.constr} that is defined as follows:
 %
 \begin{itemize}
 \item
@@ -1841,7 +1841,7 @@ [temp.constr.normal]
 
 \item
 The normal form of an expression \tcode{E1 || E2} is
-the disjunction\iref{temp.constr.op} of
+the \deflink{disjunction}{temp.constr.op} of
 the normal forms of \tcode{E1} and \tcode{E2}.
 
 \item
@@ -1961,7 +1961,7 @@ [temp.constr.order]
 \end{itemize}
 %
 \begin{example}
-Let $A$ and $B$ be atomic constraints\iref{temp.constr.atomic}.
+Let $A$ and $B$ be \deflinkx{atomic constraints}{constraint!atomic}{temp.constr.atomic}.
 %
 The constraint $A \land B$ subsumes $A$, but $A$ does not subsume $A \land B$.
 %
@@ -2134,7 +2134,7 @@ [temp.type]
 \end{example}
 
 \pnum
-If an expression $e$ is type-dependent\iref{temp.dep.expr},
+If an expression $e$ is \link{type-dependent}{temp.dep.expr},
 \tcode{decltype($e$)}
 denotes a unique dependent type. Two such \grammarterm{decltype-specifier}{s}
 refer to the same type only if their \grammarterm{expression}{s} are
@@ -2191,8 +2191,8 @@ [temp.decls.general]
 \grammarterm{requires-clause}{s},
 or
 \grammarterm{noexcept-specifier}{s}.
-For the purpose of instantiation, the substatements of a constexpr if
-statement\iref{stmt.if} are considered definitions.
+For the purpose of instantiation, the substatements of a
+\deflink{constexpr if}{stmt.if} statement are considered definitions.
 
 \pnum
 Because an \grammarterm{alias-declaration} cannot declare a
@@ -2544,7 +2544,7 @@ [temp.mem]
 
 \pnum
 A local class of non-closure type shall not have member templates.
-Access control rules\iref{class.access}
+\link{Access control rules}{class.access}
 apply to member template names.
 A destructor shall not be a member
 template.
@@ -2737,7 +2737,7 @@ [temp.variadic]
 \item In a \grammarterm{capture-list}\iref{expr.prim.lambda.capture}; the pattern is
 the \grammarterm{capture} without the ellipsis.
 
-\item In a \tcode{sizeof...} expression\iref{expr.sizeof}; the pattern is an
+\item In a \link{\tcode{sizeof...} expression}{expr.sizeof}; the pattern is an
 \grammarterm{identifier}.
 
 \item In a \grammarterm{fold-expression}\iref{expr.prim.fold};
@@ -3324,9 +3324,9 @@ [temp.spec.partial.match]
 \pnum
 A partial specialization matches a given actual template argument
 list if the template arguments of the partial specialization can be
-deduced from the actual template argument list\iref{temp.deduct},
-and the deduced template arguments satisfy the associated constraints
-of the partial specialization, if any\iref{temp.constr.decl}.
+\link{deduced}{temp.deduct} from the actual template argument list,
+and the deduced template arguments satisfy the \deflink{associated constraints}{temp.constr.decl}
+of the partial specialization, if any.
 \begin{example}
 \begin{codeblock}
 template<class T1, class T2, int I> class A             { };    // \#1
@@ -3388,14 +3388,14 @@ [temp.spec.partial.order]
 For two partial specializations,
 the first is \defn{more specialized} than the second if, given the following
 rewrite to two function templates, the first function template is more
-specialized than the second according to the ordering rules for function
-templates\iref{temp.func.order}:
+specialized than the second according to the \link{ordering rules for function
+templates}{temp.func.order}:
 
 \begin{itemize}
 \item
 Each of the two
 function templates has the same template parameters
-and associated constraints\iref{temp.constr.decl}
+and \deflink{associated constraints}{temp.constr.decl}
 as the corresponding partial specialization.
 \item
 Each function template
@@ -3601,8 +3601,8 @@ [temp.over.link]
 \end{example}
 
 \pnum
-Such specializations are distinct functions and do not violate the one-definition
-rule\iref{basic.def.odr}.
+Such specializations are distinct functions and do not violate the
+\link{one-definition rule}{basic.def.odr}.
 
 \pnum
 The signature of a function template
@@ -3653,7 +3653,7 @@ [temp.over.link]
 Two expressions involving template parameters are considered
 \defnx{equivalent}{equivalent!expressions}
 if two function definitions containing the expressions would satisfy
-the one-definition rule\iref{basic.def.odr}, except that the tokens used
+the \link{one-definition rule}{basic.def.odr}, except that the tokens used
 to name the template parameters may differ as long as a token used to
 name a template parameter in one expression is replaced by another token
 that names the same template parameter in the other expression.
@@ -3819,8 +3819,8 @@ [temp.func.order]
 specialization
 is selected to match a placement operator new\iref{basic.stc.dynamic.deallocation,expr.new};
 \item
-when a friend function declaration\iref{temp.friend}, an
-explicit instantiation\iref{temp.explicit} or an explicit specialization\iref{temp.expl.spec} refers to
+when a \link{friend function declaration}{temp.friend}, an
+\link{explicit instantiation}{temp.explicit} or an \link{explicit specialization}{temp.expl.spec} refers to
 a function template specialization.
 \end{itemize}
 
@@ -3838,7 +3838,8 @@ [temp.func.order]
 
 \pnum
 To produce the transformed template, for each type, non-type, or template
-template parameter (including template parameter packs\iref{temp.variadic}
+template parameter (including
+\deflinkx{template parameter packs}{template parameter pack}{temp.variadic}
 thereof) synthesize a unique type, value, or class template
 respectively and substitute it for each occurrence of that parameter
 in the function type of the template.
@@ -4188,7 +4189,7 @@ [temp.concept]
 shall inhabit a namespace scope\iref{basic.scope.namespace}.
 
 \pnum
-A concept shall not have associated constraints\iref{temp.constr.decl}.
+A concept shall not have \deflink{associated constraints}{temp.constr.decl}.
 
 \pnum
 A concept is not instantiated\iref{temp.spec}.
@@ -4447,7 +4448,7 @@ [temp.res.general]
 no valid specialization,
 ignoring \grammarterm{static_assert-declaration}{s} that fail,
 can be generated for a template
-or a substatement of a constexpr if statement\iref{stmt.if} within a template
+or a substatement of a \deflink{constexpr if}{stmt.if} statement within a template
 and the template is not instantiated, or
 \item
 any \grammarterm{constraint-expression} in the program, introduced or otherwise,
@@ -4484,7 +4485,7 @@ [temp.res.general]
 \item an instantiation uses a default argument or default template argument
 that had not been defined at the point at which the template was defined, or
 
-\item constant expression evaluation\iref{expr.const} within the template
+\item \link{constant expression evaluation}{expr.const} within the template
 instantiation uses
   \begin{itemize}
   \item the value of a const object of integral or unscoped enumeration type or
@@ -4739,7 +4740,7 @@ [temp.dep.general]
 or \grammarterm{braced-init-list}{s}
 in the
 \grammarterm{expression-list}
-is type-dependent\iref{temp.dep.expr}, or
+is \link{type-dependent}{temp.dep.expr}, or
 \item
 the \grammarterm{unqualified-id}
 is a \grammarterm{template-id} in which any of the template arguments depends
@@ -4799,7 +4800,7 @@ [temp.dep.type]
 \item
 in the definition of a class template, a nested class of a class template,
 a member of a class template, or a member of a nested class of a class template,
-the injected-class-name\iref{class.pre} of the class template or nested class,
+the \deflink{injected-class-name}{class.pre} of the class template or nested class,
 \item
 in the definition of a primary class template
 or a member of a primary class template, the name of the
@@ -5035,7 +5036,7 @@ [temp.dep.type]
 \end{footnote}
 or
 \item denoted by \tcode{decltype(}\grammarterm{expression}{}\tcode{)},
-where \grammarterm{expression} is type-dependent\iref{temp.dep.expr}.
+where \grammarterm{expression} is \link{type-dependent}{temp.dep.expr}.
 \end{itemize}
 
 \pnum
@@ -5069,7 +5070,7 @@ [temp.dep.expr]
 associated by name lookup with
 a non-type \grammarterm{template-parameter}
 declared with a type
-that contains a placeholder type\iref{dcl.spec.auto},
+that contains a \deflinkx{placeholder type}{type!placeholder}{dcl.spec.auto},
 \item
 associated by name lookup with
 a variable declared with a type that contains a placeholder type\iref{dcl.spec.auto}
@@ -5147,7 +5148,7 @@ [temp.dep.expr]
 \end{note}
 
 \pnum
-A class member access expression\iref{expr.ref} is
+A \link{class member access expression}{expr.ref} is
 type-dependent if
 the terminal name of its \grammarterm{id-expression}, if any, is dependent or
 the expression refers to a member of the current instantiation and
@@ -5262,7 +5263,7 @@ [temp.dep.constexpr]
 instantiation is value-dependent.
 An expression of the form \tcode{\&}\grammarterm{cast-expression}
 is also value-dependent if evaluating \grammarterm{cast-expression}
-as a core constant expression\iref{expr.const} succeeds and
+as a \deflinkx{core constant expression}{expression!core constant}{expr.const} succeeds and
 the result of the evaluation refers to a templated entity
 that is an object with static or thread storage duration or a member function.
 
@@ -5382,7 +5383,7 @@ [temp.point]
 A specialization for any template may have points of instantiation in multiple
 translation units.
 If two different points of instantiation give a template specialization
-different meanings according to the one-definition rule\iref{basic.def.odr},
+different meanings according to the \link{one-definition rule}{basic.def.odr},
 the program is ill-formed, no diagnostic required.
 
 \rSec3[temp.dep.candidate]{Candidate functions}
@@ -5687,7 +5688,7 @@ [temp.spec.general]
 
 \pnum
 If a function declaration acquired its function type through
-a dependent type\iref{temp.dep.type} without using the syntactic form of
+a \link{dependent type}{temp.dep.type} without using the syntactic form of
 a function declarator, the program is ill-formed.
 \begin{example}
 \begin{codeblock}
@@ -5768,7 +5769,7 @@ [temp.inst]
 \end{example}
 \begin{note}
 Within a template declaration,
-a local class\iref{class.local} or enumeration and the members of
+a \link{local class}{class.local} or enumeration and the members of
 a local class are never considered to be entities that can be separately
 instantiated (this includes their default arguments,
 \grammarterm{noexcept-specifier}{s}, and non-static data member
@@ -5946,7 +5947,7 @@ [temp.inst]
 \end{example}
 
 \pnum
-If the function selected by overload resolution\iref{over.match}
+If the function selected by \link{overload resolution}{over.match}
 can be determined without instantiating a class template definition,
 it is unspecified whether that instantiation actually takes place.
 \begin{example}
@@ -6299,7 +6300,7 @@ [temp.explicit]
 and an explicit instantiation definition in the same translation unit, the
 definition shall follow the declaration. An entity that is the subject of an
 explicit instantiation declaration and that is also used
-in a way that would otherwise cause an implicit instantiation\iref{temp.inst}
+in a way that would otherwise cause an \link{implicit instantiation}{temp.inst}
 in the translation unit
 shall be the subject of an explicit instantiation definition somewhere in the
 program; otherwise the program is ill-formed, no diagnostic required.
@@ -7371,7 +7372,7 @@ [temp.deduct.general]
 In the following example,
 assuming a \tcode{signed char}
 cannot represent the value 1000,
-a narrowing conversion\iref{dcl.init.list}
+a \deflinkx{narrowing conversion}{conversion!narrowing}{dcl.init.list}
 would be required
 to convert the \grammarterm{template-argument}
 of type \tcode{int} to \tcode{signed char},
@@ -7480,8 +7481,8 @@ [temp.deduct.call]
 \item
 If
 \tcode{A}
-is an array type, the pointer type produced by the array-to-pointer
-standard conversion\iref{conv.array} is used in place of
+is an array type, the pointer type produced by the \link{array-to-pointer
+standard conversion}{conv.array} is used in place of
 \tcode{A}
 for type deduction;
 otherwise,
@@ -7489,7 +7490,7 @@ [temp.deduct.call]
 If
 \tcode{A}
 is a function type, the pointer type produced by the
-function-to-pointer standard conversion\iref{conv.func} is used in place
+\link{function-to-pointer standard conversion}{conv.func} is used in place
 of
 \tcode{A}
 for type
@@ -7585,8 +7586,8 @@ [temp.deduct.call]
 can be another pointer or pointer-to-member type that can be converted
 to the deduced
 \tcode{A}
-via a function pointer conversion\iref{conv.fctptr} and/or
-qualification conversion\iref{conv.qual}.
+via a \link{function pointer conversion}{conv.fctptr} and/or
+\link{qualification conversion}{conv.qual}.
 
 \item
 If
@@ -7702,7 +7703,7 @@ [temp.deduct.funcaddr]
 
 \pnum
 Template arguments can be deduced from the type specified when taking
-the address of an overload set\iref{over.over}.
+the address of an \link{overload set}{over.over}.
 If there is a target,
 the function template's function type and the target type
 are used as the types of
@@ -7714,7 +7715,7 @@ [temp.deduct.funcaddr]
 Otherwise, deduction is performed with empty sets of types \tcode{P} and \tcode{A}.
 
 \pnum
-A placeholder type\iref{dcl.spec.auto} in the return type of a
+A \deflinkx{placeholder type}{type!placeholder}{dcl.spec.auto} in the return type of a
 function template is a non-deduced context. If template argument
 deduction succeeds for such a function, the return type is determined
 from instantiation of the function body.
@@ -7749,7 +7750,7 @@ [temp.deduct.conv]
 If
 \tcode{P}
 is an array type, the pointer type produced by the
-array-to-pointer standard conversion\iref{conv.array} is used in place of
+\link{array-to-pointer standard conversion}{conv.array} is used in place of
 \tcode{P}
 for type
 deduction; otherwise,
@@ -7757,7 +7758,7 @@ [temp.deduct.conv]
 If
 \tcode{P}
 is a function type, the pointer type produced by the
-function-to-pointer standard conversion\iref{conv.func} is used in place of
+\link{function-to-pointer standard conversion}{conv.func} is used in place of
 \tcode{P}
 for
 type deduction; otherwise,
@@ -7848,7 +7849,7 @@ [temp.deduct.partial]
 In the context of a call to a conversion function, the return types of
 the conversion function templates are used.
 \item
-In other contexts\iref{temp.func.order} the function template's function
+In \link{other contexts}{temp.func.order} the function template's function
 type is used.
 \end{itemize}
 
@@ -8355,7 +8356,7 @@ [temp.deduct.type]
 template argument list of \tcode{A}. Each comparison deduces
 template arguments for subsequent positions in the template parameter
 packs expanded by $\texttt{P}_i$.
-During partial ordering\iref{temp.deduct.partial}, if $\texttt{A}_i$ was
+During \link{partial ordering}{temp.deduct.partial}, if $\texttt{A}_i$ was
 originally a pack expansion:
 \begin{itemize}
 \item if \tcode{P} does not contain a template argument corresponding to
@@ -8418,7 +8419,7 @@ [temp.deduct.type]
 of \tcode{A}. Each comparison deduces template arguments for
 subsequent positions in the template parameter packs expanded by the
 function parameter pack.
-During partial ordering\iref{temp.deduct.partial}, if $\texttt{A}_i$ was
+During \link{partial ordering}{temp.deduct.partial}, if $\texttt{A}_i$ was
 originally a function parameter pack:
 \begin{itemize}
 \item if \tcode{P} does not contain a function parameter type corresponding to
@@ -8715,8 +8716,8 @@ [temp.deduct.decl]
 In a declaration whose \grammarterm{declarator-id} refers to a specialization
 of a function template, template argument deduction is performed to identify
 the specialization to which the declaration refers. Specifically, this is done
-for explicit instantiations\iref{temp.explicit}, explicit specializations\iref{temp.expl.spec},
-and certain friend declarations\iref{temp.friend}. This is also done to
+for \link{explicit instantiations}{temp.explicit}, \link{explicit specializations}{temp.expl.spec},
+and certain \link{friend declarations}{temp.friend}. This is also done to
 determine whether a deallocation function template specialization matches a placement
 \tcode{operator new}\iref{basic.stc.dynamic.deallocation,expr.new}.
 In all these cases, \tcode{P} is the type of the function template being considered
diff --git a/source/exceptions.tex b/source/exceptions.tex
index f7ce5ae4..eafe88e1 100644
--- a/source/exceptions.tex
+++ b/source/exceptions.tex
@@ -184,7 +184,7 @@ [except.pre]
 
 \pnum
 In this Clause, ``before'' and ``after'' refer to the
-``sequenced before'' relation\iref{intro.execution}.
+\deflinkx{``sequenced before''}{sequenced before}{intro.execution} relation.
 
 \rSec1[except.throw]{Throwing an exception}%
 \indextext{exception handling!throwing}%
@@ -284,7 +284,7 @@ [except.throw]
 declared in the \grammarterm{exception-declaration} in the handler;
 
 \item
-when an object of type \tcode{std::exception_ptr}\iref{propagation}
+when an object of type \libglobalrefx{std::exception_ptr}{exception_ptr}
 that refers to the exception object is destroyed,
 before the destructor of \tcode{std::exception_ptr} returns.
 \end{itemize}
@@ -292,7 +292,7 @@ [except.throw]
 Among all points of potential destruction for the exception object,
 there is an unspecified last one
 where the exception object is destroyed.
-All other points happen before that last one\iref{intro.races}.
+All other points \deflinkx{happen before}{happens before}{intro.races} that last one.
 \begin{note}
 No other thread synchronization is implied in exception handling.
 \end{note}
@@ -319,7 +319,7 @@ [except.throw]
 \indextext{exception handling!rethrow}%
 \indextext{rethrow|see{exception handling, rethrow}}%
 An exception is considered caught when a handler for that exception
-becomes active\iref{except.handle}.
+becomes \deflinkx{active}{exception handling!handler!active}{except.handle}.
 \begin{note}
 An exception can have active handlers and still be considered uncaught if
 it is rethrown.
@@ -329,9 +329,9 @@ [except.throw]
 \indextext{exception handling!terminate called@\tcode{terminate} called}%
 \indextext{\idxcode{terminate}!called}%
 If the exception handling mechanism
-handling an uncaught exception\iref{except.uncaught}
+handling an \link{uncaught exception}{except.uncaught}
 directly invokes a function that exits via an
-exception, the function \tcode{std::terminate} is invoked\iref{except.terminate}.
+exception, the function \link{\tcode{std::terminate}}{except.terminate} is invoked.
 \begin{example}
 \begin{codeblock}
 struct C {
@@ -467,7 +467,7 @@ [except.ctor]
 \pnum
 \begin{note}
 If the object was allocated by a \grammarterm{new-expression}\iref{expr.new},
-the matching deallocation function\iref{basic.stc.dynamic.deallocation},
+the matching \link{deallocation function}{basic.stc.dynamic.deallocation},
 if any, is called to free the storage occupied by the object.
 \end{note}
 
@@ -532,12 +532,12 @@ [except.handle]
 \begin{itemize}
 
 \item%
-a standard pointer conversion\iref{conv.ptr} not involving conversions
+a standard \link{pointer conversion}{conv.ptr} not involving conversions
 to pointers to private or protected or ambiguous classes
 \item%
-a function pointer conversion\iref{conv.fctptr}
+a \link{function pointer conversion}{conv.fctptr}
 \item%
-a qualification conversion\iref{conv.qual}, or
+a \link{qualification conversion}{conv.qual}, or
 
 \end{itemize}
 
@@ -651,7 +651,7 @@ [except.handle]
 constructors of objects associated with non-block variables with static storage duration are not caught by a
 \grammarterm{function-try-block}
 on
-the \tcode{main} function\iref{basic.start.main}.
+the \link{\tcode{main} function}{basic.start.main}.
 Exceptions thrown in destructors of objects with thread storage duration or in constructors of objects associated with non-block variables with thread storage duration are not caught by a
 \grammarterm{function-try-block}
 on the initial function of the thread.
@@ -720,7 +720,7 @@ [except.spec]
 The exception specification is either defined implicitly,
 or defined explicitly
 by using a \grammarterm{noexcept-specifier}
-as a suffix of a function declarator\iref{dcl.fct}.
+as a suffix of a \link{function declarator}{dcl.fct}.
 
 \begin{bnf}
 \nontermdef{noexcept-specifier}\br
@@ -760,7 +760,7 @@ [except.spec]
 is as specified below
 and no other declaration for that function
 shall have a \grammarterm{noexcept-specifier}.
-In an explicit instantiation\iref{temp.explicit}
+In an \link{explicit instantiation}{temp.explicit}
 a \grammarterm{noexcept-specifier} may be specified,
 but is not required.
 If a \grammarterm{noexcept-specifier} is specified
@@ -836,7 +836,7 @@ [except.spec]
 \defnx{potentially-throwing}{potentially-throwing!expression} if
 \begin{itemize}
 \item
-$E$ is a function call\iref{expr.call}
+$E$ is a \link{function call}{expr.call}
 whose \grammarterm{postfix-expression}
 has a function type,
 or a pointer-to-function type,
@@ -847,7 +847,7 @@ [except.spec]
 (such as an overloaded operator,
 an allocation function in a \grammarterm{new-expression},
 a constructor for a function argument,
-or a destructor if $E$ is a full-expression\iref{intro.execution})
+or a destructor if $E$ is a \deflink{full-expression}{intro.execution})
 that has a potentially-throwing exception specification,
 or
 \item
@@ -864,7 +864,7 @@ [except.spec]
 polymorphic class type\iref{expr.typeid},
 or
 \item
-any of the immediate subexpressions\iref{intro.execution}
+any of the \deflinkx{immediate subexpressions}{immediate subexpression}{intro.execution}
 of $E$ is potentially-throwing.
 \end{itemize}
 
@@ -917,7 +917,7 @@ [except.spec]
 in the implicit definition is potentially-throwing.
 
 \pnum
-A deallocation function\iref{basic.stc.dynamic.deallocation}
+A \link{deallocation function}{basic.stc.dynamic.deallocation}
 with no explicit \grammarterm{noexcept-specifier}
 has a non-throwing exception specification.
 
@@ -1005,8 +1005,8 @@ [except.special.general]
 is used by the exception
 handling mechanism for coping with errors related to the exception handling
 mechanism itself. The function
-\tcode{std::current_exception()}\iref{propagation} and the class
-\tcode{std::nested_exception}\iref{except.nested} can be used by a program to
+\link{\tcode{std::current_exception()}}{propagation} and the class
+\link{\tcode{std::nested_exception}}{except.nested} can be used by a program to
 capture the currently handled exception.
 
 \rSec2[except.terminate]{The \tcode{std::terminate} function}
@@ -1031,12 +1031,12 @@ [except.terminate]
 \item%
 when the exception handling mechanism cannot find a handler for a thrown exception\iref{except.handle}, or
 
-\item when the search for a handler\iref{except.handle} encounters the
+\item when the search for a \link{handler}{except.handle} encounters the
 outermost block of a function
-with a non-throwing exception specification\iref{except.spec}, or
+with a non-throwing \link{exception specification}{except.spec}, or
 
 \item%
-when the destruction of an object during stack unwinding\iref{except.ctor}
+when the destruction of an object during \deflink{stack unwinding}{except.ctor}
 terminates by throwing an exception, or
 
 \item%
@@ -1115,7 +1115,7 @@ [except.uncaught]
 
 \pnum
 An exception is considered uncaught
-after completing the initialization of the exception object\iref{except.throw}
+after completing the initialization of the \deflinkx{exception object}{exception handling!exception object}{except.throw}
 until completing the activation of a handler for the exception\iref{except.handle}.
 \begin{note}
 As a consequence, an exception is considered uncaught
diff --git a/source/preprocessor.tex b/source/preprocessor.tex
index 0093ee7c..736cf97b 100644
--- a/source/preprocessor.tex
+++ b/source/preprocessor.tex
@@ -416,7 +416,7 @@ [cpp.cond]
 Each preprocessing token that remains (in the list of preprocessing tokens that
 will become the controlling expression)
 after all macro replacements have occurred
-shall be in the lexical form of a token\iref{lex.token}.
+shall be in the lexical form of a \link{token}{lex.token}.
 
 \pnum
 Preprocessing directives of the forms
@@ -462,8 +462,8 @@ [cpp.cond]
 \tcode{0},
 and then each preprocessing token is converted into a token.
 \begin{note}
-An alternative
-token\iref{lex.digraph} is not an identifier,
+An \link{alternative
+token}{lex.digraph} is not an identifier,
 even when its spelling consists entirely of letters and underscores.
 Therefore it is not subject to this replacement.
 \end{note}
@@ -481,8 +481,8 @@ [cpp.cond]
 implementation where \tcode{std::numeric_limits<int>::max()} is \tcode{0x7FFF}
 and \tcode{std::numeric_limits<unsigned int>::max()} is \tcode{0xFFFF},
 the integer literal \tcode{0x8000} is signed and positive within a \tcode{\#if}
-expression even though it is unsigned in translation phase
-7\iref{lex.phases}.
+expression even though it is unsigned in \link{translation phase
+7}{lex.phases}.
 \end{note}
 This includes interpreting \grammarterm{character-literal}s
 according to the rules in \ref{lex.ccon}.
@@ -1576,7 +1576,7 @@ [cpp.line]
 \defn{line number}
 of the current source line is one greater than
 the number of new-line characters read or introduced
-in translation phase 1\iref{lex.phases}
+in \link{translation phase 1}{lex.phases}
 while processing the source file to the current token.
 
 \pnum
@@ -1906,7 +1906,7 @@ [cpp.predefined]
 \indextext{__stdcpp_threads__@\mname{STDCPP_THREADS}}%
 \mname{STDCPP_THREADS}\\
 Defined, and has the value integer literal 1, if and only if a program
-can have more than one thread of execution\iref{intro.multithread}.
+can have more than one \link{thread of execution}{intro.multithread}.
 
 \end{description}
 
diff --git a/source/lib-intro.tex b/source/lib-intro.tex
index f5039472..0670a00e 100644
--- a/source/lib-intro.tex
+++ b/source/lib-intro.tex
@@ -92,7 +92,7 @@ [library.general]
 to a subset of the most widely used algorithms and data structures.
 
 \pnum
-The numerics library\iref{numerics} provides
+The \link{numerics library}{numerics} provides
 numeric algorithms and complex number components that extend support for numeric processing.
 The
 \tcode{valarray}
@@ -118,7 +118,7 @@ [library.general]
 strings, locales, and iterators.
 
 \pnum
-The regular expressions library\iref{re} provides regular expression matching and searching.
+The \link{regular expressions library}{re} provides regular expression matching and searching.
 
 \pnum
 The concurrency support library\iref{thread} provides components to create
@@ -475,8 +475,8 @@ [conventions.general]
 Subclause \ref{conventions} describes several editorial conventions used to describe the contents
 of the \Cpp{} standard library.
 These conventions are for describing
-implementation-defined types\iref{type.descriptions},
-and member functions\iref{functions.within.classes}.
+\link{implementation-defined types}{type.descriptions},
+and \link{member functions}{functions.within.classes}.
 
 \rSec3[expos.only.entity]{Exposition-only entities, etc.}
 
@@ -589,7 +589,7 @@ [bitmask.types]
 Each bitmask type can be implemented as an
 enumerated type that overloads certain operators, as an integer type,
 or as a
-\tcode{bitset}\iref{template.bitset}.
+\link{\tcode{bitset}}{template.bitset}.
 \indextext{type!enumerated}%
 
 \pnum
@@ -715,7 +715,7 @@ [character.seq.general]
 \item
 A
 \defn{character sequence}
-is an array object\iref{dcl.array} \tcode{\placeholdernc{A}} that
+is an \link{array object}{dcl.array} \tcode{\placeholdernc{A}} that
 can be declared as
 \tcode{\placeholdernc{T\;A}[\placeholder{N}]},
 where \tcode{\placeholder{T}} is any of the types
@@ -865,7 +865,7 @@ [objects.within.classes]
 \pnum
 \ref{\firstlibchapter} through \ref{\lastlibchapter} and
 \ref{depr} do not specify the representation of classes, and intentionally
-omit specification of class members\iref{class.mem}. An implementation may
+omit specification of \link{class members}{class.mem}. An implementation may
 define static or non-static class members, or both, as needed to implement the
 semantics of the member functions specified in \ref{\firstlibchapter}
 through \ref{\lastlibchapter} and \ref{depr}.
@@ -1212,10 +1212,10 @@ [headers]
 Except as noted in \ref{library} through \ref{\lastlibchapter}
 and \ref{depr}, the contents of each header \tcode{c\placeholder{name}} is
 the same as that of the corresponding header \tcode{\placeholder{name}.h} as
-specified in the C standard library\iref{intro.refs}.
+specified in the \deflinkx{C standard library}{C!standard library}{intro.refs}.
 In the \Cpp{} standard library, however, the
 declarations (except for names which are defined as macros in C) are within
-namespace scope\iref{basic.scope.namespace} of the namespace \tcode{std}.
+\link{namespace scope}{basic.scope.namespace} of the namespace \tcode{std}.
 It is unspecified whether these names (including any overloads added in
 \ref{\firstlibchapter} through \ref{\lastlibchapter} and \ref{depr})
 are first declared within the global namespace scope
@@ -1478,8 +1478,8 @@ [using.overview]
 \pnum
 Subclause \ref{using} describes how a \Cpp{} program gains access to the facilities of the
 \Cpp{} standard library. \ref{using.headers} describes effects during translation
-phase 4, while~\ref{using.linkage} describes effects during phase
-8\iref{lex.phases}.
+phase 4, while~\ref{using.linkage} describes effects during \link{phase
+8}{lex.phases}.
 
 \rSec3[using.headers]{Headers}
 
@@ -1522,7 +1522,7 @@ [using.headers]
 \rSec3[using.linkage]{Linkage}
 
 \pnum
-Entities in the \Cpp{} standard library have external linkage\iref{basic.link}.
+Entities in the \Cpp{} standard library have \link{external linkage}{basic.link}.
 Unless otherwise specified, objects and functions have the default
 \tcode{extern "C++"}
 linkage\iref{dcl.link}.
@@ -1557,8 +1557,8 @@ [using.linkage]
 \indextext{startup!program}%
 \pnum
 See also
-replacement functions\iref{replacement.functions},
-runtime changes\iref{handler.functions}.
+\link{replacement functions}{replacement.functions},
+\link{runtime changes}{handler.functions}.
 
 \rSec2[utility.requirements]{Requirements on types and expressions}
 
@@ -1606,7 +1606,7 @@ [utility.arg.requirements]
 In general, a default constructor is not required. Certain container class
 member function signatures specify \tcode{T()} as a default argument.
 \tcode{T()} shall be a well-defined expression\iref{dcl.init} if one of those
-signatures is called using the default argument\iref{dcl.fct.default}.
+signatures is called using the \link{default argument}{dcl.fct.default}.
 
 \begin{oldconcepttable}{EqualityComparable}{}{cpp17.equalitycomparable}
 {x{1in}x{1in}p{3in}}
@@ -1732,13 +1732,13 @@ [swappable.requirements]
 
 \pnum
 The context in which \tcode{swap(t, u)} and \tcode{swap(u, t)} are evaluated shall
-ensure that a binary non-member function named ``swap'' is selected via overload
-resolution\iref{over.match} on a candidate set that includes:
+ensure that a binary non-member function named ``swap'' is selected via \link{overload
+resolution}{over.match} on a candidate set that includes:
 \begin{itemize}
 \item the two \tcode{swap} function templates defined in
 \libheaderref{utility} and
 
-\item the lookup set produced by argument-dependent lookup\iref{basic.lookup.argdep}.
+\item the lookup set produced by \link{argument-dependent lookup}{basic.lookup.argdep}.
 \end{itemize}
 \begin{note}
 If \tcode{T} and \tcode{U} are both fundamental types or arrays of
@@ -1841,8 +1841,9 @@ [nullablepointer.requirements]
 \end{note}
 
 \pnum
-An object \tcode{p} of type \tcode{P} can be contextually converted to
-\tcode{bool}\iref{conv}. The effect shall be as if \tcode{p != nullptr}
+An object \tcode{p} of type \tcode{P} can be
+\deflinkx{contextually converted to \tcode{bool}}{conversion!contextual to \tcode{bool}}{conv}.
+The effect shall be as if \tcode{p != nullptr}
 had been evaluated in place of \tcode{p}.
 
 \pnum
@@ -1942,10 +1943,10 @@ [allocator.requirements.general]
 This information includes the knowledge of pointer types, the type of their
 difference, the type of the size of objects in this allocation model, as well
 as the memory allocation and deallocation primitives for it. All of the
-string types\iref{strings},
-containers\iref{containers} (except \tcode{array}),
+\link{string types}{strings},
+\link{containers}{containers} (except \tcode{array}),
 string buffers and string streams\iref{input.output}, and
-\tcode{match_results}\iref{re} are parameterized in terms of
+\link{\tcode{match_results}}{re} are parameterized in terms of
 allocators.
 
 \pnum
@@ -2753,7 +2754,7 @@ [allocator.requirements.completeness]
 whether or not \tcode{T} is a complete type:
 \begin{itemize}
 \item \tcode{X} is a complete type, and
-\item all the member types of \tcode{allocator_traits<X>}\iref{allocator.traits}
+\item all the member types of \link{\tcode{allocator_traits<X>}}{allocator.traits}
   other than \tcode{value_type} are complete types.
 \end{itemize}
 
@@ -2764,11 +2765,11 @@ [constraints.overview]
 \pnum
 Subclause \ref{constraints} describes restrictions on \Cpp{} programs that use the facilities of
 the \Cpp{} standard library. The following subclauses specify constraints on the
-program's use of namespaces\iref{namespace.std}, its use of various reserved
-names\iref{reserved.names}, its use of headers\iref{alt.headers}, its use of
+program's use of \link{namespaces}{namespace.std}, its use of various \link{reserved
+names}{reserved.names}, its use of \link{headers}{alt.headers}, its use of
 standard library classes as base classes\iref{derived.classes}, its
-definitions of replacement functions\iref{replacement.functions}, and its
-installation of handler functions during execution\iref{handler.functions}.
+definitions of \link{replacement functions}{replacement.functions}, and its
+installation of \link{handler functions}{handler.functions} during execution.
 
 \rSec3[namespace.constraints]{Namespace use}
 
@@ -3107,7 +3108,7 @@ [alt.headers]
 If a file with a name
 equivalent to the derived file name for one of the \Cpp{} standard library headers
 is not provided as part of the implementation, and a file with that name
-is placed in any of the standard places for a source file to be included\iref{cpp.include},
+is placed in any of the standard places for a source file to be \link{included}{cpp.include},
 the behavior is undefined.%
 \indextext{source file}%
 \indextext{undefined}
@@ -3330,7 +3331,7 @@ [res.on.objects]
 
 \pnum
 If an object of a standard library type is accessed, and
-the beginning of the object's lifetime\iref{basic.life}
+the beginning of the object's \link{lifetime}{basic.life}
 does not happen before the access, or
 the access does not happen before the end of the object's lifetime,
 the behavior is undefined unless otherwise specified.
@@ -3390,7 +3391,7 @@ [res.on.headers]
 included after any other header that also defines it\iref{basic.def.odr}.
 
 \pnum
-The C standard library headers\iref{support.c.headers}
+The \link{C standard library headers}{support.c.headers}
 shall include only their corresponding \Cpp{} standard library header,
 as described in~\ref{headers}.
 
@@ -3418,7 +3419,7 @@ [global.functions]
 It is unspecified whether any
 non-member
 functions in the \Cpp{} standard library are defined as
-inline\iref{dcl.inline}.
+\link{inline}{dcl.inline}.
 
 \pnum
 A call to a non-member function signature
@@ -3446,7 +3447,7 @@ [global.functions]
 the swappable with requirements\iref{swappable.requirements}.
 The exception for overloaded operators allows argument-dependent lookup
 in cases like that of
-\tcode{ostream_iterator::operator=}\iref{ostream.iterator.ops}:
+\libmemberrefx{ostream_iterator::operator=}{ostream_iterator}{operator=}:
 
 \effects
 \begin{codeblock}
@@ -3461,7 +3462,7 @@ [member.functions]
 
 \pnum
 It is unspecified whether any member functions in the \Cpp{} standard library are defined as
-inline\iref{dcl.inline}.
+\link{inline}{dcl.inline}.
 
 \pnum
 For a non-virtual member function described in the \Cpp{} standard library,
@@ -3540,8 +3541,8 @@ [reentrancy]
 \rSec3[res.on.data.races]{Data race avoidance}
 
 \pnum
-This subclause specifies requirements that implementations shall meet to prevent data
-races\iref{intro.multithread}.
+This subclause specifies requirements that implementations shall meet to prevent
+\deflinkx{data races}{data race}{intro.multithread}.
 Every standard library function shall meet each requirement unless otherwise specified.
 Implementations may prevent data races in cases other than those specified below.
 
@@ -3584,7 +3585,7 @@ [res.on.data.races]
 \pnum
 Unless otherwise specified, \Cpp{} standard library functions shall perform all operations
 solely within the current thread if those operations have effects that are
-visible\iref{intro.multithread} to users.
+\deflinkx{visible}{side effects!visible}{intro.multithread} to users.
 
 \pnum
 \begin{note}
@@ -3692,7 +3693,7 @@ [res.on.exception.handling]
 \begin{footnote}
 In particular, they
 can report a failure to allocate storage by throwing an exception of type
-\tcode{bad_alloc},
+\link{\tcode{bad_alloc}}{bad.alloc},
 or a class derived from
 \tcode{bad_alloc}\iref{bad.alloc}.
 \end{footnote}
@@ -3711,7 +3712,7 @@ [value.error.codes]
 
 \pnum
 Certain functions in the \Cpp{} standard library report errors via a
-\tcode{std::error_code}\iref{syserr.errcode.overview} object. That object's
+\link{\tcode{std::error_code}}{syserr.errcode.overview} object. That object's
 \tcode{category()} member shall return \tcode{std::system_category()} for
 errors originating from the operating system, or a reference to an
 \impldef{\tcode{error_category} for errors originating outside the
diff --git a/source/support.tex b/source/support.tex
index 60320199..336a2f73 100644
--- a/source/support.tex
+++ b/source/support.tex
@@ -43,22 +43,15 @@ [support.types]
 
 \rSec2[cstddef.syn]{Header \tcode{<cstddef>} synopsis}
 
-\indexlibraryglobal{NULL}%
-\indexlibraryglobal{offsetof}%
-\indexlibraryglobal{ptrdiff_t}%
-\indexlibraryglobal{size_t}%
-\indexlibraryglobal{max_align_t}%
-\indexlibraryglobal{nullptr_t}%
-\indexlibraryglobal{byte}%
 \begin{codeblock}
 // all freestanding
 namespace std {
-  using ptrdiff_t = @\seebelow@;
-  using size_t = @\seebelow@;
-  using max_align_t = @\seebelow@;
-  using nullptr_t = decltype(nullptr);
+  using @\libglobal{ptrdiff_t}@ = @\seebelow@;
+  using @\libglobal{size_t}@ = @\seebelow@;
+  using @\libglobal{max_align_t}@ = @\seebelow@;
+  using @\libglobal{nullptr_t}@ = decltype(nullptr);
 
-  enum class byte : unsigned char {};
+  enum class @\libglobal{byte}@ : unsigned char {};
 
   // \ref{support.types.byteops}, \tcode{byte} type operations
   template<class IntType>
@@ -80,8 +73,8 @@ [cstddef.syn]
     constexpr IntType to_integer(byte b) noexcept;
 }
 
-#define NULL @\seebelow@
-#define offsetof(P, D) @\seebelow@
+#define @\libglobal{NULL}@ @\seebelow@
+#define @\libglobal{offsetof}@(P, D) @\seebelow@
 \end{codeblock}
 
 \pnum
@@ -99,11 +92,6 @@ [cstddef.syn]
 \rSec2[cstdlib.syn]{Header \tcode{<cstdlib>} synopsis}
 
 \indexheader{cstdlib}%
-\indexlibraryglobal{EXIT_FAILURE}%
-\indexlibraryglobal{EXIT_SUCCESS}%
-\indexlibraryglobal{MB_CUR_MAX}%
-\indexlibraryglobal{NULL}%
-\indexlibraryglobal{RAND_MAX}%
 \indexlibraryglobal{_Exit}%
 \indexlibraryglobal{abort}%
 \indexlibraryglobal{abs}%
@@ -120,7 +108,6 @@ [cstdlib.syn]
 \indexlibraryglobal{div_t}%
 \indexlibraryglobal{exit}%
 \indexlibraryglobal{free}%
-\indexlibraryglobal{getenv}%
 \indexlibraryglobal{labs}%
 \indexlibraryglobal{ldiv}%
 \indexlibraryglobal{ldiv_t}%
@@ -155,11 +142,11 @@ [cstdlib.syn]
   using lldiv_t = @\seebelow@;
 }
 
-#define NULL @\seebelow@                                                  // freestanding
-#define EXIT_FAILURE @\seebelow@
-#define EXIT_SUCCESS @\seebelow@
-#define RAND_MAX @\seebelow@
-#define MB_CUR_MAX @\seebelow@
+#define @\libglobal{NULL}@ @\seebelow@                                                  // freestanding
+#define @\libglobal{EXIT_FAILURE}@ @\seebelow@
+#define @\libglobal{EXIT_SUCCESS}@ @\seebelow@
+#define @\libglobal{RAND_MAX}@ @\seebelow@
+#define @\libglobal{MB_CUR_MAX}@ @\seebelow@
 
 namespace std {
   // Exposition-only function type aliases
@@ -178,7 +165,7 @@ [cstdlib.syn]
   [[noreturn]] void _Exit(int status) noexcept;                         // freestanding
   [[noreturn]] void quick_exit(int status) noexcept;                    // freestanding
 
-  char* getenv(const char* name);
+  char* @\libglobal{getenv}@(const char* name);
   int system(const char* string);
 
   // \ref{c.malloc}, C library memory allocation
@@ -251,7 +238,7 @@ [cstdlib.syn]
 \ref{c.math.abs}.
 \begin{note}
 Several functions have additional overloads in this document,
-but they have the same behavior as in the C standard library\iref{library.c}.
+but they have the same behavior as in the \link{C standard library}{library.c}.
 \end{note}
 
 \xrefc{7.22}
@@ -305,8 +292,8 @@ [support.types.layout]
 is overloaded for any of the types involved.
 \end{footnote}
 The expression \tcode{offsetof(\placeholder{type}, \placeholder{member-designator})}
-is never type-dependent\iref{temp.dep.expr} and it is
-value-dependent\iref{temp.dep.constexpr} if and only if \tcode{\placeholder{type}} is
+is never \link{type-dependent}{temp.dep.expr} and it is
+\link{value-dependent}{temp.dep.constexpr} if and only if \tcode{\placeholder{type}} is
 dependent. The result of applying the \tcode{offsetof} macro to
 a static data member or a function member is undefined.
 No operation invoked by the \tcode{offsetof} macro shall throw an exception and
@@ -934,13 +921,13 @@ [numeric.limits.general]
 
 \pnum
 Non-arithmetic standard types, such as
-\tcode{complex<T>}\iref{complex}, shall not have specializations.
+\link{\tcode{complex<T>}}{complex}, shall not have specializations.
 
 \rSec3[numeric.limits.members]{\tcode{numeric_limits} members}
 
 \pnum
 \indextext{signal-safe!\idxcode{numeric_limits} members}%
-Each member function defined in this subclause is signal-safe\iref{support.signal}.
+Each member function defined in this subclause is \deflinkx{signal-safe}{evaluation!signal-safe}{support.signal}.
 
 \indexlibrarymember{min}{numeric_limits}%
 \begin{itemdecl}
@@ -1962,7 +1949,7 @@ [support.start.term]
 thread, or static storage duration and without calling functions passed to
 \tcode{atexit()}\iref{basic.start.term}.
 \indextext{signal-safe!\idxcode{_Exit}}%
-The function \tcode{_Exit} is signal-safe\iref{support.signal}.
+The function \tcode{_Exit} is \deflinkx{signal-safe}{evaluation!signal-safe}{support.signal}.
 \end{itemdescr}
 
 \indexlibraryglobal{abort}%
@@ -1982,7 +1969,7 @@ [support.start.term]
 duration and without calling functions passed to
 \tcode{atexit()}\iref{basic.start.term}.
 \indextext{signal-safe!\idxcode{abort}}%
-The function \tcode{abort} is signal-safe\iref{support.signal}.
+The function \tcode{abort} is \deflinkx{signal-safe}{evaluation!signal-safe}{support.signal}.
 \end{itemdescr}
 
 \indexlibraryglobal{atexit}%
@@ -1999,7 +1986,8 @@ [support.start.term]
 functions register the function pointed to by \tcode{f}
 to be called without arguments at normal program termination.
 It is unspecified whether a call to \tcode{atexit()} that does not
-happen before\iref{intro.multithread} a call to \tcode{exit()} will succeed.
+\deflinkx{happen before}{happens before}{intro.multithread}
+a call to \tcode{exit()} will succeed.
 \begin{note}
 The \tcode{atexit()} functions do not introduce a data
 race\iref{res.on.data.races}.
@@ -2093,7 +2081,8 @@ [support.start.term]
 The \tcode{at_quick_exit()} functions register the function pointed to by \tcode{f}
 to be called without arguments when \tcode{quick_exit} is called.
 It is unspecified whether a call to \tcode{at_quick_exit()} that does not
-happen before\iref{intro.multithread} all calls to \tcode{quick_exit} will succeed.
+\deflinkx{happen before}{happens before}{intro.multithread}
+all calls to \tcode{quick_exit} will succeed.
 \begin{note}
 The
 \tcode{at_quick_exit()} functions do not introduce a
@@ -2145,7 +2134,7 @@ [support.start.term]
 \pnum
 \remarks
 \indextext{signal-safe!\idxcode{quick_exit}}%
-The function \tcode{quick_exit} is signal-safe\iref{support.signal}
+The function \tcode{quick_exit} is \deflinkx{signal-safe}{evaluation!signal-safe}{support.signal}
 when the functions registered with \tcode{at_quick_exit} are.
 \end{itemdescr}
 
@@ -2260,7 +2249,7 @@ [new.delete.single]
 \pnum
 \effects
 The
-allocation functions\iref{basic.stc.dynamic.allocation}
+\link{allocation functions}{basic.stc.dynamic.allocation}
 called by a
 \grammarterm{new-expression}\iref{expr.new}
 to allocate
@@ -2300,7 +2289,7 @@ [new.delete.single]
 \tcode{bad_alloc}.
 \item
 Otherwise, the function calls the current
-\tcode{new_handler} function\iref{new.handler}.
+\link{\tcode{new_handler}}{new.handler} function.
 If the called function returns, the loop repeats.
 \item
 The loop terminates when an attempt to allocate the requested storage is
@@ -2517,7 +2506,7 @@ [new.delete.array]
 \pnum
 \effects
 The
-allocation functions\iref{basic.stc.dynamic.allocation}
+\link{allocation functions}{basic.stc.dynamic.allocation}
 called by the array form of a
 \grammarterm{new-expression}\iref{expr.new}
 to allocate
@@ -2826,8 +2815,8 @@ [new.delete.dataraces]
 introduce a data race\iref{res.on.data.races}.
 Calls to these functions that allocate or deallocate a particular unit
 of storage shall occur in a single total order, and each such deallocation call
-shall happen before\iref{intro.multithread} the next allocation (if any) in
-this order.
+shall \deflinkx{happen before}{happens before}{intro.multithread}
+the next allocation (if any) in this order.
 
 \rSec2[alloc.errors]{Storage allocation errors}
 
@@ -2981,8 +2970,8 @@ [ptr.launder]
 \pnum
 \expects
 \tcode{p} represents the address \placeholder{A} of a byte in memory.
-An object \placeholder{X} that is within its lifetime\iref{basic.life}
-and whose type is similar\iref{conv.qual} to \tcode{T}
+An object \placeholder{X} that is within its \deflink{lifetime}{basic.life}
+and whose type is \deflinkx{similar}{similar types}{conv.qual} to \tcode{T}
 is located at the address \placeholder{A}.
 All bytes of storage that would be
 reachable through\iref{basic.compound} the result
@@ -3191,7 +3180,8 @@ [type.info]
 
 \pnum
 \remarks
-The message may be a null-terminated multibyte string\iref{multibyte.strings},
+The message may be a
+\deflinkx{null-terminated multibyte string}{NTMBS@\ntmbs{}}{multibyte.strings},
 suitable for conversion and display as a
 \tcode{wstring}\iref{string.classes,locale.codecvt}.
 \end{itemdescr}
@@ -3602,7 +3592,8 @@ [exception]
 
 \pnum
 \remarks
-The message may be a null-terminated multibyte string\iref{multibyte.strings},
+The message may be a
+\deflinkx{null-terminated multibyte string}{NTMBS@\ntmbs{}}{multibyte.strings},
 suitable for conversion and display as a
 \tcode{wstring}\iref{string.classes,locale.codecvt}.
 The return value remains valid until the exception object from which
@@ -3747,13 +3738,13 @@ [uncaught.exceptions]
 \begin{itemdescr}
 \pnum
 \returns
-The number of uncaught exceptions\iref{except.uncaught}.
+The number of \link{uncaught exceptions}{except.uncaught}.
 
 \pnum
 \remarks
 When \tcode{uncaught_exceptions() > 0},
 throwing an exception can result in a call of the function
-\tcode{std::terminate}\iref{except.terminate}.
+\link{\tcode{std::terminate}}{except.terminate}.
 \end{itemdescr}
 
 \rSec2[propagation]{Exception propagation}
@@ -3812,8 +3803,9 @@ [propagation]
 \begin{itemdescr}
 \pnum
 \returns
-An \tcode{exception_ptr} object that refers to
-the currently handled exception\iref{except.handle} or a copy of the currently
+An \tcode{exception_ptr} object that refers to the
+\deflinkx{currently handled exception}{exception handling!currently handled exception}{except.handle}
+or a copy of the currently
 handled exception, or a null \tcode{exception_ptr} object if no exception is being
 handled. The referenced object shall remain valid at least as long as there is an
 \tcode{exception_ptr} object that refers to it.
@@ -4137,7 +4129,7 @@ [compare.syn]
 \pnum
 The header \libheaderdef{compare} specifies types, objects, and functions
 for use primarily in connection with
-the three-way comparison operator\iref{expr.spaceship}.
+the \link{three-way comparison operator}{expr.spaceship}.
 
 \indexlibraryglobal{is_eq}%
 \indexlibraryglobal{is_neq}%
@@ -5674,7 +5666,7 @@ [support.runtime.general]
 \end{note}
 
 \pnum
-A call to the \tcode{setlocale} function\iref{c.locales}
+A call to the \libglobalref{setlocale} function
 may introduce a data race with other
 calls to the \tcode{setlocale} function or with calls to functions that are
 affected by the current C locale. The implementation shall behave as if no
@@ -5684,21 +5676,16 @@ [support.runtime.general]
 \rSec2[cstdarg.syn]{Header \tcode{<cstdarg>} synopsis}
 
 \indexheader{cstdarg}%
-\indexlibraryglobal{va_list}%
-\indexlibraryglobal{va_start}%
-\indexlibraryglobal{va_copy}%
-\indexlibraryglobal{va_end}%
-\indexlibraryglobal{va_arg}%
 \begin{codeblock}
 // all freestanding
 namespace std {
-  using va_list = @\seebelow@;
+  using @\libglobal{va_list}@ = @\seebelow@;
 }
 
-#define va_arg(V, P) @\seebelow@
-#define va_copy(VDST, VSRC) @\seebelow@
-#define va_end(V) @\seebelow@
-#define va_start(V, P) @\seebelow@
+#define @\libglobal{va_arg}@(V, P) @\seebelow@
+#define @\libglobal{va_copy}@(VDST, VSRC) @\seebelow@
+#define @\libglobal{va_end}@(V) @\seebelow@
+#define @\libglobal{va_start}@(V, P) @\seebelow@
 \end{codeblock}
 
 \pnum
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 @@ [concept.same]
 
 \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 @@ [concepts.arithmetic]
 
 \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 @@ [concept.destructible]
 
 \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 @@ [concept.constructible]
 
 \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/diagnostics.tex b/source/diagnostics.tex
index be48fa02..9f933c24 100644
--- a/source/diagnostics.tex
+++ b/source/diagnostics.tex
@@ -473,13 +473,13 @@ [assertions.assert]
 
 \pnum
 An expression \tcode{assert(E)}
-is a constant subexpression\iref{defns.const.subexpr}, if
+is a \link{constant subexpression}{defns.const.subexpr}, if
 \begin{itemize}
 \item
 \tcode{NDEBUG} is defined at the point where \tcode{assert}
 is last defined or redefined, or
 \item
-\tcode{E} contextually converted to \tcode{bool}\iref{conv}
+\tcode{E} \deflinkx{contextually converted to \tcode{bool}}{conversion!contextual to \tcode{bool}}{conv}
 is a constant subexpression that evaluates to the value \tcode{true}.
 \end{itemize}
 
@@ -1572,7 +1572,7 @@ [syserr.syserr.overview]
 \pnum
 \begin{note}
 If an error represents an out-of-memory condition, implementations are
-encouraged to throw an exception object of type \tcode{bad_alloc}\iref{bad.alloc} rather
+encouraged to throw an exception object of type \link{\tcode{bad_alloc}}{bad.alloc} rather
 than \tcode{system_error}.
 \end{note}
 \indexlibraryglobal{system_error}%
diff --git a/source/utilities.tex b/source/utilities.tex
index cc7b733d..a524a07f 100644
--- a/source/utilities.tex
+++ b/source/utilities.tex
@@ -106,15 +106,15 @@ [utility.syn]
   template<class T, T...>
     struct integer_sequence;
   template<size_t... I>
-    using index_sequence = integer_sequence<size_t, I...>;
+    using @\libglobal{index_sequence}@ = integer_sequence<size_t, I...>;
 
   template<class T, T N>
     using make_integer_sequence = integer_sequence<T, @\seebelow{}@>;
   template<size_t N>
-    using make_index_sequence = make_integer_sequence<size_t, N>;
+    using @\libglobal{make_index_sequence}@ = make_integer_sequence<size_t, N>;
 
   template<class... T>
-    using index_sequence_for = make_index_sequence<sizeof...(T)>;
+    using @\libglobal{index_sequence_for}@ = make_index_sequence<sizeof...(T)>;
 
   // \ref{pairs}, class template \tcode{pair}
   template<class T1, class T2>
@@ -311,7 +311,7 @@ [forward]
 \indextext{signal-safe!\idxcode{forward}}%
 \indextext{signal-safe!\idxcode{move}}%
 \indextext{signal-safe!\idxcode{move_if_noexcept}}%
-All functions specified in this subclause are signal-safe\iref{support.signal}.
+All functions specified in this subclause are \deflinkx{signal-safe}{evaluation!signal-safe}{support.signal}.
 
 \indexlibraryglobal{forward}%
 \indextext{\idxcode{forward}}%
@@ -486,7 +486,7 @@ [declval]
 
 \pnum
 The library provides the function template \tcode{declval} to simplify the definition of
-expressions which occur as unevaluated operands\iref{term.unevaluated.operand}.
+expressions which occur as \deflinkx{unevaluated operands}{unevaluated operand}{expr.context}.
 
 \indexlibraryglobal{declval}%
 \begin{itemdecl}
@@ -1464,7 +1464,7 @@ [pair.piecewise]
 The \keyword{struct} \tcode{piecewise_construct_t} is an empty class type
 used as a unique type to disambiguate constructor and function overloading. Specifically,
 \tcode{pair} has a constructor with \tcode{piecewise_construct_t} as the
-first argument, immediately followed by two \tcode{tuple}\iref{tuple} arguments used
+first argument, immediately followed by two \link{\tcode{tuple}}{tuple} arguments used
 for piecewise construction of the elements of the \tcode{pair} object.
 
 \rSec1[tuple]{Tuples}
@@ -2087,7 +2087,7 @@ [tuple.cnstr]
 \pnum
 \effects
 Equivalent to the preceding constructors except that each element is constructed with
-uses-allocator construction\iref{allocator.uses.construction}.
+\deflink{uses-allocator construction}{allocator.uses.construction}.
 \end{itemdescr}
 
 \rSec3[tuple.assign]{Assignment}
@@ -2754,7 +2754,7 @@ [tuple.helper]
 \pnum
 Let \tcode{TS} denote \tcode{tuple_size<T>} of the cv-unqualified type \tcode{T}.
 If the expression \tcode{TS::value} is well-formed
-when treated as an unevaluated operand\iref{term.unevaluated.operand}, then
+when treated as an \deflink{unevaluated operand}{expr.context}, then
 each specialization of the template meets the \oldconcept{Unary\-Type\-Trait} requirements\iref{meta.rqmts}
 with a base characteristic of
 \begin{codeblock}
@@ -6134,6 +6134,7 @@ [variant.visit]
 \rSec2[variant.monostate]{Class \tcode{monostate}}%
 \indexlibraryglobal{monostate}%
 
+\indexlibrary{\idxcode{monostate}}%
 \begin{itemdecl}
 struct monostate{};
 \end{itemdecl}
@@ -6300,7 +6301,8 @@ [any.bad.any.cast]
 \end{codeblock}
 
 \pnum
-Objects of type \tcode{bad_any_cast} are thrown by a failed \tcode{any_cast}\iref{any.nonmembers}.
+Objects of type \tcode{bad_any_cast} are thrown by a failed
+\libglobalref{any_cast}.
 
 \indexlibrarymember{what}{bad_any_cast}%
 \begin{itemdecl}
@@ -13833,9 +13835,9 @@ [type.index.overview]
 
 \pnum
 The class \tcode{type_index} provides a simple wrapper for
-\tcode{type_info} which can be used as an index type in associative
-containers\iref{associative} and in unordered associative
-containers\iref{unord}.
+\tcode{type_info} which can be used as an index type in
+\link{associative containers}{associative} and in
+\link{unordered associative containers}{unord}.
 
 \rSec2[type.index.members]{\tcode{type_index} members}
 
@@ -14169,18 +14171,13 @@ [charconv.syn]
 \indexheader{charconv}%
 \begin{codeblock}
 @%
-\indexlibraryglobal{chars_format}%
-\indexlibrarymember{scientific}{chars_format}%
-\indexlibrarymember{fixed}{chars_format}%
-\indexlibrarymember{hex}{chars_format}%
-\indexlibrarymember{general}{chars_format}%
 @namespace std {
   // floating-point format for primitive numerical conversion
-  enum class chars_format {
-    scientific = @\unspec@,
-    fixed = @\unspec@,
-    hex = @\unspec@,
-    general = fixed | scientific
+  enum class @\libglobal{chars_format}@ {
+    @\libmember{scientific}{chars_format}@ = @\unspec@,
+    @\libmember{fixed}{chars_format}@ = @\unspec@,
+    @\libmember{hex}{chars_format}@ = @\unspec@,
+    @\libmember{general}{chars_format}@ = fixed | scientific
   };
 @%
 \indexlibraryglobal{to_chars_result}%
@@ -14268,7 +14265,7 @@ [charconv.to.chars]
 the representation with the smallest difference from
 the floating-point argument value is chosen,
 resolving any remaining ties using rounding according to
-\tcode{round_to_nearest}\iref{round.style}.
+\libglobalref{round_to_nearest}.
 
 \pnum
 The functions taking a \tcode{chars_format} parameter
@@ -14409,7 +14406,7 @@ [charconv.from.chars]
 is equal to \tcode{errc::result_out_of_range}.
 Otherwise,
 \tcode{value} is set to the parsed value,
-after rounding according to \tcode{round_to_nearest}\iref{round.style}, and
+after rounding according to \libglobalref{round_to_nearest}, and
 the member \tcode{ec} is value-initialized.
 
 \indexlibraryglobal{from_chars}%
diff --git a/source/strings.tex b/source/strings.tex
index 9adcd211..2c4b1ce3 100644
--- a/source/strings.tex
+++ b/source/strings.tex
@@ -5554,13 +5554,13 @@ [cstring.syn]
 are the same as the C standard library header \libheader{string.h}.
 
 \pnum
-The functions \tcode{strerror} and \tcode{strtok} are not required to avoid data
-races\iref{res.on.data.races}.
+The functions \tcode{strerror} and \tcode{strtok} are not required to
+\link{avoid data races}{res.on.data.races}.
 
 \pnum
 \indextext{signal-safe!\idxcode{memcpy}}%
 \indextext{signal-safe!\idxcode{memmove}}%
-The functions \tcode{memcpy} and \tcode{memmove} are signal-safe\iref{support.signal}.
+The functions \tcode{memcpy} and \tcode{memmove} are \deflinkx{signal-safe}{evaluation!signal-safe}{support.signal}.
 Both functions implicitly create objects\iref{intro.object}
 in the destination region of storage
 immediately prior to copying the sequence of characters to the destination.
@@ -5570,7 +5570,7 @@ [cstring.syn]
 The functions
 \tcode{strchr}, \tcode{strpbrk}, \tcode{strrchr}, \tcode{strstr}, and \tcode{memchr},
 have different signatures in this document,
-but they have the same behavior as in the C standard library\iref{library.c}.
+but they have the same behavior as in the \link{C standard library}{library.c}.
 \end{note}
 
 \xrefc{7.24}
@@ -5737,7 +5737,7 @@ [cwchar.syn]
 The functions
 \tcode{wcschr}, \tcode{wcspbrk}, \tcode{wcsrchr}, \tcode{wcsstr}, and \tcode{wmemchr}
 have different signatures in this document,
-but they have the same behavior as in the C standard library\iref{library.c}.
+but they have the same behavior as in the \link{C standard library}{library.c}.
 \end{note}
 
 \xrefc{7.29}
diff --git a/source/containers.tex b/source/containers.tex
index 39d1107d..44ded792 100644
--- a/source/containers.tex
+++ b/source/containers.tex
@@ -6151,14 +6151,14 @@ [array.overview]
 \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}.
 
@@ -6169,24 +6169,24 @@ [array.overview]
 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
 for operations where there is additional semantic information.
 
 \pnum
-\tcode{array<T, N>} is a structural type\iref{temp.param} if
+\tcode{array<T, N>} is a \deflinkx{structural type}{type!structural}{temp.param} 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}%
@@ -6260,7 +6260,7 @@ [array.cons]
 \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}.
@@ -6474,7 +6474,7 @@ [deque.overview]
 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.
@@ -7089,7 +7089,7 @@ [forward.list.overview]
 \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.
 
@@ -7669,7 +7669,7 @@ [forward.list.ops]
 
 \pnum
 \remarks
-Stable\iref{algorithm.stable}.
+\link{Stable}{algorithm.stable}.
 \end{itemdescr}
 
 \indexlibrarymember{unique}{forward_list}%
@@ -7774,7 +7774,7 @@ [forward.list.ops]
 
 \pnum
 \remarks
-Stable\iref{algorithm.stable}.
+\link{Stable}{algorithm.stable}.
 \end{itemdescr}
 
 \indexlibrarymember{reverse}{forward_list}%
@@ -7832,7 +7832,7 @@ [list.overview]
 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.
 
@@ -8001,7 +8001,7 @@ [list.overview]
 \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.
 
@@ -8415,7 +8415,7 @@ [list.ops]
 
 \pnum
 \remarks
-Stable\iref{algorithm.stable}.
+\link{Stable}{algorithm.stable}.
 \end{itemdescr}
 
 \indexlibrarymember{unique}{list}%
@@ -8539,7 +8539,7 @@ [list.ops]
 
 \pnum
 \remarks
-Stable\iref{algorithm.stable}.
+\link{Stable}{algorithm.stable}.
 \end{itemdescr}
 
 \rSec3[list.erasure]{Erasure}
@@ -8592,7 +8592,7 @@ [vector.overview]
 of a sequence container, including most of the optional sequence container
 requirements\iref{sequence.reqmts},
 and, for an element type other than \tcode{bool},
-of a contiguous container\iref{container.reqmts}.
+of a \deflinkx{contiguous container}{container!contiguous}{container.reqmts}.
 The exceptions are the
 \tcode{push_front}, \tcode{prepend_range}, \tcode{pop_front}, and \tcode{emplace_front} member functions, which are not
 provided. Descriptions are provided here only for operations on \tcode{vector}
@@ -8730,7 +8730,7 @@ [vector.overview]
 \pnum
 An incomplete type \tcode{T} may be used when instantiating \tcode{vector}
 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{vector} is referenced.
 
@@ -9301,7 +9301,7 @@ [vector.bool.pspc]
 semantics as the primary \tcode{vector} template, except that operations
 dealing with the \tcode{bool} value type map to bit values in the
 container storage and
-\tcode{allocator_traits::construct}\iref{allocator.traits.members}
+\libmemberrefx{allocator_traits::construct}{allocator_traits}{construct}
 is not used to construct these values.
 
 \pnum
@@ -13398,9 +13398,9 @@ [queue.defn]
 can be used to instantiate
 \tcode{queue}.
 In particular,
-\tcode{list}\iref{list}
+\link{\tcode{list}}{list}
 and
-\tcode{deque}\iref{deque}
+\link{\tcode{deque}}{deque}
 can be used.
 
 \begin{codeblock}
@@ -13755,15 +13755,15 @@ [priqueue.overview]
 can be used to instantiate
 \tcode{priority_queue}.
 In particular,
-\tcode{vector}\iref{vector}
+\link{\tcode{vector}}{vector}
 and
-\tcode{deque}\iref{deque}
+\link{\tcode{deque}}{deque}
 can be used.
 Instantiating
 \tcode{priority_queue}
 also involves supplying a function or function object for making
 priority comparisons; the library assumes that the function or function
-object defines a strict weak ordering\iref{alg.sorting}.
+object defines a \link{strict weak ordering}{alg.sorting}.
 
 \begin{codeblock}
 namespace std {
@@ -14263,10 +14263,10 @@ [stack.general]
 can be used to instantiate
 \tcode{stack}.
 In particular,
-\tcode{vector}\iref{vector},
-\tcode{list}\iref{list}
+\link{\tcode{vector}}{vector},
+\link{\tcode{list}}{list}
 and
-\tcode{deque}\iref{deque}
+\link{\tcode{deque}}{deque}
 can be used.
 
 \rSec3[stack.defn]{Definition}
diff --git a/source/iterators.tex b/source/iterators.tex
index 0a3eb7dd..9b1c441e 100644
--- a/source/iterators.tex
+++ b/source/iterators.tex
@@ -707,8 +707,7 @@ [iterator.requirements.general]
 \end{footnote}
 
 \pnum
-\indextext{iterator!constexpr}%
-Iterators are called \defn{constexpr iterators}
+Iterators are called \defnadjx{constexpr}{iterators}{iterator}
 if all operations provided to meet iterator category requirements
 are constexpr functions.
 \begin{note}
@@ -6817,7 +6816,7 @@ [istreambuf.iterator.general]
 The
 class template
 \tcode{istreambuf_iterator}
-defines an input iterator\iref{input.iterators} that
+defines an \link{input iterator}{input.iterators} that
 reads successive
 \textit{characters}
 from the streambuf for which it was constructed.
@@ -6942,7 +6941,6 @@ [istreambuf.iterator.cons]
 Initializes \tcode{sbuf_} with \keyword{nullptr}.
 \end{itemdescr}
 
-
 \indexlibraryctor{istreambuf_iterator}%
 \begin{itemdecl}
 istreambuf_iterator(istream_type& s) noexcept;
@@ -6954,7 +6952,6 @@ [istreambuf.iterator.cons]
 Initializes \tcode{sbuf_} with \tcode{s.rdbuf()}.
 \end{itemdescr}
 
-
 \indexlibraryctor{istreambuf_iterator}%
 \begin{itemdecl}
 istreambuf_iterator(streambuf_type* s) noexcept;
@@ -6966,7 +6963,6 @@ [istreambuf.iterator.cons]
 Initializes \tcode{sbuf_} with \tcode{s}.
 \end{itemdescr}
 
-
 \indexlibraryctor{istreambuf_iterator}%
 \begin{itemdecl}
 istreambuf_iterator(const @\placeholder{proxy}@& p) noexcept;
@@ -7117,7 +7113,6 @@ [ostreambuf.iter.cons]
 Initializes \tcode{sbuf_} with \tcode{s.rdbuf()}.
 \end{itemdescr}
 
-
 \indexlibraryctor{ostreambuf_iterator}%
 \begin{itemdecl}
 ostreambuf_iterator(streambuf_type* s) noexcept;
diff --git a/source/algorithms.tex b/source/algorithms.tex
index 448ffe21..787f1c72 100644
--- a/source/algorithms.tex
+++ b/source/algorithms.tex
@@ -5,7 +5,7 @@ [algorithms.general]
 
 \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
@@ -7859,7 +7859,7 @@ [alg.merge]
 
 \pnum
 \remarks
-Stable\iref{algorithm.stable}.
+\link{Stable}{algorithm.stable}.
 \end{itemdescr}
 
 \begin{itemdecl}
@@ -11344,7 +11344,7 @@ [specialized.construct]
 \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/numerics.tex b/source/numerics.tex
index 9f2ebe47..3be8ccfe 100644
--- a/source/numerics.tex
+++ b/source/numerics.tex
@@ -165,8 +165,8 @@ [cfenv.syn]
 \rSec2[cfenv.thread]{Threads}
 
 \pnum
-The floating-point environment has thread storage
-duration\iref{basic.stc.thread}. The initial state for a thread's floating-point
+The floating-point environment has \deflinkx{thread storage duration}{storage duration!thread}{basic.stc.thread}.
+The initial state for a thread's floating-point
 environment is the state of the floating-point environment of the thread that constructs
 the corresponding \tcode{thread} object\iref{thread.thread.class}
 or \tcode{jthread} object\iref{thread.jthread.class}
@@ -1470,21 +1470,21 @@ [rand.req.genl]
     is undefined unless the corresponding template argument
     is cv-unqualified and
     meets the requirements
-    of seed sequence\iref{rand.req.seedseq}.
+    of \link{seed sequence}{rand.req.seedseq}.
   \item
     that has a template type parameter
     named \tcode{URBG}
     is undefined unless the corresponding template argument
     is cv-unqualified and
     meets the requirements
-    of uniform random bit generator\iref{rand.req.urng}.
+    of \link{uniform random bit generator}{rand.req.urng}.
   \item
     that has a template type parameter
     named \tcode{Engine}
     is undefined unless the corresponding template argument
     is cv-unqualified and
     meets the requirements
-    of random number engine\iref{rand.req.eng}.
+    of \link{random number engine}{rand.req.eng}.
   \item
     that has a template type parameter
     named \tcode{RealType}
@@ -1608,7 +1608,7 @@ [rand.req.seedseq]
 \endhead
 \tcode{S::result_type}
   & \tcode{T}
-  & \tcode{T} is an unsigned integer type\iref{basic.fundamental}
+  & \tcode{T} is an \deflinkx{unsigned integer type}{type!unsigned integer}{basic.fundamental}
     of at least 32 bits.
   & compile-time
   \\ \rowsep
@@ -1773,7 +1773,7 @@ [rand.req.eng]
 \pnum
 A class \tcode{E}
 that meets the requirements
-of a uniform random bit generator\iref{rand.req.urng}
+of a \link{uniform random bit generator}{rand.req.urng}
 also meets the requirements
 of a \term{random number engine}
 if the expressions shown
@@ -1794,7 +1794,7 @@ [rand.req.eng]
     \tcode{s} is a value of \tcode{T};
   \item
     \tcode{q} is an lvalue
-    meeting the requirements of a seed sequence\iref{rand.req.seedseq};
+    meeting the requirements of a \link{seed sequence}{rand.req.seedseq};
   \item
     \tcode{z} is a value
     of type \tcode{unsigned long long};
@@ -2185,7 +2185,7 @@ [rand.req.dist]
   \item
     \tcode{g}, \tcode{g1}, and \tcode{g2} are lvalues of a type
     meeting the requirements
-    of a uniform random bit generator\iref{rand.req.urng};
+    of a \link{uniform random bit generator}{rand.req.urng};
   \item
     \tcode{os} is an lvalue of the type of some class template specialization
     \tcode{basic_ostream<charT,} \tcode{traits>};
@@ -2216,7 +2216,7 @@ [rand.req.dist]
 \endhead
 \tcode{D::result_type}
   & \tcode{T}
-  & \tcode{T} is an arithmetic type\iref{basic.fundamental}.
+  & \tcode{T} is an \deflinkx{arithmetic type}{type!arithmetic}{basic.fundamental}.
   & compile-time
   \\ \rowsep
 \tcode{D::param_type}
@@ -2423,7 +2423,7 @@ [rand.eng.general]
 Each type instantiated
 from a class template specified in \ref{rand.eng}
 meets the requirements
-of a random number engine\iref{rand.req.eng} type.
+of a \link{random number engine}{rand.req.eng} type.
 
 \pnum
 Except where specified otherwise,
@@ -2984,7 +2984,7 @@ [rand.adapt.general]
 Each type instantiated
 from a class template specified in this subclause~\ref{rand.adapt}
 meets the requirements
-of a random number engine adaptor\iref{rand.req.adapt} type.
+of a \link{random number engine adaptor}{rand.req.adapt} type.
 
 \pnum
 Except where specified otherwise,
@@ -4035,7 +4035,7 @@ [rand.dist.general]
 Each type instantiated
 from a class template specified in this subclause~\ref{rand.dist}
 meets the requirements
-of a random number distribution\iref{rand.req.dist} type.
+of a \link{random number distribution}{rand.req.dist} type.
 
 \pnum
 Descriptions are provided in this subclause~\ref{rand.dist}
@@ -4869,6 +4869,7 @@ [rand.dist.pois.gamma]
 
 \indexlibraryglobal{gamma_distribution}%
 \indexlibrarymember{result_type}{gamma_distribution}%
+\indexlibrary{\idxcode{gamma_distribution}}%
 \begin{codeblock}
 namespace std {
   template<class RealType = double>
@@ -4912,7 +4913,6 @@ [rand.dist.pois.gamma]
 }
 \end{codeblock}
 
-
 \indexlibraryctor{gamma_distribution}%
 \begin{itemdecl}
 explicit gamma_distribution(RealType alpha, RealType beta = 1.0);
@@ -5018,7 +5018,7 @@ [rand.dist.pois.weibull]
 \indexlibraryctor{weibull_distribution}%
 \begin{itemdecl}
 explicit weibull_distribution(RealType a, RealType b = 1.0);
-\end{itemdecl}%
+\end{itemdecl}
 
 \begin{itemdescr}
 \pnum
@@ -5127,7 +5127,6 @@ [rand.dist.pois.extreme]
 }
 \end{codeblock}
 
-
 \indexlibraryctor{extreme_value_distribution}%
 \begin{itemdecl}
 explicit extreme_value_distribution(RealType a, RealType b = 1.0);
@@ -5252,7 +5251,6 @@ [rand.dist.norm.normal]
 }
 \end{codeblock}
 
-
 \indexlibraryctor{normal_distribution}%
 \begin{itemdecl}
 explicit normal_distribution(RealType mean, RealType stddev = 1.0);
@@ -5453,7 +5451,6 @@ [rand.dist.norm.chisq]
 }
 \end{codeblock}
 
-
 \indexlibraryctor{chi_squared_distribution}%
 \begin{itemdecl}
 explicit chi_squared_distribution(RealType n);
@@ -5644,7 +5641,6 @@ [rand.dist.norm.f]
 }
 \end{codeblock}
 
-
 \indexlibraryctor{fisher_f_distribution}%
 \begin{itemdecl}
 explicit fisher_f_distribution(RealType m, RealType n = 1);
@@ -5746,7 +5742,6 @@ [rand.dist.norm.t]
 }
 \end{codeblock}
 
-
 \indexlibraryctor{student_t_distribution}%
 \begin{itemdecl}
 explicit student_t_distribution(RealType n);
@@ -5860,7 +5855,7 @@ [rand.dist.samp.discrete]
 }
 \end{codeblock}
 
-\indexlibraryctor{discrete_distribution}
+\indexlibraryctor{discrete_distribution}%
 \begin{itemdecl}
 discrete_distribution();
 \end{itemdecl}
@@ -6681,8 +6676,9 @@ [valarray.syn]
 \begin{itemize}
 \item
 for every function taking a
-\tcode{const valarray<T>\&} other than \tcode{begin} and
-\tcode{end}\iref{valarray.range},
+\tcode{const valarray<T>\&} other than
+\libmemberrefx{begin}{begin}{valarray} and
+\libmemberrefx{end}{end}{valarray},
 identical functions taking the replacement types shall be added;
 \item
 for every function taking two
@@ -6707,7 +6703,7 @@ [valarray.syn]
 
 \pnum
 These library functions are permitted to throw a
-\tcode{bad_alloc}\iref{bad.alloc} exception if there are not sufficient resources available
+\link{\tcode{bad_alloc}}{bad.alloc} exception if there are not sufficient resources available
 to carry out the operation.
 Note that the exception is not mandated.
 
@@ -6867,7 +6863,7 @@ [valarray.cons]
 \pnum
 \effects
 Constructs a \tcode{valarray} that has length \tcode{n}.
-Each element of the array is value-initialized\iref{dcl.init}.
+Each element of the array is \deflinkx{value-initialized}{value-initialization}{dcl.init}.
 \end{itemdescr}
 
 \indexlibraryctor{valarray}%
@@ -7127,7 +7123,7 @@ [valarray.access]
 \pnum
 The reference returned by the subscript operator for an array shall
 be valid until the member function
-\tcode{resize(size_t, T)}\iref{valarray.members} is called for that array or until the lifetime of
+\libmemberrefx{resize(size_t, T)}{valarray}{resize} is called for that array or until the lifetime of
 that array ends, whichever happens first.
 \end{itemdescr}
 
@@ -7553,7 +7549,7 @@ [valarray.members]
 \pnum
 \begin{example}
 If the argument has the value $-2$,
-the first two elements of the result will be value-initialized\iref{dcl.init}; the third element of the result will be assigned the value
+the first two elements of the result will be \deflinkx{value-initialized}{value-initialization}{dcl.init}; the third element of the result will be assigned the value
 of the first element of \tcode{*this}; etc.
 \end{example}
 \end{itemdescr}
@@ -8678,7 +8674,7 @@ [valarray.range]
 \pnum
 The iterators returned by \tcode{begin} and \tcode{end} for an array
 are guaranteed to be valid until the member function
-\tcode{resize(size_t, T)}\iref{valarray.members} is called for that
+\libmemberrefx{resize(size_t, T)}{valarray}{resize} is called for that
 array or until the lifetime of that array ends, whichever happens
 first.
 
@@ -9315,12 +9311,12 @@ [cmath.syn]
 The contents and meaning of the header \libheader{cmath}
 are the same as the C standard library header \libheader{math.h},
 with the addition of
-a three-dimensional hypotenuse function\iref{c.math.hypot3},
-a linear interpolation function\iref{c.math.lerp}, and
+a \link{three-dimensional hypotenuse function}{c.math.hypot3},
+a \link{linear interpolation function}{c.math.lerp}, and
 the mathematical special functions described in \ref{sf.cmath}.
 \begin{note}
 Several functions have additional overloads in this document,
-but they have the same behavior as in the C standard library\iref{library.c}.
+but they have the same behavior as in the \link{C standard library}{library.c}.
 \end{note}
 
 \pnum
@@ -9384,7 +9380,7 @@ [c.math.abs]
 If \tcode{abs} is called with an argument of type \tcode{X}
 for which \tcode{is_unsigned_v<X>} is \tcode{true} and
 if \tcode{X} cannot be converted to \tcode{int}
-by integral promotion\iref{conv.prom}, the program is ill-formed.
+by \link{integral promotion}{conv.prom}, the program is ill-formed.
 \begin{note}
 Arguments that can be promoted to \tcode{int} are permitted for compatibility with C.
 \end{note}
diff --git a/source/time.tex b/source/time.tex
index ef7289cb..d21cb3bc 100644
--- a/source/time.tex
+++ b/source/time.tex
@@ -1196,7 +1196,7 @@ [time.traits.is.clock]
 are valid and each denotes a type\iref{temp.deduct},
 \item the expression
 \tcode{T::is_steady}
-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},
 \item the expression
 \tcode{T::now()}
 is well-formed when treated as an unevaluated operand.
@@ -11029,7 +11029,7 @@ [time.parse]
 \begin{codeblock}
 from_stream(declval<basic_istream<charT, traits>&>(), @$F$@, tp)
 \end{codeblock}
-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
 \returns
@@ -11062,7 +11062,7 @@ [time.parse]
 \begin{codeblock}
 from_stream(declval<basic_istream<charT, traits>&>(), @$F$@, tp, addressof(abbrev))
 \end{codeblock}
-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
 \returns
@@ -11099,7 +11099,7 @@ [time.parse]
             declval<basic_string<charT, traits, Alloc>*>(),
             &offset)
 \end{codeblock}
-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
 \returns
@@ -11139,7 +11139,7 @@ [time.parse]
 from_stream(declval<basic_istream<charT, traits>&>(),
             @$F$@, tp, addressof(abbrev), &offset)
 \end{codeblock}
-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
 \returns
diff --git a/source/locales.tex b/source/locales.tex
index 4b6e0376..70813d84 100644
--- a/source/locales.tex
+++ b/source/locales.tex
@@ -973,7 +973,7 @@ [category.ctype.general]
 \end{codeblock}
 
 \pnum
-The type \tcode{mask} is a bitmask type\iref{bitmask.types}.
+The type \tcode{mask} is a \link{bitmask type}{bitmask.types}.
 
 \rSec3[locale.ctype]{Class template \tcode{ctype}}
 
@@ -4531,31 +4531,21 @@ [c.locales]
 
 \rSec2[clocale.syn]{Header \tcode{<clocale>} synopsis}
 
-\indexlibraryglobal{lconv}%
-\indexlibraryglobal{setlocale}%
-\indexlibraryglobal{localeconv}%
-\indexlibraryglobal{NULL}%
-\indexlibraryglobal{LC_ALL}%
-\indexlibraryglobal{LC_COLLATE}%
-\indexlibraryglobal{LC_CTYPE}%
-\indexlibraryglobal{LC_MONETARY}%
-\indexlibraryglobal{LC_NUMERIC}%
-\indexlibraryglobal{LC_TIME}%
 \begin{codeblock}
 namespace std {
-  struct lconv;
+  struct @\libglobal{lconv}@;
 
-  char* setlocale(int category, const char* locale);
-  lconv* localeconv();
+  char* @\libglobal{setlocale}@(int category, const char* locale);
+  lconv* @\libglobal{localeconv}@();
 }
 
-#define NULL @\textit{see \ref{support.types.nullptr}}@
-#define LC_ALL @\seebelow@
-#define LC_COLLATE @\seebelow@
-#define LC_CTYPE @\seebelow@
-#define LC_MONETARY @\seebelow@
-#define LC_NUMERIC @\seebelow@
-#define LC_TIME @\seebelow@
+#define @\libglobal{NULL}@ @\textit{see \ref{support.types.nullptr}}@
+#define @\libglobal{LC_ALL}@ @\seebelow@
+#define @\libglobal{LC_COLLATE}@ @\seebelow@
+#define @\libglobal{LC_CTYPE}@ @\seebelow@
+#define @\libglobal{LC_MONETARY}@ @\seebelow@
+#define @\libglobal{LC_NUMERIC}@ @\seebelow@
+#define @\libglobal{LC_TIME}@ @\seebelow@
 \end{codeblock}
 
 \pnum
diff --git a/source/iostreams.tex b/source/iostreams.tex
index 10fe61d2..8a53649b 100644
--- a/source/iostreams.tex
+++ b/source/iostreams.tex
@@ -554,7 +554,7 @@ [narrow.stream.objects]
 returns
 \tcode{\&cout}.
 Its state is otherwise the same as required for
-\tcode{basic_ios<char>::init}\iref{basic.ios.cons}.
+\libmemberrefx{basic_ios<char>::init}{basic_ios}{init}.
 \end{itemdescr}
 
 \indexlibraryglobal{cout}%
@@ -587,7 +587,7 @@ [narrow.stream.objects]
 \tcode{cerr.flags() \& unitbuf}
 is nonzero and \tcode{cerr.tie()} returns \tcode{\&cout}.
 Its state is otherwise the same as required for
-\tcode{basic_ios<char>::init}\iref{basic.ios.cons}.
+\libmemberrefx{basic_ios<char>::init}{basic_ios}{init}.
 \end{itemdescr}
 
 \indexlibraryglobal{clog}%
@@ -624,7 +624,7 @@ [wide.stream.objects]
 returns
 \tcode{\&wcout}.
 Its state is otherwise the same as required for
-\tcode{basic_ios<wchar_t>::init}\iref{basic.ios.cons}.
+\libmemberrefx{basic_ios<wchar_t>::init}{basic_ios}{init}.
 \end{itemdescr}
 
 \indexlibraryglobal{wcout}%
@@ -657,7 +657,7 @@ [wide.stream.objects]
 \tcode{wcerr.flags() \& unitbuf}
 is nonzero and \tcode{wcerr.tie()} returns \tcode{\&wcout}.
 Its state is otherwise the same as required for
-\tcode{basic_ios<wchar_t>::init}\iref{basic.ios.cons}.
+\libmemberrefx{basic_ios<wchar_t>::init}{basic_ios}{init}.
 \end{itemdescr}
 
 \indexlibraryglobal{wclog}%
@@ -1387,7 +1387,7 @@ [ios.members.static]
 \pnum
 \returns
 \tcode{true}
-if the previous state of the standard iostream objects\iref{iostream.objects}
+if the previous state of the \link{standard iostream objects}{iostream.objects}
 was synchronized and otherwise returns
 \tcode{false}.
 The first time it is called,
@@ -1446,8 +1446,8 @@ [ios.base.storage]
 
 \pnum
 \remarks
-Concurrent access to this function by multiple threads does not result in a data
-race\iref{intro.multithread}.
+Concurrent access to this function by multiple threads does not result in a
+\deflink{data race}{intro.multithread}.
 \end{itemdescr}
 
 \indexlibrarymember{iword}{ios_base}%
@@ -2032,12 +2032,12 @@ [basic.ios.members]
 \pnum
 \effects
 Calls
-\tcode{ios_base::imbue(loc)}\iref{ios.base.locales}
+\libmemberrefx{ios_base::imbue}{ios_base}{imbue}\tcode{(loc)}
 and
 if
 \tcode{rdbuf() != 0}
 then
-\tcode{rdbuf()->pubimbue(loc)}\iref{streambuf.locales}.
+\tcode{rdbuf()->}\libmemberrefx{pubimbue}{basic_streambuf}{pubimbue}\tcode{(loc)}.
 
 \pnum
 \returns
@@ -3289,7 +3289,7 @@ [streambuf.pub.get]
 If a read position is available, returns
 \tcode{egptr() - gptr()}.
 Otherwise returns
-\tcode{showmanyc()}\iref{streambuf.virt.get}.
+\libmemberrefx{showmanyc()}{basic_streambuf}{showmanyc}.
 \end{itemdescr}
 
 \indexlibrarymember{snextc}{basic_streambuf}%
@@ -4289,7 +4289,7 @@ [istream.general]
   template<class charT, class traits = char_traits<charT>>
   class basic_istream : virtual public basic_ios<charT, traits> {
   public:
-    // types (inherited from \tcode{basic_ios}\iref{ios})
+    // types (inherited from \link{\tcode{basic_ios}}{ios})
     using char_type   = charT;
     using int_type    = typename traits::int_type;
     using pos_type    = typename traits::pos_type;
@@ -4695,7 +4695,7 @@ [istream.formatted.arithmetic]
 \pnum
 As in the case of the inserters, these extractors depend on the
 locale's
-\tcode{num_get<>}\iref{locale.num.get} object to perform parsing the input
+\link{\tcode{num_get<>}}{locale.num.get} object to perform parsing the input
 stream data.
 These extractors behave as formatted input functions (as described in~\ref{istream.formatted.reqmts}).  After a \tcode{sentry} object is constructed, the
 conversion occurs as if performed by the following code fragment,
@@ -4982,7 +4982,7 @@ [istream.extractors]
 \begin{itemdescr}
 \pnum
 \effects
-Behaves as an unformatted input function\iref{istream.unformatted}.
+Behaves as an \link{unformatted input function}{istream.unformatted}.
 If \tcode{sb} is null, calls
 \tcode{setstate(fail\-bit)},
 which may throw
@@ -5377,7 +5377,7 @@ [istream.unformatted]
 Characters are extracted until any of the following occurs:
 \begin{itemize}
 \item
-\tcode{n != numeric_limits<streamsize>::max()}\iref{numeric.limits}
+\tcode{n != \libmemberrefx{numeric_limits<streamsize>::max()}{numeric_limits}{max}{numeric.limits}}
 and
 \tcode{n} characters have been extracted so far
 \item
@@ -5713,12 +5713,12 @@ [istream.manip]
 \begin{itemdescr}
 \pnum
 \effects
-Behaves as an unformatted input function\iref{istream.unformatted}, except that it does not count the number of characters extracted and
+Behaves as an \link{unformatted input function}{istream.unformatted}, except that it does not count the number of characters extracted and
 does not affect the value returned by subsequent calls to \tcode{is.gcount()}. After
 constructing a \tcode{sentry} object extracts characters as long as the next available
 character \tcode{c} is whitespace or until there are no more characters in the sequence.
 Whitespace characters are distinguished with the same criterion as used by
-\tcode{sentry::sentry}\iref{istream.sentry}.
+\link{\tcode{sentry::sentry}}{istream.sentry}.
 If
 \tcode{ws}
 stops extracting characters because there are no more available it sets
@@ -5743,7 +5743,7 @@ [istream.rvalue]
 \pnum
 \constraints
 The expression \tcode{is >> std::forward<T>(x)} is well-formed
-when treated as an unevaluated operand\iref{term.unevaluated.operand} and
+when treated as an \deflink{unevaluated operand}{expr.context} and
 \tcode{Istream} is publicly and unambiguously derived from \tcode{ios_base}.
 
 \pnum
@@ -5811,7 +5811,7 @@ [iostream.cons]
 Initializes the base class subobjects with
 \tcode{basic_istream<charT, traits>(sb)}\iref{istream}
 and
-\tcode{basic_ostream<charT, traits>(sb)}\iref{ostream}.
+\link{\tcode{basic_ostream<charT, traits>(sb)}}{ostream}.
 
 \pnum
 \ensures
@@ -5897,7 +5897,7 @@ [ostream.general]
   template<class charT, class traits = char_traits<charT>>
   class basic_ostream : virtual public basic_ios<charT, traits> {
   public:
-    // types (inherited from \tcode{basic_ios}\iref{ios})
+    // types (inherited from \link{\tcode{basic_ios}}{ios})
     using char_type   = charT;
     using int_type    = typename traits::int_type;
     using pos_type    = typename traits::pos_type;
@@ -6677,7 +6677,7 @@ [ostream.inserters]
 \end{codeblock}
 where \tcode{s} is an
 \impldef{NTCTS in \tcode{basic_ostream<charT, traits>\& op\-er\-ator<<(nullptr_t)}}
-NTCTS\iref{defns.ntcts}.
+\link{NTCTS}{defns.ntcts}.
 \end{itemdescr}
 
 \rSec4[ostream.inserters.character]{Character inserter function templates}
@@ -6701,7 +6701,7 @@ [ostream.inserters.character]
 \begin{itemdescr}
 \pnum
 \effects
-Behaves as a formatted output function\iref{ostream.formatted.reqmts}
+Behaves as a \link{formatted output function}{ostream.formatted.reqmts}
 of \tcode{out}. Constructs a character sequence \tcode{seq}.
 If \tcode{c} has type
 \tcode{char}
@@ -7433,7 +7433,7 @@ [ext.manip]
 \pnum
 \effects
 The expression \tcode{in >> get_money(mon, intl)} described below
-behaves as a formatted input function\iref{istream.formatted.reqmts}.
+behaves as a \link{formatted input function}{istream.formatted.reqmts}.
 
 \pnum
 \returns
@@ -7478,7 +7478,7 @@ [ext.manip]
 An object of unspecified type such that if
 \tcode{out} is an object of type \tcode{basic_ostream<charT, traits>}
 then the expression \tcode{out << put_money(mon, intl)} behaves as a
-formatted output function\iref{ostream.formatted.reqmts} that calls
+\link{formatted output function}{ostream.formatted.reqmts} that calls
 \tcode{f(out, mon, intl)}, where the function \tcode{f} is defined as:
 
 \begin{codeblock}
@@ -7602,7 +7602,7 @@ [quoted.manip]
 \tcode{charT} and with member type \tcode{traits_type}, which in the second and third
 forms is the same as \tcode{traits}, then the expression
 \tcode{out << quoted(s, delim, escape)}
-behaves as a formatted output function\iref{ostream.formatted.reqmts}
+behaves as a \link{formatted output function}{ostream.formatted.reqmts}
 of \tcode{out}. This forms a character sequence \tcode{seq}, initially
 consisting of the following elements:
 \begin{itemize}
@@ -13683,7 +13683,7 @@ [fs.path.req]
 
 \pnum
 \begin{note}
-See path conversions\iref{fs.path.cvt}
+See \link{path conversions}{fs.path.cvt}
 for how the value types above and their encodings convert to
 \tcode{path::value_type} and its encoding.
 \end{note}
@@ -14283,7 +14283,7 @@ [fs.path.generic.obs]
 
 \pnum
 Generic format observer functions return strings formatted according to the
-generic pathname format\iref{fs.path.generic}.
+\link{generic pathname format}{fs.path.generic}.
 A single slash (\tcode{'/'}) character is used as
 the \grammarterm{directory-separator}.
 
@@ -14826,11 +14826,11 @@ [fs.path.itr]
 \indexlibrarymember{path}{iterator}%
 \pnum
 Path iterators iterate over the elements of the pathname
-in the generic format\iref{fs.path.generic}.
+in the \link{generic format}{fs.path.generic}.
 
 \pnum
 A \tcode{path::iterator} is a constant iterator meeting all the
-requirements of a bidirectional iterator\iref{bidirectional.iterators}
+requirements of a \link{bidirectional iterator}{bidirectional.iterators}
 except that,
 for dereferenceable iterators \tcode{a} and \tcode{b}
 of type \tcode{path::iterator}
@@ -16097,7 +16097,7 @@ [fs.class.directory.iterator.general]
 construction of a \tcode{directory_iterator} for the directory, it is
 unspecified whether or not subsequently incrementing the iterator will ever
 result in an iterator referencing the removed or added directory entry. See
-POSIX \tcode{readdir}.
+POSIX \weblink{\tcode{readdir}}{http://pubs.opengroup.org/onlinepubs/9699919799/functions/readdir.html}.
 \end{note}
 
 \rSec3[fs.dir.itr.members]{Members}
@@ -16189,7 +16189,7 @@ [fs.dir.itr.members]
 \pnum
 \effects
 As specified for the prefix increment operation of
-Input iterators\iref{input.iterators}.
+\link{Input iterators}{input.iterators}.
 
 \pnum
 \returns
@@ -16501,7 +16501,7 @@ [fs.rec.dir.itr.members]
 \pnum
 \effects
 As specified for the prefix increment operation of
-Input iterators\iref{input.iterators},
+\link{Input iterators}{input.iterators},
 except that:
 
 \begin{itemize}
@@ -17092,7 +17092,7 @@ [fs.op.create.dir.symlk]
 \begin{itemdescr}
 \pnum
 \effects
-Establishes the postcondition, as if by POSIX \tcode{symlink()}.
+Establishes the postcondition, as if by POSIX \weblink{\tcode{symlink()}}{http://pubs.opengroup.org/onlinepubs/9699919799/functions/symlink.html}.
 
 \pnum
 \ensures
@@ -17168,7 +17168,7 @@ [fs.op.create.symlink]
 \begin{itemdescr}
 \pnum
 \effects
-Establishes the postcondition, as if by POSIX \tcode{symlink()}.
+Establishes the postcondition, as if by POSIX \weblink{\tcode{symlink()}}{http://pubs.opengroup.org/onlinepubs/9699919799/functions/symlink.html}.
 
 \pnum
 \ensures
@@ -17201,7 +17201,7 @@ [fs.op.current.path]
 \returns
 The absolute path of the current working directory,
   whose pathname in the native format is
-  obtained as if by POSIX \tcode{getcwd()}.
+  obtained as if by POSIX \weblink{\tcode{getcwd()}}{http://pubs.opengroup.org/onlinepubs/9699919799/functions/getcwd.html}.
   The signature with argument \tcode{ec} returns \tcode{path()} if an
   error occurs.
 
@@ -17238,7 +17238,7 @@ [fs.op.current.path]
 \begin{itemdescr}
 \pnum
 \effects
-Establishes the postcondition, as if by POSIX \tcode{chdir()}.
+Establishes the postcondition, as if by POSIX \weblink{\tcode{chdir()}}{http://pubs.opengroup.org/onlinepubs/9699919799/functions/chdir.html}.
 
 \pnum
 \ensures
@@ -17349,7 +17349,7 @@ [fs.op.file.size]
 \item
   If \tcode{is_regular_file(p)}, the size in bytes of the file
   \tcode{p} resolves to, determined as if by the value of the POSIX \tcode{stat}
-  class member \tcode{st_size} obtained as if by POSIX \tcode{stat()}.
+  class member \tcode{st_size} obtained as if by POSIX \weblink{\tcode{stat()}}{http://pubs.opengroup.org/onlinepubs/9699919799/functions/stat.html}.
 \item
   Otherwise, the result is \impldef{result of \tcode{filesystem::file_size}}.
 \end{itemize}
@@ -17731,7 +17731,7 @@ [fs.op.last.write.time]
 \pnum
 \effects
 Sets the time of last data modification of the file
-  resolved to by \tcode{p} to \tcode{new_time}, as if by POSIX \tcode{futimens()}.
+  resolved to by \tcode{p} to \tcode{new_time}, as if by POSIX \weblink{\tcode{futimens()}}{http://pubs.opengroup.org/onlinepubs/9699919799/functions/futimens.html}.
 
 \pnum
 \throws
diff --git a/source/regex.tex b/source/regex.tex
index 6fc3b5a0..159a1fbd 100644
--- a/source/regex.tex
+++ b/source/regex.tex
@@ -705,13 +705,13 @@ [re.synopt]
 %
 \tcode{awk} &
 Specifies that the grammar recognized by the regular expression engine
-shall be that used by the utility awk in POSIX.
+shall be that used by the utility \weblink{awk}{http://pubs.opengroup.org/onlinepubs/9699919799/utilities/awk.html} in POSIX.
 \indexlibrarymember{syntax_option_type}{awk}%
 \\ \rowsep
 %
 \tcode{grep} &
 Specifies that the grammar recognized by the regular expression engine
-shall be that used by the utility grep in POSIX.
+shall be that used by the utility \weblink{grep}{http://pubs.opengroup.org/onlinepubs/9699919799/utilities/grep.html} in POSIX.
 \indexlibrarymember{syntax_option_type}{grep}%
 \\ \rowsep
 %
@@ -735,42 +735,29 @@ [re.matchflag]
 
 \indexlibraryglobal{match_flag_type}%
 \indexlibrarymember{regex_constants}{match_flag_type}%
-\indexlibraryglobal{match_default}%
-\indexlibraryglobal{match_not_bol}%
-\indexlibraryglobal{match_not_eol}%
-\indexlibraryglobal{match_not_bow}%
-\indexlibraryglobal{match_not_eow}%
-\indexlibraryglobal{match_any}%
-\indexlibraryglobal{match_not_null}%
-\indexlibraryglobal{match_continuous}%
-\indexlibraryglobal{match_prev_avail}%
-\indexlibraryglobal{format_default}%
-\indexlibraryglobal{format_sed}%
-\indexlibraryglobal{format_no_copy}%
-\indexlibraryglobal{format_first_only}%
 \begin{codeblock}
 namespace std::regex_constants {
   using match_flag_type = @\textit{T2}@;
-  inline constexpr match_flag_type match_default = {};
-  inline constexpr match_flag_type match_not_bol = @\unspec@;
-  inline constexpr match_flag_type match_not_eol = @\unspec@;
-  inline constexpr match_flag_type match_not_bow = @\unspec@;
-  inline constexpr match_flag_type match_not_eow = @\unspec@;
-  inline constexpr match_flag_type match_any = @\unspec@;
-  inline constexpr match_flag_type match_not_null = @\unspec@;
-  inline constexpr match_flag_type match_continuous = @\unspec@;
-  inline constexpr match_flag_type match_prev_avail = @\unspec@;
-  inline constexpr match_flag_type format_default = {};
-  inline constexpr match_flag_type format_sed = @\unspec@;
-  inline constexpr match_flag_type format_no_copy = @\unspec@;
-  inline constexpr match_flag_type format_first_only = @\unspec@;
+  inline constexpr match_flag_type @\libglobal{match_default}@ = {};
+  inline constexpr match_flag_type @\libglobal{match_not_bol}@ = @\unspec@;
+  inline constexpr match_flag_type @\libglobal{match_not_eol}@ = @\unspec@;
+  inline constexpr match_flag_type @\libglobal{match_not_bow}@ = @\unspec@;
+  inline constexpr match_flag_type @\libglobal{match_not_eow}@ = @\unspec@;
+  inline constexpr match_flag_type @\libglobal{match_any}@ = @\unspec@;
+  inline constexpr match_flag_type @\libglobal{match_not_null}@ = @\unspec@;
+  inline constexpr match_flag_type @\libglobal{match_continuous}@ = @\unspec@;
+  inline constexpr match_flag_type @\libglobal{match_prev_avail}@ = @\unspec@;
+  inline constexpr match_flag_type @\libglobal{format_default}@ = {};
+  inline constexpr match_flag_type @\libglobal{format_sed}@ = @\unspec@;
+  inline constexpr match_flag_type @\libglobal{format_no_copy}@ = @\unspec@;
+  inline constexpr match_flag_type @\libglobal{format_first_only}@ = @\unspec@;
 }
 \end{codeblock}
 
 \pnum
 \indexlibraryglobal{match_flag_type}%
 The type \tcode{match_flag_type} is an
-\impldef{type of \tcode{regex_constants::match_flag_type}} bitmask type\iref{bitmask.types}.
+\impldef{type of \tcode{regex_constants::match_flag_type}} \link{bitmask type}{bitmask.types}.
 The constants of that type, except for \tcode{match_default} and
 \tcode{format_default}, are bitmask elements. The \tcode{match_default} and
 \tcode{format_default} constants are empty bitmasks.
@@ -832,7 +819,7 @@ [re.matchflag]
 \tcode{match_prev_avail} &
 \verb!--first! is a valid iterator position. When this flag is
 set the flags \tcode{match_not_bol} and \tcode{match_not_bow} shall be ignored by the
-regular expression algorithms\iref{re.alg} and iterators\iref{re.iter}.
+\link{regular expression algorithms}{re.alg} and \link{iterators}{re.iter}.
 \\ \rowsep
 %
 \indexlibraryglobal{format_default}%
@@ -840,7 +827,7 @@ [re.matchflag]
 When a regular expression match is to be replaced by a
 new string, the new string shall be constructed using the rules used by
 the ECMAScript replace function in ECMA-262,
-part 15.5.4.11 String.prototype.replace. In
+part 15.5.4.11 \weblink{String.prototype.replace}{https://tc39.github.io/ecma262/#sec-string.prototype.replace}. In
 addition, during search and replace operations all non-overlapping
 occurrences of the regular expression shall be located and replaced, and
 sections of the input that did not match the expression shall be copied
@@ -851,7 +838,7 @@ [re.matchflag]
 \tcode{format_sed} &
 When a regular expression match is to be replaced by a
 new string, the new string shall be constructed using the rules used by
-the sed utility in POSIX.
+the \weblink{sed}{http://pubs.opengroup.org/onlinepubs/9699919799/utilities/sed.html} utility in POSIX.
 \\ \rowsep
 %
 \indexlibraryglobal{format_no_copy}%
@@ -893,7 +880,7 @@ [re.err]
 \indexlibraryglobal{error_type}%
 \indexlibrarymember{regex_constants}{error_type}%
 The type \tcode{error_type} is an \impldef{type of
-\tcode{regex_constants::error_type}} enumerated type\iref{enumerated.types}.
+\tcode{regex_constants::error_type}} \link{enumerated type}{enumerated.types}.
 Values of type \tcode{error_type} represent the error
 conditions described in \tref{re.err}:
 
diff --git a/source/threads.tex b/source/threads.tex
index e4fa6273..0781b360 100644
--- a/source/threads.tex
+++ b/source/threads.tex
@@ -5,7 +5,7 @@ [thread.general]
 
 \pnum
 The following subclauses describe components to create and manage
-threads\iref{intro.multithread}, perform mutual exclusion, and communicate conditions
+\deflinkx{threads}{thread}{intro.multithread}, perform mutual exclusion, and communicate conditions
 and values
 between threads, as summarized in \tref{thread.summary}.
 
@@ -293,8 +293,8 @@ [thread.req.lockable.timed]
 A type \tcode{L} meets the \oldconcept{TimedLockable} requirements if it meets the \oldconcept{Lockable}
 requirements and the following expressions are well-formed and have the specified semantics
 (\tcode{m} denotes a value of type \tcode{L}, \tcode{rel_time} denotes a value of an
-instantiation of \tcode{duration}\iref{time.duration}, and \tcode{abs_time} denotes a value
-of an instantiation of \tcode{time_point}\iref{time.point}).
+instantiation of \link{\tcode{duration}}{time.duration}, and \tcode{abs_time} denotes a value
+of an instantiation of \link{\tcode{time_point}}{time.point}).
 
 \begin{itemdecl}
 m.try_lock_for(rel_time)
@@ -6038,7 +6038,7 @@ [thread.mutex.requirements.general]
 
 \pnum
 A mutex object facilitates protection against data races and allows safe synchronization of
-data between execution agents\iref{thread.req.lockable}.
+data between \deflinkx{execution agents}{execution agent}{thread.req.lockable}.
 An execution agent \term{owns} a mutex from the time it successfully calls one of the
 lock functions until it calls unlock. Mutexes can be either recursive or non-recursive, and can
 grant simultaneous ownership to one or many execution agents. Both
@@ -6082,7 +6082,7 @@ [thread.mutex.requirements.mutex.general]
 a single mutex appears to occur in a single total order.
 \begin{note}
 This
-can be viewed as the modification order\iref{intro.multithread} of the
+can be viewed as the \deflink{modification order}{intro.multithread} of the
 mutex.
 \end{note}
 \begin{note}
@@ -6162,7 +6162,7 @@ [thread.mutex.requirements.mutex.general]
 \pnum
 \sync
 If \tcode{try_lock()} returns \tcode{true}, prior \tcode{unlock()} operations
-on the same object \term{synchronize with}\iref{intro.multithread} this operation.
+on the same object \deflink{synchronize with}{intro.multithread} this operation.
 \begin{note}
 Since \tcode{lock()} does not synchronize with a failed subsequent
 \tcode{try_lock()}, the visibility rules are weak enough that little would be
@@ -6198,7 +6198,7 @@ [thread.mutex.requirements.mutex.general]
 
 \pnum
 \sync
-This operation synchronizes with\iref{intro.multithread} subsequent
+This operation \deflinkx{synchronizes with}{synchronize with}{intro.multithread} subsequent
 lock operations that obtain ownership on the same object.
 
 \pnum
@@ -6327,9 +6327,9 @@ [thread.timedmutex.requirements.general]
 meet the requirements set out below.
 In this description, \tcode{m} denotes an object of a mutex type,
 \tcode{rel_time} denotes an object of an
-instantiation of \tcode{duration}\iref{time.duration}, and \tcode{abs_time} denotes an
+instantiation of \link{\tcode{duration}}{time.duration}, and \tcode{abs_time} denotes an
 object of an
-instantiation of \tcode{time_point}\iref{time.point}.
+instantiation of \link{\tcode{time_point}}{time.point}.
 \begin{note}
 The timed mutex types meet the \oldconcept{TimedLockable}
 requirements\iref{thread.req.lockable.timed}.
@@ -6619,7 +6619,7 @@ [thread.sharedmutex.requirements.general]
 
 \pnum
 \sync
-This operation synchronizes with\iref{intro.multithread} subsequent
+This operation \deflinkx{synchronizes with}{synchronize with}{intro.multithread} subsequent
 \tcode{lock()} operations that obtain ownership on the same object.
 
 \pnum
@@ -6723,7 +6723,7 @@ [thread.sharedtimedmutex.requirements.general]
 \tcode{rel_time} denotes an object of an instantiation of
 \tcode{duration}\iref{time.duration}, and
 \tcode{abs_time} denotes an object of an instantiation of
-\tcode{time_point}\iref{time.point}.
+\link{\tcode{time_point}}{time.point}.
 \begin{note}
 The shared timed mutex types meet the \oldconcept{SharedTimedLockable}
 requirements\iref{thread.req.lockable.shared.timed}.
@@ -6934,7 +6934,7 @@ [thread.lock.guard]
 \pnum
 An object of type \tcode{lock_guard} controls the ownership of a lockable object
 within a scope. A \tcode{lock_guard} object maintains ownership of a lockable
-object throughout the \tcode{lock_guard} object's lifetime\iref{basic.life}.
+object throughout the \tcode{lock_guard} object's \deflink{lifetime}{basic.life}.
 The behavior of a program is undefined if the lockable object referenced by
 \tcode{pm} does not exist for the entire lifetime of the \tcode{lock_guard}
 object. The supplied \tcode{Mutex} type shall meet the \oldconcept{BasicLockable}
@@ -7007,7 +7007,7 @@ [thread.lock.scoped]
 \pnum
 An object of type \tcode{scoped_lock} controls the ownership of lockable objects
 within a scope. A \tcode{scoped_lock} object maintains ownership of lockable
-objects throughout the \tcode{scoped_lock} object's lifetime\iref{basic.life}.
+objects throughout the \tcode{scoped_lock} object's \deflink{lifetime}{basic.life}.
 The behavior of a program is undefined if the lockable objects referenced by
 \tcode{pm} do not exist for the entire lifetime of the \tcode{scoped_lock}
 object.
@@ -8175,7 +8175,7 @@ [thread.once.callonce]
 \pnum
 \sync
 For any given \tcode{once_flag}: all active executions occur in a total
-order; completion of an active execution synchronizes with\iref{intro.multithread}
+order; completion of an active execution \deflinkx{synchronizes with}{synchronize with}{intro.multithread}
 the start of the next one in this total order; and the returning execution
 synchronizes with the return from all passive executions.
 
@@ -10143,22 +10143,21 @@ [futures.state]
 
 \pnum
 Calls to functions that successfully set the stored result of a shared
-state synchronize
-with\iref{intro.multithread} calls to functions
+state \deflink{synchronize with}{intro.multithread} calls to functions
 successfully detecting the ready state resulting from that setting.
 The storage of the result
 (whether normal or exceptional) into the shared state
-synchronizes with\iref{intro.multithread}
+\deflinkx{synchronizes with}{synchronize with}{intro.multithread}
 the successful return from a call to a waiting function on the shared state.
 
 \pnum
 Some functions (e.g., \tcode{promise::set_value_at_thread_exit}) delay making
 the shared state ready until the calling thread exits. The destruction of
-each of that thread's objects with thread storage duration\iref{basic.stc.thread}
+each of that thread's objects with \link{thread storage duration}{basic.stc.thread}
 is sequenced before making that shared state ready.
 
 \pnum
-Access to the result of the same shared state may conflict\iref{intro.multithread}.
+Access to the result of the same shared state may \deflink{conflict}{intro.multithread}.
 \begin{note}
 This explicitly specifies that the result of the shared state is
 visible in the objects that reference this state in the sense of data race
@@ -10494,8 +10493,8 @@ [futures.unique.future]
 do not share their shared state with other asynchronous return objects.
 A default-constructed \tcode{future} object has no
 shared state. A \tcode{future} object with shared state can be created by
-functions on asynchronous providers\iref{futures.state} or by the move constructor
-and shares its shared state with
+functions on \deflinkx{asynchronous providers}{asynchronous provider}{futures.state}
+or by the move constructor and shares its shared state with
 the original asynchronous provider. The result (value or exception) of
 a \tcode{future} object
 can be
@@ -10805,7 +10804,7 @@ [futures.shared.future]
 shared state can
 be created
 by conversion from a \tcode{future} object and shares its shared state with the
-original asynchronous provider\iref{futures.state} of the shared state.
+original \deflink{asynchronous provider}{futures.state} of the shared state.
 The result (value or exception) of a \tcode{shared_future} object
 can be set by
 calling a respective function on an
@@ -11254,7 +11253,7 @@ [futures.async]
 out\iref{thread.thread.member};
 \item
 the associated thread completion
-synchronizes with\iref{intro.multithread}
+\deflinkx{synchronizes with}{synchronize with}{intro.multithread}
 the return from
 the first function
 that successfully detects the ready status of the shared state or
@@ -11419,7 +11418,7 @@ [futures.task.members]
 \pnum
 \constraints
 \tcode{\&F::operator()} is well-formed when
-treated as an unevaluated operand\iref{term.unevaluated.operand} and either
+treated as an \deflink{unevaluated operand}{term.unevaluated.operand} and either
 \begin{itemize}
 \item
 \tcode{F::operator()} is a non-static member function and
diff --git a/source/limits.tex b/source/limits.tex
index b3188315..30fbd815 100644
--- a/source/limits.tex
+++ b/source/limits.tex
@@ -131,6 +131,6 @@
 \item%
 Handlers per try block\iref{except.handle} [256].
 \item%
-Number of placeholders\iref{func.bind.place} [10].
+Number of \link{placeholders}{func.bind.place} [10].
 
 \end{itemize}
diff --git a/source/compatibility.tex b/source/compatibility.tex
index 0bdb90b9..10312e97 100644
--- a/source/compatibility.tex
+++ b/source/compatibility.tex
@@ -1515,8 +1515,8 @@ [diff.cpp11.expr]
 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/future.tex b/source/future.tex
index 3b75e30c..bfc60427 100644
--- a/source/future.tex
+++ b/source/future.tex
@@ -16,7 +16,7 @@ [depr.general]
 Normative for the current revision of \Cpp{},
 but having been identified as a candidate for removal from future revisions.
 An implementation may declare library names and entities described in this Clause with the
-\tcode{deprecated} attribute\iref{dcl.attr.deprecated}.
+\link{\tcode{deprecated} attribute}{dcl.attr.deprecated}.
 
 \rSec1[depr.arith.conv.enum]{Arithmetic conversion on enumerations}
 
@@ -177,11 +177,11 @@ [depr.local]
 \rSec1[depr.impldec]{Implicit declaration of copy functions}
 
 \pnum
-The implicit definition of a copy constructor\iref{class.copy.ctor}
+The implicit definition of a \link{copy constructor}{class.copy.ctor}
 as defaulted is deprecated if the class has
 a user-declared copy assignment operator or
-a user-declared destructor\iref{class.dtor}.
-The implicit definition of a copy assignment operator\iref{class.copy.assign}
+a user-declared \link{destructor}{class.dtor}.
+The implicit definition of a \link{copy assignment operator}{class.copy.assign}
 as defaulted is deprecated if the class has
 a user-declared copy constructor or
 a user-declared destructor.
@@ -1609,7 +1609,7 @@ [depr.tuple]
 \pnum
 Let \tcode{TS} denote \tcode{tuple_size<T>} of the cv-unqualified type \tcode{T}.
 If the expression \tcode{TS::value} is well-formed
-when treated as an unevaluated operand\iref{term.unevaluated.operand},
+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
 \tcode{integral_constant<size_t, TS::value>}.
-- 
2.25.1


From 3b33a826e667d40356e4c58730752b43c15b09db Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Tue, 1 Aug 2017 14:38:23 +0200
Subject: [PATCH 09/21] Fix dubious \defnx that has see{} in it, and remove
 range index entry with the same key.

---
 source/templates.tex | 5 ++---
 source/iostreams.tex | 2 +-
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/source/templates.tex b/source/templates.tex
index 2ef7da3c..d90d295f 100644
--- a/source/templates.tex
+++ b/source/templates.tex
@@ -1828,7 +1828,6 @@ [temp.constr.decl]
 \end{example}
 
 \rSec2[temp.constr.normal]{Constraint normalization}
-\indextext{constraint!normalization|(}%
 
 \pnum
 The \defnx{normal form}{normal form!constraint} of an \grammarterm{expression} \tcode{E} is
@@ -1884,10 +1883,11 @@ [temp.constr.normal]
 \end{itemize}
 
 \pnum
+\indextext{normalization|see{constraint, normalization}}%
 The process of obtaining the normal form of a
 \grammarterm{constraint-expression}
 is called
-\defnx{normalization}{normalization!constraint|see{constraint, normalization}}.
+\defnx{normalization}{constraint!normalization}.
 \begin{note}
 Normalization of \grammarterm{constraint-expression}{s}
 is performed
@@ -1917,7 +1917,6 @@ [temp.constr.normal]
 The associated constraints of \#3 are
 \tcode{requires (T x) \{ ++x; \}} (with mapping $\tcode{T} \mapsto \tcode{U}$).
 \end{example}
-\indextext{constraint!normalization|)}
 
 \rSec2[temp.constr.order]{Partial ordering by constraints}
 \indextext{subsume|see{constraint, subsumption}}
diff --git a/source/iostreams.tex b/source/iostreams.tex
index 8a53649b..285af950 100644
--- a/source/iostreams.tex
+++ b/source/iostreams.tex
@@ -13476,7 +13476,7 @@ [fs.path.generic]
 
 \pnum
 \indextext{path!normalization|(}%
-\defnx{Normalization}{normalization!path|see{path, normalization}} of a generic format pathname means:
+\defnx{Normalization}{normalization!path} of a generic format pathname means:
 
 \begin{enumerate}
 \item If the path is empty, stop.
-- 
2.25.1


From 3f3eb511d9140276a231c9b19e096e7c0d8b0576 Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Sun, 11 Nov 2018 02:27:17 +0100
Subject: [PATCH 10/21] Replace more non-codeblocks with outputblocks.

---
 source/iostreams.tex | 12 ++++++------
 source/regex.tex     |  4 ++--
 source/uax31.tex     |  4 ++--
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/source/iostreams.tex b/source/iostreams.tex
index 285af950..74dbe53d 100644
--- a/source/iostreams.tex
+++ b/source/iostreams.tex
@@ -16847,16 +16847,16 @@ [fs.op.copy]
 \pnum
 \begin{example}
 Given this directory structure:
-\begin{codeblock}
+\begin{outputblock}
 /dir1
   file1
   file2
   dir2
     file3
-\end{codeblock}
+\end{outputblock}
 
 Calling \tcode{copy("/dir1", "/dir3")} would result in:
-\begin{codeblock}
+\begin{outputblock}
 /dir1
   file1
   file2
@@ -16865,10 +16865,10 @@ [fs.op.copy]
 /dir3
   file1
   file2
-\end{codeblock}
+\end{outputblock}
 
 Alternatively, calling \tcode{copy("/dir1", "/dir3", copy_options::recursive)} would result in:
-\begin{codeblock}
+\begin{outputblock}
 /dir1
   file1
   file2
@@ -16879,7 +16879,7 @@ [fs.op.copy]
   file2
   dir2
     file3
-\end{codeblock}
+\end{outputblock}
 \end{example}
 \end{itemdescr}
 
diff --git a/source/regex.tex b/source/regex.tex
index 159a1fbd..cc606175 100644
--- a/source/regex.tex
+++ b/source/regex.tex
@@ -3862,7 +3862,7 @@ [re.grammar]
 \tcode{upper}, \tcode{xdigit}, \tcode{d}, \tcode{s}, \tcode{w}.
 In addition the following expressions shall be equivalent:
 
-\begin{codeblock}
+\begin{outputblock}
 \d @\textnormal{and}@ [[:digit:]]
 
 \D @\textnormal{and}@ [^[:digit:]]
@@ -3874,7 +3874,7 @@ [re.grammar]
 \w @\textnormal{and}@ [_[:alnum:]]
 
 \W @\textnormal{and}@ [^_[:alnum:]]
-\end{codeblock}
+\end{outputblock}
 
 \pnum
 \indexlibrary{regular expression traits!\idxcode{lookup_collatename}}%
diff --git a/source/uax31.tex b/source/uax31.tex
index aea6e6b5..75beaa75 100644
--- a/source/uax31.tex
+++ b/source/uax31.tex
@@ -34,11 +34,11 @@ [uaxid.def.general]
 the \tcode{<Medial>} set is empty, and
 the \tcode{<Continue>} characters are unmodified.
 In the grammar used in \UAX{31}, this is
-\begin{codeblock}
+\begin{outputblock}
 <Identifier> := <Start> <Continue>*
 <Start> := XID_Start + @\textrm{\ucode{005f}}@
 <Continue> := <Start> + XID_Continue
-\end{codeblock}
+\end{outputblock}
 
 \pnum
 This is described in the \Cpp{} grammar in \ref{lex.name},
-- 
2.25.1


From b0f111fdb3a7523e5089e4b6eff6a7eb414c8c7c Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Sun, 11 Nov 2018 02:48:33 +0100
Subject: [PATCH 11/21] Use cxxdraft-htmlgen macros to annotate non-C++ code
 and literal fragments.

---
 source/lex.tex        | 130 +++++------
 source/exceptions.tex |   4 +-
 source/utilities.tex  | 134 +++++------
 source/time.tex       | 522 +++++++++++++++++++++---------------------
 4 files changed, 395 insertions(+), 395 deletions(-)

diff --git a/source/lex.tex b/source/lex.tex
index a1ad8a34..34d313bc 100644
--- a/source/lex.tex
+++ b/source/lex.tex
@@ -327,7 +327,7 @@ [lex.charset]
 
 \begin{bnf}
 \nontermdef{named-universal-character}\br
-    \terminal{\textbackslash N\{} n-char-sequence \terminal{\}}
+    \literalterminal{\textbackslash N\{} n-char-sequence \literalterminal{\}}
 \end{bnf}
 
 \begin{bnf}
@@ -343,17 +343,17 @@ [lex.charset]
 
 \begin{bnf}
 \nontermdef{universal-character-name}\br
-    \terminal{\textbackslash u} hex-quad\br
-    \terminal{\textbackslash U} hex-quad hex-quad\br
-    \terminal{\textbackslash u\{} simple-hexadecimal-digit-sequence \terminal{\}}\br
+    \literalterminal{\textbackslash u} hex-quad\br
+    \literalterminal{\textbackslash U} hex-quad hex-quad\br
+    \literalterminal{\textbackslash u\{} simple-hexadecimal-digit-sequence \literalterminal{\}}\br
     named-universal-character
 \end{bnf}
 
 \pnum
 A \grammarterm{universal-character-name}
-of the form \tcode{\textbackslash u} \grammarterm{hex-quad},
-\tcode{\textbackslash U} \grammarterm{hex-quad} \grammarterm{hex-quad}, or
-\tcode{\textbackslash u\{\grammarterm{simple-hexadecimal-digit-sequence}\}}
+of the form \literaltcode{\textbackslash u} \grammarterm{hex-quad},
+\literaltcode{\textbackslash U} \grammarterm{hex-quad} \grammarterm{hex-quad}, or
+\literaltcode{\textbackslash u\{\grammarterm{simple-hexadecimal-digit-sequence}\}}
 designates the character in the translation character set
 whose Unicode scalar value is the hexadecimal number represented by
 the sequence of \grammarterm{hexadecimal-digit}s
@@ -514,7 +514,7 @@ [lex.pptoken]
 \item
 \indextext{literal!string!raw}%
 If the next character begins a sequence of characters that could be the prefix
-and initial double quote of a raw string literal, such as \tcode{R"}, the next preprocessing
+and initial double quote of a raw string literal, such as \literaltcode{R"}, the next preprocessing
 token shall be a raw string literal. Between the initial and final
 double quote characters of the raw string, any transformations performed in phase
 2 (line splicing) are reverted; this reversion
@@ -522,7 +522,7 @@ [lex.pptoken]
 parenthesis is identified. The raw string literal is defined as the shortest sequence
 of characters that matches the raw-string pattern
 \begin{ncbnf}
-\opt{encoding-prefix} \terminal{R} raw-string
+\opt{encoding-prefix} \literalterminal{R} raw-string
 \end{ncbnf}
 
 \item Otherwise, if the next three characters are \tcode{<::} and the subsequent character
@@ -753,15 +753,15 @@ [lex.ppnumber]
 \begin{bnf}
 \nontermdef{pp-number}\br
     digit\br
-    \terminal{.} digit\br
+    \literalterminal{.} digit\br
     pp-number identifier-continue\br
-    pp-number \terminal{'} digit\br
-    pp-number \terminal{'} nondigit\br
-    pp-number \terminal{e} sign\br
-    pp-number \terminal{E} sign\br
-    pp-number \terminal{p} sign\br
-    pp-number \terminal{P} sign\br
-    pp-number \terminal{.}
+    pp-number \literalterminal{'} digit\br
+    pp-number \literalterminal{'} nondigit\br
+    pp-number \literalterminal{e} sign\br
+    pp-number \literalterminal{E} sign\br
+    pp-number \literalterminal{p} sign\br
+    pp-number \literalterminal{P} sign\br
+    pp-number \literalterminal{.}
 \end{bnf}
 
 \pnum
@@ -1101,19 +1101,19 @@ [lex.icon]
 \nontermdef{binary-literal}\br
     \terminal{0b} binary-digit\br
     \terminal{0B} binary-digit\br
-    binary-literal \opt{\terminal{'}} binary-digit
+    binary-literal \opt{\literalterminal{'}} binary-digit
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{octal-literal}\br
     \terminal{0}\br
-    octal-literal \opt{\terminal{'}} octal-digit
+    octal-literal \opt{\literalterminal{'}} octal-digit
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{decimal-literal}\br
     nonzero-digit\br
-    decimal-literal \opt{\terminal{'}} digit
+    decimal-literal \opt{\literalterminal{'}} digit
 \end{bnf}
 
 \begin{bnf}
@@ -1144,14 +1144,14 @@ [lex.icon]
 \begin{bnf}
 \nontermdef{hexadecimal-digit-sequence}\br
     hexadecimal-digit\br
-    hexadecimal-digit-sequence \opt{\terminal{'}} hexadecimal-digit
+    hexadecimal-digit-sequence \opt{\literalterminal{'}} hexadecimal-digit
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{hexadecimal-digit} \textnormal{one of}\br
-    \terminal{0  1  2  3  4  5  6  7  8  9}\br
-    \terminal{a  b  c  d  e  f}\br
-    \terminal{A  B  C  D  E  F}
+    \literalterminal{0  1  2  3  4  5  6  7  8  9}\br
+    \literalterminal{a  b  c  d  e  f}\br
+    \literalterminal{A  B  C  D  E  F}
 \end{bnf}
 
 \begin{bnf}
@@ -1166,17 +1166,17 @@ [lex.icon]
 
 \begin{bnf}
 \nontermdef{unsigned-suffix} \textnormal{one of}\br
-    \terminal{u  U}
+    \literalterminal{u  U}
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{long-suffix} \textnormal{one of}\br
-    \terminal{l  L}
+    \literalterminal{l  L}
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{long-long-suffix} \textnormal{one of}\br
-    \terminal{ll  LL}
+    \literalterminal{ll  LL}
 \end{bnf}
 
 \begin{bnf}
@@ -1215,7 +1215,7 @@ [lex.icon]
 
 \pnum
 The \grammarterm{hexadecimal-digit}s
-\tcode{a} through \tcode{f} and \tcode{A} through \tcode{F}
+\literaltcode{a} through \literaltcode{f} and \literaltcode{A} through \literaltcode{F}
 have decimal values ten through fifteen.
 \begin{example}
 The number twelve can be written \tcode{12}, \tcode{014},
@@ -1259,7 +1259,7 @@ [lex.icon]
         &
         &
   \tcode{unsigned long long int}\\\hline
-\tcode{u} or \tcode{U}  &
+\literaltcode{u} or \literaltcode{U}  &
   \tcode{unsigned int}  &
   \tcode{unsigned int}\\
                               &
@@ -1268,7 +1268,7 @@ [lex.icon]
                               &
   \tcode{unsigned long long int}   &
   \tcode{unsigned long long int}\\\hline
-\tcode{l} or \tcode{L}  &
+\literaltcode{l} or \literaltcode{L}  &
   \tcode{long int}  &
   \tcode{long int}\\
                               &
@@ -1280,22 +1280,22 @@ [lex.icon]
                               &
                               &
   \tcode{unsigned long long int}\\\hline
-Both \tcode{u} or \tcode{U}   &
+Both \literaltcode{u} or \literaltcode{U}   &
   \tcode{unsigned long int}  &
   \tcode{unsigned long int}\\
-and \tcode{l} or \tcode{L}  &
+and \literaltcode{l} or \literaltcode{L}  &
   \tcode{unsigned long long int}  &
   \tcode{unsigned long long int}\\\hline
-\tcode{ll} or \tcode{LL}  &
+\literaltcode{ll} or \literaltcode{LL}  &
   \tcode{long long int}       &
   \tcode{long long int}\\
                               &
                               &
   \tcode{unsigned long long int}\\\hline
-Both \tcode{u} or \tcode{U}   &
+Both \literaltcode{u} or \literaltcode{U}   &
   \tcode{unsigned long long int}  &
   \tcode{unsigned long long int}\\
-and \tcode{ll} or \tcode{LL}  &
+and \literaltcode{ll} or \literaltcode{LL}  &
                               &
                               \\\hline
 \tcode{z} or \tcode{Z}                  &
@@ -1337,12 +1337,12 @@ [lex.ccon]
 \indextext{literal!character}%
 \begin{bnf}
 \nontermdef{character-literal}\br
-    \opt{encoding-prefix} \terminal{'} c-char-sequence \terminal{'}
+    \opt{encoding-prefix} \literalterminal{'} c-char-sequence \literalterminal{'}
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{encoding-prefix} \textnormal{one of}\br
-    \terminal{u8}\quad\terminal{u}\quad\terminal{U}\quad\terminal{L}
+    \literalterminal{u8}\quad\literalterminal{u}\quad\literalterminal{U}\quad\literalterminal{L}
 \end{bnf}
 
 \begin{bnf}
@@ -1395,16 +1395,16 @@ [lex.ccon]
 
 \begin{bnf}
 \nontermdef{octal-escape-sequence}\br
-    \terminal{\textbackslash} octal-digit\br
-    \terminal{\textbackslash} octal-digit octal-digit\br
-    \terminal{\textbackslash} octal-digit octal-digit octal-digit\br
-    \terminal{\textbackslash o\{} simple-octal-digit-sequence \terminal{\}}\br
+    \literalterminal{\textbackslash} octal-digit\br
+    \literalterminal{\textbackslash} octal-digit octal-digit\br
+    \literalterminal{\textbackslash} octal-digit octal-digit octal-digit\br
+    \literalterminal{\textbackslash o\{} simple-octal-digit-sequence \literalterminal{\}}\br
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{hexadecimal-escape-sequence}\br
-    \terminal{\textbackslash x} simple-hexadecimal-digit-sequence\br
-    \terminal{\textbackslash x\{} simple-hexadecimal-digit-sequence \terminal{\}}
+    \literalterminal{\textbackslash x} simple-hexadecimal-digit-sequence\br
+    \literalterminal{\textbackslash x\{} simple-hexadecimal-digit-sequence \literalterminal{\}}
 \end{bnf}
 
 \begin{bnf}
@@ -1621,42 +1621,42 @@ [lex.fcon]
 
 \begin{bnf}
 \nontermdef{fractional-constant}\br
-    \opt{digit-sequence} \terminal{.} digit-sequence\br
-    digit-sequence \terminal{.}
+    \opt{digit-sequence} \literalterminal{.} digit-sequence\br
+    digit-sequence \literalterminal{.}
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{hexadecimal-fractional-constant}\br
-    \opt{hexadecimal-digit-sequence} \terminal{.} hexadecimal-digit-sequence\br
-    hexadecimal-digit-sequence \terminal{.}
+    \opt{hexadecimal-digit-sequence} \literalterminal{.} hexadecimal-digit-sequence\br
+    hexadecimal-digit-sequence \literalterminal{.}
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{exponent-part}\br
-    \terminal{e} \opt{sign} digit-sequence\br
-    \terminal{E} \opt{sign} digit-sequence
+    \literalterminal{e} \opt{sign} digit-sequence\br
+    \literalterminal{E} \opt{sign} digit-sequence
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{binary-exponent-part}\br
-    \terminal{p} \opt{sign} digit-sequence\br
-    \terminal{P} \opt{sign} digit-sequence
+    \literalterminal{p} \opt{sign} digit-sequence\br
+    \literalterminal{P} \opt{sign} digit-sequence
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{sign} \textnormal{one of}\br
-    \terminal{+  -}
+    \literalterminal{+  -}
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{digit-sequence}\br
     digit\br
-    digit-sequence \opt{\terminal{'}} digit
+    digit-sequence \opt{\literalterminal{'}} digit
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{floating-point-suffix} \textnormal{one of}\br
-    \terminal{f  l  f16  f32  f64  f128  bf16  F  L  F16  F32  F64  F128  BF16}
+    \literalterminal{f  l  f16  f32  f64  f128  bf16  F  L  F16  F32  F64  F128  BF16}
 \end{bnf}
 
 \pnum
@@ -1684,13 +1684,13 @@ [lex.fcon]
 \topline
 \lhdr{\grammarterm{floating-point-suffix}} & \rhdr{type} \\ \capsep
 none & \keyword{double} \\
-\tcode{f} or \tcode{F} & \keyword {float} \\
-\tcode{l} or \tcode{L} & \keyword{long} \keyword{double} \\
-\tcode{f16} or \tcode{F16} & \tcode{std::float16_t} \\
-\tcode{f32} or \tcode{F32} & \tcode{std::float32_t} \\
-\tcode{f64} or \tcode{F64} & \tcode{std::float64_t} \\
-\tcode{f128} or \tcode{F128} & \tcode{std::float128_t} \\
-\tcode{bf16} or \tcode{BF16} & \tcode{std::bfloat16_t} \\
+\literaltcode{f} or \literaltcode{F} & \keyword {float} \\
+\literaltcode{l} or \literaltcode{L} & \keyword{long} \keyword{double} \\
+\literaltcode{f16} or \literaltcode{F16} & \literaltcode{std::float16_t} \\
+\literaltcode{f32} or \literaltcode{F32} & \literaltcode{std::float32_t} \\
+\literaltcode{f64} or \literaltcode{F64} & \literaltcode{std::float64_t} \\
+\literaltcode{f128} or \literaltcode{F128} & \literaltcode{std::float128_t} \\
+\literaltcode{bf16} or \literaltcode{BF16} & \literaltcode{std::bfloat16_t} \\
 \end{simpletypetable}
 
 \pnum
@@ -1741,8 +1741,8 @@ [lex.string]
 \indextext{literal!string}%
 \begin{bnf}
 \nontermdef{string-literal}\br
-    \opt{encoding-prefix} \terminal{"} \opt{s-char-sequence} \terminal{"}\br
-    \opt{encoding-prefix} \terminal{R} raw-string
+    \opt{encoding-prefix} \literalterminal{"} \opt{s-char-sequence} \literalterminal{"}\br
+    \opt{encoding-prefix} \literalterminal{R} raw-string
 \end{bnf}
 
 \begin{bnf}
@@ -1766,7 +1766,7 @@ [lex.string]
 
 \begin{bnf}
 \nontermdef{raw-string}\br
-    \terminal{"} \opt{d-char-sequence} \terminal{(} \opt{r-char-sequence} \terminal{)} \opt{d-char-sequence} \terminal{"}
+    \literalterminal{"} \opt{d-char-sequence} \literalterminal{(} \opt{r-char-sequence} \literalterminal{)} \opt{d-char-sequence} \literalterminal{"}
 \end{bnf}
 
 \begin{bnf}
@@ -1853,7 +1853,7 @@ [lex.string]
 
 \pnum
 \indextext{literal!string!raw}%
-A \grammarterm{string-literal} that has an \tcode{R}
+A \grammarterm{string-literal} that has an \literaltcode{R}
 \indextext{prefix!\idxcode{R}}%
 in the prefix is a \defn{raw string literal}. The
 \grammarterm{d-char-sequence} serves as a delimiter. The terminating
diff --git a/source/exceptions.tex b/source/exceptions.tex
index eafe88e1..ac2b59fa 100644
--- a/source/exceptions.tex
+++ b/source/exceptions.tex
@@ -135,11 +135,11 @@ [except.pre]
 Any exception thrown while destroying
 \tcode{t2}
 will result in executing
-\tcode{handler 2};
+\noncxxtcode{handler 2};
 any exception thrown while destroying
 \tcode{t1}
 will result in executing
-\tcode{handler 1}.
+\noncxxtcode{handler 1}.
 \end{example}
 
 \pnum
diff --git a/source/utilities.tex b/source/utilities.tex
index a524a07f..a437974e 100644
--- a/source/utilities.tex
+++ b/source/utilities.tex
@@ -14674,23 +14674,23 @@ [format.string.general]
 a (possibly empty) sequence of
 \defnx{replacement fields}{replacement field!format string},
 \defnx{escape sequences}{escape sequence!format string},
-and characters other than \tcode{\{} and \tcode{\}}.
+and characters other than \noncxxtcode{\{} and \noncxxtcode{\}}.
 Let \tcode{charT} be the character type of the format string.
 Each character that is not part of
 a replacement field or an escape sequence
 is copied unchanged to the output.
-An escape sequence is one of \tcode{\{\{} or \tcode{\}\}}.
-It is replaced with \tcode{\{} or \tcode{\}}, respectively, in the output.
+An escape sequence is one of \noncxxtcode{\{\{} or \noncxxtcode{\}\}}.
+It is replaced with \noncxxtcode{\{} or \noncxxtcode{\}}, respectively, in the output.
 The syntax of replacement fields is as follows:
 
 \begin{ncbnf}
 \fmtnontermdef{replacement-field}\br
-    \terminal{\{} \opt{arg-id} \opt{format-specifier} \terminal{\}}
+    \noncxxterminal{\{} \opt{arg-id} \opt{format-specifier} \noncxxterminal{\}}
 \end{ncbnf}
 
 \begin{ncbnf}
 \fmtnontermdef{arg-id}\br
-    \terminal{0}\br
+    \noncxxterminal{0}\br
     positive-integer
 \end{ncbnf}
 
@@ -14708,18 +14708,18 @@ [format.string.general]
 
 \begin{ncbnf}
 \fmtnontermdef{nonzero-digit} \textnormal{one of}\br
-    \terminal{1 2 3 4 5 6 7 8 9}
+    \noncxxterminal{1 2 3 4 5 6 7 8 9}
 \end{ncbnf}
 
 % FIXME: This exactly duplicates the digit grammar term from [lex]
 \begin{ncbnf}
 \fmtnontermdef{digit} \textnormal{one of}\br
-    \terminal{0 1 2 3 4 5 6 7 8 9}
+    \noncxxterminal{0 1 2 3 4 5 6 7 8 9}
 \end{ncbnf}
 
 \begin{ncbnf}
 \fmtnontermdef{format-specifier}\br
-    \terminal{:} format-spec
+    \noncxxterminal{:} format-spec
 \end{ncbnf}
 
 \begin{ncbnf}
@@ -14815,7 +14815,7 @@ [format.string.std]
 
 \begin{ncbnf}
 \fmtnontermdef{std-format-spec}\br
-    \opt{fill-and-align} \opt{sign} \opt{\terminal{\#}} \opt{\terminal{0}} \opt{width} \opt{precision} \opt{\terminal{L}} \opt{type}
+    \opt{fill-and-align} \opt{sign} \opt{\noncxxterminal{\#}} \opt{\noncxxterminal{0}} \opt{width} \opt{precision} \opt{\noncxxterminal{L}} \opt{type}
 \end{ncbnf}
 
 \begin{ncbnf}
@@ -14825,34 +14825,34 @@ [format.string.std]
 
 \begin{ncbnf}
 \fmtnontermdef{fill}\br
-    \textnormal{any character other than \tcode{\{} or \tcode{\}}}
+    \textnormal{any character other than \noncxxtcode{\{} or \noncxxtcode{\}}}
 \end{ncbnf}
 
 \begin{ncbnf}
 \fmtnontermdef{align} \textnormal{one of}\br
-    \terminal{< > \caret}
+    \noncxxterminal{< > \caret}
 \end{ncbnf}
 
 \begin{ncbnf}
 \fmtnontermdef{sign} \textnormal{one of}\br
-    \terminal{+ -} \textnormal{space}
+    \noncxxterminal{+ -} \textnormal{space}
 \end{ncbnf}
 
 \begin{ncbnf}
 \fmtnontermdef{width}\br
     positive-integer\br
-    \terminal{\{} \opt{arg-id} \terminal{\}}
+    \noncxxterminal{\{} \opt{arg-id} \noncxxterminal{\}}
 \end{ncbnf}
 
 \begin{ncbnf}
 \fmtnontermdef{precision}\br
-    \terminal{.} nonnegative-integer\br
-    \terminal{.} \terminal{\{} \opt{arg-id} \terminal{\}}
+    \noncxxterminal{.} nonnegative-integer\br
+    \noncxxterminal{.} \noncxxterminal{\{} \opt{arg-id} \noncxxterminal{\}}
 \end{ncbnf}
 
 \begin{ncbnf}
 \fmtnontermdef{type} \textnormal{one of}\br
-    \terminal{a A b B c d e E f F g G o p s x X ?}
+    \noncxxterminal{a A b B c d e E f F g G o p s x X ?}
 \end{ncbnf}
 
 \pnum
@@ -14931,7 +14931,7 @@ [format.string.std]
 \begin{floattable}{Meaning of \fmtgrammarterm{align} options}{format.align}{lp{.8\hsize}}
 \topline
 \lhdr{Option} & \rhdr{Meaning} \\ \rowsep
-\tcode{<} &
+\noncxxtcode{<} &
 Forces the formatted argument to be aligned to the start of the field
 by inserting $n$ fill characters after the formatted argument
 where $n$ is the padding width.
@@ -14950,7 +14950,7 @@ [format.string.std]
 or when an integer presentation type is specified.
 \\ \rowsep
 %
-\tcode{\caret} &
+\noncxxtcode{\caret} &
 Forces the formatted argument to be centered within the field
 by inserting
 $\bigl\lfloor \frac{n}{2} \bigr\rfloor$
@@ -14970,10 +14970,10 @@ [format.string.std]
 \begin{floattable}{Meaning of \fmtgrammarterm{sign} options}{format.sign}{lp{.8\hsize}}
 \topline
 \lhdr{Option} & \rhdr{Meaning} \\ \rowsep
-\tcode{+} &
+\noncxxtcode{+} &
 Indicates that a sign should be used for both non-negative and negative
 numbers.
-The \tcode{+} sign is inserted before the output of \tcode{to_chars} for
+The \noncxxtcode{+} sign is inserted before the output of \tcode{to_chars} for
 non-negative numbers other than negative zero.
 \begin{tailnote}
 For negative numbers and negative zero
@@ -14982,7 +14982,7 @@ [format.string.std]
 \end{tailnote}
 \\ \rowsep
 %
-\tcode{-} &
+\noncxxtcode{-} &
 Indicates that a sign should be used for
 negative numbers and negative zero only (this is the default behavior).
 \\ \rowsep
@@ -15008,7 +15008,7 @@ [format.string.std]
 \end{example}
 
 \pnum
-The \tcode{\#} option causes the
+The \noncxxtcode{\#} option causes the
 % FIXME: This is not a definition.
 \defnx{alternate form}{alternate form!format string}
 to be used for the conversion.
@@ -15027,7 +15027,7 @@ [format.string.std]
 % FIXME: This is a weird place for this part of the spec to appear.
 Normally, a decimal-point character appears in the result of these
 conversions only if a digit follows it.
-In addition, for \tcode{g} and \tcode{G} conversions,
+In addition, for \noncxxtcode{g} and \noncxxtcode{G} conversions,
 % FIXME: Are they normally? What does this even mean? Reach into to_chars and
 % alter its behavior?
 trailing zeros are not removed from the result.
@@ -15059,7 +15059,7 @@ [format.string.std]
 the minimum field width is \tcode{0}.
 
 \pnum
-If \tcode{\{ \opt{\fmtgrammarterm{arg-id}} \}} is used in
+If \noncxxtcode{\{ \opt{\fmtgrammarterm{arg-id}} \}} is used in
 a \fmtgrammarterm{width} or \fmtgrammarterm{precision} option,
 the value of the corresponding formatting argument is used as the value of the option.
 If the corresponding formatting argument is
@@ -15133,9 +15133,9 @@ [format.string.std]
 the value of the decimal integer is used as the value of the option.
 
 \pnum
-When the \tcode{L} option is used, the form used for the conversion is called
+When the \noncxxtcode{L} option is used, the form used for the conversion is called
 the \defnx{locale-specific form}{locale-specific form!format string}.
-The \tcode{L} option is only valid for arithmetic types, and
+The \noncxxtcode{L} option is only valid for arithmetic types, and
 its effect depends upon the type.
 \begin{itemize}
 \item
@@ -15206,52 +15206,52 @@ [format.string.std]
 \begin{floattable}{Meaning of \fmtgrammarterm{type} options for integer types}{format.type.int}{lp{.8\hsize}}
 \topline
 \lhdr{Type} & \rhdr{Meaning} \\ \rowsep
-\tcode{b} &
+\noncxxtcode{b} &
 \tcode{to_chars(first, last, value, 2)};
 \indextext{base prefix}%
-the base prefix is \tcode{0b}.
+the base prefix is \noncxxtcode{0b}.
 \\ \rowsep
 %
-\tcode{B} &
-The same as \tcode{b}, except that
+\noncxxtcode{B} &
+The same as \noncxxtcode{b}, except that
 \indextext{base prefix}%
-the base prefix is \tcode{0B}.
+the base prefix is \noncxxtcode{0B}.
 \\ \rowsep
 %
-\tcode{c} &
+\noncxxtcode{c} &
 Copies the character \tcode{static_cast<charT>(value)} to the output.
 Throws \tcode{format_error} if \tcode{value} is not
 in the range of representable values for \tcode{charT}.
 \\ \rowsep
 %
-\tcode{d} &
+\noncxxtcode{d} &
 \tcode{to_chars(first, last, value)}.
 \\ \rowsep
 %
-\tcode{o} &
+\noncxxtcode{o} &
 \tcode{to_chars(first, last, value, 8)};
 \indextext{base prefix}%
-the base prefix is \tcode{0} if \tcode{value} is nonzero and is empty otherwise.
+the base prefix is \noncxxtcode{0} if \tcode{value} is nonzero and is empty otherwise.
 \\ \rowsep
 %
-\tcode{x} &
+\noncxxtcode{x} &
 \tcode{to_chars(first, last, value, 16)};
 \indextext{base prefix}%
-the base prefix is \tcode{0x}.
+the base prefix is \noncxxtcode{0x}.
 \\ \rowsep
 %
-\tcode{X} &
-The same as \tcode{x}, except that
+\noncxxtcode{X} &
+The same as \noncxxtcode{x}, except that
 it uses uppercase letters for digits above 9 and
 \indextext{base prefix}%
-the base prefix is \tcode{0X}.
+the base prefix is \noncxxtcode{0X}.
 \\ \rowsep
 %
 none &
-The same as \tcode{d}.
+The same as \noncxxtcode{d}.
 \begin{tailnote}
 If the formatting argument type is \tcode{charT} or \tcode{bool},
-the default is instead \tcode{c} or \tcode{s}, respectively.
+the default is instead \noncxxtcode{c} or \noncxxtcode{s}, respectively.
 \end{tailnote}
 \\
 \end{floattable}
@@ -15262,11 +15262,11 @@ [format.string.std]
 \begin{floattable}{Meaning of \fmtgrammarterm{type} options for \tcode{charT}}{format.type.char}{ll}
 \topline
 \lhdr{Type} & \rhdr{Meaning} \\ \rowsep
-none, \tcode{c} &
+none, \noncxxtcode{c} &
 Copies the character to the output.
 \\ \rowsep
 %
-\tcode{b}, \tcode{B}, \tcode{d}, \tcode{o}, \tcode{x}, \tcode{X} &
+\noncxxtcode{b}, \noncxxtcode{B}, \noncxxtcode{d}, \noncxxtcode{o}, \noncxxtcode{x}, \noncxxtcode{X} &
 As specified in \tref{format.type.int}.
 \\ \rowsep
 %
@@ -15282,8 +15282,8 @@ [format.string.std]
 \topline
 \lhdr{Type} & \rhdr{Meaning} \\ \rowsep
 none,
-\tcode{s} &
-Copies textual representation, either \tcode{true} or \tcode{false}, to the output.
+\noncxxtcode{s} &
+Copies textual representation, either \noncxxtcode{true} or \noncxxtcode{false}, to the output.
 \\ \rowsep
 %
 \tcode{b}, \tcode{B}, \tcode{d}, \tcode{o}, \tcode{x}, \tcode{X} &
@@ -15298,9 +15298,9 @@ [format.string.std]
 for values other than infinity and NaN are
 specified in \tref{format.type.float}.
 For lower-case presentation types, infinity and NaN are formatted as
-\tcode{inf} and \tcode{nan}, respectively.
+\noncxxtcode{inf} and \noncxxtcode{nan}, respectively.
 For upper-case presentation types, infinity and NaN are formatted as
-\tcode{INF} and \tcode{NAN}, respectively.
+\noncxxtcode{INF} and \noncxxtcode{NAN}, respectively.
 \begin{note}
 In either case, a sign is included
 if indicated by the \fmtgrammarterm{sign} option.
@@ -15309,7 +15309,7 @@ [format.string.std]
 \begin{floattable}{Meaning of \fmtgrammarterm{type} options for floating-point types}{format.type.float}{lp{.8\hsize}}
 \topline
 \lhdr{Type} & \rhdr{Meaning} \\ \rowsep
-\tcode{a} &
+\noncxxtcode{a} &
 If \fmtgrammarterm{precision} is specified, equivalent to
 \begin{codeblock}
 to_chars(first, last, value, chars_format::hex, precision)
@@ -15322,46 +15322,46 @@ [format.string.std]
 \\
 \rowsep
 %
-\tcode{A} &
-The same as \tcode{a}, except that
+\noncxxtcode{A} &
+The same as \noncxxtcode{a}, except that
 it uses uppercase letters for digits above 9 and
-\tcode{P} to indicate the exponent.
+\noncxxtcode{P} to indicate the exponent.
 \\ \rowsep
 %
-\tcode{e} &
+\noncxxtcode{e} &
 Equivalent to
 \begin{codeblock}
 to_chars(first, last, value, chars_format::scientific, precision)
 \end{codeblock}
 where \tcode{precision} is the specified formatting precision,
-or \tcode{6} if \fmtgrammarterm{precision} is not specified.
+or \noncxxtcode{6} if \fmtgrammarterm{precision} is not specified.
 \\ \rowsep
 %
-\tcode{E} &
-The same as \tcode{e}, except that it uses \tcode{E} to indicate exponent.
+\noncxxtcode{E} &
+The same as \noncxxtcode{e}, except that it uses \noncxxtcode{E} to indicate exponent.
 \\ \rowsep
 %
-\tcode{f}, \tcode{F} &
+\noncxxtcode{f}, \noncxxtcode{F} &
 Equivalent to
 \begin{codeblock}
 to_chars(first, last, value, chars_format::fixed, precision)
 \end{codeblock}
 where \tcode{precision} is the specified formatting precision,
-or \tcode{6} if \fmtgrammarterm{precision} is not specified.
+or \noncxxtcode{6} if \fmtgrammarterm{precision} is not specified.
 \\ \rowsep
 %
-\tcode{g} &
+\noncxxtcode{g} &
 Equivalent to
 \begin{codeblock}
 to_chars(first, last, value, chars_format::general, precision)
 \end{codeblock}
 where \tcode{precision} is the specified formatting precision,
-or \tcode{6} if \fmtgrammarterm{precision} is not specified.
+or \noncxxtcode{6} if \fmtgrammarterm{precision} is not specified.
 \\ \rowsep
 %
-\tcode{G} &
-The same as \tcode{g}, except that
-it uses \tcode{E} to indicate exponent.
+\noncxxtcode{G} &
+The same as \noncxxtcode{g}, except that
+it uses \noncxxtcode{E} to indicate exponent.
 \\ \rowsep
 %
 none &
@@ -15387,12 +15387,12 @@ [format.string.std]
 \begin{floattable}{Meaning of \fmtgrammarterm{type} options for pointer types}{format.type.ptr}{lp{.8\hsize}}
 \topline
 \lhdr{Type} & \rhdr{Meaning} \\ \rowsep
-none, \tcode{p} &
+none, \noncxxtcode{p} &
 If \tcode{uintptr_t} is defined,
 \begin{codeblock}
 to_chars(first, last, reinterpret_cast<uintptr_t>(value), 16)
 \end{codeblock}
-with the prefix \tcode{0x} inserted immediately before the output of \tcode{to_chars};
+with the prefix \noncxxtcode{0x} inserted immediately before the output of \tcode{to_chars};
 otherwise, implementation-defined.
 \\
 \end{floattable}
@@ -16053,7 +16053,7 @@ [format.string.escaped]
 of separator or non-printable characters
 \end{itemize}
 
-then the sequence \tcode{\textbackslash u\{\placeholder{hex-digit-sequence}\}}
+then the sequence \literaltcode{\textbackslash u\{\placeholder{hex-digit-sequence}\}}
 is appended to \placeholder{E},
 where \tcode{\placeholder{hex-digit-sequence}}
 is the shortest hexadecimal representation
@@ -16076,7 +16076,7 @@ [format.string.escaped]
 \item
 Otherwise (\placeholder{X} is a sequence of ill-formed code units),
 each code unit \placeholder{U} is appended to \placeholder{E} in order
-as the sequence \tcode{\textbackslash x\{\placeholder{hex-digit-sequence}\}},
+as the sequence \literaltcode{\textbackslash x\{\placeholder{hex-digit-sequence}\}},
 where \tcode{\placeholder{hex-digit-sequence}}
 is the shortest hexadecimal representation of \placeholder{U}
 using lower-case hexadecimal digits.
diff --git a/source/time.tex b/source/time.tex
index d21cb3bc..1eba6175 100644
--- a/source/time.tex
+++ b/source/time.tex
@@ -2174,7 +2174,7 @@ [time.duration.io]
 \tcode{is.setstate(ios_base::failbit)} is called and \tcode{d} is not modified.
 If \tcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 
 \pnum
@@ -2766,9 +2766,9 @@ [time.clock.system.nonmembers]
 If the parse fails to decode a valid date,
 \tcode{is.setstate(ios_base::failbit)} is called and
 \tcode{tp} is not modified.
-If \tcode{\%Z} is used and successfully parsed,
+If \noncxxtcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 Additionally, the parsed offset will be subtracted
 from the successfully parsed timestamp
@@ -2959,9 +2959,9 @@ [time.clock.utc.nonmembers]
 If the parse fails to decode a valid date,
 \tcode{is.setstate(ios_base::failbit)} is called and
 \tcode{tp} is not modified.
-If \tcode{\%Z} is used and successfully parsed,
+If \noncxxtcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 Additionally, the parsed offset will be subtracted from
 the successfully parsed timestamp
@@ -3158,9 +3158,9 @@ [time.clock.tai.nonmembers]
 If the parse fails to decode a valid date,
 \tcode{is.setstate(ios_base::failbit)} is called and
 \tcode{tp} is not modified.
-If \tcode{\%Z} is used and successfully parsed,
+If \noncxxtcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 Additionally, the parsed offset will be subtracted from
 the successfully parsed timestamp prior to assigning that difference to \tcode{tp}.
@@ -3321,9 +3321,9 @@ [time.clock.gps.nonmembers]
 If the parse fails to decode a valid date,
 \tcode{is.setstate(ios_base::failbit)} is called and
 \tcode{tp} is not modified.
-If \tcode{\%Z} is used and successfully parsed,
+If \noncxxtcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 Additionally, the parsed offset will be subtracted from
 the successfully parsed timestamp prior to assigning that difference to \tcode{tp}.
@@ -3428,9 +3428,9 @@ [time.clock.file.nonmembers]
 If the parse fails to decode a valid date,
 \tcode{is.setstate(ios_base::failbit)} is called and
 \tcode{tp} is not modified.
-If \tcode{\%Z} is used and successfully parsed,
+If \noncxxtcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 Additionally, the parsed offset will be subtracted from
 the successfully parsed timestamp prior to assigning that difference to \tcode{tp}.
@@ -3539,9 +3539,9 @@ [time.clock.local]
 If the parse fails to decode a valid date,
 \tcode{is.setstate(ios_base::failbit)} is called and
 \tcode{tp} is not modified.
-If \tcode{\%Z} is used and successfully parsed,
+If \noncxxtcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 
 \pnum
@@ -4192,9 +4192,9 @@ [time.cal.day.nonmembers]
 If the parse fails to decode a valid day,
 \tcode{is.setstate(ios_base::failbit)} is called and
 \tcode{d} is not modified.
-If \tcode{\%Z} is used and successfully parsed,
+If \noncxxtcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 
 \pnum
@@ -4506,9 +4506,9 @@ [time.cal.month.nonmembers]
 If the parse fails to decode a valid month,
 \tcode{is.setstate(ios_base::failbit)} is called and
 \tcode{m} is not modified.
-If \tcode{\%Z} is used and successfully parsed,
+If \noncxxtcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 
 \pnum
@@ -4850,9 +4850,9 @@ [time.cal.year.nonmembers]
 If the parse fails to decode a valid year,
 \tcode{is.setstate(ios_base::failbit)} is called and
 \tcode{y} is not modified.
-If \tcode{\%Z} is used and successfully parsed,
+If \noncxxtcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 
 \pnum
@@ -5233,9 +5233,9 @@ [time.cal.wd.nonmembers]
 If the parse fails to decode a valid weekday,
 \tcode{is.setstate(ios_base::failbit)} is called and
 \tcode{wd} is not modified.
-If \tcode{\%Z} is used and successfully parsed,
+If \noncxxtcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 
 \pnum
@@ -5616,9 +5616,9 @@ [time.cal.md.nonmembers]
 If the parse fails to decode a valid \tcode{month_day},
 \tcode{is.setstate(ios_base::failbit)} is called and
 \tcode{md} is not modified.
-If \tcode{\%Z} is used and successfully parsed,
+If \noncxxtcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 
 \pnum
@@ -6296,9 +6296,9 @@ [time.cal.ym.nonmembers]
 If the parse fails to decode a valid \tcode{year_month},
 \tcode{is.setstate(ios_base::failbit)} is called and
 \tcode{ym} is not modified.
-If \tcode{\%Z} is used and successfully parsed,
+If \noncxxtcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 
 \pnum
@@ -6760,9 +6760,9 @@ [time.cal.ymd.nonmembers]
 If the parse fails to decode a valid \tcode{year_month_day},
 \tcode{is.setstate(ios_base::failbit)} is called and
 \tcode{ymd} is not modified.
-If \tcode{\%Z} is used and successfully parsed,
+If \noncxxtcode{\%Z} is used and successfully parsed,
 that value will be assigned to \tcode{*abbrev} if \tcode{abbrev} is non-null.
-If \tcode{\%z} (or a modified variant) is used and successfully parsed,
+If \noncxxtcode{\%z} (or a modified variant) is used and successfully parsed,
 that value will be assigned to \tcode{*offset} if \tcode{offset} is non-null.
 
 \pnum
@@ -10452,23 +10452,23 @@ [time.format]
 
 \begin{ncbnf}
 \fmtnontermdef{literal-char}\br
-    \textnormal{any character other than \tcode{\{}, \tcode{\}}, or \tcode{\%}}
+    \textnormal{any character other than \noncxxtcode{\{}, \noncxxtcode{\}}, or \noncxxtcode{\%}}
 \end{ncbnf}
 
 \begin{ncbnf}
 \fmtnontermdef{conversion-spec}\br
-    \terminal{\%} \opt{modifier} type
+    \noncxxterminal{\%} \opt{modifier} type
 \end{ncbnf}
 
 \begin{ncbnf}
 \fmtnontermdef{modifier} \textnormal{one of}\br
-    \terminal{E O}
+    \noncxxterminal{E O}
 \end{ncbnf}
 
 \begin{ncbnf}
 \fmtnontermdef{type} \textnormal{one of}\br
-    \terminal{a A b B c C d D e F g G h H I j m M n}\br
-    \terminal{p q Q r R S t T u U V w W x X y Y z Z \%}
+    \noncxxterminal{a A b B c C d D e F g G h H I j m M n}\br
+    \noncxxterminal{p q Q r R S t T u U V w W x X y Y z Z \%}
 \end{ncbnf}
 
 The productions
@@ -10541,11 +10541,11 @@ [time.format]
 does not contain time zone abbreviation
 and time zone offset information.
 If the information is available,
-the conversion specifiers \tcode{\%Z} and \tcode{\%z}
+the conversion specifiers \noncxxtcode{\%Z} and \noncxxtcode{\%z}
 will format this information (respectively).
 \begin{note}
 If the information is not available and
-a \tcode{\%Z} or \tcode{\%z}
+a \noncxxtcode{\%Z} or \noncxxtcode{\%z}
 conversion specifier appears in
 the \fmtgrammarterm{chrono-format-spec},
 an exception of type \tcode{format_error} is thrown,
@@ -10561,7 +10561,7 @@ [time.format]
 to format as a \tcode{weekday}.
 \end{example}
 However, if a flag refers to a ``time of day''
-(e.g., \tcode{\%H}, \tcode{\%I}, \tcode{\%p}, etc.),
+(e.g., \noncxxtcode{\%H}, \noncxxtcode{\%I}, \noncxxtcode{\%p}, etc.),
 then a specialization of \tcode{duration} is interpreted as
 the time of day elapsed since midnight.
 
@@ -10573,215 +10573,215 @@ [time.format]
 \hline
 \lhdr{Specifier} & \rhdr{Replacement} \\ \capsep
 \endhead
-\tcode{\%a} &
+\noncxxtcode{\%a} &
 The locale's abbreviated weekday name.
 If the value does not contain a valid weekday,
 an exception of type \tcode{format_error} is thrown.
 \\ \rowsep
-\tcode{\%A} &
+\noncxxtcode{\%A} &
 The locale's full weekday name.
 If the value does not contain a valid weekday,
 an exception of type \tcode{format_error} is thrown.
 \\ \rowsep
-\tcode{\%b} &
+\noncxxtcode{\%b} &
 The locale's abbreviated month name.
 If the value does not contain a valid month,
 an exception of type \tcode{format_error} is thrown.
 \\ \rowsep
-\tcode{\%B} &
+\noncxxtcode{\%B} &
 The locale's full month name.
 If the value does not contain a valid month,
 an exception of type \tcode{format_error} is thrown.
 \\ \rowsep
-\tcode{\%c} &
+\noncxxtcode{\%c} &
 The locale's date and time representation.
-The modified command \tcode{\%Ec} produces
+The modified command \noncxxtcode{\%Ec} produces
 the locale's alternate date and time representation.
 \\ \rowsep
-\tcode{\%C} &
+\noncxxtcode{\%C} &
 The year divided by 100 using floored division.
 If the result is a single decimal digit,
-it is prefixed with \tcode{0}.
-The modified command \tcode{\%EC} produces
+it is prefixed with \noncxxtcode{0}.
+The modified command \noncxxtcode{\%EC} produces
 the locale's alternative representation of the century.
 \\ \rowsep
-\tcode{\%d} &
+\noncxxtcode{\%d} &
 The day of month as a decimal number.
 If the result is a single decimal digit,
-it is prefixed with \tcode{0}.
-The modified command \tcode{\%Od} produces
+it is prefixed with \noncxxtcode{0}.
+The modified command \noncxxtcode{\%Od} produces
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%D} &
-Equivalent to \tcode{\%m/\%d/\%y}.
+\noncxxtcode{\%D} &
+Equivalent to \noncxxtcode{\%m/\%d/\%y}.
 \\ \rowsep
-\tcode{\%e} &
+\noncxxtcode{\%e} &
 The day of month as a decimal number.
 If the result is a single decimal digit,
 it is prefixed with a space.
-The modified command \tcode{\%Oe} produces
+The modified command \noncxxtcode{\%Oe} produces
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%F} &
-Equivalent to \tcode{\%Y-\%m-\%d}.
+\noncxxtcode{\%F} &
+Equivalent to \noncxxtcode{\%Y-\%m-\%d}.
 \\ \rowsep
-\tcode{\%g} &
+\noncxxtcode{\%g} &
 The last two decimal digits of the ISO week-based year.
-If the result is a single digit it is prefixed by \tcode{0}.
+If the result is a single digit it is prefixed by \noncxxtcode{0}.
 \\ \rowsep
-\tcode{\%G} &
+\noncxxtcode{\%G} &
 The ISO week-based year as a decimal number.
 If the result is less than four digits
-it is left-padded with \tcode{0} to four digits.
+it is left-padded with \noncxxtcode{0} to four digits.
 \\ \rowsep
-\tcode{\%h} &
-Equivalent to \tcode{\%b}.
+\noncxxtcode{\%h} &
+Equivalent to \noncxxtcode{\%b}.
 \\ \rowsep
-\tcode{\%H} &
+\noncxxtcode{\%H} &
 The hour (24-hour clock) as a decimal number.
 If the result is a single digit,
-it is prefixed with \tcode{0}.
-The modified command \tcode{\%OH} produces
+it is prefixed with \noncxxtcode{0}.
+The modified command \noncxxtcode{\%OH} produces
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%I} &
+\noncxxtcode{\%I} &
 The hour (12-hour clock) as a decimal number.
 If the result is a single digit,
-it is prefixed with \tcode{0}.
-The modified command \tcode{\%OI} produces
+it is prefixed with \noncxxtcode{0}.
+The modified command \noncxxtcode{\%OI} produces
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%j} &
+\noncxxtcode{\%j} &
 If the type being formatted is a specialization of \tcode{duration},
 the decimal number of \tcode{days} without padding.
 Otherwise,
 the day of the year as a decimal number.
-Jan 1 is \tcode{001}.
+Jan 1 is \noncxxtcode{001}.
 If the result is less than three digits,
-it is left-padded with \tcode{0} to three digits.
+it is left-padded with \noncxxtcode{0} to three digits.
 \\ \rowsep
-\tcode{\%m} &
+\noncxxtcode{\%m} &
 The month as a decimal number.
-Jan is \tcode{01}.
-If the result is a single digit, it is prefixed with \tcode{0}.
-The modified command \tcode{\%Om} produces
+Jan is \noncxxtcode{01}.
+If the result is a single digit, it is prefixed with \noncxxtcode{0}.
+The modified command \noncxxtcode{\%Om} produces
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%M} &
+\noncxxtcode{\%M} &
 The minute as a decimal number.
-If the result is a single digit, it is prefixed with \tcode{0}.
-The modified command \tcode{\%OM} produces
+If the result is a single digit, it is prefixed with \noncxxtcode{0}.
+The modified command \noncxxtcode{\%OM} produces
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%n} &
+\noncxxtcode{\%n} &
 A new-line character.
 \\ \rowsep
-\tcode{\%p} &
+\noncxxtcode{\%p} &
 The locale's equivalent of the AM/PM designations associated with a 12-hour clock.
 \\ \rowsep
-\tcode{\%q} &
+\noncxxtcode{\%q} &
 The duration's unit suffix as specified in \ref{time.duration.io}.
 \\ \rowsep
-\tcode{\%Q} &
+\noncxxtcode{\%Q} &
 The duration's numeric value (as if extracted via \tcode{.count()}).
 \\ \rowsep
-\tcode{\%r} &
+\noncxxtcode{\%r} &
 The locale's 12-hour clock time.
 \\ \rowsep
-\tcode{\%R} &
-Equivalent to \tcode{\%H:\%M}.
+\noncxxtcode{\%R} &
+Equivalent to \noncxxtcode{\%H:\%M}.
 \\ \rowsep
-\tcode{\%S} &
+\noncxxtcode{\%S} &
 Seconds as a decimal number.
-If the number of seconds is less than \tcode{10}, the result is prefixed with \tcode{0}.
+If the number of seconds is less than \noncxxtcode{10}, the result is prefixed with \noncxxtcode{0}.
 If the precision of the input cannot be exactly represented with seconds,
 then the format is a decimal floating-point number with a fixed format
 and a precision matching that of the precision of the input
 (or to a microseconds precision if the conversion to floating-point decimal seconds
 cannot be made within 18 fractional digits).
 The character for the decimal point is localized according to the locale.
-The modified command \tcode{\%OS} produces
+The modified command \noncxxtcode{\%OS} produces
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%t} &
+\noncxxtcode{\%t} &
 A horizontal-tab character.
 \\ \rowsep
-\tcode{\%T} &
-Equivalent to \tcode{\%H:\%M:\%S}.
+\noncxxtcode{\%T} &
+Equivalent to \noncxxtcode{\%H:\%M:\%S}.
 \\ \rowsep
-\tcode{\%u} &
-The ISO weekday as a decimal number (\tcode{1}-\tcode{7}),
-where Monday is \tcode{1}.
-The modified command \tcode{\%Ou} produces
+\noncxxtcode{\%u} &
+The ISO weekday as a decimal number (\noncxxtcode{1}-\noncxxtcode{7}),
+where Monday is \noncxxtcode{1}.
+The modified command \noncxxtcode{\%Ou} produces
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%U} &
+\noncxxtcode{\%U} &
 The week number of the year as a decimal number.
-The first Sunday of the year is the first day of week \tcode{01}.
-Days of the same year prior to that are in week \tcode{00}.
-If the result is a single digit, it is prefixed with \tcode{0}.
-The modified command \tcode{\%OU} produces
+The first Sunday of the year is the first day of week \noncxxtcode{01}.
+Days of the same year prior to that are in week \noncxxtcode{00}.
+If the result is a single digit, it is prefixed with \noncxxtcode{0}.
+The modified command \noncxxtcode{\%OU} produces
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%V} &
+\noncxxtcode{\%V} &
 The ISO week-based week number as a decimal number.
-If the result is a single digit, it is prefixed with \tcode{0}.
-The modified command \tcode{\%OV} produces
+If the result is a single digit, it is prefixed with \noncxxtcode{0}.
+The modified command \noncxxtcode{\%OV} produces
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%w} &
-The weekday as a decimal number (\tcode{0}-\tcode{6}), where Sunday is \tcode{0}.
-The modified command \tcode{\%Ow} produces
+\noncxxtcode{\%w} &
+The weekday as a decimal number (\noncxxtcode{0}-\noncxxtcode{6}), where Sunday is \noncxxtcode{0}.
+The modified command \noncxxtcode{\%Ow} produces
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%W} &
+\noncxxtcode{\%W} &
 The week number of the year as a decimal number.
-The first Monday of the year is the first day of week \tcode{01}.
-Days of the same year prior to that are in week \tcode{00}.
-If the result is a single digit, it is prefixed with \tcode{0}.
-The modified command \tcode{\%OW} produces
+The first Monday of the year is the first day of week \noncxxtcode{01}.
+Days of the same year prior to that are in week \noncxxtcode{00}.
+If the result is a single digit, it is prefixed with \noncxxtcode{0}.
+The modified command \noncxxtcode{\%OW} produces
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%x} &
+\noncxxtcode{\%x} &
 The locale's date representation.
-The modified command \tcode{\%Ex} produces
+The modified command \noncxxtcode{\%Ex} produces
 the locale's alternate date representation.
 \\ \rowsep
-\tcode{\%X} &
+\noncxxtcode{\%X} &
 The locale's time representation.
-The modified command \tcode{\%EX} produces
+The modified command \noncxxtcode{\%EX} produces
 the locale's alternate time representation.
 \\ \rowsep
-\tcode{\%y} &
+\noncxxtcode{\%y} &
 The last two decimal digits of the year.
-If the result is a single digit it is prefixed by \tcode{0}.
-The modified command \tcode{\%Oy} produces the locale's alternative representation.
-The modified command \tcode{\%Ey} produces the locale's alternative representation
-of offset from \tcode{\%EC} (year only).
+If the result is a single digit it is prefixed by \noncxxtcode{0}.
+The modified command \noncxxtcode{\%Oy} produces the locale's alternative representation.
+The modified command \noncxxtcode{\%Ey} produces the locale's alternative representation
+of offset from \noncxxtcode{\%EC} (year only).
 \\ \rowsep
-\tcode{\%Y} &
+\noncxxtcode{\%Y} &
 The year as a decimal number.
 If the result is less than four digits
-it is left-padded with \tcode{0} to four digits.
-The modified command \tcode{\%EY} produces
+it is left-padded with \noncxxtcode{0} to four digits.
+The modified command \noncxxtcode{\%EY} produces
 the locale's alternative full year representation.
 \\ \rowsep
-\tcode{\%z} &
+\noncxxtcode{\%z} &
 The offset from UTC as specified in ISO 8601:2004, subclause 4.2.5.2.
-For example \tcode{-0430} refers to 4 hours 30 minutes behind UTC\@.
-If the offset is zero, \tcode{+0000} is used.
-The modified commands \tcode{\%Ez} and  \tcode{\%Oz}
-insert a \tcode{:} between the hours and minutes: \tcode{-04:30}.
+For example \noncxxtcode{-0430} refers to 4 hours 30 minutes behind UTC\@.
+If the offset is zero, \noncxxtcode{+0000} is used.
+The modified commands \noncxxtcode{\%Ez} and  \noncxxtcode{\%Oz}
+insert a \noncxxtcode{:} between the hours and minutes: \noncxxtcode{-04:30}.
 If the offset information is not available,
 an exception of type \tcode{format_error} is thrown.
 \\ \rowsep
-\tcode{\%Z} &
+\noncxxtcode{\%Z} &
 The time zone abbreviation.
 If the time zone abbreviation is not available,
 an exception of type \tcode{format_error} is thrown.
 \\ \rowsep
-\tcode{\%\%} &
-A \tcode{\%} character.
+\noncxxtcode{\%\%} &
+A \noncxxtcode{\%} character.
 \\
 \end{LongTable}
 
@@ -10807,9 +10807,9 @@ [time.format]
 \begin{itemdescr}
 \pnum
 \remarks
-If \tcode{\%Z} is used,
+If \noncxxtcode{\%Z} is used,
 it is replaced with \tcode{\exposid{STATICALLY-WIDEN}<charT>("UTC")}.
-If \tcode{\%z} (or a modified variant of \tcode{\%z}) is used,
+If \noncxxtcode{\%z} (or a modified variant of \noncxxtcode{\%z}) is used,
 an offset of \tcode{0min} is formatted.
 \end{itemdescr}
 
@@ -10822,9 +10822,9 @@ [time.format]
 \begin{itemdescr}
 \pnum
 \remarks
-If \tcode{\%Z} is used,
+If \noncxxtcode{\%Z} is used,
 it is replaced with \tcode{\exposid{STATICALLY-WIDEN}<charT>("UTC")}.
-If \tcode{\%z} (or a modified variant of \tcode{\%z}) is used,
+If \noncxxtcode{\%z} (or a modified variant of \noncxxtcode{\%z}) is used,
 an offset of \tcode{0min} is formatted.
 If the argument represents a time during a positive leap second insertion,
 and if a seconds field is formatted,
@@ -10841,9 +10841,9 @@ [time.format]
 \begin{itemdescr}
 \pnum
 \remarks
-If \tcode{\%Z} is used,
+If \noncxxtcode{\%Z} is used,
 it is replaced with \tcode{\exposid{STATICALLY-WIDEN}<charT>("TAI")}.
-If \tcode{\%z} (or a modified variant of \tcode{\%z}) is used,
+If \noncxxtcode{\%z} (or a modified variant of \noncxxtcode{\%z}) is used,
 an offset of \tcode{0min} is formatted.
 The date and time formatted are equivalent to
 those formatted by a \tcode{sys_time} initialized with
@@ -10862,9 +10862,9 @@ [time.format]
 \begin{itemdescr}
 \pnum
 \remarks
-If \tcode{\%Z} is used,
+If \noncxxtcode{\%Z} is used,
 it is replaced with \tcode{\exposid{STATICALLY-WIDEN}<charT>("GPS")}.
-If \tcode{\%z} (or a modified variant of \tcode{\%z}) is used,
+If \noncxxtcode{\%z} (or a modified variant of \noncxxtcode{\%z}) is used,
 an offset of \tcode{0min} is formatted.
 The date and time formatted are equivalent to
 those formatted by a \tcode{sys_time} initialized with
@@ -10883,9 +10883,9 @@ [time.format]
 \begin{itemdescr}
 \pnum
 \remarks
-If \tcode{\%Z} is used,
+If \noncxxtcode{\%Z} is used,
 it is replaced with \tcode{\exposid{STATICALLY-WIDEN}<charT>("UTC")}.
-If \tcode{\%z} (or a modified variant of \tcode{\%z}) is used,
+If \noncxxtcode{\%z} (or a modified variant of \noncxxtcode{\%z}) is used,
 an offset of \tcode{0min} is formatted.
 The date and time formatted are equivalent to
 those formatted
@@ -10903,7 +10903,7 @@ [time.format]
 \begin{itemdescr}
 \pnum
 \remarks
-If \tcode{\%Z}, \tcode{\%z}, or a modified version of \tcode{\%z} is used,
+If \noncxxtcode{\%Z}, \noncxxtcode{\%z}, or a modified version of \noncxxtcode{\%z} is used,
 an exception of type \tcode{format_error} is thrown.
 \end{itemdescr}
 
@@ -10943,16 +10943,16 @@ [time.format]
 
 \pnum
 \remarks
-If \tcode{\%Z} is used,
+If \noncxxtcode{\%Z} is used,
 it is replaced with \tcode{*f.abbrev}
 if \tcode{f.abbrev} is not a null pointer value.
-If \tcode{\%Z} is used
+If \noncxxtcode{\%Z} is used
 and \tcode{f.abbrev} is a null pointer value,
 an exception of type \tcode{format_error} is thrown.
-If \tcode{\%z} (or a modified variant of \tcode{\%z}) is used,
+If \noncxxtcode{\%z} (or a modified variant of \noncxxtcode{\%z}) is used,
 it is formatted with the value of \tcode{*f.offset_sec}
 if \tcode{f.offset_sec} is not a null pointer value.
-If \tcode{\%z} (or a modified variant of \tcode{\%z}) is used
+If \noncxxtcode{\%z} (or a modified variant of \noncxxtcode{\%z}) is used
 and \tcode{f.offset_sec} is a null pointer value,
 then an exception of type \tcode{format_error} is thrown.
 \end{itemdescr}
@@ -11156,8 +11156,8 @@ [time.parse]
 on the value returned by subsequent calls to \tcode{basic_istream<>::gcount()}.
 Each overload takes a format string containing ordinary characters
 and flags which have special meaning.
-Each flag begins with a \tcode{\%}.
-Some flags can be modified by \tcode{E} or \tcode{O}.
+Each flag begins with a \noncxxtcode{\%}.
+Some flags can be modified by \noncxxtcode{E} or \noncxxtcode{O}.
 During parsing each flag interprets characters as parts of date and time types
 according to~\tref{time.parse.spec}.
 Some flags can be modified by a width parameter
@@ -11175,7 +11175,7 @@ [time.parse]
 A \tcode{duration} cannot represent a \tcode{weekday}.
 \end{example}
 However, if a flag refers to a ``time of day''
-(e.g., \tcode{\%H}, \tcode{\%I}, \tcode{\%p}, etc.),
+(e.g., \noncxxtcode{\%H}, \noncxxtcode{\%I}, \noncxxtcode{\%p}, etc.),
 then a specialization of \tcode{duration} is parsed as
 the time of day elapsed since midnight.
 
@@ -11195,246 +11195,246 @@ [time.parse]
 \hline
 \lhdr{Flag} & \rhdr{Parsed value} \\ \capsep
 \endhead
-\tcode{\%a} &
+\noncxxtcode{\%a} &
 The locale's full or abbreviated case-insensitive weekday name.
 \\ \rowsep
-\tcode{\%A} &
-Equivalent to \tcode{\%a}.
+\noncxxtcode{\%A} &
+Equivalent to \noncxxtcode{\%a}.
 \\ \rowsep
-\tcode{\%b} &
+\noncxxtcode{\%b} &
 The locale's full or abbreviated case-insensitive month name.
 \\ \rowsep
-\tcode{\%B} &
-Equivalent to \tcode{\%b}.
+\noncxxtcode{\%B} &
+Equivalent to \noncxxtcode{\%b}.
 \\ \rowsep
-\tcode{\%c} &
+\noncxxtcode{\%c} &
 The locale's date and time representation.
-The modified command \tcode{\%Ec} interprets
+The modified command \noncxxtcode{\%Ec} interprets
 the locale's alternate date and time representation.
 \\ \rowsep
-\tcode{\%C} &
+\noncxxtcode{\%C} &
 The century as a decimal number.
-The modified command \tcode{\%\placeholder{N}C} specifies
+The modified command \noncxxtcode{\%\placeholder{N}C} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 2.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 2.
 Leading zeroes are permitted but not required.
-The modified command \tcode{\%EC} interprets
+The modified command \noncxxtcode{\%EC} interprets
 the locale's alternative representation of the century.
 \\ \rowsep
-\tcode{\%d} &
+\noncxxtcode{\%d} &
 The day of the month as a decimal number.
-The modified command \tcode{\%\placeholder{N}d} specifies
+The modified command \noncxxtcode{\%\placeholder{N}d} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 2.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 2.
 Leading zeroes are permitted but not required.
-The modified command \tcode{\%Od} interprets
+The modified command \noncxxtcode{\%Od} interprets
 the locale's alternative representation of the day of the month.
 \\ \rowsep
-\tcode{\%D} &
-Equivalent to \tcode{\%m/\%d/\%y}.
+\noncxxtcode{\%D} &
+Equivalent to \noncxxtcode{\%m/\%d/\%y}.
 \\ \rowsep
-\tcode{\%e} &
-Equivalent to \tcode{\%d} and can be modified like \tcode{\%d}.
+\noncxxtcode{\%e} &
+Equivalent to \noncxxtcode{\%d} and can be modified like \noncxxtcode{\%d}.
 \\ \rowsep
-\tcode{\%F} &
-Equivalent to \tcode{\%Y-\%m-\%d}.
-If modified with a width \tcode{\placeholder{N}},
-the width is applied to only \tcode{\%Y}.
+\noncxxtcode{\%F} &
+Equivalent to \noncxxtcode{\%Y-\%m-\%d}.
+If modified with a width \noncxxtcode{\placeholder{N}},
+the width is applied to only \noncxxtcode{\%Y}.
 \\ \rowsep
-\tcode{\%g} &
+\noncxxtcode{\%g} &
 The last two decimal digits of the ISO week-based year.
-The modified command \tcode{\%\placeholder{N}g} specifies
+The modified command \noncxxtcode{\%\placeholder{N}g} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 2.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 2.
 Leading zeroes are permitted but not required.
 \\ \rowsep
-\tcode{\%G} &
+\noncxxtcode{\%G} &
 The ISO week-based year as a decimal number.
-The modified command \tcode{\%\placeholder{N}G} specifies
+The modified command \noncxxtcode{\%\placeholder{N}G} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 4.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 4.
 Leading zeroes are permitted but not required.
 \\ \rowsep
-\tcode{\%h} &
-Equivalent to \tcode{\%b}.
+\noncxxtcode{\%h} &
+Equivalent to \noncxxtcode{\%b}.
 \\ \rowsep
-\tcode{\%H} &
+\noncxxtcode{\%H} &
 The hour (24-hour clock) as a decimal number.
-The modified command \tcode{\%\placeholder{N}H} specifies
+The modified command \noncxxtcode{\%\placeholder{N}H} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 2.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 2.
 Leading zeroes are permitted but not required.
-The modified command \tcode{\%OH} interprets
+The modified command \noncxxtcode{\%OH} interprets
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%I} &
+\noncxxtcode{\%I} &
 The hour (12-hour clock) as a decimal number.
-The modified command \tcode{\%\placeholder{N}I} specifies
+The modified command \noncxxtcode{\%\placeholder{N}I} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 2.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 2.
 Leading zeroes are permitted but not required.
-The modified command \tcode{\%OI}
+The modified command \noncxxtcode{\%OI}
 interprets the locale's alternative representation.
 \\ \rowsep
-\tcode{\%j} &
+\noncxxtcode{\%j} &
 If the type being parsed is a specialization of \tcode{duration},
 a decimal number of \tcode{days}.
 Otherwise,
 the day of the year as a decimal number.
-Jan 1 is \tcode{1}.
+Jan 1 is \noncxxtcode{1}.
 In either case,
-the modified command \tcode{\%\placeholder{N}j} specifies
+the modified command \noncxxtcode{\%\placeholder{N}j} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 3.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 3.
 Leading zeroes are permitted but not required.
 \\ \rowsep
-\tcode{\%m} &
+\noncxxtcode{\%m} &
 The month as a decimal number.
-Jan is \tcode{1}.
-The modified command \tcode{\%\placeholder{N}m} specifies
+Jan is \noncxxtcode{1}.
+The modified command \noncxxtcode{\%\placeholder{N}m} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 2.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 2.
 Leading zeroes are permitted but not required.
-The modified command \tcode{\%Om} interprets
+The modified command \noncxxtcode{\%Om} interprets
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%M} &
+\noncxxtcode{\%M} &
 The minutes as a decimal number.
-The modified command \tcode{\%\placeholder{N}M} specifies
+The modified command \noncxxtcode{\%\placeholder{N}M} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 2.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 2.
 Leading zeroes are permitted but not required.
-The modified command \tcode{\%OM} interprets
+The modified command \noncxxtcode{\%OM} interprets
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%n} &
+\noncxxtcode{\%n} &
 Matches one whitespace character.
 \begin{tailnote}
-\tcode{\%n}, \tcode{\%t}, and a space
+\noncxxtcode{\%n}, \noncxxtcode{\%t}, and a space
 can be combined to match a wide range of whitespace patterns.
 For example,
 \tcode{"\%n "} matches one or more whitespace characters, and
 \tcode{"\%n\%t\%t"} matches one to three whitespace characters.
 \end{tailnote}
 \\ \rowsep
-\tcode{\%p} &
+\noncxxtcode{\%p} &
 The locale's equivalent of the AM/PM designations associated with a 12-hour clock.
 \\ \rowsep
-\tcode{\%r} &
+\noncxxtcode{\%r} &
 The locale's 12-hour clock time.
 \\ \rowsep
-\tcode{\%R} &
-Equivalent to \tcode{\%H:\%M}.
+\noncxxtcode{\%R} &
+Equivalent to \noncxxtcode{\%H:\%M}.
 \\ \rowsep
-\tcode{\%S} &
+\noncxxtcode{\%S} &
 The seconds as a decimal number.
-The modified command \tcode{\%\placeholder{N}S} specifies
+The modified command \noncxxtcode{\%\placeholder{N}S} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified,
+If \noncxxtcode{\placeholder{N}} is not specified,
 the default is 2 if the input time has a precision convertible to seconds.
 Otherwise the default width is determined by
 the decimal precision of the input
 and the field is interpreted as a \tcode{long double} in a fixed format.
 If encountered, the locale determines the decimal point character.
 Leading zeroes are permitted but not required.
-The modified command \tcode{\%OS} interprets
+The modified command \noncxxtcode{\%OS} interprets
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%t} &
+\noncxxtcode{\%t} &
 Matches zero or one whitespace characters.
 \\ \rowsep
-\tcode{\%T} &
-Equivalent to \tcode{\%H:\%M:\%S}.
+\noncxxtcode{\%T} &
+Equivalent to \noncxxtcode{\%H:\%M:\%S}.
 \\ \rowsep
-\tcode{\%u} &
-The ISO weekday as a decimal number (\tcode{1}-\tcode{7}), where Monday is \tcode{1}.
-The modified command \tcode{\%\placeholder{N}u} specifies
+\noncxxtcode{\%u} &
+The ISO weekday as a decimal number (\noncxxtcode{1}-\noncxxtcode{7}), where Monday is \noncxxtcode{1}.
+The modified command \noncxxtcode{\%\placeholder{N}u} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is \tcode{1}.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is \noncxxtcode{1}.
 Leading zeroes are permitted but not required.
 \\ \rowsep
-\tcode{\%U} &
+\noncxxtcode{\%U} &
 The week number of the year as a decimal number.
-The first Sunday of the year is the first day of week \tcode{01}.
-Days of the same year prior to that are in week \tcode{00}.
-The modified command \tcode{\%\placeholder{N}U} specifies
+The first Sunday of the year is the first day of week \noncxxtcode{01}.
+Days of the same year prior to that are in week \noncxxtcode{00}.
+The modified command \noncxxtcode{\%\placeholder{N}U} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 2.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 2.
 Leading zeroes are permitted but not required.
-The modified command \tcode{\%OU} interprets
+The modified command \noncxxtcode{\%OU} interprets
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%V} &
+\noncxxtcode{\%V} &
 The ISO week-based week number as a decimal number.
-The modified command \tcode{\%\placeholder{N}V} specifies
+The modified command \noncxxtcode{\%\placeholder{N}V} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 2.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 2.
 Leading zeroes are permitted but not required.
 \\ \rowsep
-\tcode{\%w} &
-The weekday as a decimal number (\tcode{0}-\tcode{6}), where Sunday is \tcode{0}.
-The modified command \tcode{\%\placeholder{N}w} specifies
+\noncxxtcode{\%w} &
+The weekday as a decimal number (\noncxxtcode{0}-\noncxxtcode{6}), where Sunday is \noncxxtcode{0}.
+The modified command \noncxxtcode{\%\placeholder{N}w} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is \tcode{1}.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is \noncxxtcode{1}.
 Leading zeroes are permitted but not required.
-The modified command \tcode{\%Ow} interprets
+The modified command \noncxxtcode{\%Ow} interprets
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%W} &
+\noncxxtcode{\%W} &
 The week number of the year as a decimal number.
-The first Monday of the year is the first day of week \tcode{01}.
-Days of the same year prior to that are in week \tcode{00}.
-The modified command \tcode{\%\placeholder{N}W} specifies
+The first Monday of the year is the first day of week \noncxxtcode{01}.
+Days of the same year prior to that are in week \noncxxtcode{00}.
+The modified command \noncxxtcode{\%\placeholder{N}W} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 2.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 2.
 Leading zeroes are permitted but not required.
-The modified command \tcode{\%OW} interprets
+The modified command \noncxxtcode{\%OW} interprets
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%x} &
+\noncxxtcode{\%x} &
 The locale's date representation.
-The modified command \tcode{\%Ex} interprets the locale's alternate date representation.
+The modified command \noncxxtcode{\%Ex} interprets the locale's alternate date representation.
 \\ \rowsep
-\tcode{\%X} &
+\noncxxtcode{\%X} &
 The locale's time representation.
-The modified command \tcode{\%EX} interprets the locale's alternate time representation.
+The modified command \noncxxtcode{\%EX} interprets the locale's alternate time representation.
 \\ \rowsep
-\tcode{\%y} &
+\noncxxtcode{\%y} &
 The last two decimal digits of the year.
 If the century is not otherwise specified
-(e.g.,  with \tcode{\%C}),
+(e.g.,  with \noncxxtcode{\%C}),
 values in the range \crange{69}{99}
 are presumed to refer to the years 1969 to 1999,
 and values in the range \crange{00}{68}
 are presumed to refer to the years 2000 to 2068.
-The modified command \tcode{\%\placeholder{N}y} specifies
+The modified command \noncxxtcode{\%\placeholder{N}y} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 2.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 2.
 Leading zeroes are permitted but not required.
-The modified commands \tcode{\%Ey} and \tcode{\%Oy} interpret
+The modified commands \noncxxtcode{\%Ey} and \noncxxtcode{\%Oy} interpret
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%Y} &
+\noncxxtcode{\%Y} &
 The year as a decimal number.
-The modified command \tcode{\%\placeholder{N}Y} specifies
+The modified command \noncxxtcode{\%\placeholder{N}Y} specifies
 the maximum number of characters to read.
-If \tcode{\placeholder{N}} is not specified, the default is 4.
+If \noncxxtcode{\placeholder{N}} is not specified, the default is 4.
 Leading zeroes are permitted but not required.
-The modified command \tcode{\%EY} interprets
+The modified command \noncxxtcode{\%EY} interprets
 the locale's alternative representation.
 \\ \rowsep
-\tcode{\%z} &
-The offset from UTC in the format \tcode{[+|-]hh[mm]}.
-For example \tcode{-0430} refers to 4 hours 30 minutes behind UTC,
-and \tcode{04} refers to 4 hours ahead of UTC\@.
-The modified commands \tcode{\%Ez} and \tcode{\%Oz}
-parse a \tcode{:} between the hours and minutes
+\noncxxtcode{\%z} &
+The offset from UTC in the format \noncxxtcode{[+|-]hh[mm]}.
+For example \noncxxtcode{-0430} refers to 4 hours 30 minutes behind UTC,
+and \noncxxtcode{04} refers to 4 hours ahead of UTC\@.
+The modified commands \noncxxtcode{\%Ez} and \noncxxtcode{\%Oz}
+parse a \noncxxtcode{:} between the hours and minutes
 and render leading zeroes on the hour field optional:
-\tcode{[+|-]h[h][:mm]}.
-For example \tcode{-04:30} refers to 4 hours 30 minutes behind UTC,
-and \tcode{4} refers to 4 hours ahead of UTC.
+\noncxxtcode{[+|-]h[h][:mm]}.
+For example \noncxxtcode{-04:30} refers to 4 hours 30 minutes behind UTC,
+and \noncxxtcode{4} refers to 4 hours ahead of UTC.
 \\ \rowsep
-\tcode{\%Z} &
+\noncxxtcode{\%Z} &
 The time zone abbreviation or name.
 A single word is parsed.
 This word can only contain characters
@@ -11442,8 +11442,8 @@ [time.parse]
 that are alphanumeric, or one of
 \tcode{'_'}, \tcode{'/'}, \tcode{'-'}, or \tcode{'+'}.
 \\ \rowsep
-\tcode{\%\%} &
-A \tcode{\%} character is extracted.
+\noncxxtcode{\%\%} &
+A \noncxxtcode{\%} character is extracted.
 \\
 \end{LongTable}
 
-- 
2.25.1


From 6bc3b7465d49365a4f5bb3e81c21eb5584d30ed8 Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Sun, 11 Nov 2018 15:23:33 +0100
Subject: [PATCH 12/21] Use \textnormal{..} and \textit{..} instead of
 \normalfont and \itshape.

The stateful ones are harder to handle.
---
 source/basic.tex | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/basic.tex b/source/basic.tex
index ec3f3e3e..8a96e07f 100644
--- a/source/basic.tex
+++ b/source/basic.tex
@@ -299,10 +299,10 @@ [basic.def]
   C() : s() { }
   C(const C& x): s(x.s) { }
   C(C&& x): s(static_cast<std::string&&>(x.s)) { }
-      @\rlap{\normalfont\itshape //}@    : s(std::move(x.s)) { }
+      @\rlap{\textnormal{\textit{//}}}@    : s(std::move(x.s)) { }
   C& operator=(const C& x) { s = x.s; return *this; }
   C& operator=(C&& x) { s = static_cast<std::string&&>(x.s); return *this; }
-      @\rlap{\normalfont\itshape //}@                { s = std::move(x.s); return *this; }
+      @\rlap{\textnormal{\textit{//}}}@                { s = std::move(x.s); return *this; }
   ~C() { }
 };
 \end{codeblock}
-- 
2.25.1


From 92828e3e9b176a9a1e4cbb8beb865fe8bfdbec33 Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Wed, 13 Mar 2019 21:04:43 +0100
Subject: [PATCH 13/21] [temp.deduct.call] Make sure that when math superscript
 is suffixed to \texttt, the \texttt itself is included in the formula passed
 to MathJax.

Otherwise cxxdraft-htmlgen passes a lone math superscript to MathJax and then applies our own \texttt styling to the result, which produces
a different result from letting MathJax render and style the whole thing.
---
 source/templates.tex | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/templates.tex b/source/templates.tex
index d90d295f..055ccc13 100644
--- a/source/templates.tex
+++ b/source/templates.tex
@@ -7397,7 +7397,7 @@ [temp.deduct.call]
 \tcode{A})
 as described below.
 If removing references and cv-qualifiers from \tcode{P} gives
-\tcode{std::initializer_list<P$^{\prime}$>}
+$\tcode{std::initializer_list<P}^{\prime}\tcode{>}$
 or $\tcode{P}'\tcode{[N]}$
 for some $\tcode{P}'$ and \tcode{N} and the
 argument is a non-empty initializer list\iref{dcl.init.list}, then deduction is
-- 
2.25.1


From bf0c77e0b063f21a5a8167f2c0aca1aee6ea0bf1 Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Sun, 31 May 2020 23:23:45 +0200
Subject: [PATCH 14/21] Remove more inappropriate paragraph breaks.

---
 source/lex.tex           |  2 --
 source/basic.tex         |  4 ----
 source/expressions.tex   | 26 --------------------------
 source/statements.tex    |  3 ---
 source/declarations.tex  | 14 --------------
 source/classes.tex       |  9 ---------
 source/overloading.tex   | 11 -----------
 source/templates.tex     | 35 -----------------------------------
 source/exceptions.tex    |  5 -----
 source/preprocessor.tex  | 10 ----------
 source/lib-intro.tex     | 17 -----------------
 source/support.tex       |  4 ----
 source/concepts.tex      | 16 ----------------
 source/utilities.tex     |  5 -----
 source/containers.tex    |  9 ---------
 source/iterators.tex     |  8 --------
 source/ranges.tex        |  8 --------
 source/algorithms.tex    |  4 ----
 source/numerics.tex      |  9 ---------
 source/time.tex          | 19 -------------------
 source/locales.tex       |  9 ---------
 source/iostreams.tex     | 15 ---------------
 source/regex.tex         |  2 --
 source/threads.tex       | 17 -----------------
 source/limits.tex        |  1 -
 source/compatibility.tex |  5 -----
 source/future.tex        | 22 ----------------------
 27 files changed, 289 deletions(-)

diff --git a/source/lex.tex b/source/lex.tex
index 34d313bc..85a62846 100644
--- a/source/lex.tex
+++ b/source/lex.tex
@@ -542,7 +542,6 @@ [lex.pptoken]
 
 \item
 within a \grammarterm{has-include-expression}.
-
 \end{itemize}
 \end{itemize}
 
@@ -1023,7 +1022,6 @@ [lex.operators]
 The lexical representation of \Cpp{} programs includes a number of
 preprocessing tokens that are used in the syntax of the preprocessor or
 are converted into tokens for operators and punctuators:
-
 \begin{bnf}
 \nontermdef{preprocessing-op-or-punc}\br
     preprocessing-operator\br
diff --git a/source/basic.tex b/source/basic.tex
index 8a96e07f..b0ce0352 100644
--- a/source/basic.tex
+++ b/source/basic.tex
@@ -253,7 +253,6 @@ [basic.def]
 namespace N { int d; }          // defines \tcode{N} and \tcode{N::d}
 namespace N1 = N;               // defines \tcode{N1}
 X anX;                          // defines \tcode{anX}
-
 \end{codeblock}
 whereas these are just declarations:
 \begin{codeblock}
@@ -4163,7 +4162,6 @@ [basic.align]
 
 \pnum
 Comparing alignments is meaningful and provides the obvious results:
-
 \begin{itemize}
 \item Two alignments are equal when their numeric values are equal.
 \item Two alignments are different when their numeric values are not equal.
@@ -5486,7 +5484,6 @@ [conv.rank]
 
 \pnum
 Every integer type has an \term{integer conversion rank} defined as follows:
-
 \begin{itemize}
 \item No two signed integer types other than \keyword{char} and \tcode{\keyword{signed}
 \keyword{char}} (if \keyword{char} is signed) have the same rank, even if they have
@@ -6048,7 +6045,6 @@ [intro.races]
 \item
 for some evaluation $X$, $A$ is dependency-ordered before $X$ and
 $X$ carries a dependency to $B$.
-
 \end{itemize}
 \begin{note}
 The relation ``is dependency-ordered before'' is analogous to
diff --git a/source/expressions.tex b/source/expressions.tex
index efcea31f..42e4a323 100644
--- a/source/expressions.tex
+++ b/source/expressions.tex
@@ -454,7 +454,6 @@ [expr.context]
 if and only if
 the expression is a glvalue of volatile-qualified type and it is one of the
 following:
-
 \begin{itemize}
 \item \tcode{(} \grammarterm{expression} \tcode{)}, where
 \grammarterm{expression} is one of these expressions,
@@ -497,7 +496,6 @@ [conv.general]
 \ref{conv} enumerates the full set of such conversions. A
 \defnx{standard conversion sequence}{conversion sequence!standard} is a sequence of standard
 conversions in the following order:
-
 \begin{itemize}
 \item Zero or one conversion from the following set: lvalue-to-rvalue
 conversion, array-to-pointer conversion, and function-to-pointer
@@ -524,7 +522,6 @@ [conv.general]
 \begin{note}
 Expressions with a given type will be implicitly converted to other
 types in several contexts:
-
 \begin{itemize}
 \item When used as operands of operators. The operator's requirements
 for its operands dictate the destination type\iref{expr.compound}.
@@ -650,7 +647,6 @@ [conv.lval]
 \pnum
 The result of the conversion is determined according to the
 following rules:
-
 \begin{itemize}
 
 \item If \tcode{T} is \cv{}~\tcode{std::nullptr_t}, the result is a
@@ -1115,7 +1111,6 @@ [expr.arith.conv]
 purpose is to yield a common type, which is also the type of the result.
 This pattern is called the \defnx{usual arithmetic conversions}{conversion!usual arithmetic},
 which are defined as follows:
-
 \begin{itemize}
 \item If either operand is of \deflinkx{scoped enumeration type}{enumeration!scoped}{dcl.enum}, no conversions
 are performed; if the other operand does not have the same type, the expression is
@@ -1151,7 +1146,6 @@ [expr.arith.conv]
 to some integral type.
 \end{footnote}
 Then the following rules are applied to determine \tcode{C}:
-
 \begin{itemize}
 
 \item If \tcode{T1} and \tcode{T2} are the same type, \tcode{C} is that type.
@@ -2355,7 +2349,6 @@ [expr.prim.lambda.capture]
 \pnum
 For the purposes of lambda capture,
 an expression potentially references local entities as follows:
-
 \begin{itemize}
 \item
 An \grammarterm{id-expression} that names a local entity
@@ -2948,7 +2941,6 @@ [expr.prim.req.compound]
 of the \grammarterm{expression} $E$. Substitution
 of template arguments (if any) and verification of
 semantic properties proceed in the following order:
-
 \begin{itemize}
 \item
 Substitution of template arguments (if any)
@@ -2960,7 +2952,6 @@ [expr.prim.req.compound]
 
 \item
 If the \grammarterm{return-type-requirement} is present, then:
-
 \begin{itemize}
 \item
 Substitution of template arguments (if any)
@@ -3558,7 +3549,6 @@ [expr.ref]
 otherwise \tcode{E1.E2} designates the object or function to which
 the corresponding reference member of \tcode{E1} is bound.
 Otherwise, one of the following rules applies.
-
 \begin{itemize}
 \item If \tcode{E2} is a static data member and the type of \tcode{E2}
 is \tcode{T}, then \tcode{E1.E2} is an lvalue; the expression designates
@@ -3759,7 +3749,6 @@ [expr.dynamic.cast]
 \pnum
 Let \tcode{C} be the class type to which \tcode{T} points or refers. The runtime
 check logically executes as follows:
-
 \begin{itemize}
 \item If, in the most derived object pointed (referred) to by \tcode{v},
 \tcode{v} points (refers) to a public base class subobject of a
@@ -4309,7 +4298,6 @@ [expr.reinterpret.cast]
 The null member pointer value\iref{conv.mem} is converted to the
 null member pointer value of the destination type. The result of this
 conversion is unspecified, except in the following cases:
-
 \begin{itemize}
 \item Converting a prvalue of type ``pointer to member function'' to a
 different pointer-to-member-function type and back to its original type
@@ -4732,7 +4720,6 @@ [expr.await]
 \pnum
 Evaluation of an \grammarterm{await-expression} involves the following
 auxiliary types, expressions, and objects:
-
 \begin{itemize}
 \item
 \placeholder{p} is an lvalue naming the promise
@@ -5110,7 +5097,6 @@ [expr.new]
 the \grammarterm{new-expression}, then the allocated type is the type
 deduced for the variable \tcode{x} in the invented
 declaration\iref{dcl.spec.auto}:
-
 \begin{codeblock}
 T x @\textrm{\placeholder{init}}@ ;
 \end{codeblock}
@@ -5443,7 +5429,6 @@ [expr.new]
 otherwise, an argument that
 is the type's alignment and has type \tcode{std::align_val_t}
 is added into the argument list immediately after the first argument;
-
 \end{itemize}
 and then overload resolution is performed again.
 
@@ -5520,7 +5505,6 @@ [expr.new]
 \indextext{\idxcode{new}!default constructor and}%
 A \grammarterm{new-expression} that creates an object of type \tcode{T}
 initializes that object as follows:
-
 \begin{itemize}
 \item If the \grammarterm{new-initializer} is omitted, the object is
 default-initialized\iref{dcl.init}.
@@ -5610,7 +5594,6 @@ [expr.new]
 S* p = new (0) S;   // error: non-placement deallocation function matches
                     // placement allocation function
 \end{codeblock}
-
 \end{example}
 
 \pnum
@@ -5738,7 +5721,6 @@ [expr.delete]
 \pnum
 If the value of the operand of the \grammarterm{delete-expression} is not a
 null pointer value, then:
-
 \begin{itemize}
 \item
 If the allocation call for the \grammarterm{new-expression} for the object to
@@ -6345,7 +6327,6 @@ [expr.spaceship]
 the other operand has unscoped enumeration type,
 the \link{usual arithmetic conversions}{expr.arith.conv} are applied to the operands.
 Then:
-
 \begin{itemize}
 \item
 If a \deflinkx{narrowing conversion}{conversion!narrowing}{dcl.init.list} is required,
@@ -6500,7 +6481,6 @@ [expr.rel]
 $n$ for this purpose.
 \end{footnote}
 is defined in terms of a partial order consistent with the following rules:
-
 \begin{itemize}
 \item If two pointers point to different elements of the same array, or to
 subobjects thereof, the pointer to the element with the higher subscript
@@ -6513,7 +6493,6 @@ [expr.rel]
 and their class is not a union.
 
 \item Otherwise, neither pointer is required to compare greater than the other.
-
 \end{itemize}
 
 \pnum
@@ -6575,7 +6554,6 @@ [expr.eq]
 \link{qualification conversions}{conv.qual}
 are performed on both operands to bring them to their \deflink{composite pointer type}{expr.type}.
 Comparing pointers is defined as follows:
-
 \begin{itemize}
 \item
 If one pointer represents the address of a complete object, and another
@@ -6605,7 +6583,6 @@ [expr.eq]
 are performed on both operands to bring them to
 their composite pointer type\iref{expr.type}.
 Comparing pointers to members is defined as follows:
-
 \begin{itemize}
 \item
 If two pointers to members are both the null member pointer value, they compare
@@ -6877,7 +6854,6 @@ [expr.cond]
 from an operand expression \tcode{E1} of type \tcode{T1}
 to a target type related to the type \tcode{T2}
 of the operand expression \tcode{E2} as follows:
-
 \begin{itemize}
 \item If \tcode{E2} is an lvalue, the target type is
 ``lvalue reference to \tcode{T2}'',
@@ -6948,7 +6924,6 @@ [expr.cond]
 and \link{function-to-pointer}{conv.func} standard conversions are
 performed on the second and third operands. After those conversions, one
 of the following shall hold:
-
 \begin{itemize}
 \item The second and third operands have the same type; the result is of
 that type and the result object is initialized using the selected operand.
@@ -6976,7 +6951,6 @@ [expr.cond]
 Both the second and third operands have type \tcode{std::nullptr_t} or one has
 that type and the other is a null pointer constant. The result is of type
 \tcode{std::nullptr_t}.
-
 \end{itemize}
 
 \rSec2[expr.yield]{Yielding a value}%
diff --git a/source/statements.tex b/source/statements.tex
index 29ee9f0b..26a6435b 100644
--- a/source/statements.tex
+++ b/source/statements.tex
@@ -675,7 +675,6 @@ [stmt.ranged]
 
 \item
 \exposid{begin-expr} and \exposid{end-expr} are determined as follows:
-
 \begin{itemize}
 \item if the \grammarterm{for-range-initializer} is an expression of
 array type \tcode{R}, \exposid{begin-expr} and \exposid{end-expr} are
@@ -806,7 +805,6 @@ [stmt.cont]
 causes control to pass to the loop-continuation portion of the
 smallest such enclosing statement, that is, to the end
 of the loop. More precisely, in each of the statements
-
 \begin{minipage}{.30\hsize}
 \begin{codeblock}
 while (foo) {
@@ -837,7 +835,6 @@ [stmt.cont]
 }
 \end{codeblock}
 \end{minipage}
-
 a \keyword{continue} not contained in an enclosed iteration statement is
 equivalent to \tcode{goto} \exposid{contin}.
 
diff --git a/source/declarations.tex b/source/declarations.tex
index 643c0676..2fc34eb8 100644
--- a/source/declarations.tex
+++ b/source/declarations.tex
@@ -1408,7 +1408,6 @@ [dcl.type.elab]
 specialization\iref{temp.expl.spec}, an explicit
 instantiation\iref{temp.explicit} or it has one of the following
 forms:
-
 \begin{ncsimplebnf}
 class-key \opt{attribute-specifier-seq} identifier \terminal{;}\br
 class-key \opt{attribute-specifier-seq} simple-template-id \terminal{;}
@@ -2194,7 +2193,6 @@ [dcl.decl.general]
 
 \pnum
 Declarators have the syntax
-
 \begin{bnf}
 \nontermdef{declarator}\br
     ptr-declarator\br
@@ -4052,7 +4050,6 @@ [dcl.fct.default]
 \tcode{g}
 will be called with the value
 \tcode{f(2)}:
-
 \begin{codeblock}
 int a = 1;
 int f(int);
@@ -4391,7 +4388,6 @@ [dcl.init.general]
 an object of type
 \tcode{T}
 means:
-
 \begin{itemize}
 \item
 If
@@ -4587,7 +4583,6 @@ [dcl.init.general]
 the initialization of the $j^\text{th}$ element.
 \item
 Otherwise, if the destination type is a (possibly cv-qualified) class type:
-
 \begin{itemize}
 \item
 If the initializer expression is a prvalue
@@ -5480,7 +5475,6 @@ [dcl.init.ref]
 A reference to type ``\cvqual{cv1} \tcode{T1}'' is initialized by
 an expression of type ``\cvqual{cv2} \tcode{T2}'' as follows:%
 \indextext{binding!reference}
-
 \begin{itemize}
 \item
 If the reference is an lvalue reference and the initializer expression
@@ -5940,7 +5934,6 @@ [dcl.init.list]
 int k { };                          // initialize to 0
 \end{codeblock}
 \end{example}
-
 \end{itemize}
 
 \pnum
@@ -6838,7 +6831,6 @@ [dcl.struct.bind]
 where $\tcode{U}_i$ is an lvalue reference if
 the initializer is an lvalue and an rvalue reference otherwise,
 variables are introduced with unique names $\tcode{r}_i$ as follows:
-
 \begin{ncbnf}
 \placeholder{S} \terminal{U$_i$ r$_i$ =} initializer \terminal{;}
 \end{ncbnf}
@@ -6964,7 +6956,6 @@ [dcl.enum]
   enum E : int {};              // error: redeclaration of enumeration
 };
 \end{codeblock}
-
 \end{example}
 \end{note}
 The \grammarterm{identifier} in an \grammarterm{enum-head-name}
@@ -7062,7 +7053,6 @@ [dcl.enum]
 type is not fixed,
 the type of each enumerator prior to the closing brace is determined as
 follows:
-
 \begin{itemize}
 \item If an
 initializer is specified for an enumerator, the
@@ -7502,7 +7492,6 @@ [namespace.alias]
 \pnum
 A \grammarterm{namespace-alias-definition} declares an alternate name for a
 namespace according to the following grammar:
-
 \begin{bnf}
 \nontermdef{namespace-alias}\br
         identifier
@@ -7657,7 +7646,6 @@ [namespace.udir]
 In particular, the name of a variable, function or enumerator does not
 hide the name of a class or enumeration declared in a different
 namespace. For example,
-
 \begin{codeblock}
 namespace A {
   class X { };
@@ -8180,7 +8168,6 @@ [dcl.link]
 \pnum
 \link{Linkage}{basic.link} between \Cpp{} and  non-\Cpp{} code fragments can
 be achieved using a \grammarterm{linkage-specification}:
-
 \indextext{\idxgram{linkage-specification}}%
 \indextext{specification!linkage!\idxcode{extern}}%
 %
@@ -9019,7 +9006,6 @@ [dcl.attr.nodiscard]
 to the declaration of a class or enumeration.
 An \grammarterm{attribute-argument-clause} may be present
 and, if present, shall have the form:
-
 \begin{ncbnf}
 \terminal{(} string-literal \terminal{)}
 \end{ncbnf}
diff --git a/source/classes.tex b/source/classes.tex
index 879881be..0c71d1c2 100644
--- a/source/classes.tex
+++ b/source/classes.tex
@@ -1591,7 +1591,6 @@ [class.copy.ctor]
 that is of class type (or array thereof),
 the constructor selected to copy/move that member is trivial;
 \end{itemize}
-
 \indextext{constructor!move!non-trivial}%
 otherwise the copy/move constructor is
 \defnx{non-trivial}{constructor!copy!nontrivial}.
@@ -3225,7 +3224,6 @@ [class.union.general]
 destructor and \tcode{N} has a non-trivial constructor (for instance, if they declare or inherit
 virtual functions), the active member of \tcode{u} can be safely switched from \tcode{m} to
 \tcode{n} using the destructor and placement \grammarterm{new-expression} as follows:
-
 \begin{codeblock}
 u.m.~M();
 new (&u.n) N;
@@ -3402,7 +3400,6 @@ [class.derived.general]
 \indextext{multiple inheritance}%
 A list of base classes can be specified in a class definition using
 the notation:
-
 \begin{bnf}
 \nontermdef{base-clause}\br
     \terminal{:} base-specifier-list
@@ -4859,7 +4856,6 @@ [class.friend]
 \pnum
 A friend declaration that does not declare a function
 shall have one of the following forms:
-
 \begin{ncsimplebnf}
 \keyword{friend} elaborated-type-specifier \terminal{;}\br
 \keyword{friend} simple-type-specifier \terminal{;}\br
@@ -5364,7 +5360,6 @@ [class.base.init]
 non-static data members can be specified by a
 \grammarterm{ctor-initializer},
 which has the form
-
 \begin{bnf}
 \nontermdef{ctor-initializer}\br
     \terminal{:} mem-initializer-list
@@ -5826,7 +5821,6 @@ [class.base.init]
   X(const Mixins&... mixins) : Mixins(mixins)... { }
 };
 \end{codeblock}
-
 \end{example}
 
 \rSec2[class.inhctor.init]{Initialization by inherited constructor}%
@@ -6434,7 +6428,6 @@ [class.compare.default]
 A binary operator expression \tcode{a @ b} is
 \defnx{usable}{usable!binary operator expression}
 if either
-
 \begin{itemize}
 \item
 \tcode{a} or \tcode{b} is of class or enumeration type and
@@ -6555,7 +6548,6 @@ [class.spaceship]
 of type \tcode{R}\iref{cmp.categories}
 of glvalues \tcode{a} and \tcode{b} of the same type
 is defined as follows:
-
 \begin{itemize}
 \item
 If \tcode{a <=> b} is usable\iref{class.compare.default} and
@@ -6654,7 +6646,6 @@ [class.spaceship]
 of a possibly-empty list of $n$ comparison category types
 $\tcode{T}_0$, $\tcode{T}_1$, $\dotsc$, $\tcode{T}_{n-1}$
 is defined as follows:
-
 \begin{itemize}
 \item
 If at least one $\tcode{T}_i$ is \tcode{std::partial_ordering},
diff --git a/source/overloading.tex b/source/overloading.tex
index 91bd8dab..d61cdfdd 100644
--- a/source/overloading.tex
+++ b/source/overloading.tex
@@ -98,7 +98,6 @@ [over.match.general]
 But, once the
 candidate functions and argument lists have been identified, the
 selection of the best function is the same in all cases:
-
 \begin{itemize}
 \item
 First, a subset of the candidate functions (those that have
@@ -391,7 +390,6 @@ [over.call.func]
 \grammarterm{postfix-expression},
 perhaps nested arbitrarily deep in
 parentheses, has one of the following forms:
-
 \begin{ncbnf}
 postfix-expression:\br
     postfix-expression \terminal{.} id-expression\br
@@ -979,7 +977,6 @@ [over.match.oper]
 the lookup
 rules for operator function names in a function call, as shown in the following
 example:
-
 \begin{codeblock}
 struct A { };
 void operator + (A, A);
@@ -1040,7 +1037,6 @@ [over.match.copy]
 \tcode{T}
 a class type,
 the candidate functions are selected as follows:
-
 \begin{itemize}
 \item
 The \deflinkx{converting constructors}{constructor!converting}{class.conv.ctor} of
@@ -1086,7 +1082,6 @@ [over.match.conv]
 Assuming that ``\cv{} \tcode{T}'' is the
 type of the object being initialized,
 the candidate functions are selected as follows:
-
 \begin{itemize}
 \item
 The permissible types for non-explicit conversion functions are
@@ -1158,7 +1153,6 @@ [over.match.list]
 is performed according to the rules in this subclause
 or when forming a list-initialization sequence according to \ref{over.ics.list},
 overload resolution selects the constructor in two phases:
-
 \begin{itemize}
 \item
 If the initializer list is not empty or \tcode{T} has no default constructor,
@@ -1228,7 +1222,6 @@ [over.match.class.deduct]
 For each \grammarterm{deduction-guide},
 a function or function template
 with the following properties:
-
 \begin{itemize}
 \item
 The template parameters, if any,
@@ -2613,7 +2606,6 @@ [over.ics.rank]
 Two implicit conversion sequences of the same form are
 indistinguishable conversion sequences unless one of the
 following rules applies:
-
 \begin{itemize}
 \item
 List-initialization sequence \tcode{L1} is a better conversion sequence than
@@ -2807,7 +2799,6 @@ [over.ics.rank]
                                 // better than \tcode{short} $\to$ \tcode{float}.
 \end{codeblock}
 \end{example}
-
 \end{itemize}
 
 \pnum
@@ -2816,7 +2807,6 @@ [over.ics.rank]
 a Conversion.
 Two conversion sequences with the same rank are indistinguishable unless
 one of the following rules applies:
-
 \begin{itemize}
 \item
 A conversion that does not convert a pointer or a pointer to member
@@ -3971,7 +3961,6 @@ [over.literal]
 \pnum
 The declaration of a literal operator shall have a
 \grammarterm{parameter-declaration-clause} equivalent to one of the following:
-
 \begin{codeblock}
 const char*
 unsigned long long int
diff --git a/source/templates.tex b/source/templates.tex
index 055ccc13..c3a5eb33 100644
--- a/source/templates.tex
+++ b/source/templates.tex
@@ -221,7 +221,6 @@ [temp.param]
 The syntax for
 \grammarterm{template-parameter}{s}
 is:
-
 \begin{bnf}
 \nontermdef{template-parameter}\br
   type-parameter\br
@@ -1419,7 +1418,6 @@ [temp.arg.template]
 Given an invented class template \tcode{X}
 with the \grammarterm{template-head} of \tcode{A} (including default arguments
 and \grammarterm{requires-clause}, if any):
-
 \begin{itemize}
 \item
 Each of the two function templates has the same template parameters
@@ -1709,7 +1707,6 @@ [temp.constr.decl]
 can be constrained by the use of a \grammarterm{requires-clause}.
 This allows the specification of constraints for that declaration as
 an expression:
-
 \begin{bnf}
 \nontermdef{constraint-expression}\br
     logical-or-expression
@@ -1725,7 +1722,6 @@ [temp.constr.decl]
 \pnum
 \indextext{constraint!associated|see{associated constraints}}%
 A declaration's \defn{associated constraints} are defined as follows:
-
 \begin{itemize}
 \item If there are no introduced \grammarterm{constraint-expression}{s},
 the declaration has no associated constraints.
@@ -2323,7 +2319,6 @@ [temp.mem.func]
 
 declares three member functions of a class template.
 The subscript function can be defined like this:
-
 \begin{codeblock}
 template<class T> T& Array<T>::operator[](int i) {
   if (i<0 || sz<=i) error("Array: range error");
@@ -2694,7 +2689,6 @@ [temp.variadic]
 The form of the pattern
 depends on the context in which the expansion occurs. Pack
 expansions can occur in the following contexts:
-
 \begin{itemize}
 \item In a function parameter pack\iref{dcl.fct}; the pattern is the
 \grammarterm{parameter-declaration} without the ellipsis.
@@ -3249,7 +3243,6 @@ [temp.spec.partial.general]
 \pnum
 Within the argument list of a partial specialization,
 the following restrictions apply:
-
 \begin{itemize}
 \item
 The type of a template parameter corresponding to a specialized non-type argument
@@ -3263,7 +3256,6 @@ [temp.spec.partial.general]
 int array[5];
 template< int X > class A<X,&array> { };        // error
 \end{codeblock}
-
 \end{example}
 \item
 The partial specialization shall be more specialized than the primary
@@ -3389,7 +3381,6 @@ [temp.spec.partial.order]
 rewrite to two function templates, the first function template is more
 specialized than the second according to the \link{ordering rules for function
 templates}{temp.func.order}:
-
 \begin{itemize}
 \item
 Each of the two
@@ -3541,7 +3532,6 @@ [temp.fct.general]
 A function template defines an unbounded set of related functions.
 \begin{example}
 A family of sort functions can be declared like this:
-
 \begin{codeblock}
 template<class T> class Array { };
 template<class T> void sort(Array<T>&);
@@ -3596,7 +3586,6 @@ [temp.over.link]
 }
 \end{codeblock}
 \end{minipage}
-
 \end{example}
 
 \pnum
@@ -3778,7 +3767,6 @@ [temp.over.link]
 as distinct.
 For example, the last two declarations are functionally
 equivalent and would cause a program to be ill-formed:
-
 \begin{codeblock}
 // guaranteed to be the same
 template <int I> void f(A<I>, A<I+10>);
@@ -3858,7 +3846,6 @@ [temp.func.order]
 is reversed.
 For a function template $M$ with cv-qualifiers \cv{}
 that is a member of a class $A$:
-
 \begin{itemize}
 \item
 The type $X(M)$ is ``rvalue reference to \cv{}~$A$''
@@ -4103,7 +4090,6 @@ [temp.alias]
   void g(TT<int, Alloc<int>>);
 g(v);               // OK, \tcode{TT} = \tcode{vector}
 \end{codeblock}
-
 \end{example}
 
 \pnum
@@ -4939,7 +4925,6 @@ [temp.dep.type]
 
 \pnum
 A qualified name\iref{basic.lookup.qual} is dependent if
-
 \begin{itemize}
 \item
 it is a \grammarterm{conversion-function-id}
@@ -5108,7 +5093,6 @@ [temp.dep.expr]
 or
 \grammarterm{new-type-id}
 is dependent, even if any subexpression is type-dependent:
-
 \begin{ncsimplebnf}
 simple-type-specifier \terminal{(} \opt{expression-list} \terminal{)}\br
 simple-type-specifier braced-init-list\br
@@ -5126,7 +5110,6 @@ [temp.dep.expr]
 \pnum
 Expressions of the following forms are never type-dependent (because the type
 of the expression cannot be dependent):
-
 \begin{ncsimplebnf}
 literal\br
 \keyword{sizeof} unary-expression\br
@@ -5214,7 +5197,6 @@ [temp.dep.constexpr]
 is type-dependent or the
 \grammarterm{type-id}
 is dependent:
-
 \begin{ncsimplebnf}
 \keyword{sizeof} unary-expression\br
 \keyword{sizeof} \terminal{(} type-id \terminal{)}\br
@@ -5239,7 +5221,6 @@ [temp.dep.constexpr]
 or
 \grammarterm{cast-expression}
 is value-dependent:
-
 \begin{ncsimplebnf}
 simple-type-specifier \terminal{(} \opt{expression-list} \terminal{)}\br
 \keyword{static_cast} \terminal{<} type-id \terminal{>} \terminal{(} expression \terminal{)}\br
@@ -5250,7 +5231,6 @@ [temp.dep.constexpr]
 
 \pnum
 Expressions of the following form are value-dependent:
-
 \begin{ncsimplebnf}
 \keyword{sizeof} \terminal{...} \terminal{(} identifier \terminal{)}\br
 fold-expression
@@ -6134,7 +6114,6 @@ [temp.explicit]
 
 \pnum
 The syntax for explicit instantiation is:
-
 \begin{bnf}
 \nontermdef{explicit-instantiation}\br
   \opt{\keyword{extern}} \keyword{template} declaration
@@ -6644,7 +6623,6 @@ [temp.expl.spec]
 The definition of a static data member of a template
 for which default-initialization is desired
 can use functional cast notation\iref{expr.type.conv}:
-
 \begin{codeblock}
 template<> X Q<int>::x;                         // declaration
 template<> X Q<int>::x ();                      // error: declares a function
@@ -6903,7 +6881,6 @@ [temp.arg.explicit]
 use refers to a specialization of a function template even when a
 non-template function\iref{dcl.fct} is visible that would otherwise be used.
 For example:
-
 \begin{codeblock}
 template <class T> int f(T);    // \#1
 int f(int);                     // \#2
@@ -7475,7 +7452,6 @@ [temp.deduct.call]
 If
 \tcode{P}
 is not a reference type:
-
 \begin{itemize}
 \item
 If
@@ -7570,7 +7546,6 @@ [temp.deduct.call]
 is transformed as described above).
 However, there are
 three cases that allow a difference:
-
 \begin{itemize}
 \item
 If the original
@@ -7743,7 +7718,6 @@ [temp.deduct.conv]
 If
 \tcode{A}
 is not a reference type:
-
 \begin{itemize}
 \item
 If
@@ -7789,7 +7763,6 @@ [temp.deduct.conv]
 identical to
 \tcode{A}.
 However, certain attributes of \tcode{A} may be ignored:
-
 \begin{itemize}
 \item
 If the original \tcode{A} is a reference type,
@@ -7834,7 +7807,6 @@ [temp.deduct.partial]
 \pnum
 The types used to determine the ordering depend on the context in which
 the partial ordering is done:
-
 \begin{itemize}
 \item
 In the context of a function call, the types used are those function parameter types
@@ -7862,7 +7834,6 @@ [temp.deduct.partial]
 \pnum
 Before the partial ordering is done, certain transformations are performed
 on the types used for partial ordering:
-
 \begin{itemize}
 \item
 If
@@ -8068,7 +8039,6 @@ [temp.deduct.type]
 \tcode{P}
 can be composed from a number of other
 types, templates, and non-type values:
-
 \begin{itemize}
 \item
 A function type includes the types of each of the function parameters,
@@ -8110,7 +8080,6 @@ [temp.deduct.type]
 
 \pnum
 The non-deduced contexts are:
-
 \indextext{context!non-deduced}%
 \begin{itemize}
 \item
@@ -8193,7 +8162,6 @@ [temp.deduct.type]
 \begin{example}
 Here is an example in which different parameter/argument pairs produce
 inconsistent template argument deductions:
-
 \begin{codeblock}
 template<class T> void f(T x, T y) { @\commentellip@ }
 struct A { @\commentellip@ };
@@ -8210,7 +8178,6 @@ [temp.deduct.type]
 single function parameter/argument pair.
 This can lead to conflicts
 that cause type deduction to fail:
-
 \begin{codeblock}
 template <class T, class U> void f(  T (*)( T, U, U )  );
 
@@ -8246,7 +8213,6 @@ [temp.deduct.type]
 
 Here is an example where a qualification conversion applies between the
 argument type on the function call and the deduced template argument type:
-
 \begin{codeblock}
 template<class T> void f(const T*) { }
 int* p;
@@ -8257,7 +8223,6 @@ [temp.deduct.type]
 
 Here is an example where the template argument is used to instantiate
 a derived class type of the corresponding function parameter type:
-
 \begin{codeblock}
 template <class T> struct B { };
 template <class T> struct D : public B<T> {};
diff --git a/source/exceptions.tex b/source/exceptions.tex
index ac2b59fa..33924de0 100644
--- a/source/exceptions.tex
+++ b/source/exceptions.tex
@@ -89,7 +89,6 @@ [except.pre]
     goto l2;        // OK
   }
 }
-
 \end{codeblock}
 \end{example}
 \indextext{\idxcode{goto}!and try block}%
@@ -538,12 +537,10 @@ [except.handle]
 a \link{function pointer conversion}{conv.fctptr}
 \item%
 a \link{qualification conversion}{conv.qual}, or
-
 \end{itemize}
 
 \item
 the \grammarterm{handler} is of type \cv{}~\tcode{T} or \tcode{const T\&} where \tcode{T} is a pointer or pointer-to-member type and \tcode{E} is \tcode{std::nullptr_t}.
-
 \end{itemize}
 
 \begin{note}
@@ -1082,9 +1079,7 @@ [except.terminate]
 when a call to a \tcode{wait()}, \tcode{wait_until()}, or \tcode{wait_for()}
 function on a condition variable\iref{thread.condition.condvar,thread.condition.condvarany}
 fails to meet a postcondition.
-
 \end{itemize}
-
 \end{note}
 
 \pnum
diff --git a/source/preprocessor.tex b/source/preprocessor.tex
index 736cf97b..4a518ab4 100644
--- a/source/preprocessor.tex
+++ b/source/preprocessor.tex
@@ -143,7 +143,6 @@ [cpp.pre]
 (optionally after whitespace containing no new-line characters) or
 follows whitespace containing at least one new-line character,
 and is
-
 \begin{itemize}
 \item
 a \tcode{\#} preprocessing token, or
@@ -556,7 +555,6 @@ [cpp.cond]
 \begin{example}
 This demonstrates a way to include a library \tcode{optional} facility
 only if it is available:
-
 \begin{codeblock}
 #if __has_include(<optional>)
 #  include <optional>
@@ -715,14 +713,12 @@ [cpp.include]
 with the implementation and the \tcode{" "} form for sources
 outside the control of the implementation
 achieves wider portability. For instance:
-
 \begin{codeblock}
 #include <stdio.h>
 #include <unistd.h>
 #include "usefullib.h"
 #include "myprog.h"
 \end{codeblock}
-
 \end{note}
 
 \pnum
@@ -730,7 +726,6 @@ [cpp.include]
 This illustrates macro-replaced
 \tcode{\#include}
 directives:
-
 \begin{codeblock}
 #if VERSION == 1
     #define INCFILE  "vers1.h"
@@ -1432,7 +1427,6 @@ [cpp.concat]
 \pnum
 \begin{example}
 In the following fragment:
-
 \begin{codeblock}
 #define hash_hash # ## #
 #define mkstr(a) # a
@@ -1442,7 +1436,6 @@ [cpp.concat]
 \end{codeblock}
 
 The expansion produces, at various stages:
-
 \begin{codeblock}
 join(x, y)
 in_between(x hash_hash y)
@@ -1664,7 +1657,6 @@ [cpp.predefined]
 
 \pnum
 The following macro names shall be defined by the implementation:
-
 \begin{description}
 
 \item
@@ -1872,7 +1864,6 @@ [cpp.predefined]
 
 \pnum
 The following macro names are conditionally defined by the implementation:
-
 \begin{description}
 \item
 \indextext{__stdc__@\mname{STDC}}%
@@ -1907,7 +1898,6 @@ [cpp.predefined]
 \mname{STDCPP_THREADS}\\
 Defined, and has the value integer literal 1, if and only if a program
 can have more than one \link{thread of execution}{intro.multithread}.
-
 \end{description}
 
 \pnum
diff --git a/source/lib-intro.tex b/source/lib-intro.tex
index 0670a00e..8558f7e4 100644
--- a/source/lib-intro.tex
+++ b/source/lib-intro.tex
@@ -190,7 +190,6 @@ [structure.elements]
 For example, if a Clause does not specify any requirements,
 there will be no ``Requirements'' subclause.
 \end{footnote}
-
 \begin{itemize}
 \item Summary
 \item Requirements
@@ -207,7 +206,6 @@ [structure.summary]
 
 \pnum
 The contents of the summary and the detailed specifications include:
-
 \begin{itemize}
 \item macros
 \item values
@@ -224,7 +222,6 @@ [structure.requirements]
 \indextext{requirements}%
 Requirements describe constraints that shall be met by a \Cpp{} program that extends the standard library.
 Such extensions are generally one of the following:
-
 \begin{itemize}
 \item Template arguments
 \item Derived classes
@@ -299,7 +296,6 @@ [structure.specifications]
 
 \pnum
 The detailed specifications each contain the following elements:%
-
 \begin{itemize}
 \item name and brief description
 \item synopsis (class definition or function declaration, as appropriate)
@@ -316,7 +312,6 @@ [structure.specifications]
 For example, if a class does not specify any comparison operator functions, there
 will be no ``Comparison operator functions'' subclause.
 \end{footnote}
-
 \begin{itemize}
 \item constructor(s) and destructor
 \item copying, moving \& assignment functions
@@ -334,7 +329,6 @@ [structure.specifications]
 For example, if a function specifies no
 preconditions, there will be no \expects element.
 \end{footnote}
-
 \begin{itemize}
 \item
 \constraints
@@ -561,7 +555,6 @@ [enumerated.types]
 
 \pnum
 The enumerated type \tcode{\placeholder{enumerated}} can be written:
-
 \begin{codeblock}
 enum @\placeholder{enumerated}@ { @$\tcode{\placeholder{V}}_{0}$@, @$\tcode{\placeholder{V}}_{1}$@, @$\tcode{\placeholder{V}}_{2}$@, @$\tcode{\placeholder{V}}_{3}$@, @$\ldots$@ };
 
@@ -594,7 +587,6 @@ [bitmask.types]
 
 \pnum
 The bitmask type \tcode{\placeholder{bitmask}} can be written:
-
 \begin{codeblock}
 // For exposition only.
 // \tcode{int_type} is an integral type capable of representing all values of the bitmask type.
@@ -671,7 +663,6 @@ [character.seq.general]
 The C standard library makes widespread use
 \indextext{library!C standard}%
 of characters and character sequences that follow a few uniform conventions:
-
 \begin{itemize}
 \item
 Properties specified as \defn{locale-specific}
@@ -876,7 +867,6 @@ [objects.within.classes]
 private members of classes that meet the external specifications of the classes.
 The declarations for such members are
 followed by a comment that ends with \expos, as in:
-
 \begin{codeblock}
 streambuf* sb;      // \expos
 \end{codeblock}
@@ -1723,7 +1713,6 @@ [swappable.requirements]
 evaluated in the context described below, and
 
 \item these expressions have the following effects:
-
 \begin{itemize}
 \item the object referred to by \tcode{t} has the value originally held by \tcode{u} and
 \item the object referred to by \tcode{u} has the value originally held by \tcode{t}.
@@ -2729,7 +2718,6 @@ [allocator.requirements.general]
 \begin{example}
 The following is an allocator class template supporting the minimal
 interface that meets the requirements of \ref{allocator.requirements.general}:
-
 \begin{codeblock}
 template<class T>
 struct SimpleAllocator {
@@ -3139,7 +3127,6 @@ [replacement.functions]
 A \Cpp{} program may provide the definition for any of the following
 dynamic memory allocation function signatures declared in header
 \tcode{<new>}\iref{basic.stc.dynamic,new.syn}:
-
 \indextext{\idxcode{new}!\idxcode{operator}!replaceable}%
 \indexlibrarymember{new}{operator}%
 \begin{codeblock}
@@ -3191,7 +3178,6 @@ [handler.functions]
 \pnum
 The \Cpp{} standard library provides a default version of the following handler
 function\iref{support}:
-
 \begin{itemize}
 \item
 \tcode{terminate_handler}
@@ -3212,7 +3198,6 @@ [handler.functions]
 \pnum
 A \Cpp{} program can get a pointer to the current handler function by calling the following
 functions:
-
 \begin{itemize}
 \item
 \indexlibraryglobal{get_new_handler}%
@@ -3238,7 +3223,6 @@ [res.on.functions]
 
 \pnum
 In particular, the behavior is undefined in the following cases:
-
 \begin{itemize}
 \item
 For replacement functions\iref{new.delete}, if the installed replacement function does not
@@ -3517,7 +3501,6 @@ [algorithm.stable]
 \indextext{stable algorithm}%
 When the requirements for an algorithm state that it is ``stable'' without further elaboration,
 it means:
-
 \begin{itemize}
 \item For the sort algorithms the relative order of equivalent
 elements is preserved.
diff --git a/source/support.tex b/source/support.tex
index 336a2f73..724c81c5 100644
--- a/source/support.tex
+++ b/source/support.tex
@@ -2272,7 +2272,6 @@ [new.delete.single]
 
 \pnum
 \default
-
 \begin{itemize}
 \item
 Executes a loop:
@@ -2742,7 +2741,6 @@ [new.delete.placement]
 \pnum
 \begin{example}
 This can be useful for constructing an object at a known address:
-
 \begin{codeblock}
 void* place = operator new(sizeof(Something));
 Something* p = new (place) Something();
@@ -4203,7 +4201,6 @@ [cmp.categories.pre]
 Each is specified in terms of an exposition-only data member named \tcode{value}
 whose value typically corresponds to that of an enumerator
 from one of the following exposition-only enumerations:
-
 \begin{codeblock}
 enum class @\placeholdernc{ord}@ { @\placeholdernc{equal}@ = 0, @\placeholdernc{equivalent}@ = @\placeholdernc{equal}@, @\placeholdernc{less}@ = -1, @\placeholdernc{greater}@ = 1 }; // \expos
 enum class @\placeholdernc{ncmp}@ { @\placeholdernc{unordered}@ = -127 };                                     // \expos
@@ -5111,7 +5108,6 @@ [coroutine.traits.primary]
 denotes a type\iref{temp.deduct},
 then \tcode{coroutine_traits<R, ArgTypes...>} has the following publicly
 accessible member:
-
 \begin{codeblock}
 using promise_type = typename R::promise_type;
 \end{codeblock}
diff --git a/source/concepts.tex b/source/concepts.tex
index 36b784d9..60351b43 100644
--- a/source/concepts.tex
+++ b/source/concepts.tex
@@ -150,7 +150,6 @@ [concepts.equality]
 The following type \tcode{T} meets the explicitly stated syntactic requirements
 of concept \tcode{C} above but does not meet the additional implicit
 requirements:
-
 \begin{codeblock}
 struct T {
   bool operator==(const T&) const { return true; }
@@ -365,7 +364,6 @@ [concept.convertible]
 such that \tcode{f()} is equality-preserving.
 Types \tcode{From} and \tcode{To} model \tcode{\libconcept{convertible_to}<From, To>}
 only if:
-
 \begin{itemize}
 \item
 \tcode{To} is not an object or reference-to-object type, or
@@ -373,7 +371,6 @@ [concept.convertible]
 
 \item
 \tcode{FromR} is not a reference-to-object type, or
-
 \begin{itemize}
 \item
 If \tcode{FromR} is an rvalue reference to a non const-qualified type, the
@@ -486,7 +483,6 @@ [concept.common]
 Users can customize the behavior of \libconcept{common_with} by specializing the
 \tcode{common_type} class template\iref{meta.trans.other}.
 \end{note}
-
 \end{itemdescr}
 
 \rSec2[concepts.arithmetic]{Arithmetic concepts}
@@ -540,12 +536,10 @@ [concept.assignable]
 \end{itemize}
 \tcode{LHS} and \tcode{RHS} model
 \tcode{\libconcept{assignable_from}<LHS, RHS>} only if
-
 \begin{itemize}
 \item \tcode{addressof(lhs = rhs) == addressof(lcopy)}.
 
 \item After evaluating \tcode{lhs = rhs}:
-
 \begin{itemize}
 \item \tcode{lhs} is equal to \tcode{rcopy}, unless \tcode{rhs} is a non-const
 xvalue that refers to \tcode{lcopy}.
@@ -600,7 +594,6 @@ [concept.swappable]
 \tcode{ranges::swap(E1, E2)} for subexpressions \tcode{E1}
 and \tcode{E2} is expression-equivalent to an expression
 \tcode{S} determined as follows:
-
 \begin{itemize}
 \item
   \tcode{S} is \tcode{(void)swap(E1, E2)}
@@ -808,7 +801,6 @@ [concept.moveconstructible]
 If \tcode{T} is an object type, then let \tcode{rv} be an rvalue of type
 \tcode{T} and \tcode{u2} a distinct object of type \tcode{T} equal to
 \tcode{rv}. \tcode{T} models \libconcept{move_constructible} only if
-
 \begin{itemize}
 \item After the definition \tcode{T u = rv;}, \tcode{u} is equal to \tcode{u2}.
 
@@ -835,7 +827,6 @@ [concept.copyconstructible]
 If \tcode{T} is an object type, then let \tcode{v} be an lvalue of type
 \tcode{T} or \tcode{\keyword{const} T} or an rvalue of type \tcode{\keyword{const} T}.
 \tcode{T} models \libconcept{copy_constructible} only if
-
 \begin{itemize}
 \item After the definition \tcode{T u = v;},
 \tcode{u} is equal to \tcode{v}\iref{concepts.equality} and
@@ -843,7 +834,6 @@ [concept.copyconstructible]
 
 \item \tcode{T(v)} is equal to \tcode{v} and does not modify \tcode{v}.
 \end{itemize}
-
 \end{itemdescr}
 
 \rSec1[concepts.compare]{Comparison concepts}
@@ -882,7 +872,6 @@ [concept.booleantestable]
 Let \tcode{e} be an expression such that
 \tcode{decltype((e))} is \tcode{T}.
 \tcode{T} models \exposconcept{boolean-testable-impl} only if:
-
 \begin{itemize}
 \item
 either \tcode{remove_cvref_t<T>} is not a class type, or
@@ -900,7 +889,6 @@ [concept.booleantestable]
 \pnum
 A \defnadj{disqualifying}{parameter}
 is a function parameter whose declared type \tcode{P}
-
 \begin{itemize}
 \item
 is not dependent on a template parameter, and
@@ -948,7 +936,6 @@ [concept.booleantestable]
 
 \pnum
 A \defnadj{disqualifying}{declaration} is
-
 \begin{itemize}
 \item
 a (non-template) function declaration that
@@ -1131,7 +1118,6 @@ [concept.totallyordered]
 Given a type \tcode{T}, let \tcode{a}, \tcode{b}, and \tcode{c} be
 lvalues of type \tcode{const remove_reference_t<T>}.
 \tcode{T} models \libconcept{totally_ordered} only if
-
 \begin{itemize}
 \item Exactly one of \tcode{bool(a < b)}, \tcode{bool(a > b)}, or
       \tcode{bool(a == b)} is \tcode{true}.
@@ -1140,7 +1126,6 @@ [concept.totallyordered]
 \item \tcode{bool(a <= b) == !bool(b < a)}.
 \item \tcode{bool(a >= b) == !bool(a < b)}.
 \end{itemize}
-
 \end{itemdescr}
 
 \begin{itemdecl}
@@ -1339,7 +1324,6 @@ [concept.strictweakorder]
 and
 \tcode{equiv}
 both be transitive relations:
-
 \begin{itemize}
 \item
 \tcode{comp(a, b) \&\& comp(b, c)}
diff --git a/source/utilities.tex b/source/utilities.tex
index a437974e..f5804182 100644
--- a/source/utilities.tex
+++ b/source/utilities.tex
@@ -248,7 +248,6 @@ [utility.swap]
 \pnum
 \remarks
 The exception specification is equivalent to:
-
 \begin{codeblock}
 is_nothrow_move_constructible_v<T> && is_nothrow_move_assignable_v<T>
 \end{codeblock}
@@ -2163,7 +2162,6 @@ [tuple.assign]
 \remarks
 The exception specification is equivalent to the logical \logop{and} of the
 following expressions:
-
 \begin{codeblock}
 is_nothrow_move_assignable_v<@$\mathtt{T}_i$@>
 \end{codeblock}
@@ -3114,7 +3112,6 @@ [tuple.special]
 \pnum
 \remarks
 The exception specification is equivalent to:
-
 \begin{codeblock}
 noexcept(x.swap(y))
 \end{codeblock}
@@ -14682,7 +14679,6 @@ [format.string.general]
 An escape sequence is one of \noncxxtcode{\{\{} or \noncxxtcode{\}\}}.
 It is replaced with \noncxxtcode{\{} or \noncxxtcode{\}}, respectively, in the output.
 The syntax of replacement fields is as follows:
-
 \begin{ncbnf}
 \fmtnontermdef{replacement-field}\br
     \noncxxterminal{\{} \opt{arg-id} \opt{format-specifier} \noncxxterminal{\}}
@@ -14812,7 +14808,6 @@ [format.string.std]
 are only supported for arithmetic types.
 \end{note}
 The syntax of format specifications is as follows:
-
 \begin{ncbnf}
 \fmtnontermdef{std-format-spec}\br
     \opt{fill-and-align} \opt{sign} \opt{\noncxxterminal{\#}} \opt{\noncxxterminal{0}} \opt{width} \opt{precision} \opt{\noncxxterminal{L}} \opt{type}
diff --git a/source/containers.tex b/source/containers.tex
index 44ded792..ae4734a7 100644
--- a/source/containers.tex
+++ b/source/containers.tex
@@ -641,7 +641,6 @@ [container.reqmts]
 \ref{vector.modifiers})
 all container types defined in this Clause meet
 the following additional requirements:
-
 \begin{itemize}
 \item
 If an exception is thrown by an
@@ -704,7 +703,6 @@ [container.reqmts]
 Likewise, the extent to which an implementation determines that a type cannot be
 an allocator is unspecified, except that as a minimum a type \tcode{A} shall not qualify
 as an allocator unless it meets both of the following conditions:
-
 \begin{itemize}
 \item The \grammarterm{qualified-id} \tcode{A::value_type}
 is valid and denotes a type\iref{temp.deduct}.
@@ -905,7 +903,6 @@ [container.alloc.reqmts]
 the terms below are defined as if \tcode{A} were
 \tcode{allocator<T>} --- no allocator object needs to be created
 and user specializations of \tcode{allocator<T>} are not instantiated:
-
 \begin{itemize}
 \item
 \tcode{T} is \defnx{\oldconcept{DefaultInsertable} into \tcode{X}}
@@ -3933,14 +3930,12 @@ [associative.reqmts.general]
 to
 \tcode{j}
 is positive, the following condition holds:
-
 \begin{codeblock}
 value_comp(*j, *i) == false
 \end{codeblock}
 
 \pnum
 For associative containers with unique keys the stronger condition holds:
-
 \begin{codeblock}
 value_comp(*i, *j) != false
 \end{codeblock}
@@ -5931,7 +5926,6 @@ [sequences.general]
 
 \pnum
 The following exposition-only alias template may appear in deduction guides for sequence containers:
-
 \begin{codeblock}
 template<class InputIterator>
   using @\placeholdernc{iter-value-type}@ = typename iterator_traits<InputIterator>::value_type;  // \expos
@@ -8123,7 +8117,6 @@ [list.capacity]
 appends \tcode{sz - size()} default-inserted elements to the
 sequence.
 If \tcode{sz <= size()}, equivalent to:
-
 \begin{codeblock}
 list<T>::iterator it = begin();
 advance(it, sz);
@@ -9337,13 +9330,11 @@ [vector.bool.pspc]
 \pnum
 \effects
 Exchanges the contents of \tcode{x} and \tcode{y} as if by:
-
 \begin{codeblock}
 bool b = x;
 x = y;
 y = b;
 \end{codeblock}
-
 \end{itemdescr}
 
 \begin{itemdecl}
diff --git a/source/iterators.tex b/source/iterators.tex
index 9b1c441e..a19d3d2c 100644
--- a/source/iterators.tex
+++ b/source/iterators.tex
@@ -926,7 +926,6 @@ [iterator.traits]
 \pnum
 The definitions in this subclause make use of the following
 exposition-only concepts:
-
 \begin{codeblock}
 template<class I>
 concept @\defexposconcept{cpp17-iterator}@ =
@@ -984,7 +983,6 @@ [iterator.traits]
 \pnum
 The members of a specialization \tcode{iterator_traits<I>} generated from the
 \tcode{iterator_traits} primary template are computed as follows:
-
 \begin{itemize}
 \item
 If \tcode{I} has valid\iref{temp.deduct} member
@@ -1133,7 +1131,6 @@ [iterator.cust.move]
 a customization point object\iref{customization.point.object}.
 The expression \tcode{ranges::\-iter_move(E)} for a subexpression \tcode{E} is
 expression-equivalent to:
-
 \begin{itemize}
 \item \tcode{iter_move(E)}, if
 \tcode{E} has class or enumeration type and
@@ -2776,7 +2773,6 @@ [std.iterator.tags]
 A program-defined iterator \tcode{BinaryTreeIterator}
 can be included into the bidirectional iterator category by
 specializing the \tcode{iterator_traits} template:
-
 \begin{codeblock}
 template<class T> struct iterator_traits<BinaryTreeIterator<T>> {
   using iterator_category = bidirectional_iterator_tag;
@@ -2794,7 +2790,6 @@ [std.iterator.tags]
 \tcode{evolve()}
 is well-defined for bidirectional iterators, but can be implemented more
 efficiently for random access iterators, then the implementation is as follows:
-
 \begin{codeblock}
 template<class BidirectionalIterator>
 inline void
@@ -3402,7 +3397,6 @@ [reverse.iter.elem]
 Iterator tmp = current;
 return *--tmp;
 \end{codeblock}
-
 \end{itemdescr}
 
 \indexlibrarymember{operator->}{reverse_iterator}%
@@ -4746,7 +4740,6 @@ [move.iterators.general]
 vector<string> v2(make_move_iterator(s.begin()),
                   make_move_iterator(s.end())); // moves strings into \tcode{v2}
 \end{codeblock}
-
 \end{example}
 
 \rSec3[move.iterator]{Class template \tcode{move_iterator}}
@@ -6462,7 +6455,6 @@ [stream.iterators.general]
   istream_iterator<double, char>(),
   ostream_iterator<double, char>(cout, "@\textbackslash@n"));
 \end{codeblock}
-
 reads a file containing floating-point numbers from
 \tcode{cin},
 and prints the partial sums onto
diff --git a/source/ranges.tex b/source/ranges.tex
index 851ed024..56e65110 100644
--- a/source/ranges.tex
+++ b/source/ranges.tex
@@ -624,7 +624,6 @@ [range.access.begin]
 Given a subexpression \tcode{E} with type \tcode{T},
 let \tcode{t} be an lvalue that denotes the reified object for \tcode{E}.
 Then:
-
 \begin{itemize}
 \item
   If \tcode{E} is an rvalue and
@@ -685,7 +684,6 @@ [range.access.end]
 Given a subexpression \tcode{E} with type \tcode{T},
 let \tcode{t} be an lvalue that denotes the reified object for \tcode{E}.
 Then:
-
 \begin{itemize}
 \item
   If \tcode{E} is an rvalue and
@@ -811,7 +809,6 @@ [range.access.rbegin]
 Given a subexpression \tcode{E} with type \tcode{T},
 let \tcode{t} be an lvalue that denotes the reified object for \tcode{E}.
 Then:
-
 \begin{itemize}
 \item
   If \tcode{E} is an rvalue and
@@ -875,7 +872,6 @@ [range.access.rend]
 Given a subexpression \tcode{E} with type \tcode{T},
 let \tcode{t} be an lvalue that denotes the reified object for \tcode{E}.
 Then:
-
 \begin{itemize}
 \item
   If \tcode{E} is an rvalue and
@@ -1000,7 +996,6 @@ [range.prim.size]
 Given a subexpression \tcode{E} with type \tcode{T},
 let \tcode{t} be an lvalue that denotes the reified object for \tcode{E}.
 Then:
-
 \begin{itemize}
 \item
   If \tcode{T} is an array of unknown bound\iref{term.array.type},
@@ -1086,7 +1081,6 @@ [range.prim.empty]
 Given a subexpression \tcode{E} with type \tcode{T},
 let \tcode{t} be an lvalue that denotes the reified object for \tcode{E}.
 Then:
-
 \begin{itemize}
 \item
   If \tcode{T} is an array of unknown bound\iref{term.array.type},
@@ -1137,7 +1131,6 @@ [range.prim.data]
 Given a subexpression \tcode{E} with type \tcode{T},
 let \tcode{t} be an lvalue that denotes the reified object for \tcode{E}.
 Then:
-
 \begin{itemize}
 \item
   If \tcode{E} is an rvalue and
@@ -1630,7 +1623,6 @@ [range.utility.helpers]
 \pnum
 Many of the types in subclause~\ref{range.utility} are specified in terms of
 the following exposition-only concepts:
-
 \begin{codeblock}
 template<class R>
   concept @\defexposconceptnc{simple-view}@ =                                     // \expos
diff --git a/source/algorithms.tex b/source/algorithms.tex
index 787f1c72..b6911ce2 100644
--- a/source/algorithms.tex
+++ b/source/algorithms.tex
@@ -6594,7 +6594,6 @@ [alg.sorting.general]
 If we define \tcode{equiv(a, b)} as \tcode{!comp(a, b) \&\& !comp(b, a)},
 then the requirements are that \tcode{comp} and \tcode{equiv}
 both be transitive relations:
-
 \begin{itemize}
 \item \tcode{comp(a, b) \&\& comp(b, c)} implies \tcode{comp(a, c)}
 \item \tcode{equiv(a, b) \&\& equiv(b, c)} implies \tcode{equiv(a, c)}
@@ -7505,7 +7504,6 @@ [alg.partitions]
   For the overload with an \tcode{ExecutionPolicy},
   \bigoh{N \log N} swaps and \bigoh{N} applications of the predicate.
 \end{itemize}
-
 \end{itemdescr}
 
 \indexlibraryglobal{stable_partition}%
@@ -8346,7 +8344,6 @@ [alg.heap.operations.general]
 {heap with respect to comp and proj@heap with respect to \tcode{comp} and \tcode{proj}}
 for a comparator and projection \tcode{comp} and \tcode{proj}
 if its elements are organized such that:
-
 \begin{itemize}
 \item
   With \tcode{$N$ = b - a}, for all $i$, $0 < i < N$,
@@ -10783,7 +10780,6 @@ [special.mem.concepts]
 \pnum
 Some algorithms in this subclause are constrained with the following
 exposition-only concepts:
-
 \begin{itemdecl}
 template<class I>
 concept @\defexposconcept{nothrow-input-iterator}@ = // \expos
diff --git a/source/numerics.tex b/source/numerics.tex
index 3be8ccfe..87b0b778 100644
--- a/source/numerics.tex
+++ b/source/numerics.tex
@@ -583,7 +583,6 @@ [complex.ops]
 \pnum
 \returns
 \tcode{complex<T>(lhs)}.
-
 \end{itemdescr}
 
 \begin{itemdecl}
@@ -722,7 +721,6 @@ [complex.ops]
 \effects
 Inserts the complex number \tcode{x}
 onto the stream \tcode{o} as if it were implemented as follows:
-
 \begin{codeblock}
 basic_ostringstream<charT, traits> s;
 s.flags(o.flags());
@@ -3833,7 +3831,6 @@ [rand.util.seedseq]
  each operation is to be carried out modulo $2^{32}$,
  each indexing operator applied to \tcode{begin} is to be taken modulo $n$,
  and $T(x)$ is defined as $x \xor (x \rightshift 27)$:
-
 \begin{itemize}
  \item
    By way of initialization,
@@ -7862,7 +7859,6 @@ [valarray.transcend]
 to an operand of type \tcode{T}.
 This function returns a value of type \tcode{T}
 or which can be unambiguously implicitly converted to type \tcode{T}.
-
 \end{itemdescr}
 
 \rSec3[valarray.special]{Specialized algorithms}
@@ -7878,7 +7874,6 @@ [valarray.special]
 Equivalent to \tcode{x.swap(y)}.
 \end{itemdescr}
 
-
 \rSec2[class.slice]{Class \tcode{slice}}
 
 \rSec3[class.slice.overview]{Overview}
@@ -8298,7 +8293,6 @@ [template.gslice.array.overview]
 This template is a helper template used by the
 \tcode{gslice}
 subscript operator
-
 \indexlibraryglobal{gslice_array}%
 \indexlibraryglobal{valarray}%
 \begin{itemdecl}
@@ -8424,7 +8418,6 @@ [template.mask.array.overview]
 
 \pnum
 This template is a helper template used by the mask subscript operator:
-
 \indexlibrarymember{operator[]}{mask_array}%
 \begin{itemdecl}
 mask_array<T> valarray<T>::operator[](const valarray<bool>&);
@@ -8541,7 +8534,6 @@ [template.indirect.array.overview]
 
 \pnum
 This template is a helper template used by the indirect subscript operator
-
 \indexlibrarymember{operator[]}{indirect_array}%
 \begin{itemdecl}
 indirect_array<T> valarray<T>::operator[](const valarray<size_t>&);
@@ -10013,7 +10005,6 @@ [sf.cmath.expint]
 \]
 where
 $x$ is \tcode{x}.
-
 \end{itemdescr}
 
 \rSec3[sf.cmath.hermite]{Hermite polynomials}%
diff --git a/source/time.tex b/source/time.tex
index 1eba6175..a96cdbae 100644
--- a/source/time.tex
+++ b/source/time.tex
@@ -2048,7 +2048,6 @@ [time.duration.io]
 \end{codeblock}
 where \tcode{\placeholder{units-suffix}}
 depends on the type \tcode{Period::type} as follows:
-
 \begin{itemize}
 \item
 If \tcode{Period::type} is \tcode{atto},
@@ -2926,7 +2925,6 @@ [time.clock.utc.nonmembers]
 \end{codeblock}
 
 Produces this output:
-
 \begin{outputblock}
 2015-06-30 23:59:59.500 UTC
 2015-06-30 23:59:59.750 UTC
@@ -3132,7 +3130,6 @@ [time.clock.tai.nonmembers]
 \end{codeblock}
 
 Produces this output:
-
 \begin{outputblock}
 2000-01-01 00:00:00 UTC == 2000-01-01 00:00:32 TAI
 \end{outputblock}
@@ -3295,7 +3292,6 @@ [time.clock.gps.nonmembers]
 \end{codeblock}
 
 Produces this output:
-
 \begin{outputblock}
 2000-01-01 00:00:00 UTC == 2000-01-01 00:00:13 GPS
 \end{outputblock}
@@ -3364,7 +3360,6 @@ [time.clock.file.members]
 \pnum
 The type denoted by \tcode{file_clock} provides
 precisely one of the following two sets of static member functions:
-
 \begin{codeblock}
 template<class Duration>
   static sys_time<@\seebelow@>
@@ -3373,9 +3368,7 @@ [time.clock.file.members]
   static file_time<@\seebelow@>
     from_sys(const sys_time<Duration>&);
 \end{codeblock}
-
 or:
-
 \begin{codeblock}
 template<class Duration>
   static utc_time<@\seebelow@>
@@ -3844,7 +3837,6 @@ [time.clock.cast.fn]
 \constraints
 At least one of the following clock time conversion expressions
 is well-formed:
-
 \begin{itemize}
 \item
 \begin{codeblock}
@@ -7890,7 +7882,6 @@ [time.cal.operators]
 \pnum
 \begin{note}
 The year, month, and day are accepted in any of the following 3 orders:
-
 \begin{codeblock}
 @\tcode{\placeholder{year}}@/@\tcode{\placeholder{month}}@/@\tcode{\placeholder{day}}@
 @\tcode{\placeholder{month}}@/@\tcode{\placeholder{day}}@/@\tcode{\placeholder{year}}@
@@ -7898,7 +7889,6 @@ [time.cal.operators]
 \end{codeblock}
 
 Anywhere a \tcode{\placeholder{day}} is required, any of the following can also be specified:
-
 \begin{codeblock}
 last
 @\tcode{\placeholder{weekday}}@[@\tcode{\placeholder{i}}@]
@@ -7911,7 +7901,6 @@ [time.cal.operators]
 Partial-date types such as \tcode{year_month} and \tcode{month_day}
 can be created by not applying the second division operator
 for any of the three orders. For example:
-
 \begin{codeblock}
 year_month ym = 2015y/April;
 month_day md1 = April/4;
@@ -9100,7 +9089,6 @@ [time.zone.exception.nonexist]
 Initializes the base class with a sequence of \tcode{char}
 equivalent to that produced by \tcode{os.str()}
 initialized as shown below:
-
 \begin{codeblock}
 ostringstream os;
 os << tp << " is in a gap between\n"
@@ -9130,7 +9118,6 @@ [time.zone.exception.nonexist]
 \end{codeblock}
 
 Produces the output:
-
 \begin{outputblock}
 2016-03-13 02:30:00 is in a gap between
 2016-03-13 02:00:00 EST and
@@ -9175,7 +9162,6 @@ [time.zone.exception.ambig]
 Initializes the base class with a sequence of \tcode{char}
 equivalent to that produced by \tcode{os.str()}
 initialized as shown below:
-
 \begin{codeblock}
 ostringstream os;
 os << tp << " is ambiguous.  It could be\n"
@@ -9203,7 +9189,6 @@ [time.zone.exception.ambig]
 \end{codeblock}
 
 Produces the output:
-
 \begin{outputblock}
 2016-11-06 01:30:00 is ambiguous.  It could be
 2016-11-06 01:30:00 EDT == 2016-11-06 05:30:00 UTC or
@@ -9257,7 +9242,6 @@ [time.zone.info.sys]
 the UTC offset in effect
 for the associated \tcode{time_zone} and \tcode{time_point}.
 The relationship between \tcode{local_time} and \tcode{sys_time} is:
-
 \begin{codeblock}
 offset = local_time - sys_time
 \end{codeblock}
@@ -9562,7 +9546,6 @@ [time.zone.zonedtraits]
 for the \tcode{zoned_time} default constructor,
 and constructors taking \tcode{string_view}.
 A specialization for \tcode{const time_zone*} is provided by the implementation:
-
 \begin{codeblock}
 namespace std::chrono {
   template<> struct zoned_traits<const time_zone*> {
@@ -10138,7 +10121,6 @@ [time.zone.leap.overview]
 \end{codeblock}
 
 Produces the output:
-
 \begin{outputblock}
 1972-07-01 00:00:00: 1s
 1973-01-01 00:00:00: 1s
@@ -10437,7 +10419,6 @@ [time.format]
 interpret the format specification
 as a \fmtgrammarterm{chrono-format-spec}
 according to the following syntax:
-
 \begin{ncbnf}
 \fmtnontermdef{chrono-format-spec}\br
     \opt{fill-and-align} \opt{width} \opt{precision} \opt{\terminal{L}} \opt{chrono-specs}
diff --git a/source/locales.tex b/source/locales.tex
index 70813d84..388d0a10 100644
--- a/source/locales.tex
+++ b/source/locales.tex
@@ -181,7 +181,6 @@ [locale.general]
 the stream is implicitly converted
 to an \tcode{ostreambuf_iterator<charT, traits>}.
 \end{footnote}
-
 \begin{codeblock}
 template<class charT, class traits>
 basic_ostream<charT, traits>&
@@ -216,7 +215,6 @@ [locale.general]
 All locale semantics are accessed via
 \tcode{use_facet<>} and \tcode{has_facet<>},
 except that:
-
 \begin{itemize}
 \item
 A member operator template
@@ -738,7 +736,6 @@ [locale.operators]
 A vector of strings \tcode{v}
 can be collated according to collation rules in locale \tcode{loc}
 simply by\iref{alg.sort,vector}:
-
 \begin{codeblock}
 std::sort(v.begin(), v.end(), loc);
 \end{codeblock}
@@ -2202,7 +2199,6 @@ [facet.num.get.virtuals]
 
 \pnum
 The details of this operation occur in three stages
-
 \begin{itemize}
 \item
 Stage 1:
@@ -2325,7 +2321,6 @@ [facet.num.get.virtuals]
 The sequence of \tcode{char}{s} accumulated in stage 2 (the field)
 is converted to a numeric value by the rules of one of the functions
 declared in the header \libheader{cstdlib}:
-
 \begin{itemize}
 \item
 For a signed integer value, the function \tcode{strtoll}.
@@ -2359,7 +2354,6 @@ [facet.num.get.virtuals]
 If the conversion function does not convert the entire field, or
 if the field represents a value outside the range of representable values,
 \tcode{ios_base::failbit} is assigned to \tcode{err}.
-
 \end{description}
 
 \pnum
@@ -2527,7 +2521,6 @@ [facet.num.put.virtuals]
 
 \pnum
 The details of this operation occur in several stages:
-
 \begin{itemize}
 \item
 Stage 1:
@@ -3342,7 +3335,6 @@ [locale.time.get.members]
 reading zero or more characters from \tcode{s} at each iteration.
 Unless otherwise specified below,
 the loop terminates when the first of the following conditions holds:
-
 \begin{itemize}
 \item
 The expression \tcode{fmt == fmtend} evaluates to \tcode{true}.
@@ -4154,7 +4146,6 @@ [locale.moneypunct.general]
 The symbol \locgrammarterm{decimal-point}
 indicates the character returned by \tcode{decimal_point()}.
 The other symbols are defined as follows:
-
 \begin{ncbnf}
 \locnontermdef{units}\br
     digits\br
diff --git a/source/iostreams.tex b/source/iostreams.tex
index 74dbe53d..ab5c5518 100644
--- a/source/iostreams.tex
+++ b/source/iostreams.tex
@@ -2109,14 +2109,12 @@ [basic.ios.members]
 Otherwise assigns to the member objects of
 \tcode{*this}
 the corresponding member objects of \tcode{rhs} as follows:
-
 \begin{itemize}
 \item calls each registered callback pair \tcode{(fn, idx)} as
 \tcode{(*fn)(erase_event, *this, idx)};
 
 \item then, assigns to the member objects of \tcode{*this} the corresponding member objects of
 \tcode{rhs}, except that
-
 \begin{itemize}
 \item \tcode{rdstate()}, \tcode{rdbuf()}, and \tcode{exceptions()} are left unchanged;
 
@@ -7176,7 +7174,6 @@ [std.manip]
 format flags stored in the \tcode{basic_ostream<charT, traits>} object
 \tcode{cout} (the same as \tcode{cout << noshowbase}).
 \end{footnote}
-
 \begin{codeblock}
 void f(ios_base& str, ios_base::fmtflags mask) {
   // reset specified flags
@@ -7215,7 +7212,6 @@ [std.manip]
 behaves as if it called
 \tcode{f(in, mask)}, where the function \tcode{f} is defined as:
 \indexlibrarymember{fmtflags}{ios_base}%
-
 \begin{codeblock}
 void f(ios_base& str, ios_base::fmtflags mask) {
   // set specified flags
@@ -7261,7 +7257,6 @@ [std.manip]
 \tcode{in >> setbase(base)}
 behaves as if it called
 \tcode{f(in, base)}, where the function \tcode{f} is defined as:
-
 \begin{codeblock}
 void f(ios_base& str, int base) {
   // set \tcode{basefield}
@@ -7304,7 +7299,6 @@ [std.manip]
 \tcode{out << setfill(c)}
 behaves as if it called
 \tcode{f(out, c)}, where the function \tcode{f} is defined as:
-
 \begin{codeblock}
 template<class charT, class traits>
 void f(basic_ios<charT, traits>& str, charT c) {
@@ -7345,7 +7339,6 @@ [std.manip]
 \tcode{in >> setprecision(n)}
 behaves as if it called
 \tcode{f(in, n)}, where the function \tcode{f} is defined as:
-
 \begin{codeblock}
 void f(ios_base& str, int n) {
   // set precision
@@ -7391,7 +7384,6 @@ [std.manip]
 \tcode{in >> setw(n)}
 behaves as if it called
 \tcode{f(in, n)}, where the function \tcode{f} is defined as:
-
 \begin{codeblock}
 void f(ios_base& str, int n) {
   // set width
@@ -7441,7 +7433,6 @@ [ext.manip]
 \tcode{in} is an object of type \tcode{basic_istream<charT, traits>}
 then the expression \tcode{in >> get_money(mon, intl)} behaves as if it called
 \tcode{f(in, mon, intl)}, where the function \tcode{f} is defined as:
-
 \begin{codeblock}
 template<class charT, class traits, class moneyT>
 void f(basic_ios<charT, traits>& str, moneyT& mon, bool intl) {
@@ -7480,7 +7471,6 @@ [ext.manip]
 then the expression \tcode{out << put_money(mon, intl)} behaves as a
 \link{formatted output function}{ostream.formatted.reqmts} that calls
 \tcode{f(out, mon, intl)}, where the function \tcode{f} is defined as:
-
 \begin{codeblock}
 template<class charT, class traits, class moneyT>
 void f(basic_ios<charT, traits>& str, const moneyT& mon, bool intl) {
@@ -7516,7 +7506,6 @@ [ext.manip]
 \tcode{basic_istream<charT, traits>} then the expression \tcode{in >> get_time(tmb,
 fmt)} behaves as if it called \tcode{f(in, tmb, fmt)}, where the function \tcode{f} is
 defined as:
-
 \begin{codeblock}
 template<class charT, class traits>
 void f(basic_ios<charT, traits>& str, tm* tmb, const charT* fmt) {
@@ -7555,7 +7544,6 @@ [ext.manip]
 type \tcode{basic_ostream<charT, traits>} then the expression
 \tcode{out << put_time(tmb, fmt)} behaves as if it called \tcode{f(out, tmb, fmt)},
 where the function \tcode{f} is defined as:
-
 \begin{codeblock}
 template<class charT, class traits>
 void f(basic_ios<charT, traits>& str, const tm* tmb, const charT* fmt) {
@@ -11038,7 +11026,6 @@ [filebuf.virtuals]
 sequence as if by reading from the associated file
 into an internal buffer (\tcode{extern_buf})
 and then as if by doing:
-
 \begin{codeblock}
 char   extern_buf[XSIZE];
 char*  extern_end;
@@ -13477,7 +13464,6 @@ [fs.path.generic]
 \pnum
 \indextext{path!normalization|(}%
 \defnx{Normalization}{normalization!path} of a generic format pathname means:
-
 \begin{enumerate}
 \item If the path is empty, stop.
 \item Replace each slash character in the \grammarterm{root-name} with a \grammarterm{preferred-separator}.
@@ -16503,7 +16489,6 @@ [fs.rec.dir.itr.members]
 As specified for the prefix increment operation of
 \link{Input iterators}{input.iterators},
 except that:
-
 \begin{itemize}
 \item If there are no more  entries at the current depth, then if \tcode{depth() != 0}
 iteration over the parent directory resumes; otherwise \tcode{*this = recursive_directory_iterator()}.
diff --git a/source/regex.tex b/source/regex.tex
index cc606175..cebad5b4 100644
--- a/source/regex.tex
+++ b/source/regex.tex
@@ -3861,7 +3861,6 @@ [re.grammar]
 \tcode{graph}, \tcode{lower}, \tcode{print}, \tcode{punct}, \tcode{space},
 \tcode{upper}, \tcode{xdigit}, \tcode{d}, \tcode{s}, \tcode{w}.
 In addition the following expressions shall be equivalent:
-
 \begin{outputblock}
 \d @\textnormal{and}@ [[:digit:]]
 
@@ -3950,7 +3949,6 @@ [re.grammar]
 is \tcode{false} then the character \tcode{c} is matched if \tcode{c1
 <= c \&\& c <= c2}, otherwise \tcode{c} is matched in
 accordance with the following algorithm:
-
 \begin{codeblock}
 string_type str1 = string_type(1,
   flags() & icase ?
diff --git a/source/threads.tex b/source/threads.tex
index 0781b360..24ff8828 100644
--- a/source/threads.tex
+++ b/source/threads.tex
@@ -6094,7 +6094,6 @@ [thread.mutex.requirements.mutex.general]
 
 \pnum
 The expression \tcode{m.lock()} is well-formed and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -6137,7 +6136,6 @@ [thread.mutex.requirements.mutex.general]
 
 \pnum
 The expression \tcode{m.try_lock()} is well-formed and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -6183,7 +6181,6 @@ [thread.mutex.requirements.mutex.general]
 
 \pnum
 The expression \tcode{m.unlock()} is well-formed and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -6338,7 +6335,6 @@ [thread.timedmutex.requirements.general]
 \pnum
 The expression \tcode{m.try_lock_for(rel_time)} is well-formed
 and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -6380,7 +6376,6 @@ [thread.timedmutex.requirements.general]
 \pnum
 The expression \tcode{m.try_lock_until(abs_time)} is well-formed
 and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -6567,7 +6562,6 @@ [thread.sharedmutex.requirements.general]
 \pnum
 The expression \tcode{m.lock_shared()} is well-formed and has the
 following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -6604,7 +6598,6 @@ [thread.sharedmutex.requirements.general]
 
 \pnum
 The expression \tcode{m.unlock_shared()} is well-formed and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -6629,7 +6622,6 @@ [thread.sharedmutex.requirements.general]
 
 \pnum
 The expression \tcode{m.try_lock_shared()} is well-formed and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -6732,7 +6724,6 @@ [thread.sharedtimedmutex.requirements.general]
 \pnum
 The expression \tcode{m.try_lock_shared_for(rel_time)} is well-formed and
 has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -6777,7 +6768,6 @@ [thread.sharedtimedmutex.requirements.general]
 \pnum
 The expression \tcode{m.try_lock_shared_until(abs_time)} is well-formed
 and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -8927,7 +8917,6 @@ [thread.condvarany.wait]
 \begin{itemdescr}
 \pnum
 \effects
-
 \begin{itemize}
 \item
 \indextext{block (execution)}%
@@ -10339,7 +10328,6 @@ [futures.promise]
 
 \pnum
 \errors
-
 \begin{itemize}
 \item \tcode{future_already_retrieved} if \tcode{get_future} has already been called on
 a \tcode{promise} with the same shared state as \tcode{*this}.
@@ -10402,7 +10390,6 @@ [futures.promise]
 
 \pnum
 \errors
-
 \begin{itemize}
 \item \tcode{promise_already_satisfied} if its shared state
 already has a stored value or exception.
@@ -10742,7 +10729,6 @@ [futures.unique.future]
 
 \pnum
 \returns
-
 \begin{itemize}
 \item \tcode{future_status::deferred} if the shared state contains a deferred
 function.
@@ -11086,7 +11072,6 @@ [futures.shared.future]
 
 \pnum
 \returns
-
 \begin{itemize}
 \item \tcode{future_status::deferred} if the shared state contains a deferred
 function.
@@ -11121,7 +11106,6 @@ [futures.shared.future]
 
 \pnum
 \returns
-
 \begin{itemize}
 \item \tcode{future_status::deferred} if the shared state contains a deferred
 function.
@@ -11177,7 +11161,6 @@ [futures.async]
 of the second function depends on the \tcode{policy} argument as follows (if
 more than one of these conditions applies, the implementation may choose any of
 the corresponding policies):
-
 \begin{itemize}
 \item
 If \tcode{launch::async} is set in \tcode{policy}, calls
diff --git a/source/limits.tex b/source/limits.tex
index 30fbd815..324c9e44 100644
--- a/source/limits.tex
+++ b/source/limits.tex
@@ -132,5 +132,4 @@
 Handlers per try block\iref{except.handle} [256].
 \item%
 Number of \link{placeholders}{func.bind.place} [10].
-
 \end{itemize}
diff --git a/source/compatibility.tex b/source/compatibility.tex
index 10312e97..2c9cd717 100644
--- a/source/compatibility.tex
+++ b/source/compatibility.tex
@@ -2040,7 +2040,6 @@ [diff.cpp03.containers]
 \effect
 The signatures of the following member functions changed from taking an
 \tcode{iterator} to taking a \tcode{const_iterator}:
-
 \begin{itemize}
 \item \tcode{insert(iter, val)} for \tcode{vector}, \tcode{deque}, \tcode{list},
 \tcode{set}, \tcode{multiset}, \tcode{map}, \tcode{multimap}
@@ -2112,7 +2111,6 @@ [diff.cpp03.input.output]
 Valid \CppIII{} code that relies on implicit boolean conversions will fail to
 compile with this revision of \Cpp{}. Such conversions occur in the
 following conditions:
-
 \begin{itemize}
 \item passing a value to a function that takes an argument of type \tcode{bool};
 \item using \tcode{operator==} to compare to \tcode{false} or \tcode{true};
@@ -3133,7 +3131,6 @@ [diff.mods.to.declarations]
 \pnum
 Header \libheaderref{cstring}:
 The following functions have different declarations:
-
 \begin{itemize}
 \item \tcode{strchr}
 \item \tcode{strpbrk}
@@ -3147,7 +3144,6 @@ [diff.mods.to.declarations]
 \pnum
 Header \libheaderref{cwchar}:
 The following functions have different declarations:
-
 \begin{itemize}
 \item \tcode{wcschr}
 \item \tcode{wcspbrk}
@@ -3172,7 +3168,6 @@ [diff.mods.to.behavior.general]
 \pnum
 Header \libheaderref{cstdlib}:
 The following functions have different behavior:
-
 \begin{itemize}
 \item \tcode{atexit}
 \item \tcode{exit}
diff --git a/source/future.tex b/source/future.tex
index bfc60427..afaafd02 100644
--- a/source/future.tex
+++ b/source/future.tex
@@ -284,7 +284,6 @@ [depr.relops]
 
 \pnum
 The header \libheaderref{utility} has the following additions:
-
 \begin{codeblock}
 namespace std::rel_ops {
   template<class T> bool operator!=(const T&, const T&);
@@ -298,7 +297,6 @@ [depr.relops]
 To avoid redundant definitions of \tcode{operator!=} out of \tcode{operator==}
 and operators \tcode{>}, \tcode{<=}, and \tcode{>=} out of \tcode{operator<},
 the library provides the following:
-
 \indexlibrary{\idxcode{operator"!=}}%
 \begin{itemdecl}
 template<class T> bool operator!=(const T& x, const T& y);
@@ -591,14 +589,12 @@ [depr.strstreambuf.cons]
 
 \pnum
 If \tcode{pbeg_arg} is a null pointer, the function executes:
-
 \begin{codeblock}
 setg(gnext_arg, gnext_arg, gnext_arg + N);
 \end{codeblock}
 
 \pnum
 Otherwise, the function executes:
-
 \begin{codeblock}
 setg(gnext_arg, gnext_arg, pbeg_arg);
 setp(pbeg_arg,  pbeg_arg + N);
@@ -1033,7 +1029,6 @@ [depr.istrstream.general]
 \tcode{strstreambuf}
 object to control the associated array object.
 For the sake of exposition, the maintained data is presented here as:
-
 \begin{itemize}
 \item
 \tcode{sb}, the \tcode{strstreambuf} object.
@@ -1127,7 +1122,6 @@ [depr.ostrstream.general]
 \tcode{strstreambuf}
 object to control the associated array object.
 For the sake of exposition, the maintained data is presented here as:
-
 \begin{itemize}
 \item
 \tcode{sb}, the \tcode{strstreambuf} object.
@@ -1157,7 +1151,6 @@ [depr.ostrstream.cons]
 \effects
 Initializes the base class with \tcode{ostream(\&sb)},
 and \tcode{sb} with one of two constructors:
-
 \begin{itemize}
 \item
 If
@@ -1273,7 +1266,6 @@ [depr.strstream.general]
 \tcode{strstreambuf}
 object to control the associated array object.
 For the sake of exposition, the maintained data is presented here as:
-
 \begin{itemize}
 \item
 \tcode{sb}, the \tcode{strstreambuf} object.
@@ -1469,7 +1461,6 @@ [depr.meta.types]
 \pnum
 The header \libheaderrefx{type_traits}{meta.type.synop}
 has the following addition:
-
 \begin{codeblock}
 namespace std {
   template<class T> struct is_pod;
@@ -1589,7 +1580,6 @@ [depr.tuple]
 
 \pnum
 The header \libheaderref{tuple} has the following additions:
-
 \begin{codeblock}
 namespace std {
   template<class T> struct tuple_size<volatile T>;
@@ -1659,7 +1649,6 @@ [depr.variant]
 
 \pnum
 The header \libheaderref{variant} has the following additions:
-
 \begin{codeblock}
 namespace std {
   template<class T> struct variant_size<volatile T>;
@@ -1706,7 +1695,6 @@ [depr.iterator]
 
 \pnum
 The header \libheaderrefx{iterator}{iterator.synopsis} has the following addition:
-
 \indexlibraryglobal{iterator}%
 \begin{codeblock}
 namespace std {
@@ -1740,7 +1728,6 @@ [depr.iterator]
 If a \Cpp{} program wants to define a bidirectional iterator for some data
 structure containing \tcode{double} and such that it works on a large memory
 model of the implementation, it can do so with:
-
 \begin{codeblock}
 class MyIterator :
   public iterator<bidirectional_iterator_tag, double, long, T*, T&> {
@@ -1754,7 +1741,6 @@ [depr.move.iter.elem]
 \pnum
 The following member is declared in addition to those members
 specified in \ref{move.iter.elem}:
-
 \begin{codeblock}
 namespace std {
   template<class Iterator>
@@ -1780,7 +1766,6 @@ [depr.util.smartptr.shared.atomic]
 
 \pnum
 The header \libheaderref{memory} has the following additions:
-
 \indexlibraryglobal{shared_ptr}%
 \begin{codeblock}
 namespace std {
@@ -2044,7 +2029,6 @@ [depr.string.capacity]
 \pnum
 The following member is declared in addition to those members specified
 in \ref{string.capacity}:
-
 \indexlibraryglobal{basic_string}%
 \begin{codeblock}
 namespace std {
@@ -2199,7 +2183,6 @@ [depr.conversions.general]
 
 \pnum
 The header \libheaderref{locale} has the following additions:
-
 \begin{codeblock}
 namespace std {
   template<class Codecvt, class Elem = wchar_t,
@@ -2297,7 +2280,6 @@ [depr.conversions.string]
 
 \pnum
 An object of this class template stores:
-
 \begin{itemize}
 \item \tcode{byte_err_string} --- a byte string to display on errors
 \item \tcode{wide_err_string} --- a wide string to display on errors
@@ -2338,7 +2320,6 @@ [depr.conversions.string]
 
 \pnum
 In all cases:
-
 \begin{itemize}
 \item If the \tcode{cvtstate} object was not constructed with an explicit value, it
 shall be set to its default value (the initial conversion state) before the
@@ -2385,7 +2366,6 @@ [depr.conversions.string]
 
 \pnum
 In all cases:
-
 \begin{itemize}
 \item If the \tcode{cvtstate} object was not constructed with an explicit value, it
 shall be
@@ -2495,7 +2475,6 @@ [depr.conversions.buffer]
 
 \pnum
 An object of this class template stores:
-
 \begin{itemize}
 \item \tcode{bufptr} --- a pointer to its underlying byte stream buffer
 \item \tcode{cvtptr} --- a pointer to the allocated conversion object
@@ -2682,7 +2661,6 @@ [depr.atomics.general]
 
 \pnum
 The header \libheaderrefx{atomic}{atomics.syn} has the following additions.
-
 \begin{codeblock}
 namespace std {
   template<class T>
-- 
2.25.1


From 5e25ce3e96bdbbbd05e2d32eacb8e8c054385996 Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Fri, 31 Jul 2020 05:10:44 +0200
Subject: [PATCH 15/21] Move index entry into the relevant paragraph.

---
 source/templates.tex | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/templates.tex b/source/templates.tex
index c3a5eb33..cc913c0d 100644
--- a/source/templates.tex
+++ b/source/templates.tex
@@ -1915,9 +1915,9 @@ [temp.constr.normal]
 \end{example}
 
 \rSec2[temp.constr.order]{Partial ordering by constraints}
-\indextext{subsume|see{constraint, subsumption}}
 
 \pnum
+\indextext{subsume|see{constraint, subsumption}}
 A constraint $P$ \defnx{subsumes}{constraint!subsumption} a constraint $Q$
 if and only if,
 for every disjunctive clause $P_i$
-- 
2.25.1


From d72b4eac88277a9407e97fb08b1171f3f54cbcf4 Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Sun, 30 Aug 2020 11:02:16 +0200
Subject: [PATCH 16/21] Remove duplicate index entry.

---
 source/utilities.tex | 1 -
 1 file changed, 1 deletion(-)

diff --git a/source/utilities.tex b/source/utilities.tex
index f5804182..741550e8 100644
--- a/source/utilities.tex
+++ b/source/utilities.tex
@@ -14495,7 +14495,6 @@ [format.syn]
 \indexlibraryglobal{wformat_context}%
 \indexlibraryglobal{format_args}%
 \indexlibraryglobal{wformat_args}%
-\indexlibraryglobal{format_args_t}%
 \indexlibraryglobal{format_to_n_result}%
 \indexlibrarymember{out}{format_to_n_result}%
 \indexlibrarymember{size}{format_to_n_result}%
-- 
2.25.1


From 1479d649335cd290c253a4fc7ba72afc41e5aa51 Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Wed, 9 Sep 2020 05:39:12 +0200
Subject: [PATCH 17/21] [class.pre] Index definition of 'unnamed class'.

---
 source/classes.tex | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/classes.tex b/source/classes.tex
index 0c71d1c2..33539d56 100644
--- a/source/classes.tex
+++ b/source/classes.tex
@@ -63,7 +63,7 @@ [class.pre]
 a partial specialization\iref{temp.spec.partial}.
 A \grammarterm{class-specifier} whose
 \grammarterm{class-head} omits the
-\grammarterm{class-head-name} defines an unnamed class.
+\grammarterm{class-head-name} defines an \defnadj{unnamed}{class}.
 \begin{note}
 An unnamed class thus can't
 be \tcode{final}.
-- 
2.25.1


From 8fb0aa4f35dcf6df8129b86d91cc8d89af965af8 Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Thu, 17 Sep 2020 10:17:47 +0200
Subject: [PATCH 18/21] Use monospace font for code in figures.

---
 source/assets/figdag.dot         |  8 ++++----
 source/assets/figname.dot        | 14 +++++++-------
 source/assets/fignonvirt.dot     | 12 ++++++------
 source/assets/figvirt.dot        | 10 +++++-----
 source/assets/figvirtnonvirt.dot | 14 +++++++-------
 5 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/source/assets/figdag.dot b/source/figdag.dot
index b29593a9..797d8f2b 100644
--- a/source/assets/figdag.dot
+++ b/source/assets/figdag.dot
@@ -1,10 +1,10 @@
 digraph dag {
     graph [nodesep=1.5, rankdir=BT];
 
-    Base [shape=plaintext, height=.1, fontsize=24];
-    Derived1 [shape=plaintext, height=.1, fontsize=24];
-    Derived2 [shape=plaintext, height=.1, fontsize=24];
+    Base [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    Derived1 [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    Derived2 [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
 
     Derived2 -> Derived1;
     Derived1 -> Base;
-}
\ No newline at end of file
+}
diff --git a/source/assets/figname.dot b/source/figname.dot
index 8cb94e93..9878984d 100644
--- a/source/assets/figname.dot
+++ b/source/assets/figname.dot
@@ -1,12 +1,12 @@
 digraph virt {
     graph [nodesep=1.5, rankdir=BT];
 
-    W1 [label = "W", shape=plaintext, height=.1, fontsize=24];
-    V [shape=plaintext, height=.1, fontsize=24];
-    W2 [label = "W", shape=plaintext, height=.1, fontsize=24];
-    B [shape=plaintext, height=.1, fontsize=24];
-    C [shape=plaintext, height=.1, fontsize=24];
-    D [shape=plaintext, height=.1, fontsize=24];
+    W1 [label = "W", shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    V [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    W2 [label = "W", shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    B [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    C [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    D [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
 
     D -> B;
     D -> C;
@@ -14,4 +14,4 @@ digraph virt {
     C -> V;
     B -> W1;
     C -> W2;
-}
\ No newline at end of file
+}
diff --git a/source/assets/fignonvirt.dot b/source/fignonvirt.dot
index fac23dcf..ee3a3d9b 100644
--- a/source/assets/fignonvirt.dot
+++ b/source/assets/fignonvirt.dot
@@ -1,14 +1,14 @@
 digraph nonvirt {
     graph [nodesep=1.5, rankdir=BT];
 
-    L1 [label = "L", shape=plaintext, height=.1, fontsize=24];
-    L2 [label = "L", shape=plaintext, height=.1, fontsize=24];
-    A [shape=plaintext, height=.1, fontsize=24];
-    B [shape=plaintext, height=.1, fontsize=24];
-    C [shape=plaintext, height=.1, fontsize=24];
+    L1 [label = "L", shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    L2 [label = "L", shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    A [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    B [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    C [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
 
     C -> B;
     C -> A;
     B -> L2;
     A -> L1;
-}
\ No newline at end of file
+}
diff --git a/source/assets/figvirt.dot b/source/figvirt.dot
index 4c9fa775..e1caa157 100644
--- a/source/assets/figvirt.dot
+++ b/source/assets/figvirt.dot
@@ -1,13 +1,13 @@
 digraph virt {
     graph [nodesep=1.5, rankdir=BT];
 
-    V [shape=plaintext, height=.1, fontsize=24];
-    A [shape=plaintext, height=.1, fontsize=24];
-    B [shape=plaintext, height=.1, fontsize=24];
-    C [shape=plaintext, height=.1, fontsize=24];
+    V [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    A [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    B [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    C [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
 
     C -> B;
     C -> A;
     B -> V;
     A -> V;
-}
\ No newline at end of file
+}
diff --git a/source/assets/figvirtnonvirt.dot b/source/figvirtnonvirt.dot
index b3c04d48..1ab8e364 100644
--- a/source/assets/figvirtnonvirt.dot
+++ b/source/assets/figvirtnonvirt.dot
@@ -1,12 +1,12 @@
 digraph virtnonvirt {
     graph [nodesep=1.5, rankdir=BT];
 
-    B1 [label = "B", shape=plaintext, height=.1, fontsize=24];
-    B2 [label = "B", shape=plaintext, height=.1, fontsize=24];
-    AA [shape=plaintext, height=.1, fontsize=24];
-    X [shape=plaintext, height=.1, fontsize=24];
-    Y [shape=plaintext, height=.1, fontsize=24];
-    Z [shape=plaintext, height=.1, fontsize=24];
+    B1 [label = "B", shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    B2 [label = "B", shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    AA [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    X [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    Y [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
+    Z [shape=plaintext, height=.1, fontsize=11, fontname="Courier New"];
 
     subgraph {
     AA -> X;
@@ -17,4 +17,4 @@ digraph virtnonvirt {
 
     AA -> Z [weight=0];
     Z  -> B2;
-}
\ No newline at end of file
+}
-- 
2.25.1


From 3f688f9fc23f0bd3fa98fce7d1bab7245b36980d Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Wed, 23 Jun 2021 20:54:27 +0200
Subject: [PATCH 19/21] [uaxid] Mark code that's not to be highlighted.

---
 source/uax31.tex | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/source/uax31.tex b/source/uax31.tex
index 75beaa75..16480279 100644
--- a/source/uax31.tex
+++ b/source/uax31.tex
@@ -23,16 +23,16 @@ [uaxid.def.general]
 \UAX{31} specifies a default syntax for identifiers
 based on properties from the Unicode Character Database, \UAX{44}.
 The general syntax is
-\begin{codeblock}
+\begin{outputblock}
 <Identifier> := <Start> <Continue>* (<Medial> <Continue>+)*
-\end{codeblock}
+\end{outputblock}
 where \tcode{<Start>} has the XID_Start property,
 \tcode{<Continue>} has the XID_Continue property, and
 \tcode{<Medial>} is a list of characters permitted between continue characters.
 For \Cpp{} we add the character \unicode{005f}{low line}, or \tcode{_},
 to the set of permitted \tcode{<Start>} characters,
-the \tcode{<Medial>} set is empty, and
-the \tcode{<Continue>} characters are unmodified.
+the \noncxxtcode{<Medial>} set is empty, and
+the \noncxxtcode{<Continue>} characters are unmodified.
 In the grammar used in \UAX{31}, this is
 \begin{outputblock}
 <Identifier> := <Start> <Continue>*
-- 
2.25.1


From a7f40e70b04c3876dc926791b69a6fc1faecc204 Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Sun, 27 Feb 2022 06:27:00 +0100
Subject: [PATCH 20/21] Don't use \- in index reference.

---
 source/compatibility.tex | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/compatibility.tex b/source/compatibility.tex
index 2c9cd717..c665764c 100644
--- a/source/compatibility.tex
+++ b/source/compatibility.tex
@@ -1864,7 +1864,7 @@ [diff.cpp03.library]
 \libheaderrefx{system_error}{system.error.syn},
 \libheaderref{thread},
 \libheaderref{tuple},
-\libheaderrefx{type\-index}{type.index.synopsis},
+\libheaderrefx{typeindex}{type.index.synopsis},
 \libheaderrefx{type_traits}{meta.type.synop},
 \libheaderrefx{unordered_map}{unord.map.syn},
 and
-- 
2.25.1


From f41c2397c3e6ec3d073e9e78bf5b753f15a094be Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Thu, 18 Aug 2022 18:40:34 +0200
Subject: [PATCH 21/21] Avoid nested dollar math.

Because cxxdraft-htmlgen does not support it.
---
 source/containers.tex | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/containers.tex b/source/containers.tex
index ae4734a7..0fe85286 100644
--- a/source/containers.tex
+++ b/source/containers.tex
@@ -18477,7 +18477,7 @@ [mdspan.overview]
 
 \pnum
 An integer $r$ is a \defn{rank index} of an index space $S$
-if $r$ is in the range $[0, \text{rank of $S$})$.
+if $r$ is in the range $[0, \text{rank of }S)$.
 
 \pnum
 A pack of integers \tcode{idx} is
-- 
2.25.1