n4868.patch

From a952e58a2d99752e980c75867807ef7618474efe Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Sun, 4 Oct 2020 05:24:40 +0200
Subject: [PATCH 01/29] [expr.const] Fix index entries for contextually
 converted constant expression of type bool.

---
 source/expressions.tex | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/source/expressions.tex b/source/expressions.tex
index 43df35d1..ebbb0950 100644
--- a/source/expressions.tex
+++ b/source/expressions.tex
@@ -7313,9 +7313,8 @@ [expr.const]
 as non-type template
 arguments\iref{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}}%
-A \term{contextually converted constant expression of type \tcode{bool}} is
+\indextext{contextually converted constant expression of type \tcode{bool}|see{conversion, contextual to constant expression of type \tcode{bool}}}%
+A \defnx{contextually converted constant expression of type \tcode{bool}}{conversion!contextual to constant expression of type \tcode{bool}} is
 an expression, contextually converted to \tcode{bool}\iref{conv},
 where the converted expression is a constant expression and
 the conversion sequence contains only the conversions above.
-- 
2.17.1


From 3a2c44a6ce0e599539d9d2f0fd4f19cc5114a65f 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 02/29] Use \defnadj more.

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

diff --git a/source/lex.tex b/source/lex.tex
index 9bce0346..40b18405 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}
@@ -290,7 +289,7 @@ [lex.charset]
 \defnx{basic execution wide-character set}{wide-character set!basic execution}
 shall each contain all the members of the
 basic source character set, plus control characters representing alert,
-backspace, and carriage return, plus a \defnx{null character}{character!null}
+backspace, and carriage return, plus a \defnadj{null}{character}
 (respectively, \defnx{null wide character}{wide-character!null}), whose value is 0.
 For each basic execution character set, the values of the
 members shall be non-negative and distinct from one another. In both the
diff --git a/source/basic.tex b/source/basic.tex
index f078e90b..9a2f1d40 100644
--- a/source/basic.tex
+++ b/source/basic.tex
@@ -3824,10 +3824,9 @@ [basic.stc.general]
 \rSec3[basic.stc.static]{Static storage duration}
 
 \pnum
-\indextext{storage duration!static}%
 All variables which do not have dynamic storage duration, do not have thread
 storage duration, and are not local
-have \defn{static storage duration}. The
+have \defnadj{static}{storage duration}. The
 storage for these entities lasts for the duration of the
 program~(\ref{basic.start.static}, \ref{basic.start.term}).
 
diff --git a/source/statements.tex b/source/statements.tex
index 215a35a0..24ecc18e 100644
--- a/source/statements.tex
+++ b/source/statements.tex
@@ -183,10 +183,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 carry a label just before
diff --git a/source/classes.tex b/source/classes.tex
index 51b5d730..f25f2dc5 100644
--- a/source/classes.tex
+++ b/source/classes.tex
@@ -2961,9 +2961,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.17.1


From c1cac0eba82c34e9fe42d1573b39772505abad1e Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Sun, 4 Oct 2020 05:10:07 +0200
Subject: [PATCH 03/29] [basic.fundamental] Redirect index entry for 'narrow
 character type'.

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

diff --git a/source/basic.tex b/source/basic.tex
index 9a2f1d40..96cb123d 100644
--- a/source/basic.tex
+++ b/source/basic.tex
@@ -5072,11 +5072,11 @@ [basic.fundamental]
 \indextext{type!\idxcode{char}}%
 \indextext{type!character}%
 \indextext{type!ordinary character}%
-\indextext{type!narrow character}%
 \indextext{\idxcode{char}!implementation-defined sign of}%
 \indextext{type!\idxcode{signed char}}%
 \indextext{character!\idxcode{signed}}%
 \indextext{type!\idxcode{unsigned char}}%
+\indextext{narrow character type|see{type, narrow character}}%
 Type \tcode{char} is a distinct type
 that has an \impldef{underlying type of \tcode{char}} choice of
 ``\tcode{signed char}'' or ``\tcode{unsigned char}'' as its underlying type.
@@ -5086,7 +5086,7 @@ [basic.fundamental]
 are collectively called
 \defnx{ordinary character types}{type!ordinary character}.
 The ordinary character types and \tcode{char8_t}
-are collectively called \defnx{narrow character types}{narrow character type}.
+are collectively called \defnx{narrow character types}{type!narrow character}.
 For narrow character types,
 each possible bit pattern of the object representation represents
 a distinct value.
-- 
2.17.1


From c7a5700c6d9c80f155af535b9deca37303fdb29e Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Sun, 4 Oct 2020 05:05:14 +0200
Subject: [PATCH 04/29] [conv.general] Fix index redirect for contextual
 conversion to bool.

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

diff --git a/source/expressions.tex b/source/expressions.tex
index ebbb0950..fa5144c9 100644
--- a/source/expressions.tex
+++ b/source/expressions.tex
@@ -483,7 +483,7 @@ [conv]
 \rSec2[conv.general]{General}
 
 \indextext{implicit conversion|see{conversion, implicit}}
-\indextext{contextually converted to bool|see{conversion, contextual}}
+\indextext{contextually converted to bool|see{conversion, contextual to \tcode{bool}}}
 \indextext{rvalue!lvalue conversion to|see{conversion, lvalue-to-rvalue}}%
 
 \pnum
-- 
2.17.1


From 1e580bc80b5a04a128f2ac0e41df47540acbf577 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 05/29] [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 8cb10c99..7b156538 100644
--- a/source/declarations.tex
+++ b/source/declarations.tex
@@ -1682,7 +1682,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.17.1


From 60c4fc7a464584e9872d255b1f739f969c9227e9 Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Wed, 9 Sep 2020 03:14:52 +0200
Subject: [PATCH 06/29] Add index entries.

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

diff --git a/source/utilities.tex b/source/utilities.tex
index 058c58e5..2925ed5e 100644
--- a/source/utilities.tex
+++ b/source/utilities.tex
@@ -16301,7 +16301,7 @@ [meta.type.synop]
   template<class T, class U>
     inline constexpr bool @\libglobal{is_layout_compatible_v}@ = is_layout_compatible<T, U>::value;
   template<class Base, class Derived>
-    inline constexpr bool is_pointer_interconvertible_base_of_v
+    inline constexpr bool @\libglobal{is_pointer_interconvertible_base_of_v}@
       = is_pointer_interconvertible_base_of<Base, Derived>::value;
   template<class Fn, class... ArgTypes>
     inline constexpr bool @\libglobal{is_invocable_v}@ = is_invocable<Fn, ArgTypes...>::value;
@@ -17114,7 +17114,7 @@ [meta.rel]
 \lhdr{Template} &   \chdr{Condition}    &   \rhdr{Comments} \\ \capsep
 \endhead
 \tcode{template<class T, class U>}\br
- \tcode{struct is_same;}                    &
+ \tcode{struct \libglobal{is_same};}                    &
  \tcode{T} and \tcode{U} name the same type with the same cv-qualifications                            &   \\ \rowsep
 
 \indexlibraryglobal{is_base_of}%
@@ -17599,7 +17599,7 @@ [meta.trans.other]
 
 \tcode{template<bool B, class T,}
  \tcode{class F>}\br
- \tcode{struct conditional;}
+ \tcode{struct \libglobal{conditional};}
  &
  If \tcode{B} is \tcode{true},  the member typedef \tcode{type} shall equal \tcode{T}.
  If \tcode{B} is \tcode{false}, the member typedef \tcode{type} shall equal \tcode{F}. \\ \rowsep
@@ -17640,7 +17640,7 @@ [meta.trans.other]
 
 \tcode{template<class Fn,}\br
  \tcode{class... ArgTypes>}\br
- \tcode{struct invoke_result;}
+ \tcode{struct \libglobal{invoke_result};}
  &
  If the expression \tcode{\placeholdernc{INVOKE}(declval<Fn>(), declval<ArgTypes>()...)}
  is well-formed when treated as an unevaluated operand\iref{expr.prop},
-- 
2.17.1


From 833846f0daf4c97e12dd0eef5b1ff8de1024096a Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Tue, 11 Aug 2020 03:33:07 +0200
Subject: [PATCH 07/29] Use \keyword more.

---
 source/lex.tex          |  6 +++---
 source/expressions.tex  | 19 ++++++-------------
 source/declarations.tex |  4 ----
 source/templates.tex    |  2 --
 source/exceptions.tex   | 14 ++++----------
 source/preprocessor.tex |  3 +--
 6 files changed, 14 insertions(+), 34 deletions(-)

diff --git a/source/lex.tex b/source/lex.tex
index 40b18405..f0823f64 100644
--- a/source/lex.tex
+++ b/source/lex.tex
@@ -1849,8 +1849,8 @@ [lex.bool]
 \indextext{literal!boolean}%
 \begin{bnf}
 \nontermdef{boolean-literal}\br
-    \terminal{false}\br
-    \terminal{true}
+    \keyword{false}\br
+    \keyword{true}
 \end{bnf}
 
 \pnum
@@ -1863,7 +1863,7 @@ [lex.nullptr]
 \indextext{literal!pointer}%
 \begin{bnf}
 \nontermdef{pointer-literal}\br
-    \terminal{nullptr}
+    \keyword{nullptr}
 \end{bnf}
 
 \pnum
diff --git a/source/expressions.tex b/source/expressions.tex
index fa5144c9..e0190616 100644
--- a/source/expressions.tex
+++ b/source/expressions.tex
@@ -1194,8 +1194,7 @@ [expr.prim.literal]
 \rSec2[expr.prim.this]{This}
 
 \pnum
-\indextext{\idxcode{this}}%
-The keyword \tcode{this} names a pointer to the object for which a non-static member
+The keyword \keyword{this} names a pointer to the object for which a non-static member
 function\iref{class.this} is invoked or a non-static data member's
 initializer\iref{class.mem} is evaluated.
 
@@ -3561,8 +3560,7 @@ [expr.typeid]
 
 \pnum
 \indextext{expression!type identification}%
-\indextext{\idxcode{typeid}}%
-The result of a \tcode{typeid} expression is an lvalue of static type
+The result of a \keyword{typeid} expression is an lvalue of static type
 \indextext{\idxcode{type_info}}%
 \indexlibraryglobal{type_info}%
 \tcode{const} \tcode{std::type_info}\iref{type.info} and dynamic type \tcode{const}
@@ -4406,16 +4404,15 @@ [expr.pre.incr]
 
 \rSec3[expr.await]{Await}
 \indextext{expression!await}%
-\indextext{\idxcode{co_await}}%
 
 \pnum
-The \tcode{co_await} expression is used to suspend evaluation of a
+The \keyword{co_await} expression is used to suspend evaluation of a
 coroutine\iref{dcl.fct.def.coroutine} while awaiting completion of
 the computation represented by the operand expression.
 
 \begin{bnf}
 \nontermdef{await-expression}\br
-    \terminal{co_await} cast-expression
+    \keyword{co_await} cast-expression
 \end{bnf}
 
 \pnum
@@ -4682,9 +4679,8 @@ [expr.sizeof]
 \rSec3[expr.alignof]{Alignof}
 
 \pnum
-\indextext{\idxcode{alignof}}%
 \indextext{expression!\idxcode{alignof}}%
-An \tcode{alignof} expression yields the alignment requirement
+An \keyword{alignof} expression yields the alignment requirement
 of its operand type. The operand shall be a \grammarterm{type-id}
 representing a complete object type, or an array thereof, or a reference
 to one of those types.
@@ -4707,9 +4703,8 @@ [expr.alignof]
 \rSec3[expr.unary.noexcept]{\tcode{noexcept} operator}
 
 \pnum
-\indextext{\idxcode{noexcept}}%
 \indextext{expression!\idxcode{noexcept}}%
-The \tcode{noexcept} operator determines whether the evaluation of its operand,
+The \keyword{noexcept} operator determines whether the evaluation of its operand,
 which is an unevaluated operand\iref{expr.prop}, can throw an
 exception\iref{except.throw}.
 
@@ -5319,7 +5314,6 @@ [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
 \grammarterm{new-expression}.
@@ -6685,7 +6679,6 @@ [expr.yield]
 \rSec2[expr.throw]{Throwing an exception}%
 \indextext{expression!\idxcode{throw}}%
 \indextext{exception handling!throwing}%
-\indextext{\idxcode{throw}}%
 %
 \begin{bnf}
 \nontermdef{throw-expression}\br
diff --git a/source/declarations.tex b/source/declarations.tex
index 7b156538..836901ce 100644
--- a/source/declarations.tex
+++ b/source/declarations.tex
@@ -330,10 +330,6 @@ [dcl.spec.general]
 \rSec2[dcl.stc]{Storage class specifiers}%
 \indextext{specifier!storage class}%
 \indextext{declaration!storage class}%
-\indextext{\idxcode{static}}%
-\indextext{\idxcode{thread_local}}%
-\indextext{\idxcode{extern}}%
-\indextext{\idxcode{mutable}}
 
 \pnum
 The storage class specifiers are
diff --git a/source/templates.tex b/source/templates.tex
index d886adc6..1af9b3ea 100644
--- a/source/templates.tex
+++ b/source/templates.tex
@@ -13,8 +13,6 @@ [temp.pre]
 A \defn{template} defines a family of classes, functions, or variables,
 an alias for a family of types, or a concept.
 
-\indextext{\idxcode{template}}%
-%
 \begin{bnf}
 \nontermdef{template-declaration}\br
   template-head declaration\br
diff --git a/source/exceptions.tex b/source/exceptions.tex
index 4b24c2ba..3e63cb63 100644
--- a/source/exceptions.tex
+++ b/source/exceptions.tex
@@ -17,18 +17,14 @@ [except.pre]
 in code executed in the handler's try block
 or in functions called from the handler's try block.
 
-\indextext{\idxcode{try}}%
-%
 \begin{bnf}
 \nontermdef{try-block}\br
-    \terminal{try} compound-statement handler-seq
+    \keyword{try} compound-statement handler-seq
 \end{bnf}
 
-\indextext{\idxcode{try}}%
-%
 \begin{bnf}
 \nontermdef{function-try-block}\br
-    \terminal{try} \opt{ctor-initializer} compound-statement handler-seq
+    \keyword{try} \opt{ctor-initializer} compound-statement handler-seq
 \end{bnf}
 
 \begin{bnf}
@@ -36,11 +32,9 @@ [except.pre]
     handler \opt{handler-seq}
 \end{bnf}
 
-\indextext{\idxcode{catch}}%
-%
 \begin{bnf}
 \nontermdef{handler}\br
-    \terminal{catch} \terminal{(} exception-declaration \terminal{)} compound-statement
+    \keyword{catch} \terminal{(} exception-declaration \terminal{)} compound-statement
 \end{bnf}
 
 \begin{bnf}
@@ -704,7 +698,7 @@ [except.spec]
 
 \begin{bnf}
 \nontermdef{noexcept-specifier}\br
-    \terminal{noexcept} \terminal{(} constant-expression \terminal{)}\br
+    \keyword{noexcept} \terminal{(} constant-expression \terminal{)}\br
     \terminal{noexcept}\br
 \end{bnf}
 
diff --git a/source/preprocessor.tex b/source/preprocessor.tex
index c3e3db6c..afc2ed3c 100644
--- a/source/preprocessor.tex
+++ b/source/preprocessor.tex
@@ -273,10 +273,9 @@ [cpp.cond]
 \indextext{preprocessing directive!conditional inclusion}%
 \indextext{inclusion!conditional|see{preprocessing directive, conditional inclusion}}
 
-\indextext{\idxcode{defined}}%
 \begin{bnf}
 \nontermdef{defined-macro-expression}\br
-    \terminal{defined} identifier\br
+    \keyword{defined} identifier\br
     \terminal{defined (} identifier \terminal{)}
 \end{bnf}
 
-- 
2.17.1


From dd9bfa8e1019476af113c6b2ca8fed3439df484b 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 08/29] Use \range where appropriate.

---
 source/strings.tex    | 20 ++++++++++----------
 source/containers.tex | 34 +++++++++++++++++-----------------
 source/algorithms.tex |  6 +++---
 source/regex.tex      |  2 +-
 4 files changed, 31 insertions(+), 31 deletions(-)

diff --git a/source/strings.tex b/source/strings.tex
index 46dcf6b4..2d3ac622 100644
--- a/source/strings.tex
+++ b/source/strings.tex
@@ -139,31 +139,31 @@ [char.traits.require]
 whether \tcode{c} is to be treated as less than \tcode{d}.  &   constant    \\ \rowsep
 \tcode{X::compare(p,q,n)}   &   \tcode{int}     &
 \returns
-\tcode{0} if for each \tcode{i} in \tcode{[0,n)}, \tcode{X::eq(p[i],q[i])}
-is \tcode{true}; else, a negative value if, for some \tcode{j} in \tcode{[0,n)},
-\tcode{X::lt(p[j],q[j])} is \tcode{true} and for each \tcode{i} in \tcode{[0,j)}
+\tcode{0} if for each \tcode{i} in \range{0}{n}, \tcode{X::eq(p[i],q[i])}
+is \tcode{true}; else, a negative value if, for some \tcode{j} in \range{0}{n},
+\tcode{X::lt(p[j],q[j])} is \tcode{true} and for each \tcode{i} in \range{0}{j}
 \tcode{X::eq(p[i],q[i])} is \tcode{true}; else a positive value.            &   linear      \\ \rowsep
 \tcode{X::length(p)}    &   \tcode{size_t}     &
 \returns
 the smallest \tcode{i} such that \tcode{X::eq(p[i],charT())} is \tcode{true}.  &   linear  \\ \rowsep
 \tcode{X::find(p,n,c)}  &   \tcode{const X::char_type*} &
 \returns
-the smallest \tcode{q} in \tcode{[p,p+n)} such that
+the smallest \tcode{q} in \range{p}{p+n} such that
 \tcode{X::eq(*q,c)} is \tcode{true}, zero 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
-\tcode{p} not in \tcode{[s,s+n)}.\par
+\tcode{p} not in \range{s}{s+n}.\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
@@ -2488,7 +2488,7 @@ [string.erase]
 \pnum
 \effects
 Removes the characters in the range
-\tcode{[first, last)}.
+\range{first}{last}.
 
 \pnum
 \returns
diff --git a/source/containers.tex b/source/containers.tex
index ad9fba22..cbbb0f66 100644
--- a/source/containers.tex
+++ b/source/containers.tex
@@ -802,7 +802,7 @@ [sequence.reqmts]
 \tcode{i} and \tcode{j}
 denote iterators that meet the \oldconcept{InputIterator} requirements
 and refer to elements implicitly convertible to \tcode{value_type},
-\tcode{[i, j)}
+\range{i}{j}
 denotes a valid range,
 \tcode{il} designates an object of type \tcode{initializer_list<value_type>},
 \tcode{n}
@@ -810,7 +810,7 @@ [sequence.reqmts]
 \tcode{p} denotes a valid constant iterator to
 \tcode{a}, \tcode{q}
 denotes a valid dereferenceable constant iterator to
-\tcode{a}, \tcode{[q1, q2)}
+\tcode{a}, \range{q1}{q2}
 denotes a valid range of constant iterators in
 \tcode{a}, \tcode{t}
 denotes an lvalue or a const rvalue of
@@ -1651,7 +1651,7 @@ [associative.reqmts.general]
 \tcode{p} denotes a valid constant iterator to \tcode{a},
 \tcode{q} denotes a valid dereferenceable constant iterator to \tcode{a},
 \tcode{r} denotes a valid dereferenceable iterator to \tcode{a},
-\tcode{[q1, q2)} denotes a valid range of constant iterators in \tcode{a},
+\range{q1}{q2} denotes a valid range of constant iterators in \tcode{a},
 \tcode{il} designates an object of type \tcode{initializer_list<value_type>},
 \tcode{t} denotes a value of type \tcode{X::value_type},
 \tcode{k} denotes a value of type \tcode{X::key_type}
@@ -1758,9 +1758,9 @@ [associative.reqmts.general]
                         &
   \expects \tcode{value_type} is \oldconcept{EmplaceConstructible} into \tcode{X} from \tcode{*i}.\br
   \effects\ Constructs an empty container and inserts elements from the
-  range \tcode{[i, j)} into it; uses \tcode{c} as a comparison object. &
+  range \range{i}{j} into it; uses \tcode{c} as a comparison object. &
   $N \log N$ in general, where $N$ has the value \tcode{distance(i, j)};
-  linear if \tcode{[i, j)} is sorted with \tcode{value_comp()} \\ \rowsep
+  linear if \range{i}{j} is sorted with \tcode{value_comp()} \\ \rowsep
 
 \tcode{X(i,j)}\br\tcode{X~u(i,j);}    &
                                     &
@@ -2332,12 +2332,12 @@ [unord.req.general]
   are both valid and denote types\iref{temp.deduct},
 \item \tcode{i} and \tcode{j} denote input iterators
   that refer to \tcode{value_type},
-\item \tcode{[i, j)} denotes a valid range,
+\item \range{i}{j} denotes a valid range,
 \item \tcode{p} and \tcode{q2} denote valid constant iterators to \tcode{a},
 \item \tcode{q} and \tcode{q1} denote
   valid dereferenceable constant iterators to \tcode{a},
 \item \tcode{r} denotes a valid dereferenceable iterator to \tcode{a},
-\item \tcode{[q1, q2)} denotes a valid range in \tcode{a},
+\item \range{q1}{q2} denotes a valid range in \tcode{a},
 \item \tcode{il} denotes a value of type \tcode{initializer_list<value_type>},
 \item \tcode{t} denotes a value of type \tcode{X::value_type},
 \item \tcode{k} denotes a value of type \tcode{key_type},
@@ -2491,7 +2491,7 @@ [unord.req.general]
 &   \expects \tcode{value_type} is \oldconcept{EmplaceConstructible} into \tcode{X} from \tcode{*i}.\br
     \effects\ Constructs an empty container with at least \tcode{n} buckets,
 using \tcode{hf} as the hash function and \tcode{eq} as the key
-equality predicate, and inserts elements from \tcode{[i, j)} into it.
+equality predicate, and inserts elements from \range{i}{j} into it.
 &   Average case \bigoh{N} ($N$ is \tcode{distance(i, j)}), worst case
 \bigoh{N^2}
 \\ \rowsep
@@ -2502,7 +2502,7 @@ [unord.req.general]
     \tcode{value_type} is \oldconcept{EmplaceConstructible} into \tcode{X} from \tcode{*i}.\br
     \effects\ Constructs an empty container with at least \tcode{n} buckets,
 using \tcode{hf} as the hash function and \tcode{key_equal()} as the key
-equality predicate, and inserts elements from \tcode{[i, j)} into it.
+equality predicate, and inserts elements from \range{i}{j} into it.
 &   Average case \bigoh{N} ($N$ is \tcode{distance(i, j)}), worst case
 \bigoh{N^2}
 \\ \rowsep
@@ -2513,7 +2513,7 @@ [unord.req.general]
     \tcode{value_type} is \oldconcept{EmplaceConstructible} into \tcode{X} from \tcode{*i}.\br
     \effects\ Constructs an empty container with at least \tcode{n} buckets,
 using \tcode{hasher()} as the hash function and \tcode{key_equal()}
-as the key equality predicate, and inserts elements from \tcode{[i, j)}
+as the key equality predicate, and inserts elements from \range{i}{j}
 into it.
 &   Average case \bigoh{N} ($N$ is \tcode{distance(i, j)}), worst case
 \bigoh{N^2}
@@ -2526,7 +2526,7 @@ [unord.req.general]
     \effects\ Constructs an empty container with an unspecified number of
 buckets, using \tcode{hasher()} as the hash function and
 \tcode{key_equal()} as the key equality predicate, and inserts elements
-from \tcode{[i, j)} into it.
+from \range{i}{j} into it.
 &   Average case \bigoh{N} ($N$ is \tcode{distance(i, j)}), worst case
 \bigoh{N^2}
 \\ \rowsep
@@ -4758,8 +4758,8 @@ [forwardlist.ops]
 
 \pnum
 \effects
-Merges the two sorted ranges \tcode{[begin(), end())} and
-\tcode{[x.begin(), x.end())}. \tcode{x} is empty after the merge. If an
+Merges the two sorted ranges \range{begin()}{end()} and
+\range{x.begin()}{x.end()}. \tcode{x} is empty after the merge. If an
 exception is thrown other than by a comparison there are no effects.
 Pointers and references to the moved elements of \tcode{x} now refer to those same elements
 but as members of \tcode{*this}. Iterators referring to the moved elements will continue to
@@ -5433,7 +5433,7 @@ [list.ops]
 \pnum
 \complexity
 If the range
-\tcode{[first, last)}
+\range{first}{last}
 is not empty, exactly
 \tcode{(last - first) - 1}
 applications of the corresponding predicate,
@@ -5459,8 +5459,8 @@ [list.ops]
 
 \pnum
 \effects
-If \tcode{addressof(x) == this}, does nothing; otherwise, merges the two sorted ranges \tcode{[begin(),
-end())} and \tcode{[x.\brk{}begin(), x.end())}. The result is a range in which the elements
+If \tcode{addressof(x) == this}, does nothing; otherwise, merges the two sorted ranges \range{begin()}{end()}
+and \range{x.\brk{}begin()}{x.end()}. The result is a range in which the elements
 will be sorted in non-decreasing order according to the ordering defined by \tcode{comp}; that
 is, for every iterator \tcode{i}, in the range other than the first, the condition
 \tcode{comp(*i, *(i - 1))} will be \tcode{false}.
@@ -5480,7 +5480,7 @@ [list.ops]
 
 \pnum
 \remarks
-Stable\iref{algorithm.stable}. If \tcode{addressof(x) != this}, the range \tcode{[x.begin(), x.end())}
+Stable\iref{algorithm.stable}. If \tcode{addressof(x) != this}, the range \range{x.begin()}{x.end()}
 is empty after the merge.
 No elements are copied by this operation.
 \end{itemdescr}
diff --git a/source/algorithms.tex b/source/algorithms.tex
index d3c60b50..3d9719ad 100644
--- a/source/algorithms.tex
+++ b/source/algorithms.tex
@@ -6708,7 +6708,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}.
 
@@ -6772,7 +6772,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}.
 
@@ -9931,7 +9931,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 7ce7418a..a6d789d5 100644
--- a/source/regex.tex
+++ b/source/regex.tex
@@ -3221,7 +3221,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.17.1


From 30333a4d4a271b8705df0908e6608add710d0f06 Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Fri, 10 Mar 2017 14:45:02 +0100
Subject: [PATCH 09/29] [expr.mptr.oper] Add missing indentation in example
 code. [rejected upstream: 1529]

---
 source/expressions.tex | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/source/expressions.tex b/source/expressions.tex
index e0190616..2063348e 100644
--- a/source/expressions.tex
+++ b/source/expressions.tex
@@ -5718,9 +5718,9 @@ [expr.mptr.oper]
 };
 void f()
 {
-const S cs;
-int S::* pm = &S::i;            // \tcode{pm} refers to \tcode{mutable} member \tcode{S::i}
-cs.*pm = 88;                    // error: \tcode{cs} is a const object
+  const S cs;
+  int S::* pm = &S::i;          // \tcode{pm} refers to \tcode{mutable} member \tcode{S::i}
+  cs.*pm = 88;                  // error: \tcode{cs} is a const object
 }
 \end{codeblock}
 \end{note}
-- 
2.17.1


From 0a9a87ff1312771e20b7d12a5e278c7ab14d02b0 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 10/29] [some.where] Replace \term with \placeholder.

---
 source/expressions.tex |  2 +-
 source/time.tex        | 20 ++++++++++----------
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/source/expressions.tex b/source/expressions.tex
index 2063348e..0ef04e09 100644
--- a/source/expressions.tex
+++ b/source/expressions.tex
@@ -3564,7 +3564,7 @@ [expr.typeid]
 \indextext{\idxcode{type_info}}%
 \indexlibraryglobal{type_info}%
 \tcode{const} \tcode{std::type_info}\iref{type.info} and dynamic type \tcode{const}
-\tcode{std::type_info} or \tcode{const} \term{name} where \term{name} is an
+\tcode{std::type_info} or \tcode{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}.
diff --git a/source/time.tex b/source/time.tex
index aefb0722..585671cf 100644
--- a/source/time.tex
+++ b/source/time.tex
@@ -164,19 +164,19 @@ [time.syn]
                     minutes* offset = nullptr);
 
     // convenience typedefs
-    using nanoseconds  = duration<@\term{signed integer type of at least 64 bits}@, nano>;
-    using microseconds = duration<@\term{signed integer type of at least 55 bits}@, micro>;
-    using milliseconds = duration<@\term{signed integer type of at least 45 bits}@, milli>;
-    using seconds      = duration<@\term{signed integer type of at least 35 bits}@>;
-    using minutes      = duration<@\term{signed integer type of at least 29 bits}@, ratio<  60>>;
-    using hours        = duration<@\term{signed integer type of at least 23 bits}@, ratio<3600>>;
-    using days         = duration<@\term{signed integer type of at least 25 bits}@,
+    using nanoseconds  = duration<@\placeholder{signed integer type of at least 64 bits}@, nano>;
+    using microseconds = duration<@\placeholder{signed integer type of at least 55 bits}@, micro>;
+    using milliseconds = duration<@\placeholder{signed integer type of at least 45 bits}@, milli>;
+    using seconds      = duration<@\placeholder{signed integer type of at least 35 bits}@>;
+    using minutes      = duration<@\placeholder{signed integer type of at least 29 bits}@, ratio<  60>>;
+    using hours        = duration<@\placeholder{signed integer type of at least 23 bits}@, ratio<3600>>;
+    using days         = duration<@\placeholder{signed integer type of at least 25 bits}@,
                                   ratio_multiply<ratio<24>, hours::period>>;
-    using weeks        = duration<@\term{signed integer type of at least 22 bits}@,
+    using weeks        = duration<@\placeholder{signed integer type of at least 22 bits}@,
                                   ratio_multiply<ratio<7>, days::period>>;
-    using years        = duration<@\term{signed integer type of at least 17 bits}@,
+    using years        = duration<@\placeholder{signed integer type of at least 17 bits}@,
                                   ratio_multiply<ratio<146097, 400>, days::period>>;
-    using months       = duration<@\term{signed integer type of at least 20 bits}@,
+    using months       = duration<@\placeholder{signed integer type of at least 20 bits}@,
                                   ratio_divide<years::period, ratio<12>>>;
 
     // \ref{time.point.nonmember}, \tcode{time_point} arithmetic
-- 
2.17.1


From 5d0a553d076414b407342db074ad831124727dc1 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 11/29] Make references more precise.

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

diff --git a/source/basic.tex b/source/basic.tex
index 96cb123d..9b7441fd 100644
--- a/source/basic.tex
+++ b/source/basic.tex
@@ -5182,7 +5182,7 @@ [basic.fundamental]
 called \defnx{arithmetic}{type!arithmetic} types.
 \indextext{\idxcode{numeric_limits}!specializations for arithmetic types}%
 Specializations of the standard library template
-\tcode{std::numeric_limits}\iref{support.limits} shall specify the
+\tcode{std::numeric_limits}\iref{numeric.limits} shall specify the
 maximum and minimum values of each arithmetic type for an
 implementation.
 
diff --git a/source/statements.tex b/source/statements.tex
index 24ecc18e..fc01e765 100644
--- a/source/statements.tex
+++ b/source/statements.tex
@@ -1061,7 +1061,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/declarations.tex b/source/declarations.tex
index 836901ce..d5666d95 100644
--- a/source/declarations.tex
+++ b/source/declarations.tex
@@ -8264,7 +8264,7 @@ [dcl.link]
 Linkage specifications nest. When linkage specifications nest, the
 innermost one determines the language linkage. A linkage specification
 does not establish a scope. A \grammarterm{linkage-specification} shall
-occur only in namespace scope\iref{basic.scope}. In a
+occur only in namespace scope\iref{basic.scope.namespace}. In a
 \grammarterm{linkage-specification}, the specified language linkage applies
 to the function types of all function declarators, function names with
 external linkage, and variable names with external linkage declared
diff --git a/source/strings.tex b/source/strings.tex
index 2d3ac622..917e32e1 100644
--- a/source/strings.tex
+++ b/source/strings.tex
@@ -1398,7 +1398,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.17.1


From a10660e6a5ecec56de7bcbbd6a2ae4055817c925 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 12/29] [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 61f5b109..b519b9ca 100644
--- a/source/numerics.tex
+++ b/source/numerics.tex
@@ -2299,21 +2299,21 @@ [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)}
 \indextext{copy constructor!random number engine requirement}
   &
   & Creates an engine
     that compares equal to \tcode{x}.
-  & \bigoh{$\text{size of state}$}
+  & \bigoh{\text{size of state}}
   \\ \rowsep
 \tcode{E(s)}%
 \indextext{constructor!random number engine requirement}
   &
   & Creates an engine
       with initial state determined by \tcode{s}.
-  & \bigoh{$\text{size of state}$}
+  & \bigoh{\text{size of state}}
   \\ \rowsep
 \tcode{E(q)}%
 \indextext{constructor!random number engine requirement}%
@@ -2395,13 +2395,13 @@ [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}%
 \indextext{\idxcode{operator"!=}!random number engine requirement}
   & \tcode{bool}
   & \tcode{!(x == y)}.
-  & \bigoh{$\text{size of state}$}
+  & \bigoh{\text{size of state}}
   \\ \rowsep
 \tcode{os << x}%
 \indextext{\idxcode{operator<<}!random number engine requirement}
@@ -2417,7 +2417,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}%
 \indextext{\idxcode{operator>>}!random number engine requirement}
@@ -2448,7 +2448,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.17.1


From 1349f9d8f5ee34fdd6275333aa988732612f49c2 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 13/29] Reduce excessive indentation of comments. Helps layout
 on smaller (e.g. half-screen) window sizes.

---
 source/basic.tex       | 30 +++++++++++++++---------------
 source/expressions.tex | 18 +++++++++---------
 source/templates.tex   | 16 ++++++++--------
 3 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/source/basic.tex b/source/basic.tex
index 9b7441fd..c0f31742 100644
--- a/source/basic.tex
+++ b/source/basic.tex
@@ -245,7 +245,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() {
@@ -1817,8 +1817,8 @@ [basic.lookup.argdep]
 
 void g() {
   N::S s;
-  f(s);             // OK: calls \tcode{N::f}
-  (f)(s);           // error: \tcode{N::f} not considered; parentheses prevent argument-dependent lookup
+  f(s);     // OK: calls \tcode{N::f}
+  (f)(s);   // error: \tcode{N::f} not considered; parentheses prevent argument-dependent lookup
 }
 \end{codeblock}
 \end{example}
@@ -2282,23 +2282,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 0ef04e09..6e2c9933 100644
--- a/source/expressions.tex
+++ b/source/expressions.tex
@@ -2205,8 +2205,8 @@ [expr.prim.lambda.capture]
   auto m1 = [=]{
     int const M = 30;
     auto m2 = [i]{
-      int x[N][M];              // OK: \tcode{N} and \tcode{M} are not odr-used
-      x[0][0] = i;              // OK: \tcode{i} is explicitly captured by \tcode{m2} and implicitly captured by \tcode{m1}
+      int x[N][M];          // OK: \tcode{N} and \tcode{M} are not odr-used
+      x[0][0] = i;          // OK: \tcode{i} is explicitly captured by \tcode{m2} and implicitly captured by \tcode{m1}
     };
   };
   struct s1 {
@@ -2215,12 +2215,12 @@ [expr.prim.lambda.capture]
       int m = n*n;
       int j = 40;
       auto m3 = [this,m] {
-        auto m4 = [&,j] {       // error: \tcode{j} not odr-usable due to intervening lambda \tcode{m3}
-          int x = n;            // error: \tcode{n} is odr-used but not odr-usable due to intervening lambda \tcode{m3}
-          x += m;               // OK: \tcode{m} implicitly captured by \tcode{m4} and explicitly captured by \tcode{m3}
-          x += i;               // error: \tcode{i} is odr-used but not odr-usable
-                                // due to intervening function and class scopes
-          x += f;               // OK: \tcode{this} captured implicitly by \tcode{m4} and explicitly by \tcode{m3}
+        auto m4 = [&,j] {   // error: \tcode{j} not odr-usable due to intervening lambda \tcode{m3}
+          int x = n;        // error: \tcode{n} is odr-used but not odr-usable due to intervening lambda \tcode{m3}
+          x += m;           // OK: \tcode{m} implicitly captured by \tcode{m4} and explicitly captured by \tcode{m3}
+          x += i;           // error: \tcode{i} is odr-used but not odr-usable
+                            // due to intervening function and class scopes
+          x += f;           // OK: \tcode{this} captured implicitly by \tcode{m4} and explicitly by \tcode{m3}
         };
       };
     }
@@ -2238,7 +2238,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}
     }();
   }
 };
diff --git a/source/templates.tex b/source/templates.tex
index 1af9b3ea..44489138 100644
--- a/source/templates.tex
+++ b/source/templates.tex
@@ -1397,11 +1397,11 @@ [temp.arg.template]
 template <class T1, int N> struct D;
 template <class T1, class T2, int N = 17> struct E;
 
-eval<A<int>> eA;                // OK: matches partial specialization of \tcode{eval}
-eval<B<int, float>> eB;         // OK: matches partial specialization of \tcode{eval}
-eval<C<17>> eC;                 // error: \tcode{C} does not match \tcode{TT} in partial specialization
-eval<D<int, 17>> eD;            // error: \tcode{D} does not match \tcode{TT} in partial specialization
-eval<E<int, float>> eE;         // error: \tcode{E} does not match \tcode{TT} in partial specialization
+eval<A<int>> eA;            // OK: matches partial specialization of \tcode{eval}
+eval<B<int, float>> eB;     // OK: matches partial specialization of \tcode{eval}
+eval<C<17>> eC;             // error: \tcode{C} does not match \tcode{TT} in partial specialization
+eval<D<int, 17>> eD;        // error: \tcode{D} does not match \tcode{TT} in partial specialization
+eval<E<int, float>> eE;     // error: \tcode{E} does not match \tcode{TT} in partial specialization
 \end{codeblock}
 \end{example}
 \begin{example}
@@ -5324,9 +5324,9 @@ [temp.dep.type]
   int g() { return m; }         // finds \tcode{A::m} in the template definition context
 };
 
-template int C<B>::f();         // error: finds both \tcode{A::m} and \tcode{B::m}
-template int C<B>::g();         // OK: transformation to class member access syntax
-                                // does not occur in the template definition context; see~\ref{class.mfct.non-static}
+template int C<B>::f();     // error: finds both \tcode{A::m} and \tcode{B::m}
+template int C<B>::g();     // OK: transformation to class member access syntax
+                            // does not occur in the template definition context; see~\ref{class.mfct.non-static}
 \end{codeblock}
 \end{example}
 
-- 
2.17.1


From ed06bff785db66ce83eab47ed9e659dd76bef71f Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Wed, 9 Sep 2020 03:20:37 +0200
Subject: [PATCH 14/29] Use libconcept more.

---
 source/concepts.tex | 24 ++++++++++++------------
 source/ranges.tex   |  2 +-
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/source/concepts.tex b/source/concepts.tex
index 9950a816..384172f4 100644
--- a/source/concepts.tex
+++ b/source/concepts.tex
@@ -490,9 +490,9 @@ [concepts.arithmetic]
 template<class T>
   concept @\deflibconcept{integral}@ = is_integral_v<T>;
 template<class T>
-  concept @\deflibconcept{signed_integral}@ = integral<T> && is_signed_v<T>;
+  concept @\deflibconcept{signed_integral}@ = @\libconcept{integral}@<T> && is_signed_v<T>;
 template<class T>
-  concept @\deflibconcept{unsigned_integral}@ = integral<T> && !signed_integral<T>;
+  concept @\deflibconcept{unsigned_integral}@ = @\libconcept{integral}@<T> && !@\libconcept{signed_integral}@<T>;
 template<class T>
   concept @\deflibconcept{floating_point}@ = is_floating_point_v<T>;
 \end{itemdecl}
@@ -758,7 +758,7 @@ [concept.constructible]
 
 \begin{itemdecl}
 template<class T, class... Args>
-  concept @\deflibconcept{constructible_from}@ = destructible<T> && is_constructible_v<T, Args...>;
+  concept @\deflibconcept{constructible_from}@ = @\libconcept{destructible}@<T> && is_constructible_v<T, Args...>;
 \end{itemdecl}
 
 \rSec2[concept.default.init]{Concept \cname{default_initializable}}
@@ -768,7 +768,7 @@ [concept.default.init]
   inline constexpr bool @\exposid{is-default-initializable}@ = @\seebelow@;  // \expos
 
 template<class T>
-  concept @\deflibconcept{default_initializable}@ = constructible_from<T> &&
+  concept @\deflibconcept{default_initializable}@ = @\libconcept{constructible_from}@<T> &&
                                   requires { T{}; } &&
                                   @\exposid{is-default-initializable}@<T>;
 \end{itemdecl}
@@ -790,7 +790,7 @@ [concept.moveconstructible]
 
 \begin{itemdecl}
 template<class T>
-  concept @\deflibconcept{move_constructible}@ = constructible_from<T, T> && @\libconcept{convertible_to}@<T, T>;
+  concept @\deflibconcept{move_constructible}@ = @\libconcept{constructible_from}@<T, T> && @\libconcept{convertible_to}@<T, T>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -1133,9 +1133,9 @@ [concepts.object]
   concept @\deflibconcept{copyable}@ = @\libconcept{copy_constructible}@<T> && @\libconcept{movable}@<T> && @\libconcept{assignable_from}@<T&, T&> &&
                      @\libconcept{assignable_from}@<T&, const T&> && @\libconcept{assignable_from}@<T&, const T>;
 template<class T>
-  concept @\deflibconcept{semiregular}@ = copyable<T> && default_initializable<T>;
+  concept @\deflibconcept{semiregular}@ = @\libconcept{copyable}@<T> && @\libconcept{default_initializable}@<T>;
 template<class T>
-  concept @\deflibconcept{regular}@ = semiregular<T> && equality_comparable<T>;
+  concept @\deflibconcept{regular}@ = @\libconcept{semiregular}@<T> && @\libconcept{equality_comparable}@<T>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -1189,7 +1189,7 @@ [concept.regularinvocable]
 
 \begin{itemdecl}
 template<class F, class... Args>
-  concept @\deflibconcept{regular_invocable}@ = invocable<F, Args...>;
+  concept @\deflibconcept{regular_invocable}@ = @\libconcept{invocable}@<F, Args...>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -1227,15 +1227,15 @@ [concept.relation]
 \begin{itemdecl}
 template<class R, class T, class U>
   concept @\deflibconcept{relation}@ =
-    predicate<R, T, T> && predicate<R, U, U> &&
-    predicate<R, T, U> && predicate<R, U, T>;
+    @\libconcept{predicate}@<R, T, T> && @\libconcept{predicate}@<R, U, U> &&
+    @\libconcept{predicate}@<R, T, U> && @\libconcept{predicate}@<R, U, T>;
 \end{itemdecl}
 
 \rSec2[concept.equiv]{Concept \cname{equivalence_relation}}
 
 \begin{itemdecl}
 template<class R, class T, class U>
-  concept @\deflibconcept{equivalence_relation}@ = relation<R, T, U>;
+  concept @\deflibconcept{equivalence_relation}@ = @\libconcept{relation}@<R, T, U>;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -1248,7 +1248,7 @@ [concept.strictweakorder]
 
 \begin{itemdecl}
 template<class R, class T, class U>
-  concept @\deflibconcept{strict_weak_order}@ = relation<R, T, U>;
+  concept @\deflibconcept{strict_weak_order}@ = @\libconcept{relation}@<R, T, U>;
 \end{itemdecl}
 
 \begin{itemdescr}
diff --git a/source/ranges.tex b/source/ranges.tex
index 038a4d76..e343ee7d 100644
--- a/source/ranges.tex
+++ b/source/ranges.tex
@@ -1024,7 +1024,7 @@ [range.range]
 \begin{itemdecl}
 template<class T>
   concept @\deflibconcept{borrowed_range}@ =
-    range<T> &&
+    @\libconcept{range}@<T> &&
       (is_lvalue_reference_v<T> || enable_borrowed_range<remove_cvref_t<T>>);
 \end{itemdecl}
 
-- 
2.17.1


From 18ee858fcbd321918818e866543dc50320edd66d 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 15/29] Use new link macros.

---
 source/intro.tex         |  19 +-
 source/lex.tex           |  33 +--
 source/basic.tex         | 263 ++++++++++----------
 source/expressions.tex   | 510 ++++++++++++++++++++-------------------
 source/statements.tex    |  64 ++---
 source/declarations.tex  | 160 ++++++------
 source/classes.tex       |  93 ++++---
 source/overloading.tex   |  94 ++++----
 source/templates.tex     | 213 ++++++++--------
 source/exceptions.tex    |  80 +++---
 source/preprocessor.tex  |  16 +-
 source/lib-intro.tex     | 103 ++++----
 source/support.tex       | 117 ++++-----
 source/concepts.tex      |  16 +-
 source/diagnostics.tex   |   6 +-
 source/utilities.tex     | 374 ++++++++++++++--------------
 source/strings.tex       |  22 +-
 source/containers.tex    |  80 +++---
 source/iterators.tex     |   9 +-
 source/ranges.tex        |   4 +-
 source/algorithms.tex    |   4 +-
 source/numerics.tex      |  63 +++--
 source/locales.tex       |  47 ++--
 source/iostreams.tex     |  78 +++---
 source/regex.tex         |  61 ++---
 source/atomics.tex       |   5 +-
 source/threads.tex       |  55 +++--
 source/limits.tex        |   2 +-
 source/compatibility.tex |   4 +-
 source/future.tex        |   8 +-
 30 files changed, 1284 insertions(+), 1319 deletions(-)

diff --git a/source/intro.tex b/source/intro.tex
index a91c950d..e07daf11 100644
--- a/source/intro.tex
+++ b/source/intro.tex
@@ -129,8 +129,8 @@ [intro.defs]
 modifications of scalar objects are describred 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}
@@ -281,10 +281,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}
 
@@ -341,7 +342,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}
@@ -803,7 +804,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.
 
@@ -821,7 +822,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 f0823f64..b97e0b70 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 \defn{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|)}
 
@@ -73,8 +73,9 @@ [lex.phases]
 The set of physical source file characters accepted is \impldef{physical source file
 characters}.
 Any
-source file character not in the basic source character
-set\iref{lex.charset} is replaced by the
+source file character not in the
+\deflinkx{basic source character set}{character set!basic source}{lex.charset}
+is replaced by the
 \indextext{universal character name}\grammarterm{universal-character-name} that
 designates that character. An implementation may use any internal
 encoding, so long as an actual extended character encountered in the
@@ -126,8 +127,8 @@ [lex.phases]
 \item Preprocessing directives are executed, macro invocations are
 expanded, and \tcode{_Pragma} unary operator expressions are executed.
 If a character sequence that matches the syntax of a
-\grammarterm{universal-character-name} is produced by token
-concatenation\iref{cpp.concat}, the behavior is undefined. A
+\grammarterm{universal-character-name} is produced by \link{token
+concatenation}{cpp.concat}, the behavior is undefined. A
 \tcode{\#include} preprocessing directive causes the named header or
 source file to be processed from phase 1 through phase 4, recursively.
 All preprocessing directives are then deleted.
@@ -325,7 +326,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.
 
@@ -942,7 +943,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|)}
 
@@ -1931,12 +1932,12 @@ [lex.ext]
 characters that could match that non-terminal.
 
 \pnum
-A \grammarterm{user-defined-literal} is treated as a call to a literal operator or
-literal operator template\iref{over.literal}. To determine the form of this call for a
+A \grammarterm{user-defined-literal} is treated as a call to a \deflinkx{literal operator}{literal!operator}{over.literal} or
+\deflinkx{literal operator template}{literal!operator!template}{over.literal}. To determine the form of this call for a
 given \grammarterm{user-defined-literal} \placeholder{L} with \grammarterm{ud-suffix} \placeholder{X},
 the \grammarterm{literal-operator-id} whose literal suffix identifier is \placeholder{X} is
-looked up in the context of \placeholder{L} using the rules for unqualified name
-lookup\iref{basic.lookup.unqual}. Let \placeholder{S} be the set of declarations found by
+looked up in the context of \placeholder{L} using the rules for \link{unqualified name
+lookup}{basic.lookup.unqual}. Let \placeholder{S} be the set of declarations found by
 this lookup. \placeholder{S} shall not be empty.
 
 \pnum
@@ -2011,7 +2012,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 c0f31742..37cd7cb8 100644
--- a/source/basic.tex
+++ b/source/basic.tex
@@ -50,7 +50,7 @@ [basic.pre]
 \pnum
 Every name that denotes an entity is introduced by a
 \defn{declaration}. Every name that denotes a label is introduced
-either by a \tcode{goto} statement\iref{stmt.goto} or a
+either by a \link{\tcode{goto} statement}{stmt.goto} or a
 \grammarterm{labeled-statement}\iref{stmt.label}.
 
 \pnum
@@ -61,10 +61,10 @@ [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{*this} object\iref{expr.prim.this}.
+or the \link{\tcode{*this} object}{expr.prim.this}.
 
 \pnum
 Some names denote types or templates. In general,
@@ -92,7 +92,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}
@@ -101,7 +101,7 @@ [basic.def]
 \indextext{declaration!definition versus}%
 \indextext{declaration}%
 \indextext{declaration!name}%
-A declaration\iref{dcl.dcl} may introduce
+A \link{declaration}{dcl.dcl} may introduce
 one or more names into a translation
 unit or redeclare names introduced by previous declarations.
 If so, the
@@ -111,7 +111,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}
 
@@ -167,7 +167,7 @@ [basic.def]
 \item
 it is a
 \indextext{declaration!\idxcode{typedef}}%
-\tcode{typedef} declaration\iref{dcl.typedef},
+\link{\tcode{typedef}}{dcl.typedef} declaration,
 \item it is
 an \grammarterm{alias-declaration}\iref{dcl.typedef},
 \item it is
@@ -195,7 +195,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.
@@ -237,7 +237,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
@@ -282,7 +282,7 @@ [basic.def]
 In the definition of an object,
 the type of that object shall not be
 an incomplete type\iref{basic.types},
-an abstract class type\iref{class.abstract}, or
+an \link{abstract class type}{class.abstract}, or
 a (possibly multi-dimensional) array thereof.
 
 \rSec1[basic.def.odr]{One-definition rule}%
@@ -310,7 +310,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
@@ -320,16 +320,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}
@@ -441,12 +440,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 declarative region\iref{basic.scope.declarative} if:
+A \deflinkx{local entity}{entity!local}{basic.pre}
+is \defn{odr-usable} in a \deflink{declarative region}{basic.scope.declarative} if:
 \begin{itemize}
 \item either the local entity is not \tcode{*this}, or
 an enclosing class or non-lambda function parameter scope exists and,
@@ -489,7 +488,7 @@ [basic.def.odr]
 \pnum
 Every program shall contain exactly one definition of every non-inline
 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},
@@ -537,9 +536,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
@@ -550,21 +549,21 @@ [basic.def.odr]
 \ref{expr.dynamic.cast}, \ref{expr.static.cast}, \ref{expr.cast}), or
 \item an expression that is not a null pointer constant, and has type
 other than \cv{}~\tcode{void*}, is converted to the type pointer to \tcode{T}
-or reference to \tcode{T} using a standard conversion\iref{conv},
-a \tcode{dynamic_cast}\iref{expr.dynamic.cast} or
-a \tcode{static_cast}\iref{expr.static.cast}, or
-\item a class member access operator is applied to an expression of type
-\tcode{T}\iref{expr.ref}, or
-\item the \tcode{typeid} operator\iref{expr.typeid} or the
-\tcode{sizeof} operator\iref{expr.sizeof} is applied to an operand of
+or reference to \tcode{T} using a \link{standard conversion}{conv},
+a \link{\tcode{dynamic_cast}}{expr.dynamic.cast} or
+a \link{\tcode{static_cast}}{expr.static.cast}, or
+\item a \link{class member access}{expr.ref} operator is applied to an expression of type
+\tcode{T}, or
+\item the \link{\tcode{typeid} operator}{expr.typeid} or the
+\link{\tcode{sizeof} operator}{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
-\tcode{alignof} expression\iref{expr.alignof}, or
+\link{\tcode{alignof} expression}{expr.alignof}, or
 \item an \grammarterm{exception-declaration} has type \tcode{T}, reference to
 \tcode{T}, or pointer to \tcode{T}\iref{except.handle}.
 \end{itemize}
@@ -606,7 +605,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}
@@ -800,7 +799,7 @@ [basic.scope.declarative]
 \pnum
 The names declared by a declaration are introduced into the scope in
 which the declaration occurs, except that the presence of a
-\tcode{friend} specifier\iref{class.friend}, certain uses of the
+\link{\tcode{friend} specifier}{class.friend}, certain uses of the
 \grammarterm{elaborated-type-specifier}\iref{dcl.type.elab}, and
 \grammarterm{using-directive}{s}\iref{namespace.udir} alter this general
 behavior.
@@ -1080,7 +1079,7 @@ [basic.funscope]
 
 \pnum
 \indextext{label!scope of}%
-Labels\iref{stmt.label} have \defnx{function scope}{scope!function} and
+\link{Labels}{stmt.label} have \defnx{function scope}{scope!function} and
 may be used anywhere in the function in which they are declared. Only
 labels have function scope.
 
@@ -1094,8 +1093,8 @@ [basic.scope.namespace]
 namespace, and names introduced by these declarations into the
 declarative region of the namespace are said to be \defn{member
 names} of the namespace. A namespace member name has namespace scope.
-Its potential scope includes its namespace from the name's point of
-declaration\iref{basic.scope.pdecl} onwards; and for each
+Its potential scope includes its namespace from the name's \link{point of
+declaration}{basic.scope.pdecl} onwards; and for each
 \grammarterm{using-directive}\iref{namespace.udir} that nominates the
 member's namespace, the member's potential scope includes that portion
 of the potential scope of the \grammarterm{using-directive} that follows
@@ -1128,7 +1127,7 @@ [basic.scope.namespace]
 \end{example}
 
 \pnum
-If a translation unit $Q$ is imported into a translation unit $R$\iref{module.import},
+If a translation unit $Q$ is \link{imported}{module.import} into a translation unit $R$,
 the potential scope of a name $X$ declared with namespace scope in $Q$
 is extended to include the portion of the corresponding namespace
 scope in $R$ following the first \grammarterm{module-import-declaration}
@@ -1206,8 +1205,8 @@ [basic.scope.class]
 definitions, and member function definitions, including the member function
 body and any portion of the
 declarator part of such definitions which follows the \grammarterm{declarator-id},
-including a \grammarterm{parameter-declaration-clause} and any default
-arguments\iref{dcl.fct.default}).
+including a \grammarterm{parameter-declaration-clause} and any \link{default
+arguments}{dcl.fct.default}).
 
 \pnum
 \begin{example}
@@ -1239,8 +1238,8 @@ [basic.scope.class]
 \pnum
 The name of a class member shall only be used as follows:
 \begin{itemize}
-\item in the scope of its class (as described above) or a class derived\iref{class.derived}
-from its class,
+\item in the scope of its class (as described above) or a class
+\link{derived}{class.derived} from its class,
 \item after the \tcode{.} operator applied to an expression of the type
 of its class\iref{expr.ref} or a class derived from its class,
 \item after the \tcode{->} operator applied to a pointer to an object of
@@ -1254,7 +1253,7 @@ [basic.scope.enum]
 \indextext{scope!enumeration}
 
 \pnum
-The name of a scoped enumerator\iref{dcl.enum} has
+The name of a \deflinkx{scoped enumerator}{enumerator!scoped}{dcl.enum} has
 \defn{enumeration scope}. Its potential scope begins at
 its point of declaration and terminates at the end of the
 \grammarterm{enum-specifier}.
@@ -1294,8 +1293,8 @@ [basic.scope.temp]
 \end{example}
 
 \pnum
-The potential scope of a template parameter name begins at its point of
-declaration\iref{basic.scope.pdecl} and ends at the end of its declarative region.
+The potential scope of a template parameter name begins at its \deflinkx{point of
+declaration}{declaration!point of}{basic.scope.pdecl} and ends at the end of its declarative region.
 \begin{note}
 This implies that a \grammarterm{template-parameter} can be used in the
 declaration of subsequent \grammarterm{template-parameter}{s} and their default
@@ -1367,8 +1366,8 @@ [basic.scope.hiding]
 at block scope
 hides
 the declaration of a member of the class with the same name;
-see~\ref{basic.scope.class}. The declaration of a member in a derived
-class\iref{class.derived} hides the declaration of a member of
+see~\ref{basic.scope.class}. The declaration of a member in a \link{derived
+class}{class.derived} hides the declaration of a member of
 a base class of the same name; see~\ref{class.member.lookup}.
 
 \pnum
@@ -1550,8 +1549,8 @@ [basic.lookup.unqual]
 \begin{itemize}
 \item before its use in class \tcode{X} or be a member of a base class
 of \tcode{X}\iref{class.member.lookup}, or
-\item if \tcode{X} is a nested class of class
-\tcode{Y}\iref{class.nest}, before the definition of \tcode{X} in
+\item if \tcode{X} is a \deflinkx{nested class}{class!nested}{class.nest} of class
+\tcode{Y}, before the definition of \tcode{X} in
 \tcode{Y}, or shall be a member of a base class of \tcode{Y} (this
 lookup applies in turn to \tcode{Y}'s enclosing classes, starting with
 the innermost enclosing class),
@@ -1563,7 +1562,7 @@ [basic.lookup.unqual]
 definition\iref{class.nest}.
 \end{footnote}
 or
-\item if \tcode{X} is a local class\iref{class.local} or is a nested
+\item if \tcode{X} is a \link{local class}{class.local} or is a nested
 class of a local class, before the definition of class \tcode{X} in a
 block enclosing the definition of class \tcode{X}, or
 \item if \tcode{X} is a member of namespace \tcode{N}, or is a nested
@@ -1634,7 +1633,7 @@ [basic.lookup.unqual]
 class of \tcode{X}\iref{class.member.lookup}, or
 
 \item if \tcode{X}
-is a nested class of class \tcode{Y}\iref{class.nest}, shall be a
+is a \deflinkx{nested class}{class!nested}{class.nest} of class \tcode{Y}, shall be a
 member of \tcode{Y}, or shall be a member of a base class of \tcode{Y}
 (this lookup applies in turn to \tcode{Y}'s enclosing classes, starting
 with the innermost enclosing class),
@@ -1646,7 +1645,7 @@ [basic.lookup.unqual]
 \end{footnote}
 or
 
-\item if \tcode{X} is a local class\iref{class.local} or is a nested
+\item if \tcode{X} is a \link{local class}{class.local} or is a nested
 class of a local class, before the definition of class \tcode{X} in a
 block enclosing the definition of class \tcode{X}, or
 
@@ -1689,8 +1688,8 @@ [basic.lookup.unqual]
 \end{note}
 
 \pnum
-Name lookup for a name used in the definition of a friend
-function\iref{class.friend} defined inline in the class granting
+Name lookup for a name used in the definition of a \link{friend
+function}{class.friend} defined inline in the class granting
 friendship shall proceed as described for lookup in member function
 definitions. If the friend function is not defined in the class
 granting friendship, name lookup in the friend function
@@ -1726,8 +1725,8 @@ [basic.lookup.unqual]
 \end{example}
 
 \pnum
-During the lookup for a name used as a default
-argument\iref{dcl.fct.default} in a function
+During the lookup for a name used as a \link{default
+argument}{dcl.fct.default} in a function
 \grammarterm{parameter-declaration-clause} or used in the
 \grammarterm{expression} of a \grammarterm{mem-initializer} for a
 constructor\iref{class.base.init}, the function parameter names are
@@ -1747,8 +1746,8 @@ [basic.lookup.unqual]
 scopes containing the \grammarterm{enum-specifier}.
 
 \pnum
-A name used in the definition of a \tcode{static} data member of class
-\tcode{X}\iref{class.static.data} (after the \grammarterm{qualified-id}
+A name used in the definition of a \link{\tcode{static} data member}{class.static.data}
+of class \tcode{X} (after the \grammarterm{qualified-id}
 of the static member) is looked up as if the name was used in a member
 function of \tcode{X}.
 \begin{note}
@@ -1800,8 +1799,8 @@ [basic.lookup.argdep]
 
 \pnum
 When the \grammarterm{postfix-expression} in
-a function call\iref{expr.call} is an \grammarterm{unqualified-id}, other namespaces not considered
-during the usual unqualified lookup\iref{basic.lookup.unqual} may be
+a \link{function call}{expr.call} is an \grammarterm{unqualified-id}, other namespaces not considered
+during the usual \link{unqualified lookup}{basic.lookup.unqual} may be
 searched, and in those namespaces, namespace-scope friend function or
 function template declarations\iref{class.friend} not otherwise
 visible may be found.
@@ -1889,7 +1888,7 @@ [basic.lookup.argdep]
 associated namespaces and entities are those associated with the member
 type together with those associated with \tcode{X}.
 \end{itemize}
-If an associated namespace is an inline namespace\iref{namespace.def}, its
+If an associated namespace is an \deflinkx{inline namespace}{namespace!inline}{namespace.def}, its
 enclosing namespace is also included in the set. If an associated namespace
 directly contains inline namespaces, those inline namespaces are also included
 in the set.
@@ -1904,8 +1903,8 @@ [basic.lookup.argdep]
 \grammarterm{template-argument}{s}.
 
 \pnum
-Let \placeholder{X} be the lookup set produced by unqualified
-lookup\iref{basic.lookup.unqual} and let \placeholder{Y} be the lookup set produced
+Let \placeholder{X} be the lookup set produced by \link{unqualified
+lookup}{basic.lookup.unqual} and let \placeholder{Y} be the lookup set produced
 by argument dependent lookup (defined as follows). If \placeholder{X} contains
 \begin{itemize}
 \item a declaration of a class member, or
@@ -2087,7 +2086,7 @@ [basic.lookup.qual.general]
 whose declaration is visible in global scope because of a
 \grammarterm{using-directive}\iref{namespace.qual}. The use of \tcode{::}
 allows a global name to be referred to even if its identifier has been
-hidden\iref{basic.scope.hiding}.
+\link{hidden}{basic.scope.hiding}.
 
 \pnum
 A name prefixed by a \grammarterm{nested-name-specifier} that
@@ -2159,8 +2158,8 @@ [class.qual]
 
 \item the lookup for a name specified in a
 \grammarterm{using-declaration}\iref{namespace.udecl} also finds class or
-enumeration names hidden within the same
-scope\iref{basic.scope.hiding}.
+enumeration names \link{hidden}{basic.scope.hiding} within the same
+scope.
 \end{itemize}
 
 \pnum
@@ -2415,7 +2414,7 @@ [namespace.qual]
 the
 \grammarterm{unqualified-id} shall name a member of the namespace
 designated by the \grammarterm{nested-name-specifier}
-or of an element of the inline namespace set\iref{namespace.def} of that namespace.
+or of an element of the \deflink{inline namespace set}{namespace.def} of that namespace.
 \begin{example}
 \begin{codeblock}
 namespace A {
@@ -2459,8 +2458,9 @@ [basic.lookup.elab]
 \pnum
 An \grammarterm{elaborated-type-specifier}\iref{dcl.type.elab} may be
 used to refer to a previously declared \grammarterm{class-name} or
-\grammarterm{enum-name} even though the name has been hidden by a non-type
-declaration\iref{basic.scope.hiding}.
+\grammarterm{enum-name} even though the name has been
+\link{hidden}{basic.scope.hiding} by a non-type
+declaration.
 
 \pnum
 If the \grammarterm{elaborated-type-specifier} has no
@@ -2532,7 +2532,7 @@ [basic.lookup.classref]
 
 \pnum
 \indextext{lookup!class member}%
-In a class member access expression\iref{expr.ref}, if the \tcode{.}
+In a \link{class member access}{expr.ref} expression, if the \tcode{.}
 or \tcode{->} token is immediately followed by an \grammarterm{identifier}
 followed by a \tcode{<}, the identifier is looked up to determine
 whether the \tcode{<} is the beginning of a template argument
@@ -2544,8 +2544,8 @@ [basic.lookup.classref]
 whose specializations are types.
 
 \pnum
-If the \grammarterm{id-expression} in a class member
-access\iref{expr.ref} is an \grammarterm{unqualified-id}, and the type of
+If the \grammarterm{id-expression} in a \link{class member
+access}{expr.ref} is an \grammarterm{unqualified-id}, and the type of
 the object expression is of a class type \tcode{C}, the
 \grammarterm{unqualified-id} is looked up
 in the scope of class \tcode{C}\iref{class.member.lookup}.
@@ -2648,7 +2648,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.
 
@@ -2671,7 +2671,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},
@@ -2690,7 +2690,7 @@ [basic.link]
 \indextext{\idxcode{const}!linkage of}%
 \indextext{linkage!\idxcode{inline} and}%
 \indextext{\idxcode{inline}!linkage of}%
-A name having namespace scope\iref{basic.scope.namespace} has internal
+A name having \link{namespace scope}{basic.scope.namespace} has internal
 linkage if it is the name of
 \begin{itemize}
 \item
@@ -2728,7 +2728,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
@@ -2825,7 +2825,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}{block (statement)!scope}{basic.scope.block} has no
 linkage.
 
 \pnum
@@ -2895,7 +2895,7 @@ [basic.link]
 \indextext{consistency!type declaration}%
 \indextext{declaration!multiple}%
 After all adjustments of types (during which
-typedefs\iref{dcl.typedef} are replaced by their definitions), the
+\link{typedefs}{dcl.typedef} are replaced by their definitions), the
 types specified by all declarations referring to a given variable or
 function shall be identical, except that declarations for an array
 object can specify array types that differ by the presence or absence of
@@ -3075,7 +3075,7 @@ [intro.memory]
 \indextext{memory model|(}%
 The fundamental storage unit in the \Cpp{} memory model is the
 \defn{byte}.
-A byte is at least large enough to contain any member of the basic
+A byte is at least large enough to contain any member of the
 \indextext{character set!basic execution}%
 execution character set\iref{lex.charset}
 and the eight-bit code units of the Unicode
@@ -3112,8 +3112,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
@@ -3157,15 +3157,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~(\ref{conv.rval}, \ref{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}
@@ -3294,7 +3294,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
@@ -3315,7 +3315,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
@@ -3728,16 +3728,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~(\ref{conv.integral},
     \ref{expr.type.conv}, \ref{expr.static.cast}, \ref{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
@@ -3796,8 +3796,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}.
 
@@ -3808,7 +3808,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.
@@ -3895,8 +3895,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}}%
@@ -4056,19 +4056,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}
@@ -4147,12 +4147,11 @@ [basic.stc.dynamic.safety]
 \indextext{pointer!to traceable object}%
 A \defn{traceable pointer object} is
 \begin{itemize}
-\item an object of an object pointer
-type\iref{basic.compound}, or
+\item an object of an \deflink{object pointer type}{basic.compound}, or
 \item an object of an integral type that is at least as large as \tcode{std::intptr_t},
 or
-\item a sequence of elements in an array of narrow character
-type\iref{basic.fundamental}, where the size and alignment of the sequence
+\item a sequence of elements in an array of
+\deflinkx{narrow character type}{type!narrow character}{basic.fundamental}, where the size and alignment of the sequence
 match those of some object pointer type.
 \end{itemize}
 
@@ -4254,7 +4253,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
@@ -4307,8 +4306,8 @@ [basic.align]
 
 \pnum
 The alignment requirement of a complete type can be queried using an
-\tcode{alignof} expression\iref{expr.alignof}. Furthermore,
-the narrow character types\iref{basic.fundamental} shall have the weakest
+\link{\tcode{alignof} expression}{expr.alignof}. Furthermore,
+the \deflinkx{narrow character types}{type!narrow character}{basic.fundamental} shall have the weakest
 alignment requirement.
 \begin{note}
 This enables the ordinary character types to be used as the
@@ -4720,9 +4719,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
@@ -4874,7 +4873,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}.
 Scalar types, trivially copyable class types\iref{class.prop},
@@ -4898,14 +4897,14 @@ [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},
 \item it is either a closure type\iref{expr.prim.lambda.closure},
 an aggregate type\iref{dcl.init.aggr}, or
 has at least one constexpr constructor or constructor template
-(possibly inherited\iref{namespace.udecl} from a base class)
+(possibly \deflinkx{inherited}{inheritance}{class.derived} from a base class)
 that is not a copy or move constructor,
 \item if it is a union, at least one of its non-static data members is
 of non-volatile literal type, and
@@ -4927,8 +4926,8 @@ [basic.types.general]
 Two types \cvqual{cv1} \tcode{T1} and \cvqual{cv2} \tcode{T2} are
 \defn{layout-compatible} types
 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}
 
@@ -5182,7 +5181,7 @@ [basic.fundamental]
 called \defnx{arithmetic}{type!arithmetic} types.
 \indextext{\idxcode{numeric_limits}!specializations for arithmetic types}%
 Specializations of the standard library template
-\tcode{std::numeric_limits}\iref{numeric.limits} shall specify the
+\link{\tcode{std::numeric_limits}}{numeric.limits} shall specify the
 maximum and minimum values of each arithmetic type for an
 implementation.
 
@@ -5195,17 +5194,17 @@ [basic.fundamental]
 explicitly converted to type \cv{}~\tcode{void}~(\ref{expr.type.conv},
 \ref{expr.static.cast}, \ref{expr.cast}).
 An expression of type \cv{}~\tcode{void} shall
-be used only as an expression statement\iref{stmt.expr}, as an operand
-of a comma expression\iref{expr.comma}, as a second or third operand
+be used only as an \link{expression statement}{stmt.expr}, as an operand
+of a \link{comma expression}{expr.comma}, as a second or third operand
 of \tcode{?:}\iref{expr.cond}, as the operand of
 \tcode{typeid}, \tcode{noexcept}, or \tcode{decltype}, as
-the expression in a \tcode{return} statement\iref{stmt.return} for a function
+the expression in a \link{\tcode{return} statement}{stmt.return} for a function
 with the return type \cv{}~\tcode{void}, or as the operand of an explicit conversion
 to type \cv{}~\tcode{void}.
 
 \pnum
-A value of type \tcode{std::nullptr_t} is a null pointer
-constant\iref{conv.ptr}. Such values participate in the pointer and the
+A value of type \tcode{std::nullptr_t} is a \deflinkx{null pointer
+constant}{constant!null pointer}{conv.ptr}. Such values participate in the pointer and the
 pointer-to-member conversions~(\ref{conv.ptr}, \ref{conv.mem}).
 \tcode{sizeof(std::nullptr_t)} shall be equal to \tcode{sizeof(void*)}.
 
@@ -5267,7 +5266,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
@@ -5349,7 +5348,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}
@@ -5376,7 +5375,7 @@ [basic.compound]
 then they have the same address,
 and it is possible to obtain a pointer to one
 from a pointer to the other
-via a \tcode{reinterpret_cast}\iref{expr.reinterpret.cast}.
+via a \link{\tcode{reinterpret_cast}}{expr.reinterpret.cast}.
 \begin{note}
 An array object and its first element are not pointer-interconvertible,
 even though they have the same address.
@@ -5566,8 +5565,8 @@ [basic.exec]
 \rSec2[intro.execution]{Sequential 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).
@@ -5608,7 +5607,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
@@ -5630,7 +5629,7 @@ [intro.execution]
 A \defn{full-expression} is
 \begin{itemize}
 \item
-an unevaluated operand\iref{expr.prop},
+an \deflink{unevaluated operand}{expr.prop},
 \item
 a \grammarterm{constant-expression}\iref{expr.const},
 \item
diff --git a/source/expressions.tex b/source/expressions.tex
index 6e2c9933..83fbeb64 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
@@ -210,7 +210,7 @@ [basic.lval]
 \begin{example}
 \begin{codeblock}
 struct A {
-  int m;
+int m;
 };
 A&& operator+(A, A);
 A&& f();
@@ -245,8 +245,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}.
@@ -266,7 +266,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
@@ -296,9 +296,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}
@@ -371,9 +371,9 @@ [expr.type]
 
 \item
 if \tcode{T1} is ``pointer to \cvqual{cv1} \tcode{C1}'' and \tcode{T2} is ``pointer to
-\cvqual{cv2} \tcode{C2}'', where \tcode{C1} is reference-related to \tcode{C2} or \tcode{C2} is
-reference-related to \tcode{C1}\iref{dcl.init.ref},
-the cv-combined type\iref{conv.qual}
+\cvqual{cv2} \tcode{C2}'', where \tcode{C1} is \deflink{reference-related}{dcl.init.ref} to \tcode{C2} or \tcode{C2} is
+reference-related to \tcode{C1},
+the \deflinkx{cv-combined type}{type!cv-combined}{conv.qual}
 of \tcode{T1} and \tcode{T2} or the cv-combined type of \tcode{T2} and \tcode{T1},
 respectively;
 
@@ -382,8 +382,8 @@ [expr.type]
 ``pointer to member of \tcode{C1} of type function'',
 the other type is
 ``pointer to member of \tcode{C2} of type \tcode{noexcept} function'', and
-\tcode{C1} is reference-related to \tcode{C2} or
-\tcode{C2} is reference-related to \tcode{C1}\iref{dcl.init.ref},
+\tcode{C1} is \deflink{reference-related}{dcl.init.ref} to \tcode{C2} or
+\tcode{C2} is reference-related to \tcode{C1},
 where the function types are otherwise the same,
 ``pointer to member of \tcode{C2} of type function'' or
 ``pointer to member of \tcode{C1} of type function'', respectively;
@@ -395,12 +395,12 @@ [expr.type]
 ``pointer to member of \tcode{C2} of type \cvqual{cv2} \tcode{U}'',
 for some non-function type \tcode{U},
 where \tcode{C1} is
-reference-related to \tcode{C2} or \tcode{C2} is reference-related to
-\tcode{C1}\iref{dcl.init.ref}, the cv-combined type of \tcode{T2} and \tcode{T1} or the cv-combined type
+\deflink{reference-related}{dcl.init.ref} to \tcode{C2} or \tcode{C2} is reference-related to
+\tcode{C1}, the cv-combined type of \tcode{T2} and \tcode{T1} or the cv-combined type
 of \tcode{T1} and \tcode{T2}, respectively;
 
 \item
-if \tcode{T1} and \tcode{T2} are similar types\iref{conv.qual}, the cv-combined type of \tcode{T1} and
+if \tcode{T1} and \tcode{T2} are \deflink{similar types}{conv.qual}, the cv-combined type of \tcode{T1} and
 \tcode{T2};
 
 \item
@@ -437,31 +437,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}
@@ -469,7 +469,7 @@ [expr.context]
 above covers only operators with built-in meaning.
 \end{note}
 If the (possibly converted) expression is a prvalue,
-the temporary materialization conversion\iref{conv.rval} is applied.
+the \link{temporary materialization conversion}{conv.rval} is applied.
 \begin{note}
 If the expression is an lvalue of
 class type, it must have a volatile copy constructor to initialize the
@@ -599,7 +599,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}
@@ -624,18 +624,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
@@ -790,11 +790,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}
@@ -1020,7 +1020,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
@@ -1108,7 +1108,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.
 
@@ -1215,7 +1215,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}
@@ -1230,10 +1230,10 @@ [expr.prim.this]
 \end{note}
 
 \pnum
-Otherwise, if a \grammarterm{member-declarator} declares a non-static data
-member\iref{class.mem} of a class \tcode{X}, the expression \tcode{this} is
+Otherwise, if a \grammarterm{member-declarator} declares a non-static \link{data
+member}{class.mem} of a class \tcode{X}, the expression \tcode{this} is
 a prvalue of type ``pointer to \tcode{X}'' within the
-optional default member initializer\iref{class.mem}. It shall not appear elsewhere
+optional \deflink{default member initializer}{class.mem}. It shall not appear elsewhere
 in the \grammarterm{member-declarator}.
 
 \pnum
@@ -1281,15 +1281,15 @@ [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
 An \grammarterm{id-expression} that denotes a non-static data member or
 non-static 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}
@@ -1316,11 +1316,11 @@ [expr.prim.id.general]
 
 \pnum
 A potentially-evaluated \grammarterm{id-expression}
-that denotes an immediate function\iref{dcl.constexpr}
+that denotes an \deflinkx{immediate function}{function!immediate}{dcl.constexpr}
 shall appear only
 \begin{itemize}
 \item as a subexpression of an immediate invocation, or
-\item in an immediate function context\iref{expr.const}.
+\item in an \deflink{immediate function context}{expr.const}.
 \end{itemize}
 
 \pnum
@@ -1348,7 +1348,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{expr.prop}.
+\tcode{f} is an \deflink{unevaluated operand}{expr.prop}.
 \end{example}
 \end{note}
 
@@ -1414,7 +1414,7 @@ [expr.prim.id.unqual]
 if it is cv-qualified or is a reference type.
 \end{note}
 The expression is 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.
@@ -1465,7 +1465,7 @@ [expr.prim.id.qual]
 A \grammarterm{nested-name-specifier} that denotes a class, optionally
 followed by the keyword \keyword{template}\iref{temp.names}, and then
 followed by the name of a member of either that class\iref{class.mem}
-or one of its base classes\iref{class.derived}, is a
+or one of its \link{base classes}{class.derived}, is a
 \indextext{id!qualified}%
 \grammarterm{qualified-id};~\ref{class.qual} describes name lookup for
 class members that appear in \grammarterm{qualified-id}{s}. The result is the
@@ -1499,7 +1499,7 @@ [expr.prim.id.qual]
 
 \pnum
 A \grammarterm{nested-name-specifier} that denotes an
-enumeration\iref{dcl.enum}, followed by the name of an
+\link{enumeration}{dcl.enum}, followed by the name of an
 enumerator of that enumeration, is a \grammarterm{qualified-id}
 that refers to the enumerator. The result is the enumerator. The type
 of the result is the type of the enumeration. The result is a prvalue.
@@ -1593,8 +1593,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
@@ -1652,7 +1652,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:
@@ -1799,7 +1799,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 \tcode{noexcept} function''
 if the function call operator
@@ -1898,8 +1898,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); };
@@ -1916,8 +1916,8 @@ [expr.prim.lambda.closure]
 \pnum
 The \grammarterm{lambda-expression}'s \grammarterm{compound-statement} yields the
 \grammarterm{function-body}\iref{dcl.fct.def} of the function call operator, but for
-purposes of name lookup\iref{basic.lookup}, determining the type and value of
-\tcode{this}\iref{class.this} and transforming \grammarterm{id-expression}{s}
+purposes of \link{name lookup}{basic.lookup}, determining the type and value of
+\link{\tcode{this}}{class.this} and transforming \grammarterm{id-expression}{s}
 referring to non-static class members into class member access expressions using
 \tcode{(*this)}~(\ref{class.mfct.non-static}), the \grammarterm{compound-statement} is
 considered in the context of the \grammarterm{lambda-expression}.
@@ -1959,9 +1959,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}%
 
@@ -2054,7 +2054,7 @@ [expr.prim.lambda.capture]
 
 \pnum
 The \grammarterm{identifier} in a \grammarterm{simple-capture} is looked up using the
-usual rules for unqualified name lookup\iref{basic.lookup.unqual}; each such lookup
+usual rules for \link{unqualified name lookup}{basic.lookup.unqual}; each such lookup
 shall find a local entity.
 The \grammarterm{simple-capture}{s} \tcode{this} and \tcode{* this}
 denote the local entity \tcode{*this}.
@@ -2295,7 +2295,7 @@ [expr.prim.lambda.capture]
 
 \pnum
 Every \grammarterm{id-expression} within the \grammarterm{compound-statement} of a
-\grammarterm{lambda-expression} that is an odr-use\iref{basic.def.odr} of an
+\grammarterm{lambda-expression} that is an \link{odr-use}{basic.def.odr} of an
 entity captured by copy is transformed into an access to the corresponding unnamed data
 member of the closure type.
 \begin{note}
@@ -2512,7 +2512,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}
@@ -2548,7 +2548,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{expr.prop}.
+are \deflinkx{unevaluated operands}{unevaluated operand}{expr.prop}.
 
 \pnum
 \begin{example}
@@ -2646,7 +2646,7 @@ [expr.prim.req.simple]
 \begin{note}
 The enclosing \grammarterm{requires-expression} will evaluate to \tcode{false}
 if substitution of template arguments into the \grammarterm{expression} fails.
-The \grammarterm{expression} is an unevaluated operand\iref{expr.prop}.
+The \grammarterm{expression} is an \deflink{unevaluated operand}{expr.prop}.
 \end{note}
 \begin{example}
 \begin{codeblock}
@@ -2820,7 +2820,7 @@ [expr.prim.req.nested]
 \end{example}
 
 \pnum
-A local parameter shall only appear as an unevaluated operand\iref{expr.prop}
+A local parameter shall only appear as an \deflink{unevaluated operand}{expr.prop}
 within the \grammarterm{constraint-expression}.
 \begin{example}
 \begin{codeblock}
@@ -2904,7 +2904,7 @@ [expr.sub]
 
 \pnum
 \begin{note}
-A comma expression\iref{expr.comma}
+A \link{comma expression}{expr.comma}
 appearing as the \grammarterm{expr-or-braced-init-list}
 of a subscripting expression is deprecated;
 see \ref{depr.comma.subscript}.
@@ -2948,9 +2948,9 @@ [expr.call]
 For a call to a non-static member function,
 the postfix expression shall be an
 implicit~(\ref{class.mfct.non-static}, \ref{class.static}) or explicit
-class member access\iref{expr.ref} whose \grammarterm{id-expression} is a
-function member name, or a pointer-to-member
-expression\iref{expr.mptr.oper} selecting a function member; the call is as a member of
+\link{class member access}{expr.ref} whose \grammarterm{id-expression} is a
+function member name, or a \link{pointer-to-member
+expression}{expr.mptr.oper} selecting a function member; the call is as a member of
 the class object referred to by the
 object expression. In the case of an implicit class
 member access, the implied object is the one pointed to by \tcode{this}.
@@ -2963,7 +2963,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}
@@ -2976,8 +2976,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}
@@ -3021,9 +3021,9 @@ [expr.call]
 \end{codeblock}
 \end{example}
 If the function is a non-static member
-function, the \tcode{this} parameter of the function\iref{class.this}
+function, the \link{\tcode{this} parameter}{class.this} of the function
 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)
@@ -3102,7 +3102,7 @@ [expr.call]
 
 \pnum
 The result of a function call is the result of the possibly-converted operand
-of the \tcode{return} statement\iref{stmt.return}
+of the \link{\tcode{return} statement}{stmt.return}
 that transferred control out of the called function (if any),
 except in a virtual function call if the return type of the
 final overrider is different from the return type of the statically
@@ -3132,10 +3132,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.
@@ -3145,7 +3145,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},
@@ -3153,11 +3153,11 @@ [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{void*}\iref{conv.ptr}.
+An argument that has type \cv{}~\tcode{std::nullptr_t} is \link{converted}{conv.ptr}
+to type \tcode{void*}.
 After these conversions, if the
 argument does not have arithmetic, enumeration, pointer, pointer-to-member,
 or class type, the program is ill-formed. Passing a potentially-evaluated
@@ -3169,16 +3169,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
@@ -3194,8 +3194,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)
@@ -3206,14 +3206,13 @@ [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.
 
 \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{}~\tcode{void}
 and the initializer is \tcode{()} or \tcode{\{\}}
@@ -3222,7 +3221,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.
@@ -3483,8 +3482,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.
@@ -3518,9 +3517,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}%
@@ -3601,13 +3600,13 @@ [expr.typeid]
 When \tcode{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{expr.prop}.
+The expression is an \deflink{unevaluated operand}{expr.prop}.
 
 \pnum
 When \tcode{typeid} is applied to a \grammarterm{type-id}, the result
@@ -3664,15 +3663,15 @@ [expr.static.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. The \tcode{static_cast} operator shall not cast
-away constness\iref{expr.const.cast}.
+otherwise, the result is a prvalue. The \tcode{static_cast} operator shall not
+\deflinkx{cast away constness}{casting away constness}{expr.const.cast}.
 
 \pnum
 \indextext{cast!static!reference}%
 \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}
@@ -3703,11 +3702,11 @@ [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
 \grammarterm{expression} of the \tcode{static_cast} for the remainder of this subclause.
-If \tcode{T2} is an inaccessible\iref{class.access} or
-ambiguous\iref{class.member.lookup} base class of \tcode{T1},
+If \tcode{T2} is an \link{inaccessible}{class.access} or
+\link{ambiguous}{class.member.lookup} base class of \tcode{T1},
 a program that necessitates such a cast is ill-formed.
 
 \pnum
@@ -3745,11 +3744,10 @@ [expr.static.cast]
 
 \pnum
 Any expression can be explicitly converted to type \cv{}~\tcode{void},
-in which case it becomes a discarded-value
-expression\iref{expr.prop}.
+in which case it becomes a \deflink{discarded-value expression}{expr.prop}.
 \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.
@@ -3757,13 +3755,13 @@ [expr.static.cast]
 
 
 \pnum
-The inverse of any standard conversion sequence\iref{conv} not containing an
-lvalue-to-rvalue\iref{conv.lval},
-array-to-pointer\iref{conv.array},
-function-to-pointer\iref{conv.func},
-null pointer\iref{conv.ptr}, null member pointer\iref{conv.mem},
-boolean\iref{conv.bool}, or
-function pointer\iref{conv.fctptr}
+The inverse of any \link{standard conversion sequence}{conv} not containing an
+\link{lvalue-to-rvalue}{conv.lval},
+\link{array-to-pointer}{conv.array},
+\link{function-to-pointer}{conv.func},
+\link{null pointer}{conv.ptr}, \link{null member pointer}{conv.mem},
+\link{boolean}{conv.bool}, or
+\link{function pointer}{conv.fctptr}
 conversion, can be performed explicitly using \tcode{static_cast}. A
 program is ill-formed if it uses \tcode{static_cast} to perform the
 inverse of an ill-formed standard conversion sequence.
@@ -3779,12 +3777,12 @@ [expr.static.cast]
 \end{example}
 
 \pnum
-The lvalue-to-rvalue\iref{conv.lval},
-array-to-pointer\iref{conv.array}, and
-function-to-pointer\iref{conv.func} conversions are applied to the
+The \link{lvalue-to-rvalue}{conv.lval},
+\link{array-to-pointer}{conv.array}, and
+\link{function-to-pointer}{conv.func} conversions are applied to the
 operand. Such a \tcode{static_cast} is subject to the restriction that
-the explicit conversion does not cast away
-constness\iref{expr.const.cast}, and the following additional rules
+the explicit conversion does not \deflinkx{cast away
+constness}{casting away constness}{expr.const.cast}, and the following additional rules
 for specific cases:
 
 \pnum
@@ -3822,7 +3820,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}.
@@ -3843,7 +3842,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}
@@ -3854,7 +3853,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
@@ -3877,7 +3876,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 \tcode{T} (ignoring cv-qualification)
-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}
@@ -3900,14 +3899,14 @@ [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 \tcode{reinterpret_cast} are listed below. No other conversion can
 be performed explicitly using \tcode{reinterpret_cast}.
 
 \pnum
-The \tcode{reinterpret_cast} operator shall not cast away constness\iref{expr.const.cast}.
+The \tcode{reinterpret_cast} operator shall not \deflinkx{cast away constness}{casting away constness}{expr.const.cast}.
 An expression of integral, enumeration, pointer, or pointer-to-member type
 can be explicitly converted to its own type; such a cast yields the value of
 its operand.
@@ -4074,8 +4073,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
 \tcode{const_cast} are listed below. No other conversion shall be
 performed explicitly using \tcode{const_cast}.
@@ -4087,7 +4086,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 \tcode{const_cast}
 if, considering the cv-decompositions of both types,
@@ -4123,7 +4122,7 @@ [expr.const.cast]
 
 The result of a reference \tcode{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
@@ -4149,7 +4148,7 @@ [expr.const.cast]
 A conversion from a type \tcode{T1} to a type \tcode{T2}
 \defnx{casts away constness}{casting away constness}
 if \tcode{T1} and \tcode{T2} are different,
-there is a cv-decomposition\iref{conv.qual} of \tcode{T1}
+there is a \deflink{cv-decomposition}{conv.qual} of \tcode{T1}
 yielding \placeholder{n} such that
 \tcode{T2} has a cv-decomposition of the form
 \begin{indented}
@@ -4314,7 +4313,7 @@ [expr.unary.op]
 \pnum
 \indextext{overloaded function!address of}%
 \begin{note}
-The address of an overloaded function\iref{over} can be taken
+The address of an \link{overloaded function}{over} can be taken
 only in a context that uniquely determines which version of the
 overloaded function is referred to (see~\ref{over.over}).
 Since the context might determine whether the operand is a static or
@@ -4341,8 +4340,9 @@ [expr.unary.op]
 
 \pnum
 \indextext{operator!logical negation}%
-The operand of the logical negation operator \tcode{!} is contextually
-converted to \tcode{bool}\iref{conv};
+The operand of the logical negation operator \tcode{!} is
+\deflinkx{contextually converted to \tcode{bool}}
+{conversion!contextual to \tcode{bool}}{conv};
 its value is \tcode{true}
 if the converted operand is \tcode{false} and \tcode{false} otherwise.
 The type of the result is \tcode{bool}.
@@ -4387,8 +4387,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
@@ -4647,7 +4647,7 @@ [expr.sizeof]
 function-to-pointer\iref{conv.func} standard conversions are not
 applied to the operand of \tcode{sizeof}.
 If the operand is a prvalue,
-the temporary materialization conversion\iref{conv.rval}
+the \link{temporary materialization conversion}{conv.rval}
 is applied.
 
 \pnum
@@ -4789,7 +4789,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:
@@ -4845,9 +4845,8 @@ [expr.new]
 \end{codeblock}
 
 Instead, the explicitly parenthesized version of the \tcode{new}
-operator can be used to create objects of compound
-types\iref{basic.compound}:
-
+operator can be used to create objects of \link{compound
+types}{basic.compound}:
 \begin{codeblock}
 new (int (*[10])());
 \end{codeblock}
@@ -4928,7 +4927,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
@@ -4953,7 +4952,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
@@ -4963,8 +4962,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}}%
@@ -5079,7 +5078,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}%
@@ -5170,7 +5169,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}%
@@ -5314,8 +5313,8 @@ [expr.delete]
 
 \pnum
 \indextext{expression!\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}
@@ -5336,7 +5335,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}
@@ -5357,8 +5356,9 @@ [expr.delete]
 \tcode{delete} may be a null pointer value, a pointer to a non-array object
 created by a previous \grammarterm{new-expression},
 or a pointer to a
-subobject\iref{intro.object} representing a base class of such an
-object\iref{class.derived}. If not, the behavior is undefined.
+\deflink{subobject}{intro.object} representing a
+\link{base class}{class.derived} of such an
+object. If not, the behavior is undefined.
 \indextext{array!\idxcode{delete}}%
 In an array delete expression, the value of the operand of \tcode{delete}
 may be a null pointer value or a pointer value that resulted from
@@ -5377,8 +5377,9 @@ [expr.delete]
 \end{note}
 \begin{note}
 A pointer to a \tcode{const} type can be the operand of a
-\grammarterm{delete-expression}; it is not necessary to cast away the
-constness\iref{expr.const.cast} of the pointer expression before it is
+\grammarterm{delete-expression}; it is not necessary to
+\deflinkx{cast away the constness}{casting away constness}{expr.const.cast}
+of the pointer expression before it is
 used as the operand of the \grammarterm{delete-expression}.
 \end{note}
 
@@ -5424,8 +5425,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.
 
@@ -5574,8 +5575,8 @@ [expr.cast]
 \end{note}
 
 \pnum
-An explicit type conversion can be expressed using functional
-notation\iref{expr.type.conv}, a type conversion operator
+An explicit type conversion can be expressed using \link{functional
+notation}{expr.type.conv}, a type conversion operator
 (\tcode{dynamic_cast}, \tcode{static_cast}, \tcode{reinterpret_cast},
 \tcode{const_cast}), or the \term{cast} notation.
 
@@ -5595,10 +5596,10 @@ [expr.cast]
 \indextext{cast!const}%
 \indextext{cast!static}%
 \indextext{cast!reinterpret}%
-\item a \tcode{const_cast}\iref{expr.const.cast},
-\item a \tcode{static_cast}\iref{expr.static.cast},
+\item a \link{\tcode{const_cast}}{expr.const.cast},
+\item a \link{\tcode{static_cast}}{expr.static.cast},
 \item a \tcode{static_cast} followed by a \tcode{const_cast},
-\item a \tcode{reinterpret_cast}\iref{expr.reinterpret.cast}, or
+\item a \link{\tcode{reinterpret_cast}}{expr.reinterpret.cast}, or
 \item a \tcode{reinterpret_cast} followed by a \tcode{const_cast},
 \end{itemize}
 can be performed using the cast notation of explicit type conversion.
@@ -5750,8 +5751,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}%
@@ -5780,7 +5781,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
@@ -5808,7 +5809,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}%
@@ -5906,7 +5907,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{note}
 In particular, a pointer to a base class cannot be used for
 pointer arithmetic when the array contains objects of a derived class type.
@@ -5992,12 +5993,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.
 
@@ -6039,13 +6040,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
@@ -6079,8 +6080,8 @@ [expr.spaceship]
 if the header \libheaderref{compare}
 is not imported or included prior to a use of such a class type --
 even an implicit use in which the type is not named
-(e.g., via the \tcode{auto} specifier\iref{dcl.spec.auto}
-in a defaulted three-way comparison\iref{class.spaceship}
+(e.g., via the \link{\tcode{auto} specifier}{dcl.spec.auto}
+in a defaulted \link{three-way comparison}{class.spaceship}
 or use of the built-in operator) -- the program is ill-formed.
 
 \rSec2[expr.rel]{Relational operators}%
@@ -6129,11 +6130,11 @@ [expr.rel]
 \tcode{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
@@ -6166,7 +6167,7 @@ [expr.rel]
 \end{itemize}
 
 \pnum
-If two operands \tcode{p} and \tcode{q} compare equal\iref{expr.eq},
+If two operands \tcode{p} and \tcode{q} \link{compare equal}{expr.eq},
 \tcode{p<=q} and \tcode{p>=q} both yield \tcode{true} and \tcode{p<q} and
 \tcode{p>q} both yield \tcode{false}. Otherwise, if a pointer \tcode{p}
 compares greater than a pointer \tcode{q}, \tcode{p>=q}, \tcode{p>q},
@@ -6214,10 +6215,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}
@@ -6234,7 +6235,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.
@@ -6279,12 +6281,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}
@@ -6319,8 +6321,8 @@ [expr.eq]
 operators is unspecified.
 
 \pnum
-If both operands are of arithmetic or enumeration type, the usual arithmetic
-conversions\iref{expr.arith.conv} are performed on both operands; each of the operators shall yield
+If both operands are of arithmetic or enumeration type, the \link{usual arithmetic
+conversions}{expr.arith.conv} are performed on both operands; each of the operators shall yield
 \tcode{true} if the specified relationship is true and \tcode{false} if it is
 false.
 
@@ -6414,9 +6416,9 @@ [expr.log.and]
 
 \pnum
 The \tcode{\&\&} operator groups left-to-right. The operands are both
-contextually converted to \tcode{bool}\iref{conv}.
-The
-result is \tcode{true} if both operands are \tcode{true} and
+\deflinkx{contextually converted to \tcode{bool}}
+{conversion!contextual to \tcode{bool}}{conv}.
+The result is \tcode{true} if both operands are \tcode{true} and
 \tcode{false} otherwise. Unlike \tcode{\&}, \tcode{\&\&} guarantees
 left-to-right evaluation: the second operand is not evaluated if the
 first operand is \tcode{false}.
@@ -6441,7 +6443,8 @@ [expr.log.or]
 
 \pnum
 The \tcode{||} operator groups left-to-right. The operands are both
-contextually converted to \tcode{bool}\iref{conv}.
+\deflinkx{contextually converted to \tcode{bool}}
+{conversion!contextual to \tcode{bool}}{conv}.
 The result is
 \tcode{true} if either of its operands is \tcode{true}, and
 \tcode{false} otherwise. Unlike \tcode{|}, \tcode{||} guarantees
@@ -6468,8 +6471,8 @@ [expr.cond]
 
 \pnum
 Conditional expressions group right-to-left. The first expression is
-contextually converted to \tcode{bool}\iref{conv}.
-It is
+\deflinkx{contextually converted to \tcode{bool}}
+{conversion!contextual to \tcode{bool}}{conv}. It is
 evaluated and if it is \tcode{true}, the result of the conditional
 expression is the value of the second expression, otherwise that of the
 third expression. Only one of the second and third expressions is
@@ -6510,7 +6513,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
@@ -6547,9 +6550,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}
@@ -6587,8 +6590,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:
 
@@ -6597,15 +6600,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;
@@ -6689,8 +6692,8 @@ [expr.throw]
 A \grammarterm{throw-expression} is of type \tcode{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}
@@ -6700,7 +6703,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.
@@ -6725,7 +6729,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}
@@ -6786,7 +6790,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
@@ -6866,7 +6870,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}%
@@ -6894,7 +6898,7 @@ [expr.comma]
 \begin{note}
 A comma expression
 appearing as the \grammarterm{expr-or-braced-init-list}
-of a subscripting expression\iref{expr.sub} is deprecated;
+of a \link{subscripting}{expr.sub} expression is deprecated;
 see \ref{depr.comma.subscript}.
 \end{note}
 
@@ -6906,7 +6910,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}.
@@ -6959,8 +6963,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
@@ -6973,8 +6977,8 @@ [expr.const]
 machine\iref{intro.execution}, would evaluate one of the following:
 \begin{itemize}
 \item
-\tcode{this}\iref{expr.prim.this}, except in a constexpr
-function\iref{dcl.constexpr} that is being evaluated as part
+\link{\tcode{this}}{expr.prim.this}, except in a
+\deflinkx{constexpr function}{specifier!\idxcode{constexpr}!function}{dcl.constexpr} that is being evaluated as part
 of $E$;
 
 \item
@@ -6993,7 +6997,7 @@ [expr.const]
 for a constexpr function;
 
 \item
-an invocation of a virtual function\iref{class.virtual}
+an invocation of a \deflinkx{virtual function}{function!virtual}{class.virtual}
 for an object unless
   \begin{itemize}
   \item the object is usable in constant expressions or
@@ -7015,7 +7019,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
@@ -7034,7 +7038,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
@@ -7059,7 +7063,7 @@ [expr.const]
 a reference to \tcode{this} or to a variable with
 automatic storage duration defined outside that
 \grammarterm{lambda-expression}, where
-the reference would be an odr-use~(\ref{basic.def.odr}, \ref{expr.prim.lambda});
+the reference would be an \link{odr-use}{basic.def.odr};
 \begin{example}
 \begin{codeblock}
 void g() {
@@ -7255,7 +7259,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
@@ -7287,28 +7291,28 @@ [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 \tcode{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 to constant expression of type \tcode{bool}}}%
 A \defnx{contextually converted constant expression of type \tcode{bool}}{conversion!contextual to constant expression of type \tcode{bool}} is
-an expression, contextually converted to \tcode{bool}\iref{conv},
+an expression, \deflinkx{contextually converted to \tcode{bool}}{conversion!contextual to \tcode{bool}}{conv},
 where the converted expression is a constant expression and
 the conversion sequence contains only the conversions above.
 
@@ -7441,7 +7445,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},
@@ -7469,7 +7473,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 fc01e765..da65f8f5 100644
--- a/source/statements.tex
+++ b/source/statements.tex
@@ -103,7 +103,7 @@ [stmt.pre]
 The value of a \grammarterm{condition} that is an initialized declaration
 in a statement other than a \tcode{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
 \grammarterm{condition} that is an initialized declaration in a
@@ -178,7 +178,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
@@ -190,8 +190,8 @@ [stmt.expr]
 Most statements are expression statements --- usually assignments or
 function calls. A null statement is useful to carry a label just before
 the \tcode{\}} of a compound statement and to supply a null body to an
-iteration statement such as a \tcode{while}
-statement\iref{stmt.while}.
+iteration statement such as a \link{\tcode{while}
+statement}{stmt.while}.
 \end{note}
 
 \rSec1[stmt.block]{Compound statement or block}%
@@ -212,7 +212,7 @@ [stmt.block]
     statement-seq statement
 \end{bnf}
 
-A compound statement defines a block scope\iref{basic.scope}.
+A compound statement defines a \deflinkx{block scope}{block (statement)!scope}{basic.scope}.
 \begin{note}
 A declaration is a \grammarterm{statement}\iref{stmt.dcl}.
 \end{note}
@@ -283,9 +283,9 @@ [stmt.if]
 
 \pnum
 If the \tcode{if} statement is of the form \tcode{if constexpr}, the value
-of the condition shall be a contextually
-converted constant expression of type \tcode{bool}\iref{expr.const}; this
-form is called a \defn{constexpr if} statement. If the value of the
+of the condition shall be a
+\deflinkx{contextually converted constant expression of type \tcode{bool}}{conversion!contextual to constant expression of type \tcode{bool}}{expr.const};
+this form is called a \defn{constexpr if} statement. If the value of the
 converted condition is \tcode{false}, the first substatement is a
 \defn{discarded statement}, otherwise the second substatement, if
 present, is a discarded statement. During the instantiation of an
@@ -293,14 +293,14 @@ [stmt.if]
 not value-dependent after its instantiation, the discarded substatement
 (if any) is not instantiated.
 \begin{note}
-Odr-uses\iref{basic.def.odr} in a discarded statement do not require
+\link{Odr-uses}{basic.def.odr} in a discarded statement do not require
 an entity to be defined.
 \end{note}
 A \tcode{case} or \tcode{default} label appearing within such an
-\tcode{if} statement shall be associated with a \tcode{switch}
-statement\iref{stmt.switch} within the same \tcode{if} statement.
-A label\iref{stmt.label} declared in a substatement of a constexpr if
-statement shall only be referred to by a statement\iref{stmt.goto} in
+\tcode{if} statement shall be associated with a \link{\tcode{switch}
+statement}{stmt.switch} within the same \tcode{if} statement.
+A \link{label}{stmt.label} declared in a substatement of a constexpr if
+statement shall only be referred to by a \link{statement}{stmt.goto} in
 the same substatement.
 \begin{example}
 \begin{codeblock}
@@ -361,10 +361,10 @@ [stmt.switch]
 \pnum
 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 \tcode{switch} statement can be labeled with one or
@@ -374,7 +374,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.
 
@@ -405,7 +405,7 @@ [stmt.switch]
 \pnum
 \tcode{case} and \tcode{default} labels in themselves do not alter the
 flow of control, which continues unimpeded across such labels. To exit
-from a switch, see \tcode{break}, \ref{stmt.break}.
+from a switch, see \link{\tcode{break}}{stmt.break}.
 \begin{note}
 Usually, the substatement that is the subject of a switch is compound
 and \tcode{case} and \tcode{default} labels appear on the top-level
@@ -473,7 +473,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},
@@ -560,7 +560,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
@@ -728,8 +728,8 @@ [stmt.jump.general]
 \pnum
 \indextext{local variable!destruction of}%
 \indextext{scope!destructor and exit from}%
-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.
 \begin{note}
 For temporaries,
@@ -825,8 +825,8 @@ [stmt.return]
 The \grammarterm{expr-or-braced-init-list}
 of a \tcode{return} statement is called its operand. A \tcode{return} statement with
 no operand shall be used only in a function whose return type is
-\cv{}~\tcode{void}, a constructor\iref{class.ctor}, or a
-destructor\iref{class.dtor}.
+\cv{}~\tcode{void}, a \link{constructor}{class.ctor}, or a
+\link{destructor}{class.dtor}.
 \indextext{\idxcode{return}!constructor and}%
 \indextext{\idxcode{return}!constructor and}%
 A \tcode{return} statement with an operand of type \tcode{void} shall be used only
@@ -836,7 +836,7 @@ [stmt.return]
 \indextext{conversion!return type}%
 the \tcode{return} statement initializes the
 glvalue result 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 \tcode{return} statement can involve
 an invocation of a constructor to perform a copy or move of the operand
@@ -867,7 +867,7 @@ [stmt.return]
 a non-coroutine function with a \cv{}~\tcode{void} return type is
 equivalent to a \tcode{return} with no operand.
 Otherwise, flowing off the end of a function
-other than \tcode{main}\iref{basic.start.main} or a coroutine\iref{dcl.fct.def.coroutine}
+other than \link{\tcode{main}}{basic.start.main} or a coroutine\iref{dcl.fct.def.coroutine}
 results in undefined behavior.
 
 \pnum
@@ -933,7 +933,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}
@@ -957,7 +957,7 @@ [stmt.dcl]
 \pnum
 \indextext{block (statement)!initialization in}%
 \indextext{initialization!automatic}%
-Variables with automatic storage duration\iref{basic.stc.auto} are
+Variables with \link{automatic storage duration}{basic.stc.auto} are
 initialized each time their \grammarterm{declaration-statement} is executed.
 \indextext{local variable!destruction of}%
 Variables with automatic storage duration declared in the block are
@@ -1001,8 +1001,8 @@ [stmt.dcl]
 \indextext{initialization!local \tcode{static}}%
 \indextext{initialization!local \tcode{thread_local}}%
 Dynamic initialization of a block-scope 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
@@ -1045,8 +1045,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 d5666d95..8327930b 100644
--- a/source/declarations.tex
+++ b/source/declarations.tex
@@ -126,7 +126,7 @@ [dcl.pre]
 \pnum
 \indextext{declaration}%
 \indextext{scope}%
-A declaration occurs in a scope\iref{basic.scope}; the scope rules are
+A declaration occurs in a \deflink{scope}{basic.scope}; the scope rules are
 summarized in~\ref{basic.lookup}. A declaration that declares a function
 or defines a class, namespace, template, or function also has one or
 more scopes nested within it. These nested scopes, in turn, can have
@@ -141,7 +141,7 @@ [dcl.pre]
 \indextext{declarator}%
 In a \grammarterm{simple-declaration}, the optional
 \grammarterm{init-declarator-list} can be omitted only when declaring a
-class\iref{class} or enumeration\iref{dcl.enum}, that is,
+\link{class}{class} or \link{enumeration}{dcl.enum}, that is,
 when the \grammarterm{decl-specifier-seq} contains either a
 \grammarterm{class-specifier}, an \grammarterm{elaborated-type-specifier} with
 a \grammarterm{class-key}\iref{class.name}, or an
@@ -165,15 +165,15 @@ [dcl.pre]
 \indextext{\idxgram{static_assert}}%
 In a \grammarterm{static_assert-declaration}, the
 \grammarterm{constant-expression} shall be
-a contextually converted constant expression
-of type \tcode{bool}\iref{expr.const}.
+a \deflinkx{contextually converted constant expression
+of type \tcode{bool}}{conversion!contextual to constant expression of type \tcode{bool}}{expr.const}.
 If the value of the expression when
 so converted is \tcode{true}, the declaration has no
 effect. Otherwise, the program is ill-formed, and the resulting
 diagnostic message\iref{intro.compliance} shall include the text of
 the \grammarterm{string-literal}, if one is supplied,
-except that characters not in the basic
-source character set\iref{lex.charset} are not required to appear in
+except that characters not in the \deflinkx{basic
+source character set}{character set!basic source}{lex.charset} are not required to appear in
 the diagnostic message.
 \begin{example}
 \begin{codeblock}
@@ -366,12 +366,12 @@ [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
 The \tcode{thread_local} specifier
-indicates that the named entity has thread storage duration\iref{basic.stc.thread}. It
+indicates that the named entity has \deflinkx{thread storage duration}{storage duration!thread}{basic.stc.thread}. It
 shall be applied only
 to the declaration of a variable of namespace or block scope,
 to a structured binding declaration\iref{dcl.struct.bind}, or
@@ -390,10 +390,10 @@ [dcl.stc]
 There can be no
 \tcode{static} function declarations within a block, nor any
 \tcode{static} function parameters. A \tcode{static} specifier used in
-the declaration of a variable declares the variable to have static storage
-duration\iref{basic.stc.static}, unless accompanied by the
-\tcode{thread_local} specifier, which declares the variable to have thread
-storage duration\iref{basic.stc.thread}. A \tcode{static} specifier can be
+the declaration of a variable declares the variable to have
+\deflinkx{static storage duration}{storage duration!static}{basic.stc.static}, unless accompanied by the
+\tcode{thread_local} specifier, which declares the variable to have
+\deflinkx{thread storage duration}{storage duration!thread}{basic.stc.thread}. A \tcode{static} specifier can be
 used in declarations of class members;~\ref{class.static} describes its
 effect.
 \indextext{\idxcode{static}!linkage of}%
@@ -478,7 +478,7 @@ [dcl.stc]
 
 \pnum
 The \tcode{mutable} specifier shall appear only in the declaration of
-a non-static data member\iref{class.mem}
+a \deflinkx{non-static data member}{data member!non-static}{class.mem}
 whose type is neither const-qualified nor a reference type.
 \begin{example}
 \begin{codeblock}
@@ -550,7 +550,7 @@ [dcl.typedef]
 \pnum
 Declarations containing the \grammarterm{decl-specifier} \tcode{typedef}
 declare identifiers that can be used later for naming
-fundamental\iref{basic.fundamental} or compound\iref{basic.compound}
+\link{fundamental}{basic.fundamental} or \link{compound}{basic.compound}
 types. The \tcode{typedef} specifier shall not be
 combined in a \grammarterm{decl-specifier-seq} with any other kind of
 specifier except a \grammarterm{defining-type-specifier}, and it shall not be used in the
@@ -692,10 +692,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}
@@ -769,7 +769,7 @@ [dcl.constexpr]
 the declaration of a function or function template.
 A function or static data member
 declared with the \tcode{constexpr} or \tcode{consteval} specifier
-is implicitly an inline function or variable\iref{dcl.inline}.
+is implicitly an \link{inline}{dcl.inline} function or variable.
 If any declaration of a function or function template has
 a \tcode{constexpr} or \tcode{consteval} specifier,
 then all its declarations shall contain the same specifier.
@@ -829,17 +829,17 @@ [dcl.constexpr]
 each of its parameter types shall be a literal type;
 
 \item
-it shall not be a coroutine\iref{dcl.fct.def.coroutine};
+it shall not be a \link{coroutine}{dcl.fct.def.coroutine};
 
 \item
 if the function is a constructor or destructor,
 its class shall not have any virtual base classes;
 
 \item
-its \grammarterm{function-body} shall not enclose\iref{stmt.pre}
+its \grammarterm{function-body} shall not \deflinkx{enclose}{enclosing statement}{stmt.pre}
 \begin{itemize}
 \item a \tcode{goto} statement,
-\item an identifier label\iref{stmt.label},
+\item an \deflink{identifier label}{stmt.label},
 \item a definition of a variable
 of non-literal type or
 of static or thread storage duration.
@@ -920,8 +920,8 @@ [dcl.constexpr]
 For a constexpr function or constexpr constructor
 that is neither defaulted nor a template,
 if no argument values exist such that
-an invocation of the function or constructor could be an evaluated subexpression of a core
-constant expression\iref{expr.const}, or,
+an invocation of the function or constructor could be an evaluated subexpression of a
+\deflinkx{core constant expression}{expression!core constant}{expr.const}, or,
 for a constructor, an evaluated subexpression of
 the initialization full-expression of some constant-initialized object\iref{basic.start.static},
 the program is ill-formed, no diagnostic required.
@@ -998,7 +998,7 @@ [dcl.constexpr]
 shall be initialized.
 In any \tcode{constexpr} variable declaration,
 the full-expression of the initialization
-shall be a constant expression\iref{expr.const}.
+shall be a \link{constant expression}{expr.const}.
 A \tcode{constexpr} variable shall have constant destruction.
 \begin{example}
 \begin{codeblock}
@@ -1107,7 +1107,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~(\ref{class.mfct}, \ref{class.friend}).
 \end{note}
@@ -1238,7 +1238,7 @@ [dcl.type.cv]
 \pnum
 \begin{note}
 Declaring a variable \tcode{const} can affect its linkage\iref{dcl.stc}
-and its usability in constant expressions\iref{expr.const}. As
+and its usability in \link{constant expressions}{expr.const}. As
 described in~\ref{dcl.init}, the definition of an object or subobject
 of const-qualified type must specify an initializer or be subject to
 default-initialization.
@@ -1252,7 +1252,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
@@ -1594,8 +1594,8 @@ [dcl.type.decltype]
 \item otherwise, \tcode{decltype($E$)} is the type of $E$.
 \end{itemize}
 
-The operand of the \tcode{decltype} specifier is an unevaluated
-operand\iref{expr.prop}.
+The operand of the \tcode{decltype} specifier is an
+\deflink{unevaluated operand}{expr.prop}.
 
 \begin{example}
 \begin{codeblock}
@@ -1761,7 +1761,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.
 
@@ -1884,14 +1884,14 @@ [dcl.spec.auto.general]
 
 \pnum
 A function declared with a return type that uses a placeholder type shall not
-be \tcode{virtual}\iref{class.virtual}.
+be \link{\tcode{virtual}}{class.virtual}.
 
 \pnum
 A function declared with a return type that uses a placeholder type shall not
 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.
@@ -1966,7 +1966,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$.
@@ -2063,7 +2063,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}.
@@ -4170,7 +4170,7 @@ [dcl.init.general]
 \item
 if
 \tcode{T}
-is a scalar type\iref{basic.types}, the
+is a \deflinkx{scalar type}{type!scalar}{basic.types}, the
 object
 is initialized to the value obtained by converting the integer literal \tcode{0}
 (zero) to
@@ -4186,7 +4186,7 @@ [dcl.init.general]
 if
 \tcode{T}
 is a (possibly cv-qualified) non-union class type,
-its padding bits\iref{basic.types} are initialized to zero bits and
+its \deflink{padding bits}{basic.types} are initialized to zero bits and
 each non-static data member,
 each non-virtual base class subobject, and,
 if the object is not a base class subobject,
@@ -4197,7 +4197,7 @@ [dcl.init.general]
 if
 \tcode{T}
 is a (possibly cv-qualified) union type,
-its padding bits\iref{basic.types} are initialized to zero bits and
+its \deflink{padding bits}{basic.types} are initialized to zero bits and
 the
 object's first non-static named
 data member
@@ -4360,7 +4360,7 @@ [dcl.init.general]
 parenthesized \grammarterm{expression-list} or a \grammarterm{braced-init-list},
 \item for a \grammarterm{new-initializer}\iref{expr.new},
 \item in a \tcode{static_cast} expression\iref{expr.static.cast},
-\item in a functional notation type conversion\iref{expr.type.conv}, and
+\item in a \link{functional notation type conversion}{expr.type.conv}, and
 \item in the \grammarterm{braced-init-list} form of a \grammarterm{condition}
 \end{itemize}
 is called
@@ -5311,15 +5311,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 is bound 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}
@@ -6581,7 +6581,7 @@ [dcl.struct.bind]
 where \tcode{get} is looked up in the associated namespaces\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.
@@ -6719,7 +6719,7 @@ [dcl.enum]
 \end{note}
 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}%
@@ -6803,8 +6803,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
@@ -6813,8 +6814,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.
 
@@ -6831,7 +6833,7 @@ [dcl.enum]
 
 \pnum
 An enumeration whose underlying type is fixed is an incomplete type from its
-point of declaration\iref{basic.scope.pdecl} to immediately after its
+\deflinkx{point of declaration}{declaration!point of}{basic.scope.pdecl} to immediately after its
 \grammarterm{enum-base} (if any), at which point it becomes a complete type.
 An enumeration whose underlying type is not fixed is an incomplete type from
 its point of declaration to immediately after the closing \tcode{\}} of its
@@ -6877,7 +6879,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 };
@@ -7109,7 +7111,7 @@ [namespace.def.general]
 \pnum
 In a \grammarterm{named-namespace-definition},
 the \grammarterm{identifier} is the name of the namespace.
-If the \grammarterm{identifier}, when looked up\iref{basic.lookup.unqual},
+If the \grammarterm{identifier}, when \link{looked up}{basic.lookup.unqual},
 refers to a \grammarterm{namespace-name} (but not a \grammarterm{namespace-alias})
 that was introduced in the namespace
 in which the \grammarterm{named-namespace-definition} appears
@@ -7179,13 +7181,13 @@ [namespace.def.general]
 Members of an inline namespace can be used in most respects as though they were members
 of the 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
-member of the inline namespace can subsequently be partially
-specialized\iref{temp.class.spec}, explicitly
-instantiated\iref{temp.explicit}, or explicitly specialized\iref{temp.expl.spec} as
+namespace is implicitly inserted into the enclosing namespace as for an \link{unnamed
+namespace}{namespace.unnamed}. Furthermore, each
+member of the inline namespace can subsequently be \link{partially
+specialized}{temp.class.spec}, \link{explicitly
+instantiated}{temp.explicit}, or \link{explicitly specialized}{temp.expl.spec} as
 though it were a member of the enclosing namespace. Finally, looking up a name in the
 enclosing namespace via explicit qualification\iref{namespace.qual} will include
 members of the inline namespace brought in by the \grammarterm{using-directive} even if
@@ -7340,8 +7342,8 @@ [namespace.memdef]
 \end{footnote}
 the friend is a member of the innermost enclosing
 namespace. The friend declaration does not by itself make the name
-visible to unqualified lookup\iref{basic.lookup.unqual} or qualified
-lookup\iref{basic.lookup.qual}.
+visible to \link{unqualified lookup}{basic.lookup.unqual} or \link{qualified
+lookup}{basic.lookup.qual}.
 \begin{note}
 The name of the friend will be
 visible in its namespace if a matching declaration is provided at namespace
@@ -7922,8 +7924,8 @@ [namespace.udecl]
 
 \pnum
 Since a \grammarterm{using-declaration} is a declaration, the restrictions
-on declarations of the same name in the same declarative
-region\iref{basic.scope} also apply to \grammarterm{using-declaration}{s}.
+on declarations of the same name in the same
+\deflink{declarative region}{basic.scope} also apply to \grammarterm{using-declaration}{s}.
 \begin{example}
 \begin{codeblock}
 namespace A {
@@ -7958,7 +7960,7 @@ [namespace.udecl]
 
 \pnum
 If a function declaration in namespace scope or block scope has the same
-name and the same parameter-type-list\iref{dcl.fct} as
+name and the same \deflink{parameter-type-list}{dcl.fct} as
 a function introduced by a \grammarterm{using-declaration}, and the
 declarations do not declare the same function, the program is
 ill-formed. If a function template declaration in namespace scope has
@@ -8206,7 +8208,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}}%
@@ -8264,7 +8266,7 @@ [dcl.link]
 Linkage specifications nest. When linkage specifications nest, the
 innermost one determines the language linkage. A linkage specification
 does not establish a scope. A \grammarterm{linkage-specification} shall
-occur only in namespace scope\iref{basic.scope.namespace}. In a
+occur only in \link{namespace scope}{basic.scope.namespace}. In a
 \grammarterm{linkage-specification}, the specified language linkage applies
 to the function types of all function declarators, function names with
 external linkage, and variable names with external linkage declared
@@ -8335,7 +8337,7 @@ [dcl.link]
 
 \pnum
 If two declarations declare functions with the same name and
-parameter-type-list\iref{dcl.fct} to be members of the same
+\deflink{parameter-type-list}{dcl.fct} to be members of the same
 namespace or declare objects with the same name to be members of the same
 namespace and the declarations give the names different language linkages, the
 program is ill-formed; no diagnostic is required if the declarations appear in
@@ -8398,8 +8400,8 @@ [dcl.link]
 A declaration directly contained in a
 \grammarterm{linkage-specification}
 is treated as if it contains the
-\tcode{extern}
-specifier\iref{dcl.stc} for the purpose of determining the linkage of the
+\linkx{\tcode{extern}
+specifier}{\idxcode{extern}}{dcl.stc} for the purpose of determining the linkage of the
 declared name and whether it is a definition. Such a declaration shall
 not specify a storage class.
 \begin{example}
@@ -8546,16 +8548,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).
 
@@ -8645,7 +8647,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
@@ -8724,9 +8726,9 @@ [dcl.attr.depend]
 \grammarterm{attribute-argument-clause} shall be present. The attribute may be
 applied to the \grammarterm{declarator-id} of a
 \grammarterm{parameter-declaration} in a function declaration or lambda, in
-which case it specifies that the initialization of the parameter carries a
-dependency to\iref{intro.multithread} each lvalue-to-rvalue
-conversion\iref{conv.lval} of that object. The attribute may also be applied
+which case it specifies that the initialization of the parameter
+\deflink{carries a dependency}{intro.multithread} to each \link{lvalue-to-rvalue
+conversion}{conv.lval} of that object. The attribute may also be applied
 to the \grammarterm{declarator-id} of a function declaration, in which case it
 specifies that the return value, if any, carries a dependency to the evaluation
 of the function call expression.
@@ -8853,14 +8855,14 @@ [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.
 The \grammarterm{attribute-token} \tcode{fallthrough}
 shall appear at most once in each \grammarterm{attribute-list} and
 no \grammarterm{attribute-argument-clause} shall be present.
 A fallthrough statement may only appear within
-an enclosing \tcode{switch} statement\iref{stmt.switch}.
+an enclosing \link{\tcode{switch} statement}{stmt.switch}.
 The next statement that would be executed after a fallthrough statement
 shall be a labeled statement whose label is a case label or
 default label for the same \tcode{switch} statement and,
diff --git a/source/classes.tex b/source/classes.tex
index f25f2dc5..ff7528f3 100644
--- a/source/classes.tex
+++ b/source/classes.tex
@@ -175,10 +175,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,
@@ -204,7 +204,7 @@ [class.prop]
 
 \begin{itemize}
 \item If \tcode{X} is a non-union class type with no (possibly
-inherited\iref{class.derived}) non-static data members, the set
+\link{inherited}{class.derived}) non-static data members, the set
 $M(\mathtt{X})$ is empty.
 
 \item If \tcode{X} is a non-union class type with a non-static data
@@ -323,7 +323,7 @@ [class.name]
 int f(Y);
 \end{codeblock}
 \indextext{overloading}%
-declare an overloaded\iref{over} function \tcode{f()} and not
+declare an \link{overloaded}{over} function \tcode{f()} and not
 simply a single function \tcode{f()} twice. For the same reason,
 \begin{codeblock}
 struct S { int a; };
@@ -339,7 +339,7 @@ [class.name]
 \indextext{name hiding!class definition}%
 it is declared and hides any
 class, variable, function, or other declaration of that name in an
-enclosing scope\iref{basic.scope}. If a class name is declared in a
+enclosing \link{scope}{basic.scope}. If a class name is declared in a
 scope where a variable, function, or enumerator of the same name is also
 declared, then when both declarations are in scope, the class can be
 referred to only using an
@@ -504,9 +504,9 @@ [class.mem.general]
 A \defnadj{direct}{member} of a class \tcode{X} is a member of \tcode{X}
 that was first declared within the \grammarterm{member-specification} of \tcode{X},
 including anonymous union objects\iref{class.union.anon} and direct members thereof.
-Members of a class are data members, member
-functions\iref{class.mfct}, nested types, enumerators,
-and member templates\iref{temp.mem} and specializations thereof.
+Members of a class are data members, \link{member functions}{class.mfct},
+nested types, enumerators,
+and \link{member templates}{temp.mem} and specializations thereof.
 \begin{note}
 A specialization of a static data member template is a static data member.
 A specialization of a member function template is a member function.
@@ -526,7 +526,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
@@ -538,10 +538,10 @@ [class.mem.general]
 \grammarterm{member-declarator}.
 A \defn{member function} is a member that is a function.
 Nested types are classes~(\ref{class.name}, \ref{class.nest}) and
-enumerations\iref{dcl.enum} declared in the class and arbitrary types
-declared as members by use of a typedef declaration\iref{dcl.typedef}
+\link{enumerations}{dcl.enum} declared in the class and arbitrary types
+declared as members by use of a \link{typedef declaration}{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
@@ -556,7 +556,7 @@ [class.mem.general]
 \defnadj{non-static}{member function}~(\ref{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
@@ -579,7 +579,7 @@ [class.mem.general]
 A \defn{complete-class context} of a class is a
 \begin{itemize}
 \item function body\iref{dcl.fct.def.general},
-\item default argument\iref{dcl.fct.default},
+\item \link{default argument}{dcl.fct.default},
 \item \grammarterm{noexcept-specifier}\iref{except.spec}, or
 \item default member initializer
 \end{itemize}
@@ -659,9 +659,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
@@ -730,7 +730,7 @@ [class.mem.general]
 \begin{note}
 \indextext{layout!class object}%
 Non-static data members of a (non-union) class
-with the same access control\iref{class.access} and
+with the same \link{access control}{class.access} and
 non-zero size\iref{intro.object}
 are allocated so that later
 members have higher addresses within a class object\iref{expr.rel}.
@@ -752,8 +752,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;
@@ -769,7 +769,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
@@ -806,11 +806,11 @@ [class.mem.general]
 \pnum
 Two standard-layout unions are layout-compatible if they
 have the same number of non-static data members and corresponding
-non-static data members (in any order) have layout-compatible
-types\iref{basic.types}.
+non-static data members (in any order) have \deflinkx{layout-compatible
+types}{layout-compatible}{basic.types}.
 
 \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};
@@ -852,7 +852,7 @@ [class.mfct]
 \pnum
 \indextext{member function!inline}%
 \indextext{definition!member function}%
-A member function may be defined\iref{dcl.fct.def} in its class definition,
+A member function may be \link{defined}{dcl.fct.def} in its class definition,
 in which case it is an inline\iref{dcl.inline} member function
 if it is attached to the global module, or
 it may be defined outside of its class
@@ -889,8 +889,8 @@ [class.mfct]
 name using the \tcode{::} operator.
 \begin{note}
 A name used in a member function definition (that is, in the
-\grammarterm{parameter-declaration-clause} including the default
-arguments\iref{dcl.fct.default} or in the member function body) is looked up
+\grammarterm{parameter-declaration-clause} including the \link{default
+arguments}{dcl.fct.default} or in the member function body) is looked up
 as described in~\ref{basic.lookup}.
 \end{note}
 \begin{example}
@@ -956,9 +956,9 @@ [class.mfct.non-static.general]
 
 \pnum
 A non-static member function may be called for an object of
-its class type, or for an object of a class derived\iref{class.derived}
-from its class type, using the class member
-access syntax~(\ref{expr.ref}, \ref{over.match.call}). A non-static
+its class type, or for an object of a class \link{derived}{class.derived}
+from its class type, using the
+\link{class member access}{expr.ref} syntax\iref{over.match.call}. A non-static
 member function may also be called directly using the function call
 syntax~(\ref{expr.call}, \ref{over.match.call}) from within
 its class or a class derived from its class, or
@@ -972,19 +972,18 @@ [class.mfct.non-static.general]
 
 \pnum
 When an \grammarterm{id-expression}\iref{expr.prim.id} that is not part of a
-class member access syntax\iref{expr.ref} and not used to form a
+\link{class member access}{expr.ref} syntax and not used to form a
 pointer to member\iref{expr.unary.op} is used in
-a member of class \tcode{X} in a context where \tcode{this} can be
-used\iref{expr.prim.this},
-if name
-lookup\iref{basic.lookup} resolves the name in the
+a member of class \tcode{X} in a context where \link{\tcode{this}}{expr.prim.this} can be
+used,
+if \link{name lookup}{basic.lookup} resolves the name in the
 \grammarterm{id-expression} to a non-static non-type member of some class
 \tcode{C},
 and if either the \grammarterm{id-expression} is potentially evaluated or
 \tcode{C} is \tcode{X} or a base class of \tcode{X},
-the \grammarterm{id-expression} is transformed into a class
-member access expression\iref{expr.ref} using
-\tcode{(*this)}\iref{class.this} as the \grammarterm{postfix-expression}
+the \grammarterm{id-expression} is transformed into a
+\link{class member access}{expr.ref} expression using
+\link{\tcode{(*this)}}{class.this} as the \grammarterm{postfix-expression}
 to the left of the \tcode{.} operator.
 \begin{note}
 If \tcode{C} is not \tcode{X} or a base class of \tcode{X}, the class
@@ -1036,11 +1035,11 @@ [class.mfct.non-static.general]
 \indextext{member function!const volatile}%
 A non-static member function may be declared \tcode{const},
 \tcode{volatile}, or \tcode{const} \tcode{volatile}. These
-\grammarterm{cv-qualifier}{s} affect the type of the \tcode{this}
-pointer\iref{class.this}. They also affect the function
-type\iref{dcl.fct} of the member function; a member function declared
-\tcode{const} is a \defn{const member function}, a member function
-declared \tcode{volatile} is a \defn{volatile member function} and a
+\grammarterm{cv-qualifier}{s} affect the type of the \link{\tcode{this}
+pointer}{class.this}. They also affect the \link{function
+type}{dcl.fct} of the member function; a member function declared
+\tcode{const} is a \term{const} member function, a member function
+declared \tcode{volatile} is a \term{volatile} member function and a
 member function declared \tcode{const} \tcode{volatile} is a
 \defn{const volatile member function}.
 \begin{example}
@@ -1101,7 +1100,7 @@ [class.this]
 
 \pnum
 \begin{note}
-Similarly, \tcode{volatile} semantics\iref{dcl.type.cv} apply in
+Similarly, \link{\tcode{volatile}}{dcl.type.cv} semantics apply in
 volatile member functions when accessing the object and its
 non-static data members.
 \end{note}
@@ -1109,7 +1108,7 @@ [class.this]
 \pnum
 A member function whose type has a \grammarterm{cv-qualifier-seq} \cvqual{cv1}
 can be called on an
-object expression\iref{expr.ref} of type \cvqual{cv2} \tcode{T} only
+\link{object expression}{expr.ref} of type \cvqual{cv2} \tcode{T} only
 if \cvqual{cv1} is the same as or more cv-qualified than \cvqual{cv2}\iref{basic.type.qualifier}.
 \begin{example}
 \begin{codeblock}
@@ -2352,7 +2351,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}.
@@ -6555,7 +6554,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 3bcbb344..e6c41aa6 100644
--- a/source/overloading.tex
+++ b/source/overloading.tex
@@ -67,7 +67,7 @@ [over.load]
 \item
 \indextext{return type!overloading and}%
 Function declarations that differ only in the return type,
-the exception specification\iref{except.spec}, or both
+the \link{exception specification}{except.spec}, or both
 cannot be overloaded.
 \item
 \indextext{\idxcode{static}!overloading and}%
@@ -160,8 +160,8 @@ [over.load]
 Parameter declarations that differ only in the use of equivalent typedef
 ``types'' are equivalent.
 A
-\tcode{typedef}
-is not a separate type, but only a synonym for another type\iref{dcl.typedef}.
+\link{\tcode{typedef}}{dcl.typedef}
+is not a separate type, but only a synonym for another type.
 \begin{example}
 \begin{codeblock}
 typedef int Int;
@@ -450,7 +450,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
@@ -464,14 +464,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
@@ -489,7 +489,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}
@@ -500,7 +500,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.
 
@@ -612,7 +612,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
@@ -711,7 +711,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}
@@ -833,7 +833,7 @@ [over.call.func]
 in the call augmented by the addition of an implied object
 argument as in a qualified function call.
 If the keyword
-\tcode{this}\iref{class.this} is in scope and refers to
+\link{\tcode{this}}{class.this} is in scope and refers to
 class
 \tcode{T},
 or a derived class of
@@ -1218,7 +1218,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}
@@ -1301,10 +1301,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
@@ -1342,7 +1342,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
@@ -1410,11 +1410,11 @@ [over.match.conv]
 \tcode{T}
 or a type that can be converted to type
 \tcode{T}
-via a standard conversion sequence\iref{over.ics.scs}
+via a \link{standard conversion sequence}{over.ics.scs}
 are candidate functions.
 For direct-initialization, those explicit conversion functions that are not
 hidden within \tcode{S} and yield type \tcode{T} or a type that can be converted
-to type \tcode{T} with a qualification conversion\iref{conv.qual} are also
+to type \tcode{T} with a \link{qualification conversion}{conv.qual} are also
 candidate functions.
 Conversion functions that return a cv-qualified type
 are considered to yield the cv-unqualified version of that type
@@ -1460,7 +1460,7 @@ [over.match.ref]
 ``\cvqual{cv2} \tcode{T2}''
 or ``rvalue reference to \cvqual{cv2} \tcode{T2}'' (when initializing an
 rvalue reference or an lvalue reference to function),
-where ``\cvqual{cv1} \tcode{T}'' is reference-compatible\iref{dcl.init.ref}
+where ``\cvqual{cv1} \tcode{T}'' is \deflink{reference-compatible}{dcl.init.ref}
 with ``\cvqual{cv2} \tcode{T2}'',
 are candidate functions. For direct-initialization, those explicit
 conversion functions that are not hidden within \tcode{S} and yield
@@ -1469,8 +1469,8 @@ [over.match.ref]
 or ``rvalue reference to \cvqual{cv2} \tcode{T2}''
 (when initializing an rvalue reference or an lvalue reference to function),
 where \tcode{T2} is the same type as \tcode{T} or can be
-converted to type \tcode{T} with a qualification
-conversion\iref{conv.qual}, are also candidate functions.
+converted to type \tcode{T} with a \link{qualification
+conversion}{conv.qual}, are also candidate functions.
 
 \end{itemize}
 
@@ -1935,7 +1935,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
@@ -2029,8 +2029,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}
@@ -2134,7 +2134,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
@@ -2281,7 +2281,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
@@ -2294,11 +2294,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
@@ -2468,10 +2468,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
@@ -2508,7 +2508,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
 implicit object parameter of that conversion function.
@@ -2548,7 +2548,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
@@ -2564,7 +2564,7 @@ [over.ics.ref]
 \end{example}
 If the parameter binds directly to the result of
 applying a conversion function to the argument expression, the implicit
-conversion sequence is a user-defined conversion sequence\iref{over.ics.user},
+conversion sequence is a \link{user-defined conversion sequence}{over.ics.user},
 with the second standard conversion sequence either an identity conversion or,
 if the conversion function returns an entity of a type that is a derived class
 of the parameter type, a derived-to-base conversion.
@@ -2619,7 +2619,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
@@ -2771,8 +2771,8 @@ [over.ics.list]
 
 \pnum
 Otherwise, if the parameter has an aggregate type which can be initialized from
-the initializer list according to the rules for aggregate
-initialization\iref{dcl.init.aggr}, the implicit conversion sequence is a
+the initializer list according to the rules for \link{aggregate
+initialization}{dcl.init.aggr}, the implicit conversion sequence is a
 user-defined conversion sequence with the second standard conversion
 sequence an identity conversion.
 \begin{example}
@@ -2860,13 +2860,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
@@ -3238,11 +3238,11 @@ [over.over]
 an object or reference being initialized~(\ref{dcl.init}, \ref{dcl.init.ref},
 \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
@@ -3447,8 +3447,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}%
@@ -3543,7 +3543,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
@@ -3873,7 +3873,7 @@ [over.built]
 In this subclause, the term
 \defn{promoted integral type}
 is used to refer to those 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 44489138..6aad95e2 100644
--- a/source/templates.tex
+++ b/source/templates.tex
@@ -121,7 +121,7 @@ [temp.pre]
 class name
 is a
 \grammarterm{simple-template-id},
-the declaration declares a class template partial specialization\iref{temp.class.spec}.
+the declaration declares a \link{class template partial specialization}{temp.class.spec}.
 \end{note}
 
 \pnum
@@ -135,17 +135,17 @@ [temp.pre]
 
 \pnum
 \indextext{template name!linkage of}%
-A template name has linkage\iref{basic.link}.
+A template name has \link{linkage}{basic.link}.
 Specializations (explicit or implicit) of
 a template that has internal linkage are
 distinct from all specializations in other translation
 units.
-A template, a template explicit specialization\iref{temp.expl.spec}, and a class
+A template, a template \link{explicit specialization}{temp.expl.spec}, and a class
 template partial specialization shall not have C linkage. Use of a linkage specification
 other than \tcode{"C"} or \tcode{"C++"} with any of these constructs is
 conditionally-supported, with
 \impldef{semantics of linkage specification on templates} semantics.
-Template definitions shall obey the one-definition rule\iref{basic.def.odr}.
+Template definitions shall obey the \link{one-definition rule}{basic.def.odr}.
 \begin{note}
 Default arguments for function templates and for member functions of
 class templates are considered definitions for the purpose of template
@@ -493,7 +493,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.
@@ -629,7 +629,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
@@ -661,7 +661,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}
@@ -964,8 +964,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}
@@ -1130,7 +1130,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}
@@ -1142,7 +1142,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}
 
@@ -1320,7 +1320,7 @@ [temp.arg.template]
 parameter.
 
 \pnum
-Any partial specializations\iref{temp.class.spec} associated with the
+Any \link{partial specializations}{temp.class.spec} associated with the
 primary class template or primary variable template are considered when a
 specialization based on the template
 \grammarterm{template-parameter}
@@ -1428,8 +1428,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):
@@ -1479,14 +1479,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
@@ -1494,7 +1494,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}
@@ -1551,7 +1551,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}
@@ -1609,9 +1609,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
@@ -1685,7 +1685,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}
@@ -1743,11 +1743,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
@@ -1844,7 +1844,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
@@ -1853,7 +1853,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
@@ -1973,7 +1973,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$.
 %
@@ -1989,9 +1989,9 @@ [temp.constr.order]
 \begin{itemize}
 \item the best viable candidate of non-template functions\iref{over.match.best},
 \item the address of a non-template function\iref{over.over},
-\item the matching of template template arguments\iref{temp.arg.template},
-\item the partial ordering of class template specializations\iref{temp.class.order}, and
-\item the partial ordering of function templates\iref{temp.func.order}.
+\item the matching of \link{template template arguments}{temp.arg.template},
+\item the \link{partial ordering of class template specializations}{temp.class.order}, and
+\item the \link{partial ordering of function templates}{temp.func.order}.
 \end{itemize}
 \end{note}
 
@@ -2146,7 +2146,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
@@ -2175,7 +2175,7 @@ [temp.decls.general]
 \end{codeblock}
 \end{example}
 \begin{note}
-However, this syntax is allowed in class template partial specializations\iref{temp.class.spec}.
+However, this syntax is allowed in \link{class template partial specializations}{temp.class.spec}.
 \end{note}
 
 \pnum
@@ -2204,8 +2204,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
@@ -2562,7 +2562,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.
@@ -2667,8 +2667,8 @@ [temp.mem]
 in a base class.
 
 \pnum
-Overload resolution\iref{over.ics.rank} and partial
-ordering\iref{temp.func.order} are used to select the best conversion function
+\link{Overload resolution}{over.ics.rank} and \link{partial
+ordering}{temp.func.order} are used to select the best conversion function
 among multiple
 specializations of conversion function templates
 and/or non-template
@@ -2782,7 +2782,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};
@@ -3077,8 +3077,8 @@ [temp.friend]
 
 \pnum
 A template friend declaration specifies that all specializations of that
-template, whether they are implicitly instantiated\iref{temp.inst}, partially
-specialized\iref{temp.class.spec} or explicitly specialized\iref{temp.expl.spec},
+template, whether they are \link{implicitly instantiated}{temp.inst}, \link{partially
+specialized}{temp.class.spec} or \link{explicitly specialized}{temp.expl.spec},
 are friends of the class containing the template friend declaration.
 \begin{example}
 \begin{codeblock}
@@ -3349,8 +3349,8 @@ [temp.class.spec.general]
 
 \end{example}
 \item
-The specialization shall be more specialized than the primary
-template\iref{temp.class.order}.
+The specialization shall be \deflink{more specialized}{temp.class.order}
+than the primary template.
 
 \item
 The template parameter list of a specialization shall not contain default
@@ -3392,7 +3392,7 @@ [temp.class.spec.match]
 generated from that specialization.
 \item
 If more than one matching specialization is found,
-the partial order rules\iref{temp.class.order} are used to determine
+the \link{partial order rules}{temp.class.order} are used to determine
 whether one of the specializations is more specialized than the
 others.
 If none of the specializations is more specialized than all of the
@@ -3406,9 +3406,9 @@ [temp.class.spec.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
@@ -3470,14 +3470,14 @@ [temp.class.order]
 For two class template 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
@@ -3688,8 +3688,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
@@ -3740,7 +3740,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.
@@ -3911,8 +3911,8 @@ [temp.func.order]
 specialization
 is selected to match a placement operator new~(\ref{basic.stc.dynamic.deallocation}, \ref{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}
 
@@ -3930,7 +3930,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.
@@ -4279,7 +4280,7 @@ [temp.concept]
 shall appear at 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}.
@@ -4528,7 +4529,7 @@ [temp.res.general]
 \begin{itemize}
 \item
 no valid specialization 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
 no substitution of template arguments
@@ -4563,7 +4564,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
@@ -4885,9 +4886,9 @@ [temp.local]
 or the name of a member of the
 base class is the same as the name of a
 \grammarterm{template-parameter},
-the base class name or member name hides the
+the base class name or member name \link{hides}{basic.scope.hiding} the
 \grammarterm{template-parameter}
-name\iref{basic.scope.hiding}.
+name.
 \begin{example}
 \begin{codeblock}
 struct A {
@@ -4943,14 +4944,14 @@ [temp.dep.general]
 if
 \begin{itemize}
 \item
-any of the expressions in the \grammarterm{expression-list} is a pack
-expansion\iref{temp.variadic},
+any of the expressions in the \grammarterm{expression-list} is a
+\deflink{pack expansion}{temp.variadic},
 \item
 any of the expressions
 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
@@ -4992,7 +4993,7 @@ [temp.dep.general]
 
 \pnum
 In the definition of a class or class template,
-the scope of a dependent base class\iref{temp.dep.type}
+the scope of a \deflinkx{dependent base class}{base class!dependent}{temp.dep.type}
 is not examined during unqualified
 name lookup either at the point of definition of the
 class template or member or during an instantiation of
@@ -5058,7 +5059,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
@@ -5088,9 +5089,9 @@ [temp.dep.type]
 template argument has the value of the
 $n^\text{th}$
 template parameter of the class template.
-If the $n^\text{th}$ template parameter is a template
-parameter pack\iref{temp.variadic}, the $n^\text{th}$ template argument is a pack
-expansion\iref{temp.variadic} whose pattern is the name of
+If the $n^\text{th}$ template parameter is a
+\deflink{template parameter pack}{temp.variadic}, the $n^\text{th}$ template argument is a
+\deflink{pack expansion}{temp.variadic} whose pattern is the name of
 the template parameter pack.
 
 \pnum
@@ -5209,10 +5210,10 @@ [temp.dep.type]
 \end{note}
 
 \item
-An \grammarterm{id-expression} denoting the member in a class member access
-expression\iref{expr.ref} for which the type of the object expression is the
-current instantiation, and the \grammarterm{id-expression}, when looked
-up\iref{basic.lookup.classref}, refers to at least one member of a class
+An \grammarterm{id-expression} denoting the member in a \link{class member access}{expr.ref}
+expression for which the type of the object expression is the
+current instantiation, and the \grammarterm{id-expression}, when \link{looked
+up}{basic.lookup.classref}, refers to at least one member of a class
 that is the current
 instantiation or a non-dependent base class thereof.
 \begin{note}
@@ -5263,8 +5264,8 @@ [temp.dep.type]
 find any member of a class that is the current instantiation or a non-dependent
 base class thereof.
 
-\item An \grammarterm{id-expression} denoting the member in a class member access
-expression\iref{expr.ref} in which either
+\item An \grammarterm{id-expression} denoting the member in a
+\link{class member access}{expr.ref} expression in which either
 \begin{itemize}
 \item the type of the object expression is the current instantiation, the
 current instantiation has at least one dependent base class, and name lookup
@@ -5360,7 +5361,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
@@ -5398,7 +5399,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
 an
 \grammarterm{identifier}
@@ -5411,7 +5412,7 @@ [temp.dep.expr]
 with a return type that contains a placeholder type,
 \item
 an \grammarterm{identifier} associated by name lookup with
-a structured binding declaration\iref{dcl.struct.bind} whose
+a \link{structured binding declaration}{dcl.struct.bind} whose
 \grammarterm{brace-or-equal-initializer} is type-dependent,
 \item
 the
@@ -5479,7 +5480,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 expression refers to a member of the current instantiation and
 the type of the referenced member is dependent, or the class member access
@@ -5600,7 +5601,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.
 
@@ -5747,7 +5748,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}
@@ -6096,7 +6097,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}
@@ -6166,7 +6167,7 @@ [temp.inst]
 \end{codeblock}
 \end{example}
 If a class template has been declared, but not defined,
-at the point of instantiation\iref{temp.point},
+at the \link{point of instantiation}{temp.point},
 the instantiation yields an incomplete class type\iref{basic.types}.
 \begin{example}
 \begin{codeblock}
@@ -6176,7 +6177,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
@@ -6355,7 +6356,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}
@@ -6672,8 +6673,8 @@ [temp.explicit]
 specialization of the entity with the same template arguments.
 If the
 \grammarterm{declaration}
-of the explicit instantiation names an implicitly-declared special member
-function\iref{special}, the program is ill-formed.
+of the explicit instantiation names an implicitly-declared \link{special member
+function}{special}, the program is ill-formed.
 
 \pnum
 The \grammarterm{declaration} in an \grammarterm{explicit-instantiation} and
@@ -6796,7 +6797,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.arg.explicit]
 \end{itemize}
 
 \pnum
-Trailing template arguments that can be deduced\iref{temp.deduct} or
+Trailing template arguments that can be \link{deduced}{temp.deduct} or
 obtained from default
 \grammarterm{template-argument}{s}
 may be omitted from the list of explicit
@@ -7832,7 +7833,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},
@@ -7941,8 +7942,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,
@@ -7950,7 +7951,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
@@ -8046,8 +8047,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
@@ -8192,7 +8193,7 @@ [temp.deduct.funcaddr]
 
 \pnum
 Template arguments can be deduced from the type specified when taking
-the address of an overloaded function\iref{over.over}.
+the address of an \link{overloaded function}{over.over}.
 If there is a target,
 the function template's function type and the target type
 are used as the types of
@@ -8204,7 +8205,7 @@ [temp.deduct.funcaddr]
 Otherwise, deduction is performed with empty sets of types P and 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.
@@ -8238,7 +8239,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,
@@ -8246,7 +8247,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,
@@ -8343,7 +8344,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}
 
@@ -8826,7 +8827,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
@@ -8889,7 +8890,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
@@ -9169,8 +9170,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}~(\ref{basic.stc.dynamic.deallocation}, \ref{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 3e63cb63..24a5445a 100644
--- a/source/exceptions.tex
+++ b/source/exceptions.tex
@@ -178,7 +178,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}%
@@ -189,9 +189,9 @@ [except.throw]
 \begin{note}
 An exception can be thrown from one of the following contexts:
 \grammarterm{throw-expression}{s}\iref{expr.throw},
-allocation functions\iref{basic.stc.dynamic.allocation},
-\tcode{dynamic_cast}\iref{expr.dynamic.cast},
-\tcode{typeid}\iref{expr.typeid},
+\link{allocation functions}{basic.stc.dynamic.allocation},
+\link{\tcode{dynamic_cast}}{expr.dynamic.cast},
+\link{\tcode{typeid}}{expr.typeid},
 \grammarterm{new-expression}{s}\iref{expr.new}, and standard library
 functions\iref{structure.specifications}.
 \end{note}
@@ -281,7 +281,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}
@@ -289,7 +289,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}
@@ -316,7 +316,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.
@@ -326,9 +326,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 called\iref{except.terminate}.
+exception, the function \link{\tcode{std::terminate}}{except.terminate} is called.
 \begin{example}
 \begin{codeblock}
 struct C {
@@ -371,7 +371,7 @@ [except.ctor]
 constructed, but not yet destroyed,
 since the try block was entered.
 If an exception is thrown during the destruction of temporaries or
-local variables for a \tcode{return} statement\iref{stmt.return},
+local variables for a \link{\tcode{return} statement}{stmt.return},
 the destructor for the returned object (if any) is also invoked.
 The objects are destroyed in the reverse order of the completion
 of their construction.
@@ -435,7 +435,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}
 
@@ -500,12 +500,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}
 
@@ -626,7 +626,7 @@ [except.handle]
 constructors of namespace-scope objects 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 namespace-scope objects with thread storage duration are not caught by a
 \grammarterm{function-try-block}
 on the initial function of the thread.
@@ -657,9 +657,11 @@ [except.handle]
 \begin{itemize}
 \item
 if \tcode{T} is a base class of \tcode{E}, the variable is
-copy-initialized\iref{dcl.init} from the corresponding base class subobject
+\deflinkx{copy-initialized}{copy-initialization}{dcl.init}
+from the corresponding base class subobject
 of the exception object;
-\item otherwise, the variable is copy-initialized\iref{dcl.init}
+\item otherwise, the variable is
+\deflinkx{copy-initialized}{copy-initialization}{dcl.init}
 from the exception object.
 \end{itemize}
 
@@ -694,7 +696,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
@@ -705,13 +707,13 @@ [except.spec]
 \pnum
 \indextext{exception specification!noexcept!constant expression and}%
 In a \grammarterm{noexcept-specifier}, the \grammarterm{constant-expression},
-if supplied, shall be a contextually converted constant expression
-of type \tcode{bool}\iref{expr.const};
+if supplied, shall be a
+\deflinkx{contextually converted constant expression of type \tcode{bool}}{conversion!contextual to constant expression of type \tcode{bool}}{expr.const};
 that constant expression is the exception specification of
 the function type in which the \grammarterm{noexcept-specifier} appears.
 A \tcode{(} token that follows \tcode{noexcept} is part of the
 \grammarterm{noexcept-specifier} and does not commence an
-initializer\iref{dcl.init}.
+\link{initializer}{dcl.init}.
 The \grammarterm{noexcept-specifier} \tcode{noexcept}
 without a \grammarterm{constant-expression}
 is
@@ -728,7 +730,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
@@ -806,7 +808,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,
@@ -817,15 +819,15 @@ [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 is potentially-throwing,
 or
 \item
 $E$ is a \grammarterm{throw-expression}\iref{expr.throw},
 or
 \item
-$E$ is a \tcode{dynamic_cast} expression that casts to a reference type and
-requires a runtime check\iref{expr.dynamic.cast},
+$E$ is a \link{\tcode{dynamic_cast}}{expr.dynamic.cast} expression that casts to a reference type and
+requires a runtime check,
 or
 \item
 $E$ is a \tcode{typeid} expression applied to a
@@ -834,7 +836,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}
 
@@ -887,7 +889,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.
 
@@ -938,7 +940,7 @@ [except.spec]
 \item in an expression, the function is the unique lookup result or the selected
 member of a set of overloaded functions~(\ref{basic.lookup}, \ref{over.match}, \ref{over.over});
 
-\item the function is odr-used\iref{basic.def.odr} or, if it appears in an
+\item the function is \link{odr-used}{basic.def.odr} or, if it appears in an
 unevaluated operand, would be odr-used if the expression were
 potentially-evaluated;
 
@@ -975,8 +977,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}
@@ -1001,12 +1003,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%
@@ -1060,17 +1062,17 @@ [except.terminate]
 \pnum
 \indextext{\idxcode{terminate}}%
 In such cases,
-the function \tcode{std::terminate}
-is called\iref{exception.terminate}.
+the function \link{\tcode{std::terminate}}{exception.terminate}
+is called.
 In the situation where no matching handler is found, it is
 \impldef{stack unwinding before call to \tcode{std::terminate}} whether or not the
 stack is unwound
 before
 \tcode{std::terminate}
 is called.
-In the situation where the search for a handler\iref{except.handle} encounters the
+In the situation where the search for a \link{handler}{except.handle} encounters the
 outermost block of a function
-with a non-throwing exception specification\iref{except.spec}, it is
+with a non-throwing \link{exception specification}{except.spec}, it is
 \impldef{whether stack is unwound before calling the function \tcode{std::terminate}
 when a \tcode{noexcept} specification
 is violated}
@@ -1089,7 +1091,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 afc2ed3c..80f06a76 100644
--- a/source/preprocessor.tex
+++ b/source/preprocessor.tex
@@ -409,7 +409,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
@@ -455,8 +455,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}
@@ -474,8 +474,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, which may involve
 converting escape sequences into execution character set members.
@@ -1563,7 +1563,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
@@ -1844,13 +1844,13 @@ [cpp.predefined]
 \indextext{__stdcpp_strict_pointer_safety__@\mname{STDCPP_STRICT_POINTER_SAFETY}}%
 \mname{STDCPP_STRICT_POINTER_SAFETY}\\
 Defined, and has the value integer literal 1, if and only if the implementation
-has strict pointer safety\iref{basic.stc.dynamic.safety}.
+has \deflink{strict pointer safety}{basic.stc.dynamic.safety}.
 
 \item
 \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 a2a3c0e3..ce75fa9f 100644
--- a/source/lib-intro.tex
+++ b/source/lib-intro.tex
@@ -45,9 +45,9 @@ [library.general]
 \end{floattable}
 
 \pnum
-The language support library\iref{support} provides components that are
+The \link{language support library}{support} provides components that are
 required by certain parts of the \Cpp{} language, such as memory allocation~(\ref{expr.new},
-\ref{expr.delete}) and exception processing\iref{except}.
+\ref{expr.delete}) and \link{exception processing}{except}.
 
 \pnum
 The concepts library\iref{concepts} describes library components that \Cpp{}
@@ -59,9 +59,9 @@ [library.general]
 reporting errors in a \Cpp{} program, including predefined exception classes.
 
 \pnum
-The general utilities library\iref{utilities} includes components used
-by other library elements, such as a predefined storage allocator for dynamic
-storage management\iref{basic.stc.dynamic}, and components used
+The \link{general utilities library}{utilities} includes components used
+by other library elements, such as a predefined storage allocator for \link{dynamic
+storage management}{basic.stc.dynamic}, and components used
 as infrastructure
 in \Cpp{} programs,
 such as tuples, function wrappers, and time facilities.
@@ -76,7 +76,7 @@ [library.general]
 and sequences of any other character-like type.
 
 \pnum
-The localization library\iref{localization} provides extended internationalization
+The \link{localization library}{localization} provides extended internationalization
 support for text processing.
 
 \pnum
@@ -85,7 +85,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}
@@ -96,21 +96,21 @@ [library.general]
 The random number component provides facilities for generating pseudo-random numbers.
 
 \pnum
-The input/output library\iref{input.output} provides the
+The \link{input/output library}{input.output} provides the
 \tcode{iostream}
 components that are the primary mechanism for \Cpp{} program input and output.
 They can be used with other elements of the library, particularly
 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 atomic operations library\iref{atomics} allows more fine-grained
+The \link{atomic operations library}{atomics} allows more fine-grained
 concurrent access to shared data than is possible with locks.
 
 \pnum
-The thread support library\iref{thread} provides components to create
+The \link{thread support library}{thread} provides components to create
 and manage threads, including mutual exclusion and interthread communication.
 
 \rSec1[library.c]{The C standard library}
@@ -430,8 +430,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.func]{Exposition-only functions}
 
@@ -555,7 +555,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
@@ -673,7 +673,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
@@ -813,7 +813,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}.
@@ -1069,10 +1069,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
@@ -1293,8 +1293,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}
 
@@ -1337,7 +1337,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}.
@@ -1372,8 +1372,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}
 
@@ -1412,7 +1412,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}}
@@ -1538,13 +1538,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
@@ -1626,7 +1626,7 @@ [nullablepointer.requirements]
 \oldconcept{DefaultConstructible}, \oldconcept{CopyConstructible}, \oldconcept{\-Copy\-Assign\-able},
 and \oldconcept{Destructible} requirements,
 
-\item lvalues of type \tcode{P} are swappable\iref{swappable.requirements},
+\item lvalues of type \tcode{P} are \link{swappable}{swappable.requirements},
 
 \item the expressions shown in \tref{cpp17.nullablepointer} are
 valid and have the indicated semantics, and
@@ -1644,8 +1644,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
@@ -1745,10 +1746,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.
 
 \begin{shortlibreqtab2}
@@ -2039,7 +2040,7 @@ [allocator.requirements.general]
 \oldconcept{\-Move\-Assign\-able} requirements (\tref{cpp17.moveassignable})
 and the move operation shall not throw exceptions.
 If \tcode{X::propagate_on_container_swap::value} is \tcode{true},
-lvalues of type \tcode{X} shall be swappable\iref{swappable.requirements}
+lvalues of type \tcode{X} shall be \link{swappable}{swappable.requirements}
 and the \tcode{swap} operation shall not throw exceptions.
 
 \pnum
@@ -2144,7 +2145,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}
 
@@ -2155,11 +2156,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}
 
@@ -2523,7 +2524,7 @@ [extern.types]
 \rSec4[usrlit.suffix]{User-defined literal suffixes}
 
 \pnum
-Literal suffix identifiers\iref{over.literal} that do not start with an underscore are reserved for future standardization.
+\link{Literal suffix identifiers}{over.literal} that do not start with an underscore are reserved for future standardization.
 
 \rSec3[alt.headers]{Headers}
 
@@ -2531,7 +2532,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}
@@ -2752,7 +2753,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.
@@ -2812,7 +2813,7 @@ [res.on.headers]
 included after any other header that also defines it\iref{basic.def.odr}.
 
 \pnum
-The C standard library headers\iref{depr.c.headers}
+The \link{C standard library headers}{depr.c.headers}
 shall include only their corresponding \Cpp{} standard library header,
 as described in~\ref{headers}.
 
@@ -2840,7 +2841,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
@@ -2868,7 +2869,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}
@@ -2883,7 +2884,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,
@@ -2962,8 +2963,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.
 
@@ -3006,7 +3007,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}
@@ -3114,7 +3115,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}
@@ -3142,7 +3143,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 ec09a5ea..00983373 100644
--- a/source/support.tex
+++ b/source/support.tex
@@ -43,21 +43,14 @@ [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}
 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>
@@ -79,8 +72,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
@@ -98,11 +91,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}%
@@ -119,7 +107,6 @@ [cstdlib.syn]
 \indexlibraryglobal{div_t}%
 \indexlibraryglobal{exit}%
 \indexlibraryglobal{free}%
-\indexlibraryglobal{getenv}%
 \indexlibraryglobal{labs}%
 \indexlibraryglobal{ldiv}%
 \indexlibraryglobal{ldiv_t}%
@@ -154,11 +141,11 @@ [cstdlib.syn]
   using lldiv_t = @\seebelow@;
 }
 
-#define NULL @\seebelow@
-#define EXIT_FAILURE @\seebelow@
-#define EXIT_SUCCESS @\seebelow@
-#define RAND_MAX @\seebelow@
-#define MB_CUR_MAX @\seebelow@
+#define @\libglobal{NULL}@ @\seebelow@
+#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
@@ -177,7 +164,7 @@ [cstdlib.syn]
   [[noreturn]] void _Exit(int status) noexcept;
   [[noreturn]] void quick_exit(int status) noexcept;
 
-  char* getenv(const char* name);
+  char* @\libglobal{getenv}@(const char* name);
   int system(const char* string);
 
   // \ref{c.malloc}, C library memory allocation
@@ -252,7 +239,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}
@@ -306,8 +293,8 @@ [support.types.layout]
 is overloaded for any of the types involved.
 \end{footnote}\space
 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
@@ -328,7 +315,7 @@ [support.types.layout]
 \pnum
 \begin{note}
 It is recommended that implementations choose types for \tcode{ptrdiff_t} and \tcode{size_t}
-whose integer conversion ranks\iref{conv.rank} are no greater than that of
+whose integer \link{conversion ranks}{conv.rank} are no greater than that of
 \tcode{signed long int} unless a larger size is necessary to contain all the possible values.
 \end{note}
 
@@ -914,13 +901,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}
@@ -1908,7 +1895,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}%
@@ -1928,7 +1915,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}%
@@ -1945,7 +1932,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}.
@@ -2039,7 +2027,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
@@ -2091,7 +2080,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}
 
@@ -2205,7 +2194,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
@@ -2245,7 +2234,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
@@ -2470,7 +2459,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
@@ -2797,8 +2786,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}
 
@@ -2952,8 +2941,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 the result
 are reachable through \tcode{p} (see below).
@@ -3168,7 +3157,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}~(\ref{string.classes}, \ref{locale.codecvt}).
 \end{itemdescr}
@@ -3578,7 +3568,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}~(\ref{string.classes}, \ref{locale.codecvt}).
 The return value remains valid until the exception object from which
@@ -3725,13 +3716,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}
@@ -3790,8 +3781,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.
@@ -4101,7 +4093,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}%
@@ -4210,7 +4202,7 @@ [cmp.partialord]
 
 \pnum
 The \tcode{partial_ordering} type is typically used
-as the result type of a three-way comparison operator\iref{expr.spaceship}
+as the result type of a \link{three-way comparison operator}{expr.spaceship}
 that (a) admits all of the six two-way comparison operators (\ref{expr.rel}, \ref{expr.eq}),
 (b) does not imply substitutability,
 and (c) permits two values to be incomparable.
@@ -4327,7 +4319,7 @@ [cmp.weakord]
 
 \pnum
 The \tcode{weak_ordering} type is typically used
-as the result type of a three-way comparison operator\iref{expr.spaceship}
+as the result type of a \link{three-way comparison operator}{expr.spaceship}
 that (a) admits all of the six two-way comparison operators (\ref{expr.rel}, \ref{expr.eq}),
 and (b) does not imply substitutability.
 
@@ -4451,7 +4443,7 @@ [cmp.strongord]
 
 \pnum
 The \tcode{strong_ordering} type is typically used
-as the result type of a three-way comparison operator\iref{expr.spaceship}
+as the result type of a \link{three-way comparison operator}{expr.spaceship}
 that (a) admits all of the six two-way comparison operators (\ref{expr.rel}, \ref{expr.eq}),
 and (b) does imply substitutability.
 
@@ -5532,7 +5524,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
@@ -5542,20 +5534,15 @@ [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}
 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 384172f4..6b42dead 100644
--- a/source/concepts.tex
+++ b/source/concepts.tex
@@ -295,7 +295,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>;
@@ -488,13 +488,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}
@@ -738,7 +738,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}
@@ -758,7 +758,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}}
@@ -1127,8 +1127,8 @@ [concepts.object]
 
 \begin{itemdecl}
 template<class T>
-  concept @\deflibconcept{movable}@ = is_object_v<T> && move_constructible<T> &&
-                    @\libconcept{assignable_from}@<T&, T> && swappable<T>;
+  concept @\deflibconcept{movable}@ = @\libglobalref{is_object_v}@<T> && @\libconcept{move_constructible}@<T> &&
+                    @\libconcept{assignable_from}@<T&, T> && @\libconcept{swappable}@<T>;
 template<class T>
   concept @\deflibconcept{copyable}@ = @\libconcept{copy_constructible}@<T> && @\libconcept{movable}@<T> && @\libconcept{assignable_from}@<T&, T&> &&
                      @\libconcept{assignable_from}@<T&, const T&> && @\libconcept{assignable_from}@<T&, const T>;
diff --git a/source/diagnostics.tex b/source/diagnostics.tex
index ac074815..e1540bd6 100644
--- a/source/diagnostics.tex
+++ b/source/diagnostics.tex
@@ -471,13 +471,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}
 
@@ -1558,7 +1558,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 2925ed5e..becf21ea 100644
--- a/source/utilities.tex
+++ b/source/utilities.tex
@@ -102,15 +102,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>
@@ -284,7 +284,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}}%
@@ -404,7 +404,7 @@ [declval]
 
 \pnum
 The library provides the function template \tcode{declval} to simplify the definition of
-expressions which occur as unevaluated operands\iref{expr.prop}.
+expressions which occur as \deflinkx{unevaluated operands}{unevaluated operand}{expr.prop}.
 
 \indexlibraryglobal{declval}%
 \begin{itemdecl}
@@ -1173,7 +1173,7 @@ [pair.piecewise]
 The \tcode{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}
@@ -1661,7 +1661,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}
@@ -5167,6 +5167,7 @@ [variant.visit]
 \rSec2[variant.monostate]{Class \tcode{monostate}}%
 \indexlibraryglobal{monostate}%
 
+\indexlibrary{\idxcode{monostate}}%
 \begin{itemdecl}
 struct monostate{};
 \end{itemdecl}
@@ -5329,7 +5330,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}
@@ -5910,7 +5912,7 @@ [bitset.syn]
 
 \begin{codeblock}
 #include <string>
-#include <iosfwd>   // for \tcode{istream}\iref{istream.syn}, \tcode{ostream}\iref{ostream.syn}, see \ref{iosfwd.syn}
+#include <iosfwd>   // for \link{\tcode{istream}}{istream.syn}, \link{\tcode{ostream}}{ostream.syn}, see \ref{iosfwd.syn}
 
 namespace std {
   template<size_t N> class bitset;
@@ -6085,8 +6087,8 @@ [bitset.cons]
 \effects
 Initializes the first \tcode{M} bit positions to the corresponding bit
 values in \tcode{val}.
-\tcode{M} is the smaller of \tcode{N} and the number of bits in the value
-representation\iref{basic.types} of \tcode{unsigned long long}.
+\tcode{M} is the smaller of \tcode{N} and the number of bits in the
+\deflinkx{value representation}{representation!value}{basic.types} of \tcode{unsigned long long}.
 If \tcode{M < N}, the remaining bit positions are initialized to zero.
 \end{itemdescr}
 
@@ -6624,8 +6626,8 @@ [bitset.members]
 
 \pnum
 \remarks
-For the purpose of determining the presence of a data
-race\iref{intro.multithread}, any access or update through the resulting
+For the purpose of determining the presence of a
+\deflink{data race}{intro.multithread}, any access or update through the resulting
 reference potentially accesses or modifies, respectively, the entire
 underlying bitset.
 \end{itemdescr}
@@ -6687,7 +6689,7 @@ [bitset.operators]
 
 \begin{itemdescr}
 \pnum
-A formatted input function\iref{istream.formatted}.
+A \link{formatted input function}{istream.formatted}.
 
 \pnum
 \effects
@@ -7523,8 +7525,8 @@ [util.dynamic.safety]
 \begin{itemdescr}
 \pnum
 \returns
-\tcode{pointer_safety::strict} if the implementation has strict pointer
-safety\iref{basic.stc.dynamic.safety}. It is
+\tcode{pointer_safety::strict} if the implementation has
+\deflink{strict pointer safety}{basic.stc.dynamic.safety}. It is
 \impldef{whether \tcode{get_pointer_safety} returns
 \tcode{pointer_safety::relaxed} or
 \tcode{pointer_safety::\brk{}preferred} if the implementation has relaxed pointer safety}
@@ -8210,13 +8212,13 @@ [default.allocator.general]
 All specializations of the default allocator meet the
 allocator completeness requirements\iref{allocator.requirements.completeness}.
 
-\indexlibraryglobal{allocator}%
 \indexlibrarymember{value_type}{allocator}%
 \indexlibrarymember{size_type}{allocator}%
 \indexlibrarymember{difference_type}{allocator}%
 \indexlibrarymember{propagate_on_container_move_assignment}{allocator}%
 \indexlibrarymember{is_always_equal}{allocator}%
 \indexlibrarymember{operator=}{allocator}%
+\indexlibraryglobal{allocator}%
 \begin{codeblock}
 namespace std {
   template<class T> class allocator {
@@ -8243,7 +8245,7 @@ [allocator.members]
 
 \pnum
 Except for the destructor, member functions of the default allocator shall not introduce
-data races\iref{intro.multithread} as a result of concurrent calls to those member
+\deflinkx{data races}{data race}{intro.multithread} as a result of concurrent calls to those member
 functions from different threads. 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 the next allocation (if any) in this order.
@@ -8271,7 +8273,7 @@ [allocator.members]
 \pnum
 \remarks
 The storage for the array
-is obtained by calling \tcode{::operator new}\iref{new.delete},
+is obtained by calling \link{\tcode{::operator new}}{new.delete},
 but it is unspecified when or how often this
 function is called.
 This function starts the lifetime of the array object,
@@ -8297,7 +8299,7 @@ [allocator.members]
 \pnum
 \remarks
 Uses
-\tcode{::operator delete}\iref{new.delete},
+\link{\tcode{::operator delete}}{new.delete},
 but it is unspecified
 when this function is called.
 \end{itemdescr}
@@ -8607,8 +8609,9 @@ [unique.ptr.single.general]
 \pnum
 The default type for the template parameter \tcode{D} is
 \tcode{default_delete}. A client-supplied template argument
-\tcode{D} shall be a function
-object type\iref{function.objects}, lvalue reference to function, or
+\tcode{D} shall be a
+\deflinkx{function object type}{function object!type}{function.objects},
+lvalue reference to function, or
 lvalue reference to function object type
 for which, given
 a value \tcode{d} of type \tcode{D} and a value
@@ -9806,7 +9809,7 @@ [util.smartptr.shared.const]
 enables \tcode{shared_from_this} with \tcode{p},
 for a pointer \tcode{p} of type \tcode{Y*},
 means that if \tcode{Y} has an unambiguous and accessible base class
-that is a specialization of \tcode{enable_shared_from_this}\iref{util.smartptr.enab},
+that is a specialization of \link{\tcode{enable_shared_from_this}}{util.smartptr.enab},
 then \tcode{remove_cv_t<Y>*} shall be implicitly convertible to \tcode{T*} and
 the constructor evaluates the statement:
 \begin{codeblock}
@@ -12268,8 +12271,7 @@ [mem.res.pool.ctor]
 
 \rSec3[mem.res.pool.mem]{Members}
 
-\indexlibrarymember{release}{synchronized_pool_resource}%
-\indexlibrarymember{release}{unsynchronized_pool_resource}%
+\indexlibrarymember{release}{synchronized_pool_resource}\indexlibrarymember{release}{unsynchronized_pool_resource}%
 \begin{itemdecl}
 void release();
 \end{itemdecl}
@@ -13046,8 +13048,8 @@ [function.objects]
 \rSec2[function.objects.general]{General}
 
 \pnum
-A \defnx{function object type}{function object!type} is an object
-type\iref{basic.types} that can be the type of the
+A \defnx{function object type}{function object!type} is an
+\deflink{object type}{basic.types} that can be the type of the
 \grammarterm{postfix-expression} in a function call
 (\ref{expr.call}, \ref{over.match.call}).
 \begin{footnote}
@@ -13057,7 +13059,7 @@ [function.objects.general]
 \end{footnote}
 A \defn{function object} is an
 object of a function object type. In the places where one would expect to pass a
-pointer to a function to an algorithmic template\iref{algorithms}, the
+pointer to a function to an \link{algorithmic template}{algorithms}, the
 interface is specified to accept a function object. This not only makes
 algorithmic templates work with pointers to functions, but also enables them to
 work with arbitrary function objects.
@@ -13243,7 +13245,7 @@ [func.def]
 parenthesized comma-separated list of zero or more argument types.
 
 \pnum
-A \defnadj{callable}{type} is a function object type\iref{function.objects} or a pointer to member.
+A \defnadj{callable}{type} is a \deflinkx{function object type}{function object!type}{function.objects} or a pointer to member.
 
 \pnum
 A \defnadj{callable}{object} is an object of a callable type.
@@ -13376,8 +13378,8 @@ [func.require]
 if the types of their corresponding state entities are the same.
 
 \rSec2[func.invoke]{Function template \tcode{invoke}}
-\indexlibraryglobal{invoke}%
 \indexlibrary{invoke@\tcode{\placeholder{INVOKE}}}%
+\indexlibraryglobal{invoke}%
 \begin{itemdecl}
 template<class F, class... Args>
   constexpr invoke_result_t<F, Args...> invoke(F&& f, Args&&... args)
@@ -13387,7 +13389,8 @@ [func.invoke]
 \begin{itemdescr}
 \pnum
 \returns
-\tcode{\placeholdernc{INVOKE}(std::forward<F>(f), std::forward<Args>(args)...)}\iref{func.require}.
+\libglobalrefx{\placeholdernc{INVOKE}}{invoke}%
+\tcode{(std::forward<F>(f), std::forward<Args>(args)...)}.
 \end{itemdescr}
 
 \rSec2[refwrap]{Class template \tcode{reference_wrapper}}
@@ -13430,7 +13433,8 @@ [refwrap.general]
 around a reference to an object or function of type \tcode{T}.
 
 \pnum
-\tcode{reference_wrapper<T>} is a trivially copyable type\iref{basic.types}.
+\tcode{reference_wrapper<T>} is a
+\deflinkx{trivially copyable type}{type!trivially copyable}{basic.types}.
 
 \pnum
 The template parameter \tcode{T} of \tcode{reference_wrapper}
@@ -15107,23 +15111,23 @@ [func.wrap.func.general]
 \pnum
 The \tcode{function} class template provides polymorphic wrappers that
 generalize the notion of a function pointer. Wrappers can store, copy,
-and call arbitrary callable objects\iref{func.def}, given a call
-signature\iref{func.def}, allowing functions to be first-class objects.
+and call arbitrary \deflinkx{callable objects}{object!callable}{func.def}, given a
+\deflink{call signature}{func.def}, allowing functions to be first-class objects.
 
 \pnum
 \indextext{callable type}%
-A callable type\iref{func.def} \tcode{F}
+A \deflinkx{callable type}{type!callable}{func.def} \tcode{F}
 is \defn{Lvalue-Callable} for argument
 types \tcode{ArgTypes}
 and return type \tcode{R}
 if the expression
 \tcode{\placeholdernc{INVOKE}<R>(declval<F\&>(), declval<ArgTypes>()...)},
-considered as an unevaluated operand\iref{expr.prop}, is
+considered as an \deflink{unevaluated operand}{expr.prop}, is
 well-formed\iref{func.require}.
 
 \pnum
-The \tcode{function} class template is a call
-wrapper\iref{func.def} whose call signature\iref{func.def}
+The \tcode{function} class template is a
+\deflink{call wrapper}{func.def} whose \deflink{call signature}{func.def}
 is \tcode{R(ArgTypes...)}.
 
 \pnum
@@ -15399,8 +15403,7 @@ [func.wrap.func.cap]
 
 \rSec4[func.wrap.func.inv]{Invocation}
 
-\indexlibrary{\idxcode{function}!invocation}%
-\indexlibrarymember{operator()}{function}%
+\indexlibrary{\idxcode{function}!invocation}\indexlibrarymember{operator()}{function}%
 \begin{itemdecl}
 R operator()(ArgTypes... args) const;
 \end{itemdecl}
@@ -15409,7 +15412,7 @@ [func.wrap.func.inv]
 \pnum
 \returns
 \tcode{\placeholdernc{INVOKE}<R>(f, std::forward<ArgTypes>(args)...)}\iref{func.require},
-where \tcode{f} is the target object\iref{func.def} of \tcode{*this}.
+where \tcode{f} is the \deflink{target object}{func.def} of \tcode{*this}.
 
 \pnum
 \throws
@@ -15801,7 +15804,7 @@ [unord.hash]
 \tcode{is_copy_assignable_v<H>}, and
 \tcode{is_move_assignable_v<H>}.
 Disabled specializations of \tcode{hash}
-are not function object types\iref{function.objects}.
+are not \deflinkx{function object types}{function object!type}{function.objects}.
 \begin{note}
 This means that the specialization of \tcode{hash} exists, but
 any attempts to use it as a \oldconcept{Hash} will be ill-formed.
@@ -15855,7 +15858,7 @@ [meta.rqmts]
 and publicly and unambiguously derived, directly or indirectly, from
 its \defn{base characteristic}, which is
 a specialization of the template
-\tcode{integral_constant}\iref{meta.help}, with
+\libglobalref{integral_constant}, with
 the arguments to the template \tcode{integral_constant} determined by the
 requirements for the particular property being described.
 The member names of the base characteristic shall not be hidden and shall be
@@ -15871,7 +15874,7 @@ [meta.rqmts]
 indirectly, from
 its \term{base characteristic}, which is a specialization
 of the template
-\tcode{integral_constant}\iref{meta.help}, with
+\libglobalref{integral_constant}, with
 the arguments to the template \tcode{integral_constant} determined by the
 requirements for the particular relationship being described.
 The member names of the base characteristic shall not be hidden and shall be
@@ -16031,17 +16034,17 @@ [meta.type.synop]
   template<class T> struct add_cv;
 
   template<class T>
-    using @\libglobal{remove_const_t}@    = typename remove_const<T>::type;
+    using @\libglobal{remove_const_t}@    = typename @\libglobalref{remove_const}@<T>::type;
   template<class T>
-    using @\libglobal{remove_volatile_t}@ = typename remove_volatile<T>::type;
+    using @\libglobal{remove_volatile_t}@ = typename @\libglobalref{remove_volatile}@<T>::type;
   template<class T>
-    using @\libglobal{remove_cv_t}@       = typename remove_cv<T>::type;
+    using @\libglobal{remove_cv_t}@       = typename @\libglobalref{remove_cv}@<T>::type;
   template<class T>
-    using @\libglobal{add_const_t}@       = typename add_const<T>::type;
+    using @\libglobal{add_const_t}@       = typename @\libglobalref{add_const}@<T>::type;
   template<class T>
-    using @\libglobal{add_volatile_t}@    = typename add_volatile<T>::type;
+    using @\libglobal{add_volatile_t}@    = typename @\libglobalref{add_volatile}@<T>::type;
   template<class T>
-    using @\libglobal{add_cv_t}@          = typename add_cv<T>::type;
+    using @\libglobal{add_cv_t}@          = typename @\libglobalref{add_cv}@<T>::type;
 
   // \ref{meta.trans.ref}, reference modifications
   template<class T> struct remove_reference;
@@ -16049,38 +16052,38 @@ [meta.type.synop]
   template<class T> struct add_rvalue_reference;
 
   template<class T>
-    using @\libglobal{remove_reference_t}@     = typename remove_reference<T>::type;
+    using @\libglobal{remove_reference_t}@     = typename @\libglobalref{remove_reference}@<T>::type;
   template<class T>
-    using @\libglobal{add_lvalue_reference_t}@ = typename add_lvalue_reference<T>::type;
+    using @\libglobal{add_lvalue_reference_t}@ = typename @\libglobalref{add_lvalue_reference}@<T>::type;
   template<class T>
-    using @\libglobal{add_rvalue_reference_t}@ = typename add_rvalue_reference<T>::type;
+    using @\libglobal{add_rvalue_reference_t}@ = typename @\libglobalref{add_rvalue_reference}@<T>::type;
 
   // \ref{meta.trans.sign}, sign modifications
   template<class T> struct make_signed;
   template<class T> struct make_unsigned;
 
   template<class T>
-    using @\libglobal{make_signed_t}@   = typename make_signed<T>::type;
+    using @\libglobal{make_signed_t}@   = typename @\libglobalref{make_signed}@<T>::type;
   template<class T>
-    using @\libglobal{make_unsigned_t}@ = typename make_unsigned<T>::type;
+    using @\libglobal{make_unsigned_t}@ = typename @\libglobalref{make_unsigned}@<T>::type;
 
   // \ref{meta.trans.arr}, array modifications
   template<class T> struct remove_extent;
   template<class T> struct remove_all_extents;
 
   template<class T>
-    using @\libglobal{remove_extent_t}@      = typename remove_extent<T>::type;
+    using @\libglobal{remove_extent_t}@      = typename @\libglobalref{remove_extent}@<T>::type;
   template<class T>
-    using @\libglobal{remove_all_extents_t}@ = typename remove_all_extents<T>::type;
+    using @\libglobal{remove_all_extents_t}@ = typename @\libglobalref{remove_all_extents}@<T>::type;
 
   // \ref{meta.trans.ptr}, pointer modifications
   template<class T> struct remove_pointer;
   template<class T> struct add_pointer;
 
   template<class T>
-    using @\libglobal{remove_pointer_t}@ = typename remove_pointer<T>::type;
+    using @\libglobal{remove_pointer_t}@ = typename @\libglobalref{remove_pointer}@<T>::type;
   template<class T>
-    using @\libglobal{add_pointer_t}@    = typename add_pointer<T>::type;
+    using @\libglobal{add_pointer_t}@    = typename @\libglobalref{add_pointer}@<T>::type;
 
   // \ref{meta.trans.other}, other transformations
   template<class T> struct type_identity;
@@ -16101,31 +16104,31 @@ [meta.type.synop]
   template<class T> struct unwrap_ref_decay;
 
   template<class T>
-    using @\libglobal{type_identity_t}@    = typename type_identity<T>::type;
+    using @\libglobal{type_identity_t}@    = typename @\libglobalref{type_identity}@<T>::type;
   template<size_t Len, size_t Align = @\textit{default-alignment}@> // see \ref{meta.trans.other}
-    using @\libglobal{aligned_storage_t}@  = typename aligned_storage<Len, Align>::type;
+    using @\libglobal{aligned_storage_t}@  = typename @\libglobalref{aligned_storage}@<Len, Align>::type;
   template<size_t Len, class... Types>
-    using @\libglobal{aligned_union_t}@    = typename aligned_union<Len, Types...>::type;
+    using @\libglobal{aligned_union_t}@    = typename @\libglobalref{aligned_union}@<Len, Types...>::type;
   template<class T>
-    using @\libglobal{remove_cvref_t}@     = typename remove_cvref<T>::type;
+    using @\libglobal{remove_cvref_t}@     = typename @\libglobalref{remove_cvref}@<T>::type;
   template<class T>
-    using @\libglobal{decay_t}@            = typename decay<T>::type;
+    using @\libglobal{decay_t}@            = typename @\libglobalref{decay}@<T>::type;
   template<bool b, class T = void>
-    using @\libglobal{enable_if_t}@        = typename enable_if<b, T>::type;
+    using @\libglobal{enable_if_t}@        = typename @\libglobalref{enable_if}@<b, T>::type;
   template<bool b, class T, class F>
-    using @\libglobal{conditional_t}@      = typename conditional<b, T, F>::type;
+    using @\libglobal{conditional_t}@      = typename @\libglobalref{conditional}@<b, T, F>::type;
   template<class... T>
-    using @\libglobal{common_type_t}@      = typename common_type<T...>::type;
+    using @\libglobal{common_type_t}@      = typename @\libglobalref{common_type}@<T...>::type;
   template<class... T>
-    using @\libglobal{common_reference_t}@ = typename common_reference<T...>::type;
+    using @\libglobal{common_reference_t}@ = typename @\libglobalref{common_reference}@<T...>::type;
   template<class T>
-    using @\libglobal{underlying_type_t}@  = typename underlying_type<T>::type;
+    using @\libglobal{underlying_type_t}@  = typename @\libglobalref{underlying_type}@<T>::type;
   template<class Fn, class... ArgTypes>
-    using @\libglobal{invoke_result_t}@    = typename invoke_result<Fn, ArgTypes...>::type;
+    using @\libglobal{invoke_result_t}@    = typename @\libglobalref{invoke_result}@<Fn, ArgTypes...>::type;
   template<class T>
-    using unwrap_reference_t = typename unwrap_reference<T>::type;
+    using unwrap_reference_t = typename @\libglobalref{unwrap_reference}@<T>::type;
   template<class T>
-    using unwrap_ref_decay_t = typename unwrap_ref_decay<T>::type;
+    using unwrap_ref_decay_t = typename @\libglobalref{unwrap_ref_decay}@<T>::type;
   template<class...>
     using @\libglobal{void_t}@             = void;
 
@@ -16136,190 +16139,190 @@ [meta.type.synop]
 
   // \ref{meta.unary.cat}, primary type categories
   template<class T>
-    inline constexpr bool @\libglobal{is_void_v}@ = is_void<T>::value;
+    inline constexpr bool @\libglobal{is_void_v}@ = @\libglobalref{is_void}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_null_pointer_v}@ = is_null_pointer<T>::value;
+    inline constexpr bool @\libglobal{is_null_pointer_v}@ = @\libglobalref{is_null_pointer}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_integral_v}@ = is_integral<T>::value;
+    inline constexpr bool @\libglobal{is_integral_v}@ = @\libglobalref{is_integral}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_floating_point_v}@ = is_floating_point<T>::value;
+    inline constexpr bool @\libglobal{is_floating_point_v}@ = @\libglobalref{is_floating_point}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_array_v}@ = is_array<T>::value;
+    inline constexpr bool @\libglobal{is_array_v}@ = @\libglobalref{is_array}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_pointer_v}@ = is_pointer<T>::value;
+    inline constexpr bool @\libglobal{is_pointer_v}@ = @\libglobalref{is_pointer}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_lvalue_reference_v}@ = is_lvalue_reference<T>::value;
+    inline constexpr bool @\libglobal{is_lvalue_reference_v}@ = @\libglobalref{is_lvalue_reference}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_rvalue_reference_v}@ = is_rvalue_reference<T>::value;
+    inline constexpr bool @\libglobal{is_rvalue_reference_v}@ = @\libglobalref{is_rvalue_reference}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_member_object_pointer_v}@ = is_member_object_pointer<T>::value;
+    inline constexpr bool @\libglobal{is_member_object_pointer_v}@ = @\libglobalref{is_member_object_pointer}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_member_function_pointer_v}@ = is_member_function_pointer<T>::value;
+    inline constexpr bool @\libglobal{is_member_function_pointer_v}@ = @\libglobalref{is_member_function_pointer}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_enum_v}@ = is_enum<T>::value;
+    inline constexpr bool @\libglobal{is_enum_v}@ = @\libglobalref{is_enum}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_union_v}@ = is_union<T>::value;
+    inline constexpr bool @\libglobal{is_union_v}@ = @\libglobalref{is_union}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_class_v}@ = is_class<T>::value;
+    inline constexpr bool @\libglobal{is_class_v}@ = @\libglobalref{is_class}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_function_v}@ = is_function<T>::value;
+    inline constexpr bool @\libglobal{is_function_v}@ = @\libglobalref{is_function}@<T>::value;
 
   // \ref{meta.unary.comp}, composite type categories
   template<class T>
-    inline constexpr bool @\libglobal{is_reference_v}@ = is_reference<T>::value;
+    inline constexpr bool @\libglobal{is_reference_v}@ = @\libglobalref{is_reference}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_arithmetic_v}@ = is_arithmetic<T>::value;
+    inline constexpr bool @\libglobal{is_arithmetic_v}@ = @\libglobalref{is_arithmetic}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_fundamental_v}@ = is_fundamental<T>::value;
+    inline constexpr bool @\libglobal{is_fundamental_v}@ = @\libglobalref{is_fundamental}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_object_v}@ = is_object<T>::value;
+    inline constexpr bool @\libglobal{is_object_v}@ = @\libglobalref{is_object}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_scalar_v}@ = is_scalar<T>::value;
+    inline constexpr bool @\libglobal{is_scalar_v}@ = @\libglobalref{is_scalar}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_compound_v}@ = is_compound<T>::value;
+    inline constexpr bool @\libglobal{is_compound_v}@ = @\libglobalref{is_compound}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_member_pointer_v}@ = is_member_pointer<T>::value;
+    inline constexpr bool @\libglobal{is_member_pointer_v}@ = @\libglobalref{is_member_pointer}@<T>::value;
 
   // \ref{meta.unary.prop}, type properties
   template<class T>
-    inline constexpr bool @\libglobal{is_const_v}@ = is_const<T>::value;
+    inline constexpr bool @\libglobal{is_const_v}@ = @\libglobalref{is_const}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_volatile_v}@ = is_volatile<T>::value;
+    inline constexpr bool @\libglobal{is_volatile_v}@ = @\libglobalref{is_volatile}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_trivial_v}@ = is_trivial<T>::value;
+    inline constexpr bool @\libglobal{is_trivial_v}@ = @\libglobalref{is_trivial}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_trivially_copyable_v}@ = is_trivially_copyable<T>::value;
+    inline constexpr bool @\libglobal{is_trivially_copyable_v}@ = @\libglobalref{is_trivially_copyable}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_standard_layout_v}@ = is_standard_layout<T>::value;
+    inline constexpr bool @\libglobal{is_standard_layout_v}@ = @\libglobalref{is_standard_layout}@<T>::value;
   template<class T>
     inline constexpr bool @\libglobal{is_empty_v}@ = is_empty<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_polymorphic_v}@ = is_polymorphic<T>::value;
+    inline constexpr bool @\libglobal{is_polymorphic_v}@ = @\libglobalref{is_polymorphic}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_abstract_v}@ = is_abstract<T>::value;
+    inline constexpr bool @\libglobal{is_abstract_v}@ = @\libglobalref{is_abstract}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_final_v}@ = is_final<T>::value;
+    inline constexpr bool @\libglobal{is_final_v}@ = @\libglobalref{is_final}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_aggregate_v}@ = is_aggregate<T>::value;
+    inline constexpr bool @\libglobal{is_aggregate_v}@ = @\libglobalref{is_aggregate}@<T>::value;
   template<class T>
     inline constexpr bool @\libglobal{is_signed_v}@ = is_signed<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_unsigned_v}@ = is_unsigned<T>::value;
+    inline constexpr bool @\libglobal{is_unsigned_v}@ = @\libglobalref{is_unsigned}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_bounded_array_v}@ = is_bounded_array<T>::value;
+    inline constexpr bool @\libglobal{is_bounded_array_v}@ = @\libglobalref{is_bounded_array}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_unbounded_array_v}@ = is_unbounded_array<T>::value;
+    inline constexpr bool @\libglobal{is_unbounded_array_v}@ = @\libglobalref{is_unbounded_array}@<T>::value;
   template<class T, class... Args>
-    inline constexpr bool @\libglobal{is_constructible_v}@ = is_constructible<T, Args...>::value;
+    inline constexpr bool @\libglobal{is_constructible_v}@ = @\libglobalref{is_constructible}@<T, Args...>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_default_constructible_v}@ = is_default_constructible<T>::value;
+    inline constexpr bool @\libglobal{is_default_constructible_v}@ = @\libglobalref{is_default_constructible}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_copy_constructible_v}@ = is_copy_constructible<T>::value;
+    inline constexpr bool @\libglobal{is_copy_constructible_v}@ = @\libglobalref{is_copy_constructible}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_move_constructible_v}@ = is_move_constructible<T>::value;
+    inline constexpr bool @\libglobal{is_move_constructible_v}@ = @\libglobalref{is_move_constructible}@<T>::value;
   template<class T, class U>
-    inline constexpr bool @\libglobal{is_assignable_v}@ = is_assignable<T, U>::value;
+    inline constexpr bool @\libglobal{is_assignable_v}@ = @\libglobalref{is_assignable}@<T, U>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_copy_assignable_v}@ = is_copy_assignable<T>::value;
+    inline constexpr bool @\libglobal{is_copy_assignable_v}@ = @\libglobalref{is_copy_assignable}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_move_assignable_v}@ = is_move_assignable<T>::value;
+    inline constexpr bool @\libglobal{is_move_assignable_v}@ = @\libglobalref{is_move_assignable}@<T>::value;
   template<class T, class U>
-    inline constexpr bool @\libglobal{is_swappable_with_v}@ = is_swappable_with<T, U>::value;
+    inline constexpr bool @\libglobal{is_swappable_with_v}@ = @\libglobalref{is_swappable_with}@<T, U>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_swappable_v}@ = is_swappable<T>::value;
+    inline constexpr bool @\libglobal{is_swappable_v}@ = @\libglobalref{is_swappable}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_destructible_v}@ = is_destructible<T>::value;
+    inline constexpr bool @\libglobal{is_destructible_v}@ = @\libglobalref{is_destructible}@<T>::value;
   template<class T, class... Args>
     inline constexpr bool is_trivially_constructible_v
-      = is_trivially_constructible<T, Args...>::value;
+      = @\libglobalref{is_trivially_constructible}@<T, Args...>::value;
   template<class T>
     inline constexpr bool is_trivially_default_constructible_v
-      = is_trivially_default_constructible<T>::value;
+      = @\libglobalref{is_trivially_default_constructible}@<T>::value;
   template<class T>
     inline constexpr bool is_trivially_copy_constructible_v
-      = is_trivially_copy_constructible<T>::value;
+      = @\libglobalref{is_trivially_copy_constructible}@<T>::value;
   template<class T>
     inline constexpr bool is_trivially_move_constructible_v
-      = is_trivially_move_constructible<T>::value;
+      = @\libglobalref{is_trivially_move_constructible}@<T>::value;
   template<class T, class U>
-    inline constexpr bool @\libglobal{is_trivially_assignable_v}@ = is_trivially_assignable<T, U>::value;
+    inline constexpr bool @\libglobal{is_trivially_assignable_v}@ = @\libglobalref{is_trivially_assignable}@<T, U>::value;
   template<class T>
     inline constexpr bool is_trivially_copy_assignable_v
-      = is_trivially_copy_assignable<T>::value;
+      = @\libglobalref{is_trivially_copy_assignable}@<T>::value;
   template<class T>
     inline constexpr bool is_trivially_move_assignable_v
-      = is_trivially_move_assignable<T>::value;
+      = @\libglobalref{is_trivially_move_assignable}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_trivially_destructible_v}@ = is_trivially_destructible<T>::value;
+    inline constexpr bool @\libglobal{is_trivially_destructible_v}@ = @\libglobalref{is_trivially_destructible}@<T>::value;
   template<class T, class... Args>
     inline constexpr bool is_nothrow_constructible_v
-      = is_nothrow_constructible<T, Args...>::value;
+      = @\libglobalref{is_nothrow_constructible}@<T, Args...>::value;
   template<class T>
     inline constexpr bool is_nothrow_default_constructible_v
-      = is_nothrow_default_constructible<T>::value;
+      = @\libglobalref{is_nothrow_default_constructible}@<T>::value;
   template<class T>
     inline constexpr bool is_nothrow_copy_constructible_v
-      = is_nothrow_copy_constructible<T>::value;
+      = @\libglobalref{is_nothrow_copy_constructible}@<T>::value;
   template<class T>
     inline constexpr bool is_nothrow_move_constructible_v
-      = is_nothrow_move_constructible<T>::value;
+      = @\libglobalref{is_nothrow_move_constructible}@<T>::value;
   template<class T, class U>
-    inline constexpr bool @\libglobal{is_nothrow_assignable_v}@ = is_nothrow_assignable<T, U>::value;
+    inline constexpr bool @\libglobal{is_nothrow_assignable_v}@ = @\libglobalref{is_nothrow_assignable}@<T, U>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_nothrow_copy_assignable_v}@ = is_nothrow_copy_assignable<T>::value;
+    inline constexpr bool @\libglobal{is_nothrow_copy_assignable_v}@ = @\libglobalref{is_nothrow_copy_assignable}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_nothrow_move_assignable_v}@ = is_nothrow_move_assignable<T>::value;
+    inline constexpr bool @\libglobal{is_nothrow_move_assignable_v}@ = @\libglobalref{is_nothrow_move_assignable}@<T>::value;
   template<class T, class U>
-    inline constexpr bool @\libglobal{is_nothrow_swappable_with_v}@ = is_nothrow_swappable_with<T, U>::value;
+    inline constexpr bool @\libglobal{is_nothrow_swappable_with_v}@ = @\libglobalref{is_nothrow_swappable_with}@<T, U>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_nothrow_swappable_v}@ = is_nothrow_swappable<T>::value;
+    inline constexpr bool @\libglobal{is_nothrow_swappable_v}@ = @\libglobalref{is_nothrow_swappable}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{is_nothrow_destructible_v}@ = is_nothrow_destructible<T>::value;
+    inline constexpr bool @\libglobal{is_nothrow_destructible_v}@ = @\libglobalref{is_nothrow_destructible}@<T>::value;
   template<class T>
-    inline constexpr bool @\libglobal{has_virtual_destructor_v}@ = has_virtual_destructor<T>::value;
+    inline constexpr bool @\libglobal{has_virtual_destructor_v}@ = @\libglobalref{has_virtual_destructor}@<T>::value;
   template<class T>
     inline constexpr bool has_unique_object_representations_v
-      = has_unique_object_representations<T>::value;
+      = @\libglobalref{has_unique_object_representations}@<T>::value;
 
   // \ref{meta.unary.prop.query}, type property queries
   template<class T>
-    inline constexpr size_t @\libglobal{alignment_of_v}@ = alignment_of<T>::value;
+    inline constexpr size_t @\libglobal{alignment_of_v}@ = @\libglobalref{alignment_of}@<T>::value;
   template<class T>
-    inline constexpr size_t @\libglobal{rank_v}@ = rank<T>::value;
+    inline constexpr size_t @\libglobal{rank_v}@ = @\libglobalref{rank}@<T>::value;
   template<class T, unsigned I = 0>
-    inline constexpr size_t @\libglobal{extent_v}@ = extent<T, I>::value;
+    inline constexpr size_t @\libglobal{extent_v}@ = @\libglobalref{extent}@<T, I>::value;
 
   // \ref{meta.rel}, type relations
   template<class T, class U>
-    inline constexpr bool @\libglobal{is_same_v}@ = is_same<T, U>::value;
+    inline constexpr bool @\libglobal{is_same_v}@ = @\libglobalref{is_same}@<T, U>::value;
   template<class Base, class Derived>
-    inline constexpr bool @\libglobal{is_base_of_v}@ = is_base_of<Base, Derived>::value;
+    inline constexpr bool @\libglobal{is_base_of_v}@ = @\libglobalref{is_base_of}@<Base, Derived>::value;
   template<class From, class To>
-    inline constexpr bool @\libglobal{is_convertible_v}@ = is_convertible<From, To>::value;
+    inline constexpr bool @\libglobal{is_convertible_v}@ = @\libglobalref{is_convertible}@<From, To>::value;
   template<class From, class To>
-    inline constexpr bool @\libglobal{is_nothrow_convertible_v}@ = is_nothrow_convertible<From, To>::value;
+    inline constexpr bool @\libglobal{is_nothrow_convertible_v}@ = @\libglobalref{is_nothrow_convertible}@<From, To>::value;
   template<class T, class U>
-    inline constexpr bool @\libglobal{is_layout_compatible_v}@ = is_layout_compatible<T, U>::value;
+    inline constexpr bool @\libglobal{is_layout_compatible_v}@ = @\libglobalref{is_layout_compatible}@<T, U>::value;
   template<class Base, class Derived>
     inline constexpr bool @\libglobal{is_pointer_interconvertible_base_of_v}@
-      = is_pointer_interconvertible_base_of<Base, Derived>::value;
+      = @\libglobalref{is_pointer_interconvertible_base_of}@<Base, Derived>::value;
   template<class Fn, class... ArgTypes>
-    inline constexpr bool @\libglobal{is_invocable_v}@ = is_invocable<Fn, ArgTypes...>::value;
+    inline constexpr bool @\libglobal{is_invocable_v}@ = @\libglobalref{is_invocable}@<Fn, ArgTypes...>::value;
   template<class R, class Fn, class... ArgTypes>
-    inline constexpr bool @\libglobal{is_invocable_r_v}@ = is_invocable_r<R, Fn, ArgTypes...>::value;
+    inline constexpr bool @\libglobal{is_invocable_r_v}@ = @\libglobalref{is_invocable_r}@<R, Fn, ArgTypes...>::value;
   template<class Fn, class... ArgTypes>
-    inline constexpr bool @\libglobal{is_nothrow_invocable_v}@ = is_nothrow_invocable<Fn, ArgTypes...>::value;
+    inline constexpr bool @\libglobal{is_nothrow_invocable_v}@ = @\libglobalref{is_nothrow_invocable}@<Fn, ArgTypes...>::value;
   template<class R, class Fn, class... ArgTypes>
     inline constexpr bool is_nothrow_invocable_r_v
-      = is_nothrow_invocable_r<R, Fn, ArgTypes...>::value;
+      = @\libglobalref{is_nothrow_invocable_r}@<R, Fn, ArgTypes...>::value;
 
   // \ref{meta.logical}, logical operator traits
   template<class... B>
-    inline constexpr bool @\libglobal{conjunction_v}@ = conjunction<B...>::value;
+    inline constexpr bool @\libglobal{conjunction_v}@ = @\libglobalref{conjunction}@<B...>::value;
   template<class... B>
-    inline constexpr bool @\libglobal{disjunction_v}@ = disjunction<B...>::value;
+    inline constexpr bool @\libglobal{disjunction_v}@ = @\libglobalref{disjunction}@<B...>::value;
   template<class B>
-    inline constexpr bool @\libglobal{negation_v}@ = negation<B>::value;
+    inline constexpr bool @\libglobal{negation_v}@ = @\libglobalref{negation}@<B>::value;
 
   // \ref{meta.member}, member relationships
   template<class S, class M>
@@ -16335,6 +16338,7 @@ [meta.type.synop]
 \rSec2[meta.help]{Helper classes}
 
 \indexlibrarymember{value_type}{integral_constant}%
+\indexlibrary{\idxcode{integral_constant}}%
 \begin{codeblock}
 namespace std {
   template<class T, T v> struct integral_constant {
@@ -16420,7 +16424,7 @@ [meta.unary.cat]
 \tcode{template<class T>}\br
  \tcode{struct is_array;}           &
 \tcode{T} is an array type\iref{basic.compound} of known or unknown extent    &
-Class template \tcode{array}\iref{array}
+Class template \link{\tcode{array}}{array}
 is not an array type.                   \\ \rowsep
 \indexlibraryglobal{is_pointer}%
 \tcode{template<class T>}\br
@@ -16507,7 +16511,7 @@ [meta.unary.comp]
 \indexlibraryglobal{is_member_pointer}%
 \tcode{template<class T>}\br
  \tcode{struct is_member_pointer;}      &
- \tcode{T} is a pointer-to-member type\iref{basic.compound}               &   \\
+ \tcode{T} is a \deflink{pointer-to-member}{basic.compound} type               &   \\
 \end{libreqtab3b}
 
 \rSec3[meta.unary.prop]{Type properties}
@@ -16531,7 +16535,7 @@ [meta.unary.prop]
 For the purpose of defining the templates in this subclause,
 a function call expression \tcode{declval<T>()} for any type \tcode{T}
 is considered to be a trivial~(\ref{basic.types}, \ref{special}) function call
-that is not an odr-use\iref{basic.def.odr} of \tcode{declval}
+that is not an \link{odr-use}{basic.def.odr} of \tcode{declval}
 in the context of the corresponding definition
 notwithstanding the restrictions of~\ref{declval}.
 
@@ -16679,8 +16683,8 @@ [meta.unary.prop]
 \tcode{template<class T, class U>}\br
   \tcode{struct is_assignable;} &
   The expression \tcode{declval<T>() =} \tcode{declval<U>()} is well-formed
-  when treated as an unevaluated
-  operand\iref{expr.prop}. Access checking is performed as if in a context
+  when treated as an \deflink{unevaluated
+  operand}{expr.prop}. Access checking is performed as if in a context
   unrelated to \tcode{T} and \tcode{U}. Only the validity of the immediate context
   of the assignment expression is considered.
 \begin{tailnote}
@@ -16715,7 +16719,7 @@ [meta.unary.prop]
   \tcode{struct is_swappable_with;} &
   The expressions \tcode{swap(declval<T>(), declval<U>())} and
   \tcode{swap(declval<U>(), declval<T>())} are each well-formed
-  when treated as an unevaluated operand\iref{expr.prop}
+  when treated as an \deflink{unevaluated operand}{expr.prop}
   in an overload-resolution context
   for swappable values\iref{swappable.requirements}.
   Access checking is performed as if in a context
@@ -16753,7 +16757,7 @@ [meta.unary.prop]
   for which the expression
   \tcode{declval<U\&>().\~U()}
   is well-formed
-  when treated as an unevaluated operand\iref{expr.prop},
+  when treated as an \deflink{unevaluated operand}{expr.prop},
   where \tcode{U} is
   \tcode{remove_all_extents_t<T>}. &
   \tcode{T} shall be a complete type, \cv{}~\tcode{void},
@@ -16762,7 +16766,7 @@ [meta.unary.prop]
 \indexlibraryglobal{is_trivially_constructible}%
 \tcode{template<class T, class... Args>}\br
   \tcode{struct}\br
-  \tcode{is_trivially_constructible;} &
+  \tcode{\libglobal{is_trivially_constructible};} &
   \tcode{is_constructible_v<T,}\br
   \tcode{Args...>} is \tcode{true} and the variable
   definition for \tcode{is_constructible}, as defined below, is known to call
@@ -17218,7 +17222,7 @@ [meta.rel]
 For the purpose of defining the templates in this subclause,
 a function call expression \tcode{declval<T>()} for any type \tcode{T}
 is considered to be a trivial~(\ref{basic.types}, \ref{special}) function call
-that is not an odr-use\iref{basic.def.odr} of \tcode{declval}
+that is not an \link{odr-use}{basic.def.odr} of \tcode{declval}
 in the context of the corresponding definition
 notwithstanding the restrictions of~\ref{declval}.
 
@@ -17375,7 +17379,7 @@ [meta.trans.ref]
 \indexlibraryglobal{add_lvalue_reference}%
 \tcode{template<class T>\br
  struct add_lvalue_reference;}                     &
- If \tcode{T} names a referenceable type\iref{defns.referenceable} then
+ If \tcode{T} names a \link{referenceable type}{defns.referenceable} then
  the member typedef \tcode{type} names \tcode{T\&};
  otherwise, \tcode{type} names \tcode{T}.
  \begin{tailnote}
@@ -17410,14 +17414,14 @@ [meta.trans.sign]
 \indexlibraryglobal{make_signed}%
 \tcode{template<class T>}\br
  \tcode{struct make_signed;} &
- If \tcode{T} names a (possibly cv-qualified) signed integer
- type\iref{basic.fundamental} then the member typedef
+ If \tcode{T} names a (possibly cv-qualified)
+ \deflink{signed integer type}{basic.fundamental} then the member typedef
  \tcode{type} names the type \tcode{T}; otherwise,
  if \tcode{T} names a (possibly cv-qualified) unsigned integer
  type then \tcode{type} names the corresponding
  signed integer type, with the same cv-qualifiers as \tcode{T};
- otherwise, \tcode{type} names the signed integer type with smallest
- rank\iref{conv.rank} for which
+ otherwise, \tcode{type} names the signed integer type with \link{smallest
+ rank}{conv.rank} for which
  \tcode{sizeof(T) == sizeof(type)}, with the same
  cv-qualifiers as \tcode{T}.\br
  \mandates \tcode{T} is an integral or enumeration type
@@ -17426,14 +17430,14 @@ [meta.trans.sign]
 \indexlibraryglobal{make_unsigned}%
 \tcode{template<class T>}\br
  \tcode{struct make_unsigned;} &
- If \tcode{T} names a (possibly cv-qualified) unsigned integer
- type\iref{basic.fundamental} then the member typedef
+ If \tcode{T} names a (possibly cv-qualified)
+ \deflink{unsigned integer type}{basic.fundamental} then the member typedef
  \tcode{type} names the type \tcode{T}; otherwise,
  if \tcode{T} names a (possibly cv-qualified) signed integer
  type then \tcode{type} names the corresponding
  unsigned integer type, with the same cv-qualifiers as \tcode{T};
- otherwise, \tcode{type} names the unsigned integer type with smallest
- rank\iref{conv.rank} for which
+ otherwise, \tcode{type} names the unsigned integer type with \link{smallest
+ rank}{conv.rank} for which
  \tcode{sizeof(T) == sizeof(type)}, with the same
  cv-qualifiers as \tcode{T}.\br
  \mandates \tcode{T} is an integral or enumeration type
@@ -17512,7 +17516,7 @@ [meta.trans.ptr]
 \indexlibraryglobal{add_pointer}%
 \tcode{template<class T>\br
  struct add_pointer;}                       &
- If \tcode{T} names a referenceable type\iref{defns.referenceable} or a
+ If \tcode{T} names a \link{referenceable type}{defns.referenceable} or a
  \cv{}~\tcode{void} type then
  the member typedef \tcode{type} names the same type as
  \tcode{remove_reference_t<T>*};
@@ -17643,7 +17647,7 @@ [meta.trans.other]
  \tcode{struct \libglobal{invoke_result};}
  &
  If the expression \tcode{\placeholdernc{INVOKE}(declval<Fn>(), declval<ArgTypes>()...)}
- is well-formed when treated as an unevaluated operand\iref{expr.prop},
+ is well-formed when treated as an \deflink{unevaluated operand}{expr.prop},
  the member typedef \tcode{type} names the type
  \tcode{decltype(\placeholdernc{INVOKE}(declval<Fn>(), declval<ArgTypes>()...))};
  otherwise, there shall be no member \tcode{type}. Access checking is
@@ -17679,8 +17683,7 @@ [meta.trans.other]
 \indexlibraryglobal{aligned_storage}%
 \pnum
 \begin{note}
-A typical implementation would define \tcode{aligned_storage} as:
-
+A typical implementation would define \libglobal{aligned_storage} as:
 \begin{codeblock}
 template<size_t Len, size_t Alignment>
 struct aligned_storage {
@@ -18416,9 +18419,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}
 
@@ -18740,18 +18743,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}%
@@ -18853,7 +18851,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
@@ -19009,7 +19007,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 917e32e1..cc817c17 100644
--- a/source/strings.tex
+++ b/source/strings.tex
@@ -768,7 +768,6 @@ [basic.string.general]
 (a ``null terminator''\indextext{string!null terminator}),
 and \tcode{size() <= capacity()} is \tcode{true}.
 
-
 \indexlibraryglobal{basic_string}%
 \indexlibrarymember{traits_type}{basic_string}%
 \indexlibrarymember{value_type}{basic_string}%
@@ -1398,7 +1397,7 @@ [string.cons]
 \begin{itemdescr}
 \pnum
 \effects
-Move assigns as a sequence container\iref{sequence.reqmts},
+Move assigns as a \link{sequence container}{sequence.reqmts},
 except that iterators, pointers and references may be invalidated.
 
 \pnum
@@ -3433,7 +3432,6 @@ [string.cmp]
 
 \rSec3[string.special]{\tcode{swap}}
 
-\indexlibrarymember{swap}{basic_string}%
 \begin{itemdecl}
 template<class charT, class traits, class Allocator>
   constexpr void
@@ -3460,7 +3458,7 @@ [string.io]
 \begin{itemdescr}
 \pnum
 \effects
-Behaves as a formatted input function\iref{istream.formatted.reqmts}.
+Behaves as a \link{formatted input function}{istream.formatted}.
 After constructing a
 \tcode{sentry}
 object, if the sentry converts to \tcode{true}, calls
@@ -3538,7 +3536,7 @@ [string.io]
 \begin{itemdescr}
 \pnum
 \effects
-Behaves as an unformatted input function\iref{istream.unformatted},
+Behaves as an \link{unformatted input function}{istream.unformatted},
 except that it does not affect the value returned by subsequent calls to
 \tcode{basic_istream<>::gcount()}.
 After constructing a
@@ -5012,8 +5010,8 @@ [string.view.io]
 \begin{itemdescr}
 \pnum
 \effects
-Behaves as a formatted output
-function\iref{ostream.formatted.reqmts} of \tcode{os}. Forms a character sequence
+Behaves as a \link{formatted output
+function}{ostream.formatted.reqmts} of \tcode{os}. Forms a character sequence
 \tcode{seq}, initially consisting of the elements defined by the range
 \range{str.begin()}{str.end()}. Determines padding for \tcode{seq}
 as described in~\ref{ostream.formatted.reqmts}.
@@ -5273,13 +5271,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.
@@ -5289,7 +5287,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}
@@ -5456,7 +5454,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 cbbb0f66..da0f6b0a 100644
--- a/source/containers.tex
+++ b/source/containers.tex
@@ -56,9 +56,9 @@ [container.requirements.general]
 \pnum
 For the components affected by this subclause that declare an \tcode{allocator_type},
 objects stored in these components shall be constructed using the function
-\tcode{allocator_traits<allocator_type>::rebind_traits<U>::\brk{}construct}
+\libmemberrefx{allocator_traits<allocator_type>::rebind_traits<U>::\brk{}construct}{allocator_traits}{construct}
 and destroyed using the function
-\tcode{allocator_traits<allocator_type>::rebind_traits<U>::\brk{}destroy}\iref{allocator.traits.members},
+\libmemberrefx{allocator_traits<allocator_type>::rebind_traits<U>::\brk{}destroy}{allocator_traits}{destroy},
 where \tcode{U} is either \tcode{allocator_type::value_type} or
 an internal type used by the container.
 These functions are called only for the
@@ -372,7 +372,7 @@ [container.requirements.general]
 \pnum
 \indextext{reversible container|see{container, reversible}}%
 If the iterator type of a container belongs to the bidirectional or
-random access iterator categories\iref{iterator.requirements},
+random access \link{iterator categories}{iterator.requirements},
 the container is called
 \defnx{reversible}{container!reversible}
 and meets the additional requirements
@@ -739,7 +739,7 @@ [container.requirements.general]
 \rSec2[container.requirements.dataraces]{Container data races}
 
 \pnum
-For purposes of avoiding data races\iref{res.on.data.races}, implementations shall
+For purposes of \link{avoiding data races}{res.on.data.races}, implementations shall
 consider the following functions to be \tcode{const}: \tcode{begin}, \tcode{end},
 \tcode{rbegin}, \tcode{rend}, \tcode{front}, \tcode{back}, \tcode{data}, \tcode{find},
 \tcode{lower_bound}, \tcode{upper_bound}, \tcode{equal_range}, \tcode{at} and, except in
@@ -1546,7 +1546,7 @@ [associative.reqmts.general]
 \tcode{Key}
 and an ordering relation
 \tcode{Compare}
-that induces a strict weak ordering\iref{alg.sorting} on
+that induces a \link{strict weak ordering}{alg.sorting} on
 elements of
 \tcode{Key}.
 In addition,
@@ -1615,8 +1615,8 @@ [associative.reqmts.general]
 \end{note}
 
 \pnum
-The associative containers meet all the requirements of Allocator-aware
-containers\iref{container.requirements.general}, except that for
+The associative containers meet all the requirements of
+\link{Allocator-aware}{container.requirements.general} containers, except that for
 \tcode{map} and \tcode{multimap}, the requirements placed on \tcode{value_type}
 in \tref{container.alloc.req} apply instead to \tcode{key_type}
 and \tcode{mapped_type}.
@@ -2203,8 +2203,8 @@ [unord.req.general]
 \indextext{unordered associative containers!lack of comparison functions}%
 \indextext{unordered associative containers!requirements}%
 \indextext{requirements!container!not required for unordered associated containers}%
-Unordered associative containers conform to the requirements for
-Containers\iref{container.requirements}, except that
+Unordered associative containers conform to the \link{requirements for
+Containers}{container.requirements}, except that
 the expressions
 \tcode{a == b} and \tcode{a != b} have different semantics than for the other
 container types.
@@ -2295,8 +2295,8 @@ [unord.req.general]
 equivalent elements.
 
 \pnum
-The unordered associative containers meet all the requirements of Allocator-aware
-containers\iref{container.requirements.general}, except that for
+The unordered associative containers meet all the requirements of
+\link{Allocator-aware containers}{container.requirements.general}, except that for
 \tcode{unordered_map} and \tcode{unordered_multimap}, the requirements placed on \tcode{value_type}
 in \tref{container.alloc.req} apply instead to \tcode{key_type}
 and \tcode{mapped_type}.
@@ -3320,14 +3320,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.requirements.general}.
+An \tcode{array} is a \deflinkx{contiguous container}{container!contiguous}{container.requirements.general}.
 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}.
 
@@ -3336,24 +3336,24 @@ [array.overview]
 An \tcode{array} meets all of the requirements of a container and
 of a reversible container\iref{container.requirements}, except that a default
 constructed \tcode{array} object is not empty and that \tcode{swap} does not have constant
-complexity. An \tcode{array} meets some of the requirements of a sequence
-container\iref{sequence.reqmts}.
+complexity. 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}%
@@ -3427,7 +3427,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~(\ref{class.default.ctor}, \ref{class.dtor}, and \ref{class.copy.ctor}) to
 conform to the container requirements table in~\ref{container.requirements}.
@@ -3641,7 +3641,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.
@@ -4215,7 +4215,7 @@ [forwardlist.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.
 
@@ -4709,7 +4709,7 @@ [forwardlist.ops]
 
 \pnum
 \remarks
-Stable\iref{algorithm.stable}.
+\link{Stable}{algorithm.stable}.
 \end{itemdescr}
 
 \indexlibrarymember{unique}{forward_list}%
@@ -4773,7 +4773,7 @@ [forwardlist.ops]
 
 \pnum
 \remarks
-Stable\iref{algorithm.stable}.
+\link{Stable}{algorithm.stable}.
 \end{itemdescr}
 
 \indexlibrarymember{sort}{forward_list}%
@@ -4795,7 +4795,7 @@ [forwardlist.ops]
 
 \pnum
 \remarks
-Stable\iref{algorithm.stable}.
+\link{Stable}{algorithm.stable}.
 \end{itemdescr}
 
 \indexlibrarymember{reverse}{forward_list}%
@@ -4853,7 +4853,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.
 
@@ -5012,7 +5012,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.
 
@@ -5400,7 +5400,7 @@ [list.ops]
 
 \pnum
 \remarks
-Stable\iref{algorithm.stable}.
+\link{Stable}{algorithm.stable}.
 \end{itemdescr}
 
 \indexlibrarymember{unique}{list}%
@@ -5480,7 +5480,7 @@ [list.ops]
 
 \pnum
 \remarks
-Stable\iref{algorithm.stable}. If \tcode{addressof(x) != this}, the range \range{x.begin()}{x.end()}
+\link{Stable}{algorithm.stable}. If \tcode{addressof(x) != this}, the range \range{x.begin()}{x.end()}
 is empty after the merge.
 No elements are copied by this operation.
 \end{itemdescr}
@@ -5524,7 +5524,7 @@ [list.ops]
 
 \pnum
 \remarks
-Stable\iref{algorithm.stable}.
+\link{Stable}{algorithm.stable}.
 \end{itemdescr}
 
 \rSec3[list.erasure]{Erasure}
@@ -5576,7 +5576,7 @@ [vector.overview]
 requirements\iref{sequence.reqmts}, of an allocator-aware container
 (\tref{container.alloc.req}),
 and, for an element type other than \tcode{bool},
-of a contiguous container\iref{container.requirements.general}.
+of a \deflinkx{contiguous container}{container!contiguous}{container.requirements.general}.
 The exceptions are the
 \tcode{push_front}, \tcode{pop_front}, and \tcode{emplace_front} member functions, which are not
 provided. Descriptions are provided here only for operations on \tcode{vector}
@@ -5707,7 +5707,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.
 
@@ -6238,7 +6238,7 @@ [vector.bool]
 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
@@ -9785,9 +9785,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}
@@ -10047,15 +10047,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 {
@@ -10358,10 +10358,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 04b6bc1d..19a1ff43 100644
--- a/source/iterators.tex
+++ b/source/iterators.tex
@@ -646,8 +646,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}
@@ -6041,7 +6040,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.
@@ -6165,7 +6164,6 @@ [istreambuf.iterator.cons]
 Initializes \tcode{sbuf_} with \tcode{nullptr}.
 \end{itemdescr}
 
-
 \indexlibraryctor{istreambuf_iterator}%
 \begin{itemdecl}
 istreambuf_iterator(istream_type& s) noexcept;
@@ -6177,7 +6175,6 @@ [istreambuf.iterator.cons]
 Initializes \tcode{sbuf_} with \tcode{s.rdbuf()}.
 \end{itemdescr}
 
-
 \indexlibraryctor{istreambuf_iterator}%
 \begin{itemdecl}
 istreambuf_iterator(streambuf_type* s) noexcept;
@@ -6189,7 +6186,6 @@ [istreambuf.iterator.cons]
 Initializes \tcode{sbuf_} with \tcode{s}.
 \end{itemdescr}
 
-
 \indexlibraryctor{istreambuf_iterator}%
 \begin{itemdecl}
 istreambuf_iterator(const @\placeholder{proxy}@& p) noexcept;
@@ -6341,7 +6337,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/ranges.tex b/source/ranges.tex
index e343ee7d..15c75923 100644
--- a/source/ranges.tex
+++ b/source/ranges.tex
@@ -1025,7 +1025,7 @@ [range.range]
 template<class T>
   concept @\deflibconcept{borrowed_range}@ =
     @\libconcept{range}@<T> &&
-      (is_lvalue_reference_v<T> || enable_borrowed_range<remove_cvref_t<T>>);
+      (is_lvalue_reference_v<T> || @\libglobalref{enable_borrowed_range}@<remove_cvref_t<T>>);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -1183,7 +1183,7 @@ [range.view]
 \item A \libconcept{range} type that generates its elements on demand.
 \end{itemize}
 
-Most containers\iref{containers} are not views since
+Most \link{containers}{containers} are not views since
 destruction of the container destroys the elements,
 which cannot be done in constant time.
 \end{example}
diff --git a/source/algorithms.tex b/source/algorithms.tex
index 3d9719ad..8ac2de00 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
@@ -7246,7 +7246,7 @@ [alg.merge]
 
 \pnum
 \remarks
-Stable\iref{algorithm.stable}.
+\link{Stable}{algorithm.stable}.
 \end{itemdescr}
 
 \begin{itemdecl}
diff --git a/source/numerics.tex b/source/numerics.tex
index b519b9ca..a56f8925 100644
--- a/source/numerics.tex
+++ b/source/numerics.tex
@@ -166,8 +166,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}
@@ -197,7 +197,7 @@ [complex.numbers.general]
 The specializations
 \tcode{complex<float>},
 \tcode{complex<double>}, and
-\tcode{complex<long double>} are literal types\iref{basic.types}.
+\tcode{complex<long double>} are \deflinkx{literal types}{type!literal}{basic.types}.
 
 \pnum
 If the result of a function is not mathematically defined or not in
@@ -1929,21 +1929,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}
@@ -2068,7 +2068,7 @@ [rand.req.seedseq]
 \indextext{\idxcode{result_type}!seed sequence requirement}%
 \tcode{S::result_type}
   & \tcode{T}
-  & \tcode{T} is an unsigned integer type\iref{basic.fundamental}
+  & \tcode{T} is an \deflink{unsigned integer type}{basic.fundamental}
     of at least 32 bits.
   & compile-time
   \\ \rowsep
@@ -2239,7 +2239,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
@@ -2260,7 +2260,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};
@@ -2664,7 +2664,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>};
@@ -2696,7 +2696,7 @@ [rand.req.dist]
 \indextext{\idxcode{result_type}!random number distribution requirement}%
 \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}
@@ -2917,7 +2917,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,
@@ -3467,7 +3467,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,
@@ -4522,7 +4522,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}
@@ -5281,6 +5281,7 @@ [rand.dist.pois.gamma]
 
 \indexlibraryglobal{gamma_distribution}%
 \indexlibrarymember{result_type}{gamma_distribution}%
+\indexlibrary{\idxcode{gamma_distribution}}%
 \begin{codeblock}
 template<class RealType = double>
   class gamma_distribution {
@@ -5311,7 +5312,6 @@ [rand.dist.pois.gamma]
   };
 \end{codeblock}
 
-
 \indexlibraryctor{gamma_distribution}%
 \begin{itemdecl}
 explicit gamma_distribution(RealType alpha, RealType beta = 1.0);
@@ -5407,7 +5407,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
@@ -5505,7 +5505,6 @@ [rand.dist.pois.extreme]
   };
 \end{codeblock}
 
-
 \indexlibraryctor{extreme_value_distribution}%
 \begin{itemdecl}
 explicit extreme_value_distribution(RealType a, RealType b = 1.0);
@@ -5625,7 +5624,6 @@ [rand.dist.norm.normal]
   };
 \end{codeblock}
 
-
 \indexlibraryctor{normal_distribution}%
 \begin{itemdecl}
 explicit normal_distribution(RealType mean, RealType stddev = 1.0);
@@ -5806,7 +5804,6 @@ [rand.dist.norm.chisq]
   };
 \end{codeblock}
 
-
 \indexlibraryctor{chi_squared_distribution}%
 \begin{itemdecl}
 explicit chi_squared_distribution(RealType n);
@@ -5977,7 +5974,6 @@ [rand.dist.norm.f]
   };
 \end{codeblock}
 
-
 \indexlibraryctor{fisher_f_distribution}%
 \begin{itemdecl}
 explicit fisher_f_distribution(RealType m, RealType n = 1);
@@ -6069,7 +6065,6 @@ [rand.dist.norm.t]
   };
 \end{codeblock}
 
-
 \indexlibraryctor{student_t_distribution}%
 \begin{itemdecl}
 explicit student_t_distribution(RealType n);
@@ -6175,7 +6170,7 @@ [rand.dist.samp.discrete]
   };
 \end{codeblock}
 
-\indexlibraryctor{discrete_distribution}
+\indexlibraryctor{discrete_distribution}%
 \begin{itemdecl}
 discrete_distribution();
 \end{itemdecl}
@@ -6982,8 +6977,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
@@ -7008,7 +7004,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.
 
@@ -7168,7 +7164,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}%
@@ -7427,7 +7423,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}
 
@@ -7853,7 +7849,8 @@ [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 the argument; etc.
 \end{example}
 \end{itemdescr}
@@ -8979,7 +8976,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.
 
@@ -9765,11 +9762,11 @@ [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~(\ref{c.math.hypot3}) and
+a \link{three-dimensional hypotenuse}{c.math.hypot3} function 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
@@ -9780,7 +9777,7 @@ [cmath.syn]
   \item If any argument of arithmetic type
     corresponding to a \tcode{double} parameter
     has type \tcode{long double},
-    then all arguments of arithmetic type\iref{basic.fundamental}
+    then all arguments of \deflinkx{arithmetic type}{type!arithmetic}{basic.fundamental}
     corresponding to \tcode{double} parameters
     are effectively cast to \tcode{long double}.
   \item Otherwise, if any argument of arithmetic type
@@ -9836,7 +9833,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/locales.tex b/source/locales.tex
index 8c22b8e5..d2b9e86c 100644
--- a/source/locales.tex
+++ b/source/locales.tex
@@ -280,7 +280,7 @@ [locale.general]
 object per thread is \impldef{whether locale object is global or per-thread}.
 Implementations should provide one global locale object per
 thread. If there is a single global locale object for the entire program,
-implementations are not required to avoid data races on it\iref{res.on.data.races}.
+implementations are not required to \link{avoid data races}{res.on.data.races} on it.
 
 \rSec3[locale.types]{Types}
 
@@ -1087,7 +1087,7 @@ [category.ctype.general]
 \pnum
 The type
 \tcode{mask}
-is a bitmask type\iref{bitmask.types}.
+is a \link{bitmask type}{bitmask.types}.
 
 \rSec3[locale.ctype]{Class template \tcode{ctype}}
 
@@ -1397,7 +1397,7 @@ [locale.ctype.virtuals]
 to the locale's encoding.
 \end{footnote}
 The only characters for which unique transformations are required
-are those in the basic source character set\iref{lex.charset}.
+are those in the \deflinkx{basic source character set}{character set!basic source}{lex.charset}.
 
 For any named
 \tcode{ctype}
@@ -1444,7 +1444,8 @@ [locale.ctype.virtuals]
 \tcode{char}
 value or values.
 
-For any character \tcode{c} in the basic source character set\iref{lex.charset}
+For any character \tcode{c} in the
+\deflinkx{basic source character set}{character set!basic source}{lex.charset}
 the transformation is such that
 \begin{codeblock}
 do_widen(do_narrow(c, 0)) == c
@@ -1796,8 +1797,8 @@ [facet.ctype.char.virtuals]
 \pnum
 These functions are described identically as those members of the
 same name in the
-\tcode{ctype}
-class template\iref{locale.ctype.members}.
+\link{\tcode{ctype}
+class template}{locale.ctype.members}.
 
 \rSec3[locale.codecvt]{Class template \tcode{codecvt}}
 
@@ -3388,7 +3389,7 @@ [locale.collate.general]
 \tcode{collate<char>}
 and
 \tcode{collate<wchar_t>},
-apply lexicographic ordering\iref{alg.lex.comparison}.
+apply \link{lexicographic ordering}{alg.lex.comparison}.
 
 \pnum
 Each function compares a string of characters
@@ -3452,7 +3453,7 @@ [locale.collate.virtuals]
 and
 \tcode{collate<wchar_t>},
 implement
-a lexicographical comparison\iref{alg.lex.comparison}.
+a \link{lexicographical comparison}{alg.lex.comparison}.
 \end{itemdescr}
 
 \indexlibrarymember{collate}{do_transform}%
@@ -5104,31 +5105,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 14bdd416..16d04d62 100644
--- a/source/iostreams.tex
+++ b/source/iostreams.tex
@@ -492,7 +492,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}%
@@ -525,7 +525,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}%
@@ -562,7 +562,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}%
@@ -595,7 +595,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}%
@@ -1356,7 +1356,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,
@@ -1415,8 +1415,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}%
@@ -1988,12 +1988,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
@@ -3247,7 +3247,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}%
@@ -4210,7 +4210,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;
@@ -4638,7 +4638,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 sentry object is constructed, the
 conversion occurs as if performed by the following code fragment:
@@ -4879,7 +4879,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
@@ -5294,7 +5294,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
@@ -5630,12 +5630,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 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
@@ -5728,7 +5728,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
@@ -5808,7 +5808,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;
@@ -6484,7 +6484,7 @@ [ostream.inserters]
 \begin{itemdescr}
 \pnum
 \effects
-Behaves as an unformatted output function\iref{ostream.unformatted}.
+Behaves as an \link{unformatted output function}{ostream.unformatted}.
 After the sentry object is
 constructed, if
 \tcode{sb} is null calls
@@ -6541,7 +6541,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}
@@ -6565,7 +6565,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}
@@ -7206,7 +7206,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
@@ -7251,7 +7251,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}
@@ -7375,7 +7375,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}
@@ -12359,7 +12359,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}
@@ -12966,7 +12966,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}.
 
@@ -13509,11 +13509,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}
@@ -14742,7 +14742,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_r}.
+POSIX \weblink{\tcode{readdir_r}}{http://pubs.opengroup.org/onlinepubs/9699919799/functions/readdir.html}.
 \end{note}
 
 \rSec3[fs.dir.itr.members]{Members}
@@ -14834,7 +14834,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
@@ -15142,7 +15142,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}
@@ -15733,7 +15733,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
@@ -15809,7 +15809,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
@@ -15842,7 +15842,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.
 
@@ -15879,7 +15879,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
@@ -15990,7 +15990,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}
@@ -16372,7 +16372,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
@@ -17250,8 +17250,8 @@ [cinttypes.syn]
 The header \libheader{cinttypes} includes the header \libheaderref{cstdint} instead
 of \libheader{stdint.h}, and
 \item
-if and only if the type \tcode{intmax_t} designates an extended integer
-type\iref{basic.fundamental}, the following function signatures are added:
+if and only if the type \tcode{intmax_t} designates an
+\deflink{extended integer type}{basic.fundamental}, the following function signatures are added:
 \begin{codeblock}
 intmax_t abs(intmax_t);
 imaxdiv_t div(intmax_t, intmax_t);
diff --git a/source/regex.tex b/source/regex.tex
index a6d789d5..69067e06 100644
--- a/source/regex.tex
+++ b/source/regex.tex
@@ -12,7 +12,7 @@ [re.general]
 
 \pnum
 The following subclauses describe a basic regular expression class template and its
-traits that can handle char-like\iref{strings.general} template arguments,
+traits that can handle \deflinkx{char-like}{char-like type}{strings.general} template arguments,
 two specializations of this class template that handle sequences of \tcode{char} and \tcode{wchar_t},
 a class template that holds the
 result of a regular expression match, a series of algorithms that allow a character
@@ -68,8 +68,8 @@ [re.req]
 type \tcode{charT}; \tcode{u} is an object of
 type \tcode{X}; \tcode{v} is an object of type \tcode{const
 X}; \tcode{p} is a value of type \tcode{const charT*}; \tcode{I1}
-and \tcode{I2} are input iterators\iref{input.iterators};
-\tcode{F1} and \tcode{F2} are forward iterators\iref{forward.iterators};
+and \tcode{I2} are \link{input iterators}{input.iterators};
+\tcode{F1} and \tcode{F2} are \link{forward iterators}{forward.iterators};
 \tcode{c} is a value of type \tcode{const charT};
 \tcode{s} is an object of type \tcode{X::string_type};
 \tcode{cs} is an object of type \tcode{const X::string_type};
@@ -103,7 +103,7 @@ [re.req]
   & A type that represents the locale used by the traits class. \indextext{locale}
  \\ \rowsep
 \tcode{X::char_class_type}
- & A bitmask type\iref{bitmask.types}.
+ & A \link{bitmask type}{bitmask.types}.
  & A bitmask type representing a particular character classification.
    \indextext{regular expression traits!\idxcode{char_class_type}}%
    \indextext{\idxcode{char_class_type}!regular expression traits}%
@@ -566,14 +566,14 @@ [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.
 \indextext{\idxcode{awk}}%
 \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.
 \indextext{\idxcode{grep}}%
 \indexlibrarymember{syntax_option_type}{grep}%
 \\ \rowsep
@@ -600,42 +600,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.
@@ -697,7 +684,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}%
@@ -705,7 +692,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
@@ -716,7 +703,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}%
@@ -758,7 +745,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/atomics.tex b/source/atomics.tex
index 4fef68fb..68133bff 100644
--- a/source/atomics.tex
+++ b/source/atomics.tex
@@ -570,8 +570,9 @@ [atomics.order]
 \begin{itemdescr}
 \pnum
 \effects
-The argument does not carry a dependency to the return
-value\iref{intro.multithread}.
+The argument does not
+\deflinkx{carry a dependency}{carries a dependency}{intro.multithread}
+to the return value.
 
 \pnum
 \returns
diff --git a/source/threads.tex b/source/threads.tex
index 6bee8610..b39aeff7 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}.
 
@@ -261,8 +261,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)
@@ -1978,7 +1978,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
@@ -2022,7 +2022,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}
@@ -2109,7 +2109,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
@@ -2138,7 +2138,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
@@ -2267,9 +2267,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}.
 
 \pnum
 The timed mutex types meet the \oldconcept{TimedLockable}
@@ -2310,7 +2310,7 @@ [thread.timedmutex.requirements.general]
 \pnum
 \sync
 If \tcode{try_lock_for()} 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.
 
 \pnum
 \throws
@@ -2351,7 +2351,7 @@ [thread.timedmutex.requirements.general]
 \pnum
 \sync
 If \tcode{try_lock_until()} returns \tcode{true}, prior \tcode{unlock()}
-operations on the same object \term{synchronize with}\iref{intro.multithread}
+operations on the same object \deflink{synchronize with}{intro.multithread}
 this operation.
 
 \pnum
@@ -2555,7 +2555,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
@@ -2588,7 +2588,7 @@ [thread.sharedmutex.requirements.general]
 \pnum
 \sync
 If \tcode{try_lock_shared()} returns \tcode{true}, prior \tcode{unlock()}
-operations on the same object synchronize with\iref{intro.multithread} this
+operations on the same object \deflink{synchronize with}{intro.multithread} this
 operation.
 
 \pnum
@@ -2657,9 +2657,9 @@ [thread.sharedtimedmutex.requirements.general]
 meet the requirements set out below. In this description,
 \tcode{m} denotes an object of a shared timed mutex type,
 \tcode{rel_type} denotes an object of an instantiation of
-\tcode{duration}\iref{time.duration}, and
+\link{\tcode{duration}}{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}.
 
 \pnum
 The expression \tcode{m.try_lock_shared_for(rel_time)} is well-formed and
@@ -2866,7 +2866,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}
@@ -2945,7 +2945,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.
@@ -4115,7 +4115,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.
 
@@ -5881,7 +5881,7 @@ [future.syn]
 \end{codeblock}
 
 \pnum
-The \tcode{enum} type \tcode{launch} is a bitmask type\iref{bitmask.types} with
+The \tcode{enum} type \tcode{launch} is a \link{bitmask type}{bitmask.types} with
 elements \tcode{launch::async} and \tcode{launch::deferred}.
 \begin{note}
 Implementations can provide bitmasks to specify restrictions on task
@@ -6074,22 +6074,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
@@ -6424,8 +6423,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
@@ -6728,7 +6727,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
@@ -7186,7 +7185,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
diff --git a/source/limits.tex b/source/limits.tex
index c5f90e66..a6af201a 100644
--- a/source/limits.tex
+++ b/source/limits.tex
@@ -129,6 +129,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 4fd3a149..7a7ffb4e 100644
--- a/source/compatibility.tex
+++ b/source/compatibility.tex
@@ -1131,8 +1131,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 31c0b3e0..7c2a18ce 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}
 
@@ -196,11 +196,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.
-- 
2.17.1


From fe4474941dde2657f8014af2b5a298f010631f2d Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Sun, 26 Feb 2017 13:11:19 +0100
Subject: [PATCH 16/29] [temp.class.order] Merge \defn with index entry.

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

diff --git a/source/templates.tex b/source/templates.tex
index 6aad95e2..7016787f 100644
--- a/source/templates.tex
+++ b/source/templates.tex
@@ -3466,9 +3466,8 @@ [temp.class.spec.match]
 \rSec3[temp.class.order]{Partial ordering of class template specializations}
 
 \pnum
-\indextext{more specialized!class template}%
 For two class template partial specializations,
-the first is \defn{more specialized} than the second if, given the following
+the first is \defnx{more specialized}{more specialized!class template} 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 \link{ordering rules for function
 templates}{temp.func.order}:
-- 
2.17.1


From 380e25b8995da7cd4e13a207ca771e304e5259e8 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 17/29] 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 7016787f..ca49aaf6 100644
--- a/source/templates.tex
+++ b/source/templates.tex
@@ -1840,7 +1840,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
@@ -1896,10 +1895,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
@@ -1929,7 +1929,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 16d04d62..7c518b7b 100644
--- a/source/iostreams.tex
+++ b/source/iostreams.tex
@@ -12158,7 +12158,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.17.1


From 6176898bc07c945debe258e906d2015f10aeeb44 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 18/29] Replace more non-codeblocks with outputblocks.

---
 source/lex.tex       |  4 ++--
 source/support.tex   |  8 ++++----
 source/iostreams.tex | 12 ++++++------
 source/regex.tex     |  4 ++--
 4 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/source/lex.tex b/source/lex.tex
index b97e0b70..3a17a56b 100644
--- a/source/lex.tex
+++ b/source/lex.tex
@@ -233,12 +233,12 @@ [lex.charset]
 and therefore implementations must document how the basic source characters are
 represented in source files.
 \end{footnote}
-\begin{codeblock}
+\begin{outputblock}
 a b c d e f g h i j k l m n o p q r s t u v w x y z
 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
 0 1 2 3 4 5 6 7 8 9
 _ { } [ ] # ( ) < > % : ; . ? * + - / ^ & | ~ ! = , @\textbackslash@ " '
-\end{codeblock}
+\end{outputblock}
 
 \pnum
 The \grammarterm{universal-character-name} construct provides a way to name
diff --git a/source/support.tex b/source/support.tex
index 00983373..954e8692 100644
--- a/source/support.tex
+++ b/source/support.tex
@@ -1852,18 +1852,18 @@ [cstdint.syn]
 
 \pnum
 The header also defines numerous macros of the form:
-\begin{codeblock}
+\begin{outputblock}
   INT_[FAST LEAST]{8 16 32 64}_MIN
   [U]INT_[FAST LEAST]{8 16 32 64}_MAX
   INT{MAX PTR}_MIN
   [U]INT{MAX PTR}_MAX
   {PTRDIFF SIG_ATOMIC WCHAR WINT}{_MAX _MIN}
   SIZE_MAX
-\end{codeblock}
+\end{outputblock}
 plus function macros of the form:
-\begin{codeblock}
+\begin{outputblock}
   [U]INT{8 16 32 64 MAX}_C
-\end{codeblock}
+\end{outputblock}
 
 \pnum
 The header defines all types and macros the same as
diff --git a/source/iostreams.tex b/source/iostreams.tex
index 7c518b7b..461e1724 100644
--- a/source/iostreams.tex
+++ b/source/iostreams.tex
@@ -15488,16 +15488,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
@@ -15506,10 +15506,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
@@ -15520,7 +15520,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 69067e06..4d87c740 100644
--- a/source/regex.tex
+++ b/source/regex.tex
@@ -3656,7 +3656,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:]]
@@ -3668,7 +3668,7 @@ [re.grammar]
 \w @\textnormal{and}@ [_[:alnum:]]
 
 \W @\textnormal{and}@ [^_[:alnum:]]
-\end{codeblock}
+\end{outputblock}
 
 \pnum
 \indexlibrary{regular expression traits!\idxcode{lookup_collatename}}%
-- 
2.17.1


From aa1c4d3a620ef266c16568bcc283bebdb980b036 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 19/29] Use cxxdraft-htmlgen macros to annotate non-C++ code
 and literal fragments.

---
 source/lex.tex        | 272 +++++++++++-----------
 source/exceptions.tex |   4 +-
 source/utilities.tex  | 170 +++++++-------
 source/time.tex       | 524 +++++++++++++++++++++---------------------
 4 files changed, 485 insertions(+), 485 deletions(-)

diff --git a/source/lex.tex b/source/lex.tex
index 3a17a56b..41facf03 100644
--- a/source/lex.tex
+++ b/source/lex.tex
@@ -360,7 +360,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 phases
 1 and 2 (\grammarterm{universal-character-name}{s} and line splicing) are reverted; this reversion
@@ -368,7 +368,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
@@ -598,16 +598,16 @@ [lex.ppnumber]
 \begin{bnf}
 \nontermdef{pp-number}\br
     digit\br
-    \terminal{.} digit\br
+    \literalterminal{.} digit\br
     pp-number digit\br
     pp-number identifier-nondigit\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
@@ -678,61 +678,61 @@ [lex.name]
 \begin{floattable}{Ranges of characters allowed}{lex.name.allowed}
 {lllll}
 \topline
-\tcode{00A8} &
-\tcode{00AA} &
-\tcode{00AD} &
-\tcode{00AF} &
-\tcode{00B2-00B5} \\
-\tcode{00B7-00BA} &
-\tcode{00BC-00BE} &
-\tcode{00C0-00D6} &
-\tcode{00D8-00F6} &
-\tcode{00F8-00FF} \\
-\tcode{0100-167F} &
-\tcode{1681-180D} &
-\tcode{180F-1FFF} &&\\
-\tcode{200B-200D} &
-\tcode{202A-202E} &
-\tcode{203F-2040} &
-\tcode{2054} &
-\tcode{2060-206F} \\
-\tcode{2070-218F} &
-\tcode{2460-24FF} &
-\tcode{2776-2793} &
-\tcode{2C00-2DFF} &
-\tcode{2E80-2FFF} \\
-\tcode{3004-3007} &
-\tcode{3021-302F} &
-\tcode{3031-D7FF} && \\
-\tcode{F900-FD3D} &
-\tcode{FD40-FDCF} &
-\tcode{FDF0-FE44} &
-\tcode{FE47-FFFD} & \\
-\tcode{10000-1FFFD} &
-\tcode{20000-2FFFD} &
-\tcode{30000-3FFFD} &
-\tcode{40000-4FFFD} &
-\tcode{50000-5FFFD} \\
-\tcode{60000-6FFFD} &
-\tcode{70000-7FFFD} &
-\tcode{80000-8FFFD} &
-\tcode{90000-9FFFD} &
-\tcode{A0000-AFFFD} \\
-\tcode{B0000-BFFFD} &
-\tcode{C0000-CFFFD} &
-\tcode{D0000-DFFFD} &
-\tcode{E0000-EFFFD} &
+\noncxxtcode{00A8} &
+\noncxxtcode{00AA} &
+\noncxxtcode{00AD} &
+\noncxxtcode{00AF} &
+\noncxxtcode{00B2-00B5} \\
+\noncxxtcode{00B7-00BA} &
+\noncxxtcode{00BC-00BE} &
+\noncxxtcode{00C0-00D6} &
+\noncxxtcode{00D8-00F6} &
+\noncxxtcode{00F8-00FF} \\
+\noncxxtcode{0100-167F} &
+\noncxxtcode{1681-180D} &
+\noncxxtcode{180F-1FFF} &&\\
+\noncxxtcode{200B-200D} &
+\noncxxtcode{202A-202E} &
+\noncxxtcode{203F-2040} &
+\noncxxtcode{2054} &
+\noncxxtcode{2060-206F} \\
+\noncxxtcode{2070-218F} &
+\noncxxtcode{2460-24FF} &
+\noncxxtcode{2776-2793} &
+\noncxxtcode{2C00-2DFF} &
+\noncxxtcode{2E80-2FFF} \\
+\noncxxtcode{3004-3007} &
+\noncxxtcode{3021-302F} &
+\noncxxtcode{3031-D7FF} && \\
+\noncxxtcode{F900-FD3D} &
+\noncxxtcode{FD40-FDCF} &
+\noncxxtcode{FDF0-FE44} &
+\noncxxtcode{FE47-FFFD} & \\
+\noncxxtcode{10000-1FFFD} &
+\noncxxtcode{20000-2FFFD} &
+\noncxxtcode{30000-3FFFD} &
+\noncxxtcode{40000-4FFFD} &
+\noncxxtcode{50000-5FFFD} \\
+\noncxxtcode{60000-6FFFD} &
+\noncxxtcode{70000-7FFFD} &
+\noncxxtcode{80000-8FFFD} &
+\noncxxtcode{90000-9FFFD} &
+\noncxxtcode{A0000-AFFFD} \\
+\noncxxtcode{B0000-BFFFD} &
+\noncxxtcode{C0000-CFFFD} &
+\noncxxtcode{D0000-DFFFD} &
+\noncxxtcode{E0000-EFFFD} &
 \\
 \end{floattable}
 
 \begin{floattable}{Ranges of characters disallowed initially (combining characters)}{lex.name.disallowed}
 {llll}
 \topline
-\tcode{0300-036F} &
+\noncxxtcode{0300-036F} &
 % FIXME: Unicode v7 adds 1AB0-1AFF
-\tcode{1DC0-1DFF} &
-\tcode{20D0-20FF} &
-\tcode{FE20-FE2F} \\
+\noncxxtcode{1DC0-1DFF} &
+\noncxxtcode{20D0-20FF} &
+\noncxxtcode{FE20-FE2F} \\
 \end{floattable}
 
 \pnum
@@ -988,19 +988,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}
@@ -1031,14 +1031,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}
@@ -1051,17 +1051,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}
 
 \pnum
@@ -1095,7 +1095,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},
@@ -1140,7 +1140,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}\\
                               &
@@ -1149,7 +1149,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}\\
                               &
@@ -1161,22 +1161,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}  &
                               &
                               \\
 \end{floattable}
@@ -1203,12 +1203,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}
@@ -1233,20 +1233,20 @@ [lex.ccon]
 
 \begin{bnf}
 \nontermdef{simple-escape-sequence} \textnormal{one of}\br
-    \terminal{\textbackslash'}\quad\terminal{\textbackslash"}\quad\terminal{\textbackslash ?}\quad\terminal{\textbackslash\textbackslash}\br
-    \terminal{\textbackslash a}\quad\terminal{\textbackslash b}\quad\terminal{\textbackslash f}\quad\terminal{\textbackslash n}\quad\terminal{\textbackslash r}\quad\terminal{\textbackslash t}\quad\terminal{\textbackslash v}
+    \literalterminal{\textbackslash'}\quad\literalterminal{\textbackslash"}\quad\literalterminal{\textbackslash ?}\quad\literalterminal{\textbackslash\textbackslash}\br
+    \literalterminal{\textbackslash a}\quad\literalterminal{\textbackslash b}\quad\literalterminal{\textbackslash f}\quad\literalterminal{\textbackslash n}\quad\literalterminal{\textbackslash r}\quad\literalterminal{\textbackslash t}\quad\literalterminal{\textbackslash v}
 \end{bnf}
 
 \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
+    \literalterminal{\textbackslash} octal-digit\br
+    \literalterminal{\textbackslash} octal-digit octal-digit\br
+    \literalterminal{\textbackslash} octal-digit octal-digit octal-digit
 \end{bnf}
 
 \begin{bnf}
 \nontermdef{hexadecimal-escape-sequence}\br
-    \terminal{\textbackslash x} hexadecimal-digit\br
+    \literalterminal{\textbackslash x} hexadecimal-digit\br
     hexadecimal-escape-sequence hexadecimal-digit
 \end{bnf}
 
@@ -1257,7 +1257,7 @@ [lex.ccon]
 \indextext{literal!type of character}%
 \indextext{literal!character!ordinary}%
 A \grammarterm{character-literal} that does not begin with
-\tcode{u8}, \tcode{u}, \tcode{U}, or \tcode{L}
+\literaltcode{u8}, \literaltcode{u}, \literaltcode{U}, or \literaltcode{L}
 is an \defn{ordinary character literal}.
 An ordinary character literal that contains a
 single \grammarterm{c-char} representable in the execution character
@@ -1276,7 +1276,7 @@ [lex.ccon]
 \pnum
 \indextext{literal!character!UTF-8}%
 A \grammarterm{character-literal} that
-begins with \tcode{u8}, such as \tcode{u8'w'},
+begins with \literaltcode{u8}, such as \tcode{u8'w'},
 \indextext{prefix!\idxcode{u8}}%
 is a \grammarterm{character-literal} of type \tcode{char8_t},
 known as a \defn{UTF-8 character literal}.
@@ -1295,7 +1295,7 @@ [lex.ccon]
 \indextext{literal!character!UTF-16}%
 \indextext{type!\idxcode{char16_t}}%
 A \grammarterm{character-literal} that
-begins with the letter \tcode{u}, such as \tcode{u'x'},
+begins with the letter \literaltcode{u}, such as \tcode{u'x'},
 \indextext{prefix!\idxcode{u}}%
 is a \grammarterm{character-literal} of type \tcode{char16_t},
 known as a \defn{UTF-16 character literal}.
@@ -1315,7 +1315,7 @@ [lex.ccon]
 \indextext{literal!character!UTF-32}%
 \indextext{type!\idxcode{char32_t}}%
 A \grammarterm{character-literal} that
-begins with the letter \tcode{U}, such as \tcode{U'y'},
+begins with the letter \literaltcode{U}, such as \tcode{U'y'},
 \indextext{prefix!\idxcode{U}}%
 is a \grammarterm{character-literal} of type \tcode{char32_t},
 known as a \defn{UTF-32 character literal}.
@@ -1331,7 +1331,7 @@ [lex.ccon]
 \indexhdr{stddef.h}%
 \indextext{type!\idxcode{wchar_t}}%
 A \grammarterm{character-literal} that
-begins with the letter \tcode{L}, such as \tcode{L'z'},
+begins with the letter \literaltcode{L}, such as \tcode{L'z'},
 \indextext{prefix!\idxcode{L}}%
 is a \defn{wide-character literal}. A wide-character literal has type
 \tcode{wchar_t}.
@@ -1354,8 +1354,8 @@ [lex.ccon]
 \impldef{value of wide-character literal containing multiple characters}.
 
 \pnum
-Certain non-graphic characters, the single quote \tcode{'}, the double quote \tcode{"},
-the question mark \tcode{?},
+Certain non-graphic characters, the single quote \noncxxtcode{'}, the double quote \noncxxtcode{"},
+the question mark \noncxxtcode{?},
 \begin{footnote}
 Using an escape sequence for a question mark
 is supported for compatibility with ISO \CppXIV{} and ISO C.
@@ -1364,15 +1364,15 @@ [lex.ccon]
 \indextext{backslash character}%
 \indextext{\idxcode{\textbackslash}|see{backslash character}}%
 \indextext{escape character|see{backslash character}}%
-\tcode{\textbackslash}, can be represented according to
+\noncxxtcode{\textbackslash}, can be represented according to
 \tref{lex.ccon.esc}.
 \indextext{escape sequence!undefined}%
-The double quote \tcode{"}  and the question mark \tcode{?}, can be
+The double quote \noncxxtcode{"}  and the question mark \noncxxtcode{?}, can be
 represented as themselves or by the escape sequences
-\tcode{\textbackslash "} and \tcode{\textbackslash ?} respectively, but
-the single quote \tcode{'} and the backslash \tcode{\textbackslash}
-shall be represented by the escape sequences \tcode{\textbackslash'} and
-\tcode{\textbackslash\textbackslash} respectively. Escape sequences in
+\literaltcode{\textbackslash "} and \literaltcode{\textbackslash ?} respectively, but
+the single quote \noncxxtcode{'} and the backslash \noncxxtcode{\textbackslash}
+shall be represented by the escape sequences \literaltcode{\textbackslash'} and
+\literaltcode{\textbackslash\textbackslash} respectively. Escape sequences in
 which the character following the backslash is not listed in
 \tref{lex.ccon.esc} are conditionally-supported, with \impldef{semantics of
 non-standard escape sequences} semantics. An escape sequence specifies a single
@@ -1381,30 +1381,30 @@ [lex.ccon]
 \begin{floattable}{Escape sequences}{lex.ccon.esc}
 {lll}
 \topline
-new-line        &   NL(LF)          &   \tcode{\textbackslash n}                \\
-horizontal tab  &   HT              &   \tcode{\textbackslash t}                \\
-vertical tab    &   VT              &   \tcode{\textbackslash v}                \\
-backspace       &   BS              &   \tcode{\textbackslash b}                \\
-carriage return &   CR              &   \tcode{\textbackslash r}                \\
-form feed       &   FF              &   \tcode{\textbackslash f}                \\
-alert           &   BEL             &   \tcode{\textbackslash a}                \\
-backslash       &   \textbackslash  &   \tcode{\textbackslash\textbackslash}    \\
-question mark   &   ?               &   \tcode{\textbackslash ?}                \\
-single quote    &   \tcode{'}       &   \tcode{\textbackslash '}                \\
-double quote    &   \tcode{"}       &   \tcode{\textbackslash "}                \\
-octal number    &   \numconst{ooo}  &   \tcode{\textbackslash\numconst{ooo}}    \\
-hex number      &   \numconst{hhh}  &   \tcode{\textbackslash x\numconst{hhh}}  \\
+new-line        &   NL(LF)          &   \literaltcode{\textbackslash n}                \\
+horizontal tab  &   HT              &   \literaltcode{\textbackslash t}                \\
+vertical tab    &   VT              &   \literaltcode{\textbackslash v}                \\
+backspace       &   BS              &   \literaltcode{\textbackslash b}                \\
+carriage return &   CR              &   \literaltcode{\textbackslash r}                \\
+form feed       &   FF              &   \literaltcode{\textbackslash f}                \\
+alert           &   BEL             &   \literaltcode{\textbackslash a}                \\
+backslash       &   \textbackslash  &   \literaltcode{\textbackslash\textbackslash}    \\
+question mark   &   ?               &   \literaltcode{\textbackslash ?}                \\
+single quote    &   \noncxxtcode{'} &   \literaltcode{\textbackslash '}                \\
+double quote    &   \noncxxtcode{"} &   \literaltcode{\textbackslash "}                \\
+octal number    &   \numconst{ooo}  &   \literaltcode{\textbackslash\numconst{ooo}}    \\
+hex number      &   \numconst{hhh}  &   \literaltcode{\textbackslash x\numconst{hhh}}  \\
 \end{floattable}
 
 \pnum
 The escape
 \indextext{number!octal}%
-\tcode{\textbackslash\numconst{ooo}} consists of the backslash followed by one,
+\literaltcode{\textbackslash\numconst{ooo}} consists of the backslash followed by one,
 two, or three octal digits that are taken to specify the value of the
 desired character. The escape
 \indextext{number!hex}%
-\tcode{\textbackslash x\numconst{hhh}}
-consists of the backslash followed by \tcode{x} followed by one or more
+\literaltcode{\textbackslash x\numconst{hhh}}
+consists of the backslash followed by \literaltcode{x} followed by one or more
 hexadecimal digits that are taken to specify the value of the desired
 character. There is no limit to the number of digits in a hexadecimal
 sequence. A sequence of octal or hexadecimal digits is terminated by the
@@ -1414,10 +1414,10 @@ [lex.ccon]
 The value of a \grammarterm{character-literal} is \impldef{value of \grammarterm{character-literal} outside range of
 corresponding type} if it falls outside of the \impldef{range defined for \grammarterm{character-literal}s}
 range defined for \tcode{char} (for \grammarterm{character-literal}s with no prefix) or
-\tcode{wchar_t} (for \grammarterm{character-literal}s prefixed by \tcode{L}).
+\tcode{wchar_t} (for \grammarterm{character-literal}s prefixed by \literaltcode{L}).
 \begin{note}
 If the value of a \grammarterm{character-literal} prefixed by
-\tcode{u}, \tcode{u8}, or \tcode{U}
+\literaltcode{u}, \literaltcode{u8}, or \literaltcode{U}
 is outside the range defined for its type,
 the program is ill-formed.
 \end{note}
@@ -1459,42 +1459,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  F  L}
+    \literalterminal{f  l  F  L}
 \end{bnf}
 
 \pnum
@@ -1514,8 +1514,8 @@ [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} \\
+\literaltcode{f} or \literaltcode{F} & \keyword {float} \\
+\literaltcode{l} or \literaltcode{L} & \keyword{long} \keyword{double} \\
 \end{simpletypetable}
 
 \pnum
@@ -1566,8 +1566,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}
@@ -1585,7 +1585,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}
@@ -1615,7 +1615,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
@@ -1675,7 +1675,7 @@ [lex.string]
 
 \pnum
 \indextext{literal!string!UTF-8}%
-A \grammarterm{string-literal} that begins with \tcode{u8},
+A \grammarterm{string-literal} that begins with \literaltcode{u8},
 \indextext{prefix!\idxcode{u8}}%
 such as \tcode{u8"asdf"}, is a \defn{UTF-8 string literal}.
 A UTF-8 string literal
@@ -1693,7 +1693,7 @@ [lex.string]
 \indextext{literal!string!UTF-16}%
 \indextext{literal!string!\idxcode{char16_t}}%
 \indextext{type!\idxcode{char16_t}}%
-A \grammarterm{string-literal} that begins with \tcode{u},
+A \grammarterm{string-literal} that begins with \literaltcode{u},
 \indextext{prefix!\idxcode{u}}%
 such as \tcode{u"asdf"}, is
 a \defn{UTF-16 string literal}.
@@ -1715,7 +1715,7 @@ [lex.string]
 \indextext{literal!string!UTF-32}%
 \indextext{literal!string!\idxcode{char32_t}}%
 \indextext{type!\idxcode{char32_t}}%
-A \grammarterm{string-literal} that begins with \tcode{U},
+A \grammarterm{string-literal} that begins with \literaltcode{U},
 \indextext{prefix!\idxcode{U}}%
 such as \tcode{U"asdf"}, is
 a \defn{UTF-32 string literal}.
@@ -1728,7 +1728,7 @@ [lex.string]
 
 \pnum
 \indextext{literal!string!wide}%
-A \grammarterm{string-literal} that begins with \tcode{L},
+A \grammarterm{string-literal} that begins with \literaltcode{L},
 \indextext{prefix!\idxcode{L}}%
 such as \tcode{L"asdf"}, is a \defn{wide string literal}.
 \indexhdr{stddef.h}%
diff --git a/source/exceptions.tex b/source/exceptions.tex
index 24a5445a..f25891e0 100644
--- a/source/exceptions.tex
+++ b/source/exceptions.tex
@@ -129,11 +129,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 becf21ea..b551e6b3 100644
--- a/source/utilities.tex
+++ b/source/utilities.tex
@@ -19244,23 +19244,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}
 
@@ -19278,18 +19278,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}
@@ -19385,7 +19385,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}
@@ -19395,40 +19395,40 @@ [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
 \begin{note}
 The \fmtgrammarterm{fill} character can be any character
-other than \tcode{\{} or \tcode{\}}.
+other than \noncxxtcode{\{} or \noncxxtcode{\}}.
 The presence of a fill character is signaled by the
 character following it, which must be one of the alignment options.
 If the second character of \fmtgrammarterm{std-format-spec}
@@ -19460,21 +19460,21 @@ [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 field to be aligned to the start of the available space.
 This is the default for
 non-arithmetic types, \tcode{charT}, and \tcode{bool},
 unless an integer presentation type is specified.
 \\ \rowsep
 %
-\tcode{>} &
+\noncxxtcode{>} &
 Forces the field to be aligned to the end of the available space.
 This is the default for
 arithmetic types other than \tcode{charT} and \tcode{bool}
 or when an integer presentation type is specified.
 \\ \rowsep
 %
-\tcode{\caret} &
+\noncxxtcode{\caret} &
 Forces the field to be centered within the available space
 by inserting
 $\bigl\lfloor \frac{n}{2} \bigr\rfloor$
@@ -19494,10 +19494,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
@@ -19506,7 +19506,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
@@ -19532,7 +19532,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.
@@ -19551,13 +19551,13 @@ [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.
 
 \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},
 the value of the corresponding formatting argument is used in its place.
 If the corresponding formatting argument is not of integral type, or
@@ -19608,20 +19608,20 @@ [format.string.std]
 The extended grapheme clusters of a string are defined by UAX \#29.
 The estimated width of the following code points is 2:
 \begin{itemize}
-\item \tcode{U+1100-U+115F}
-\item \tcode{U+2329-U+232A}
-\item \tcode{U+2E80-U+303E}
-\item \tcode{U+3040-U+A4CF}
-\item \tcode{U+AC00-U+D7A3}
-\item \tcode{U+F900-U+FAFF}
-\item \tcode{U+FE10-U+FE19}
-\item \tcode{U+FE30-U+FE6F}
-\item \tcode{U+FF00-U+FF60}
-\item \tcode{U+FFE0-U+FFE6}
-\item \tcode{U+1F300-U+1F64F}
-\item \tcode{U+1F900-U+1F9FF}
-\item \tcode{U+20000-U+2FFFD}
-\item \tcode{U+30000-U+3FFFD}
+\item \noncxxtcode{U+1100-U+115F}
+\item \noncxxtcode{U+2329-U+232A}
+\item \noncxxtcode{U+2E80-U+303E}
+\item \noncxxtcode{U+3040-U+A4CF}
+\item \noncxxtcode{U+AC00-U+D7A3}
+\item \noncxxtcode{U+F900-U+FAFF}
+\item \noncxxtcode{U+FE10-U+FE19}
+\item \noncxxtcode{U+FE30-U+FE6F}
+\item \noncxxtcode{U+FF00-U+FF60}
+\item \noncxxtcode{U+FFE0-U+FFE6}
+\item \noncxxtcode{U+1F300-U+1F64F}
+\item \noncxxtcode{U+1F900-U+1F9FF}
+\item \noncxxtcode{U+20000-U+2FFFD}
+\item \noncxxtcode{U+30000-U+3FFFD}
 \end{itemize}
 The estimated width of other code points is 1.
 
@@ -19629,7 +19629,7 @@ [format.string.std]
 For a string in a non-Unicode encoding, the width of a string is unspecified.
 
 \pnum
-A zero (\tcode{0}) character
+A zero (\noncxxtcode{0}) character
 preceding the \fmtgrammarterm{width} field
 pads the field with leading zeros (following any indication of sign or base)
 to the field width,
@@ -19637,8 +19637,8 @@ [format.string.std]
 This option is only valid for
 arithmetic types other than \tcode{charT} and \tcode{bool}
 or when an integer presentation type is specified.
-If the \tcode{0} character and an \fmtgrammarterm{align} option both appear,
-the \tcode{0} character is ignored.
+If the \noncxxtcode{0} character and an \fmtgrammarterm{align} option both appear,
+the \noncxxtcode{0} character is ignored.
 \begin{example}
 \begin{codeblock}
 char c = 120;
@@ -19664,9 +19664,9 @@ [format.string.std]
 whose estimated width is no greater than the precision.
 
 \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
@@ -19733,52 +19733,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}
@@ -19789,11 +19789,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}.
 \\
 \end{floattable}
@@ -19805,11 +19805,11 @@ [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{c}, \tcode{d}, \tcode{o}, \tcode{x}, \tcode{X} &
+\noncxxtcode{b}, \noncxxtcode{B}, \noncxxtcode{c}, \noncxxtcode{d}, \noncxxtcode{o}, \noncxxtcode{x}, \noncxxtcode{X} &
 As specified in \tref{format.type.int}
 for the value
 \tcode{static_cast<unsigned char>(value)}.
@@ -19821,9 +19821,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.
@@ -19832,7 +19832,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)
@@ -19845,46 +19845,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 &
@@ -19910,12 +19910,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} added to the output;
+with the prefix \noncxxtcode{0x} added to the output;
 otherwise, implementation-defined.
 \\
 \end{floattable}
diff --git a/source/time.tex b/source/time.tex
index 585671cf..42883edf 100644
--- a/source/time.tex
+++ b/source/time.tex
@@ -2159,9 +2159,9 @@ [time.duration.io]
 If the parse parses everything specified by the parsing format flags without error,
 and yet none of the flags impacts a duration,
 \tcode{d} will be assigned a zero value.
-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
@@ -2760,9 +2760,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
@@ -2953,9 +2953,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
@@ -3152,9 +3152,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}.
@@ -3315,9 +3315,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}.
@@ -3422,9 +3422,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}.
@@ -3533,9 +3533,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
@@ -4186,9 +4186,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
@@ -4500,9 +4500,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
@@ -4844,9 +4844,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
@@ -5227,9 +5227,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
@@ -5610,9 +5610,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
@@ -6290,9 +6290,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
@@ -6754,9 +6754,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
@@ -10450,23 +10450,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
@@ -10522,11 +10522,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,
@@ -10542,7 +10542,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.
 
@@ -10554,215 +10554,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 in the ISO 8601:2004 format.
-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}
 
@@ -10787,9 +10787,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}
 
@@ -10802,9 +10802,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,
@@ -10821,9 +10821,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
@@ -10842,9 +10842,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
@@ -10863,9 +10863,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
@@ -10883,7 +10883,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}
 
@@ -10923,16 +10923,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}
@@ -11096,8 +11096,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
@@ -11115,7 +11115,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.
 
@@ -11135,246 +11135,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
@@ -11382,8 +11382,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.17.1


From ddc568e9575a240e5828f3303766fbdaacc17013 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 20/29] 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 37cd7cb8..5ec6149f 100644
--- a/source/basic.tex
+++ b/source/basic.tex
@@ -262,10 +262,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.17.1


From 573ead7994b444b8d4478e64e4791afc0f0f9578 Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Sat, 17 Nov 2018 21:11:41 +0100
Subject: [PATCH 21/29] Replace a \term with a \defn.

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

diff --git a/source/utilities.tex b/source/utilities.tex
index b551e6b3..28524afb 100644
--- a/source/utilities.tex
+++ b/source/utilities.tex
@@ -15872,7 +15872,7 @@ [meta.rqmts]
 be \oldconcept{DefaultConstructible}, \oldconcept{CopyConstructible},
 and publicly and unambiguously derived, directly or
 indirectly, from
-its \term{base characteristic}, which is a specialization
+its \defn{base characteristic}, which is a specialization
 of the template
 \libglobalref{integral_constant}, with
 the arguments to the template \tcode{integral_constant} determined by the
-- 
2.17.1


From 12030b177d9c772bb880dd159b4eed2d12192a81 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 22/29] [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 ca49aaf6..0a060f31 100644
--- a/source/templates.tex
+++ b/source/templates.tex
@@ -7857,7 +7857,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.17.1


From 6995a0dd3122b418b88fea0ffbe4ba2aadc1d05b 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 23/29] Remove more inappropriate paragraph breaks.

---
 source/lex.tex           |  2 --
 source/basic.tex         |  6 ------
 source/expressions.tex   | 26 --------------------------
 source/statements.tex    |  7 ++-----
 source/declarations.tex  | 15 ---------------
 source/modules.tex       |  1 -
 source/classes.tex       | 12 ------------
 source/overloading.tex   | 17 -----------------
 source/templates.tex     | 37 -------------------------------------
 source/exceptions.tex    |  5 -----
 source/preprocessor.tex  | 10 ----------
 source/lib-intro.tex     | 17 -----------------
 source/support.tex       |  4 ----
 source/concepts.tex      | 17 -----------------
 source/utilities.tex     | 22 ----------------------
 source/strings.tex       |  3 ---
 source/containers.tex    | 10 ----------
 source/iterators.tex     |  9 ---------
 source/ranges.tex        | 15 ---------------
 source/algorithms.tex    |  4 ----
 source/numerics.tex      | 12 ------------
 source/time.tex          | 19 -------------------
 source/locales.tex       |  9 ---------
 source/iostreams.tex     | 15 ---------------
 source/regex.tex         |  2 --
 source/atomics.tex       |  4 ----
 source/threads.tex       | 17 -----------------
 source/limits.tex        |  1 -
 source/compatibility.tex | 16 ----------------
 source/future.tex        | 22 ----------------------
 30 files changed, 2 insertions(+), 354 deletions(-)

diff --git a/source/lex.tex b/source/lex.tex
index 41facf03..e0106a04 100644
--- a/source/lex.tex
+++ b/source/lex.tex
@@ -388,7 +388,6 @@ [lex.pptoken]
 
 \item
 within a \grammarterm{has-include-expression}.
-
 \end{itemize}
 \end{itemize}
 
@@ -914,7 +913,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 5ec6149f..29e55b67 100644
--- a/source/basic.tex
+++ b/source/basic.tex
@@ -216,7 +216,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}
@@ -2095,7 +2094,6 @@ [basic.lookup.qual.general]
 
 \pnum
 In a \grammarterm{qualified-id} of the form:
-
 \begin{ncbnf}
 \opt{nested-name-specifier} type-name \terminal{::} \terminal{\~} type-name
 \end{ncbnf}
@@ -2844,7 +2842,6 @@ [basic.link]
 \item when both names denote functions or function templates,
 the signatures~(\ref{defns.signature}, \ref{defns.signature.templ})
 are the same.
-
 \end{itemize}
 If multiple declarations of the same name with external linkage
 would declare the same entity except that
@@ -4316,7 +4313,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.
@@ -5508,7 +5504,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 \tcode{char} and \tcode{signed
 char} (if \tcode{char} is signed) shall have the same rank, even if they have
@@ -6007,7 +6002,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 83fbeb64..2e7c7a23 100644
--- a/source/expressions.tex
+++ b/source/expressions.tex
@@ -449,7 +449,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,
@@ -493,7 +492,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
@@ -520,7 +518,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}.
@@ -646,7 +643,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
@@ -1106,7 +1102,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
@@ -1129,7 +1124,6 @@ [expr.arith.conv]
 to some integral type.
 \end{footnote}
 Then the following rules shall be applied to the promoted operands:
-
 \begin{itemize}
 
 \item If both operands have the same type, no further conversion is
@@ -2111,7 +2105,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
@@ -2714,7 +2707,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)
@@ -2726,7 +2718,6 @@ [expr.prim.req.compound]
 
 \item
 If the \grammarterm{return-type-requirement} is present, then:
-
 \begin{itemize}
 \item
 Substitution of template arguments (if any)
@@ -3315,7 +3306,6 @@ [expr.ref]
 If \tcode{E2} is declared to have type ``reference to \tcode{T}'', then
 \tcode{E1.E2} is an lvalue; the type of \tcode{E1.E2} is \tcode{T}.
 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
@@ -3498,7 +3488,6 @@ [expr.dynamic.cast]
 \pnum
 If \tcode{C} is 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
@@ -4029,7 +4018,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
@@ -4434,7 +4422,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
@@ -4800,7 +4787,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}
@@ -5127,7 +5113,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.
 
@@ -5204,7 +5189,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}.
@@ -5293,7 +5277,6 @@ [expr.new]
 S* p = new (0) S;   // error: non-placement deallocation function matches
                     // placement allocation function
 \end{codeblock}
-
 \end{example}
 
 \pnum
@@ -5420,7 +5403,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
@@ -5995,7 +5977,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,
@@ -6149,7 +6130,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
@@ -6163,7 +6143,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
@@ -6220,7 +6199,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
@@ -6250,7 +6228,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
@@ -6523,7 +6500,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}'',
@@ -6594,7 +6570,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.
@@ -6622,7 +6597,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 da65f8f5..b5f2a631 100644
--- a/source/statements.tex
+++ b/source/statements.tex
@@ -658,7 +658,6 @@ [stmt.ranged]
 
 \item
 \placeholder{begin-expr} and \placeholder{end-expr} are determined as follows:
-
 \begin{itemize}
 \item if the \grammarterm{for-range-initializer} is an expression of
 array type \tcode{R}, \placeholder{begin-expr} and \placeholder{end-expr} are
@@ -778,8 +777,7 @@ [stmt.cont]
 \grammarterm{iteration-statement}
 and causes control to pass to the loop-continuation portion of the
 smallest enclosing \grammarterm{iteration-statement}, that is, to the end
-of the loop. More precisely, in each of the statements
-
+of the loop. More precisely, in each of the statements\newline
 \begin{minipage}{.30\hsize}
 \begin{codeblock}
 while (foo) {
@@ -809,8 +807,7 @@ [stmt.cont]
 @\exposid{contin}@: ;
 }
 \end{codeblock}
-\end{minipage}
-
+\end{minipage}\newline
 a \tcode{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 8327930b..a449c2f5 100644
--- a/source/declarations.tex
+++ b/source/declarations.tex
@@ -1492,7 +1492,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
 \keyword{friend} class-key \terminal{\opt{::}} identifier \terminal{;}\br
@@ -2216,7 +2215,6 @@ [dcl.decl.general]
 
 \pnum
 Declarators have the syntax
-
 \begin{bnf}
 \nontermdef{declarator}\br
     ptr-declarator\br
@@ -3880,7 +3878,6 @@ [dcl.fct.default]
 \tcode{g}
 will be called with the value
 \tcode{f(2)}:
-
 \begin{codeblock}
 int a = 1;
 int f(int);
@@ -4220,7 +4217,6 @@ [dcl.init.general]
 an object of type
 \tcode{T}
 means:
-
 \begin{itemize}
 \item
 If
@@ -4431,7 +4427,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
@@ -5289,7 +5284,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
@@ -5743,7 +5737,6 @@ [dcl.init.list]
 int k { };                          // initialize to 0
 \end{codeblock}
 \end{example}
-
 \end{itemize}
 
 \pnum
@@ -6592,7 +6585,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}
@@ -6714,7 +6706,6 @@ [dcl.enum]
   enum E : int {};              // error: redeclaration of enumeration
 };
 \end{codeblock}
-
 \end{example}
 \end{note}
 If the \grammarterm{enum-head-name} of an \grammarterm{opaque-enum-declaration} contains
@@ -6810,7 +6801,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
@@ -7406,7 +7396,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
@@ -7440,7 +7429,6 @@ [namespace.alias]
 refers.
 \begin{example}
 The following declarations are well-formed:
-
 \begin{codeblock}
 namespace Company_with_very_long_name { @\commentellip@ }
 namespace CWVLN = Company_with_very_long_name;
@@ -7581,7 +7569,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 { };
@@ -8210,7 +8197,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}}%
 %
@@ -9029,7 +9015,6 @@ [dcl.attr.nodiscard]
 It shall appear at most once in each \grammarterm{attribute-list}.
 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/modules.tex b/source/modules.tex
index 55e84dc2..d44c1763 100644
--- a/source/modules.tex
+++ b/source/modules.tex
@@ -621,7 +621,6 @@ [module.global.frag]
 
 \item
 $S$ contains an expression \tcode{E} of the form
-
 \begin{ncsimplebnf}
 postfix-expression \terminal{(} \opt{expression-list} \terminal{)}
 \end{ncsimplebnf}
diff --git a/source/classes.tex b/source/classes.tex
index ff7528f3..edc53cfc 100644
--- a/source/classes.tex
+++ b/source/classes.tex
@@ -1723,7 +1723,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}.
@@ -3190,7 +3189,6 @@ [class.union.general]
 \pnum
 \begin{example}
 Consider the following union:
-
 \begin{codeblock}
 union U {
   int i;
@@ -3286,7 +3284,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;
@@ -3465,7 +3462,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
@@ -4316,7 +4312,6 @@ [class.member.lookup]
 \pnum
 The following steps define the result of merging lookup set $S(f,B_i)$
 into the intermediate $S(f,C)$:
-
 \begin{itemize}
 \item If each of the subobject members of $S(f,B_i)$ is a base class
 subobject of at least one of the subobject members of $S(f,C)$, or if
@@ -5179,7 +5174,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
@@ -5661,7 +5655,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
@@ -6137,7 +6130,6 @@ [class.base.init]
   X(const Mixins&... mixins) : Mixins(mixins)... { }
 };
 \end{codeblock}
-
 \end{example}
 
 \rSec2[class.inhctor.init]{Initialization by inherited constructor}%
@@ -6769,7 +6761,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
@@ -6792,7 +6783,6 @@ [class.compare.default]
 results in a usable candidate that is a non-constexpr function.
 \begin{note}
 This includes the overload resolutions performed:
-
 \begin{itemize}
 \item
 for an \tcode{operator<=>} whose return type is not \tcode{auto},
@@ -6919,7 +6909,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},
@@ -7017,7 +7006,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 e6c41aa6..af99c789 100644
--- a/source/overloading.tex
+++ b/source/overloading.tex
@@ -62,7 +62,6 @@ [over.load]
 
 \pnum
 Certain function declarations cannot be overloaded:
-
 \begin{itemize}
 \item
 \indextext{return type!overloading and}%
@@ -103,7 +102,6 @@ [over.load]
 the type of their implicit object parameter.
 \begin{example}
 The following illustrates this distinction:
-
 \begin{codeblock}
 class X {
   static void f();
@@ -140,7 +138,6 @@ [over.load]
 };
 \end{codeblock}
 \end{example}
-
 \end{itemize}
 
 \pnum
@@ -153,7 +150,6 @@ [over.load]
 declare
 the same function and therefore cannot
 be overloaded:
-
 \begin{itemize}
 \item
 \indextext{\idxcode{typedef}!overloading and}%
@@ -302,7 +298,6 @@ [over.load]
 are equivalent.
 \begin{example}
 Consider the following:
-
 \begin{codeblock}
 void f (int i, int j);
 void f (int i, int j = 99);     // OK: redeclaration of \tcode{f(int, int)}
@@ -479,7 +474,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
@@ -743,7 +737,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
@@ -1278,7 +1271,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);
@@ -1339,7 +1331,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
@@ -1397,7 +1388,6 @@ [over.match.conv]
 \tcode{S}
 a class type,
 the candidate functions are selected as follows:
-
 \begin{itemize}
 \item
 The conversion functions of
@@ -1471,7 +1461,6 @@ [over.match.ref]
 where \tcode{T2} is the same type as \tcode{T} or can be
 converted to type \tcode{T} with a \link{qualification
 conversion}{conv.qual}, are also candidate functions.
-
 \end{itemize}
 
 \pnum
@@ -1490,7 +1479,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,
@@ -1560,7 +1548,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,
@@ -2873,7 +2860,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
@@ -3067,7 +3053,6 @@ [over.ics.rank]
                                 // better than \tcode{short} $\to$ \tcode{float}.
 \end{codeblock}
 \end{example}
-
 \end{itemize}
 
 \pnum
@@ -3076,7 +3061,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
@@ -4241,7 +4225,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 0a060f31..0c2f8187 100644
--- a/source/templates.tex
+++ b/source/templates.tex
@@ -223,7 +223,6 @@ [temp.param]
 The syntax for
 \grammarterm{template-parameter}{s}
 is:
-
 \begin{bnf}
 \nontermdef{template-parameter}\br
   type-parameter\br
@@ -1433,7 +1432,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
@@ -1721,7 +1719,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
@@ -1737,7 +1734,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.
@@ -2340,7 +2336,6 @@ [temp.mem.func]
 
 declares three member functions of a class template.
 The subscript function might be defined like this:
-
 \begin{codeblock}
 template<class T> T& Array<T>::operator[](int i) {
   if (i<0 || sz<=i) error("Array: range error");
@@ -2739,7 +2734,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.
@@ -3331,7 +3325,6 @@ [temp.class.spec.general]
 \pnum
 Within the argument list of a class template partial specialization,
 the following restrictions apply:
-
 \begin{itemize}
 \item
 The type of a template parameter corresponding to a specialized non-type argument
@@ -3345,7 +3338,6 @@ [temp.class.spec.general]
 int array[5];
 template< int X > class A<X,&array> { };        // error
 \end{codeblock}
-
 \end{example}
 \item
 The specialization shall be \deflink{more specialized}{temp.class.order}
@@ -3470,7 +3462,6 @@ [temp.class.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
@@ -3629,7 +3620,6 @@ [temp.fct.general]
 A function template defines an unbounded set of related functions.
 \begin{example}
 A family of sort functions might be declared like this:
-
 \begin{codeblock}
 template<class T> class Array { };
 template<class T> void sort(Array<T>&);
@@ -3682,7 +3672,6 @@ [temp.over.link]
 }
 \end{codeblock}
 \end{minipage}
-
 \end{example}
 
 \pnum
@@ -3869,7 +3858,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>);
@@ -3949,7 +3937,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$''
@@ -4194,7 +4181,6 @@ [temp.alias]
   void g(TT<int, Alloc<int>>);
 g(v);               // OK: \tcode{TT} = \tcode{vector}
 \end{codeblock}
-
 \end{example}
 
 \pnum
@@ -4310,7 +4296,6 @@ [temp.res.general]
 \indextext{overloading!resolution!template name}%
 \indextext{lookup!template name}%
 Three kinds of names can be used within a template definition:
-
 \begin{itemize}
 \item
 The name of the template itself,
@@ -5181,7 +5166,6 @@ [temp.dep.type]
 A name is a
 \defnx{member of the current instantiation}{current instantiation!member of the}
 if it is
-
 \begin{itemize}
 \item
 An unqualified name that, when looked up, refers to
@@ -5247,7 +5231,6 @@ [temp.dep.type]
 A name is a
 \defn{member of an unknown specialization}
 if it is
-
 \begin{itemize}
 \item
 A
@@ -5442,7 +5425,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
 \opt{\terminal{::}} \keyword{new} \opt{new-placement} new-type-id \opt{new-initializer}\br
@@ -5457,7 +5439,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
@@ -5551,7 +5532,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
@@ -5576,7 +5556,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
@@ -5587,7 +5566,6 @@ [temp.dep.constexpr]
 
 \pnum
 Expressions of the following form are value-dependent:
-
 \begin{ncsimplebnf}
 \keyword{sizeof} \terminal{...} \terminal{(} identifier \terminal{)}\br
 fold-expression
@@ -6576,7 +6554,6 @@ [temp.explicit]
 
 \pnum
 The syntax for explicit instantiation is:
-
 \begin{bnf}
 \nontermdef{explicit-instantiation}\br
   \opt{\keyword{extern}} \keyword{template} declaration
@@ -7145,7 +7122,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
@@ -7409,7 +7385,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
@@ -7935,7 +7910,6 @@ [temp.deduct.call]
 If
 \tcode{P}
 is not a reference type:
-
 \begin{itemize}
 \item
 If
@@ -8030,7 +8004,6 @@ [temp.deduct.call]
 is transformed as described above).
 However, there are
 three cases that allow a difference:
-
 \begin{itemize}
 \item
 If the original
@@ -8231,7 +8204,6 @@ [temp.deduct.conv]
 If
 \tcode{A}
 is not a reference type:
-
 \begin{itemize}
 \item
 If
@@ -8277,7 +8249,6 @@ [temp.deduct.conv]
 identical to
 \tcode{A}.
 However, there are four cases that allow a difference:
-
 \begin{itemize}
 \item
 If the original \tcode{A} is a reference type,
@@ -8328,7 +8299,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
@@ -8356,7 +8326,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
@@ -8562,7 +8531,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
@@ -8604,7 +8572,6 @@ [temp.deduct.type]
 
 \pnum
 The non-deduced contexts are:
-
 \indextext{context!non-deduced}%
 \begin{itemize}
 \item
@@ -8687,7 +8654,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@ };
@@ -8704,7 +8670,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 )  );
 
@@ -8721,7 +8686,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;
@@ -8732,7 +8696,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 f25891e0..9676c027 100644
--- a/source/exceptions.tex
+++ b/source/exceptions.tex
@@ -83,7 +83,6 @@ [except.pre]
     goto l2;        // OK
   }
 }
-
 \end{codeblock}
 \end{example}
 \indextext{\idxcode{goto}!and try block}%
@@ -506,12 +505,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}
@@ -1054,9 +1051,7 @@ [except.terminate]
 when a call to a \tcode{wait()}, \tcode{wait_until()}, or \tcode{wait_for()}
 function on a condition variable~(\ref{thread.condition.condvar}, \ref{thread.condition.condvarany})
 fails to meet a postcondition.
-
 \end{itemize}
-
 \end{note}
 
 \pnum
diff --git a/source/preprocessor.tex b/source/preprocessor.tex
index 80f06a76..2eddd0f1 100644
--- a/source/preprocessor.tex
+++ b/source/preprocessor.tex
@@ -140,7 +140,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
@@ -568,7 +567,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>
@@ -727,14 +725,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
@@ -742,7 +738,6 @@ [cpp.include]
 This illustrates macro-replaced
 \tcode{\#include}
 directives:
-
 \begin{codeblock}
 #if VERSION == 1
     #define INCFILE  "vers1.h"
@@ -1419,7 +1414,6 @@ [cpp.concat]
 \pnum
 \begin{example}
 In the following fragment:
-
 \begin{codeblock}
 #define hash_hash # ## #
 #define mkstr(a) # a
@@ -1429,7 +1423,6 @@ [cpp.concat]
 \end{codeblock}
 
 The expansion produces, at various stages:
-
 \begin{codeblock}
 join(x, y)
 in_between(x hash_hash y)
@@ -1648,7 +1641,6 @@ [cpp.predefined]
 
 \pnum
 The following macro names shall be defined by the implementation:
-
 \begin{description}
 
 \item
@@ -1808,7 +1800,6 @@ [cpp.predefined]
 
 \pnum
 The following macro names are conditionally defined by the implementation:
-
 \begin{description}
 \item
 \indextext{__stdc__@\mname{STDC}}%
@@ -1851,7 +1842,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 ce75fa9f..0e4675ed 100644
--- a/source/lib-intro.tex
+++ b/source/lib-intro.tex
@@ -154,7 +154,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
@@ -171,7 +170,6 @@ [structure.summary]
 
 \pnum
 The contents of the summary and the detailed specifications include:
-
 \begin{itemize}
 \item macros
 \item values
@@ -188,7 +186,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
@@ -263,7 +260,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)
@@ -280,7 +276,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
@@ -298,7 +293,6 @@ [structure.specifications]
 For example, if a function specifies no
 preconditions, there will be no \expects element.
 \end{footnote}
-
 \begin{itemize}
 \item
 \constraints
@@ -527,7 +521,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$@ };
 
@@ -560,7 +553,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.
@@ -637,7 +629,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
 A \defn{letter} is any of the 26 lowercase or 26
@@ -824,7 +815,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}
@@ -1529,7 +1519,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}.
@@ -2117,7 +2106,6 @@ [allocator.requirements.general]
 The following is an allocator class template supporting the minimal
 interface that meets the requirements of
 \tref{cpp17.allocator}:
-
 \begin{codeblock}
 template<class Tp>
 struct SimpleAllocator {
@@ -2563,7 +2551,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>}~(\ref{basic.stc.dynamic}, \ref{new.syn}):
-
 \indextext{\idxcode{new}!\idxcode{operator}!replaceable}%
 \indexlibrarymember{new}{operator}%
 \begin{codeblock}
@@ -2615,7 +2602,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}
@@ -2636,7 +2622,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}%
@@ -2662,7 +2647,6 @@ [res.on.functions]
 
 \pnum
 In particular, the effects are undefined in the following cases:
-
 \begin{itemize}
 \item
 For replacement functions\iref{new.delete}, if the installed replacement function does not
@@ -2939,7 +2923,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 954e8692..56848e65 100644
--- a/source/support.tex
+++ b/source/support.tex
@@ -2217,7 +2217,6 @@ [new.delete.single]
 
 \pnum
 \default
-
 \begin{itemize}
 \item
 Executes a loop:
@@ -2703,7 +2702,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();
@@ -4166,7 +4164,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
@@ -5037,7 +5034,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 6b42dead..5bf65490 100644
--- a/source/concepts.tex
+++ b/source/concepts.tex
@@ -146,7 +146,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; }
@@ -360,7 +359,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
@@ -368,7 +366,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
@@ -481,7 +478,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}
@@ -535,12 +531,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}.
@@ -595,7 +589,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)}
@@ -798,7 +791,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}.
 
@@ -825,7 +817,6 @@ [concept.copyconstructible]
 If \tcode{T} is an object type, then let \tcode{v} be an lvalue of type
 (possibly \tcode{const}) \tcode{T} or an rvalue of type \tcode{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
@@ -833,7 +824,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}
@@ -863,7 +853,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
@@ -882,7 +871,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
@@ -930,7 +918,6 @@ [concept.booleantestable]
 
 \pnum
 A \defnadj{disqualifying}{declaration} is
-
 \begin{itemize}
 \item
 a (non-template) function declaration that
@@ -1071,7 +1058,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}.
@@ -1080,7 +1066,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}
@@ -1106,7 +1091,6 @@ [concept.totallyordered]
 \end{codeblock}
 \tcode{T} and \tcode{U} model
 \tcode{\libconcept{totally_ordered_with}<T, U>} only if
-
 \begin{itemize}
 \item \tcode{bool(t <  u) == bool(C(t) <  C(u)).}
 \item \tcode{bool(t >  u) == bool(C(t) >  C(u)).}
@@ -1276,7 +1260,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 28524afb..800f2917 100644
--- a/source/utilities.tex
+++ b/source/utilities.tex
@@ -228,7 +228,6 @@ [utility.swap]
 This function
 is a designated customization point\iref{namespace.std}.
 The expression inside \tcode{noexcept} is equivalent to:
-
 \begin{codeblock}
 is_nothrow_move_constructible_v<T> && is_nothrow_move_assignable_v<T>
 \end{codeblock}
@@ -1718,7 +1717,6 @@ [tuple.assign]
 \remarks
 The expression inside \tcode{noexcept} is equivalent to the logical \logop{AND} of the
 following expressions:
-
 \begin{codeblock}
 is_nothrow_move_assignable_v<@$\mathtt{T}_i$@>
 \end{codeblock}
@@ -1848,7 +1846,6 @@ [tuple.swap]
 \remarks
 The expression inside \tcode{noexcept} is equivalent to the logical
 \logop{AND} of the following expressions:
-
 \begin{codeblock}
 is_nothrow_swappable_v<@$\mathtt{T}_i$@>
 \end{codeblock}
@@ -2340,7 +2337,6 @@ [tuple.special]
 \pnum
 \remarks
 The expression inside \tcode{noexcept} is equivalent to:
-
 \begin{codeblock}
 noexcept(x.swap(y))
 \end{codeblock}
@@ -6230,7 +6226,6 @@ [bitset.members]
 Replaces each bit at position \tcode{I} in
 \tcode{*this}
 with a value determined as follows:
-
 \begin{itemize}
 \item
 If \tcode{I < pos}, the new value is zero;
@@ -6255,7 +6250,6 @@ [bitset.members]
 Replaces each bit at position \tcode{I} in
 \tcode{*this}
 with a value determined as follows:
-
 \begin{itemize}
 \item
 If \tcode{pos >= N - I}, the new value is zero;
@@ -8972,7 +8966,6 @@ [unique.ptr.single.observers]
 \pnum
 \returns
 \tcode{*get()}.
-
 \end{itemdescr}
 
 \indexlibrarymember{operator->}{unique_ptr}%
@@ -9341,7 +9334,6 @@ [unique.ptr.create]
 \pnum
 \returns
 \tcode{unique_ptr<T>(new T(std::forward<Args>(args)...))}.
-
 \end{itemdescr}
 
 \indexlibraryglobal{make_unique}%
@@ -9357,7 +9349,6 @@ [unique.ptr.create]
 \pnum
 \returns
 \tcode{unique_ptr<T>(new remove_extent_t<T>[n]())}.
-
 \end{itemdescr}
 
 \indexlibraryglobal{make_unique}%
@@ -9369,7 +9360,6 @@ [unique.ptr.create]
 \pnum
 \constraints
 \tcode{T} is an array of known bound.
-
 \end{itemdescr}
 
 \indexlibraryglobal{make_unique}%
@@ -9895,7 +9885,6 @@ [util.smartptr.shared.const]
 \tcode{is_move_constructible_v<D>} is \tcode{true}, and
 \tcode{d(p)} is a well-formed expression.
 For the first two overloads:
-
 \begin{itemize}
 \item
 If \tcode{T} is an array type, then either
@@ -10368,7 +10357,6 @@ [util.smartptr.shared.obs]
 \tcode{weak_ptr} instances are equivalent if and only if they share ownership or
 are both empty.
 \end{itemize}
-
 \end{itemdescr}
 
 \rSec3[util.smartptr.shared.create]{Creation}
@@ -13219,7 +13207,6 @@ [functional.syn]
 If a \Cpp{} program wants to have a by-element addition of two vectors \tcode{a}
 and \tcode{b} containing \tcode{double} and put the result into \tcode{a},
 it can do:
-
 \begin{codeblock}
 transform(a.begin(), a.end(), b.begin(), a.begin(), plus<double>());
 \end{codeblock}
@@ -13228,11 +13215,9 @@ [functional.syn]
 \pnum
 \begin{example}
 To negate every element of \tcode{a}:
-
 \begin{codeblock}
 transform(a.begin(), a.end(), a.begin(), negate<double>());
 \end{codeblock}
-
 \end{example}
 
 \rSec2[func.def]{Definitions}
@@ -16988,7 +16973,6 @@ [meta.unary.prop]
 The predicate condition for a template specialization
 \tcode{is_constructible<T, Args...>} shall be satisfied if and only if the
 following variable definition would be well-formed for some invented variable \tcode{t}:
-
 \begin{codeblock}
 T t(declval<Args>()...);
 \end{codeblock}
@@ -17250,7 +17234,6 @@ [meta.rel]
 The predicate condition for a template specialization \tcode{is_convertible<From, To>}
 shall be satisfied if and only if the return expression in the following code would be
 well-formed, including any implicit conversions to the return type of the function:
-
 \begin{codeblock}
 To test() {
   return declval<From>();
@@ -17757,7 +17740,6 @@ [meta.trans.other]
 Note A:
 For the \tcode{common_type} trait applied to a template parameter pack \tcode{T} of types,
 the member \tcode{type} shall be either defined or not present as follows:
-
 \begin{itemize}
 \item If \tcode{sizeof...(T)} is zero, there shall be no member \tcode{type}.
 
@@ -18246,7 +18228,6 @@ [ratio.ratio]
 The static data members \tcode{num} and \tcode{den} shall have the following values,
 where \tcode{gcd} represents the greatest common divisor of the absolute values of
 \tcode{N} and \tcode{D}:
-
 \begin{itemize}
 \item \tcode{num} shall have the value \tcode{sign(N) * sign(D) * abs(N) / gcd}.
 \item \tcode{den} shall have the value \tcode{abs(D) / gcd}.
@@ -18317,7 +18298,6 @@ [ratio.arithmetic]
 static_assert(ratio_multiply<ratio<1, INT_MAX>, ratio<INT_MAX, 2>>::den == 2,
   "1/MAX * MAX/2 == 1/2");
 \end{codeblock}
-
 \end{example}
 
 \rSec2[ratio.comparison]{Comparison of \tcode{ratio}{s}}
@@ -19252,7 +19232,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{\}}
@@ -19382,7 +19361,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/strings.tex b/source/strings.tex
index cc817c17..1a8118ec 100644
--- a/source/strings.tex
+++ b/source/strings.tex
@@ -1107,7 +1107,6 @@ [string.require]
 References, pointers, and iterators referring to the elements of a
 \tcode{basic_string} sequence may be
 invalidated by the following uses of that \tcode{basic_string} object:
-
 \begin{itemize}
 \item Passing as an argument to any standard library function taking a reference to non-const
 \tcode{basic_string} as an argument.
@@ -1791,8 +1790,6 @@ [string.op.append]
 \pnum
 \effects
 Equivalent to: \tcode{return append(str);}
-
-
 \end{itemdescr}
 
 \indexlibrarymember{operator+=}{basic_string}%
diff --git a/source/containers.tex b/source/containers.tex
index da0f6b0a..2447b0e1 100644
--- a/source/containers.tex
+++ b/source/containers.tex
@@ -423,7 +423,6 @@ [container.requirements.general]
 \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
@@ -535,7 +534,6 @@ [container.requirements.general]
 is not allocator-aware, 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}}
@@ -727,7 +725,6 @@ [container.requirements.general]
 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}.
@@ -2120,14 +2117,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}
@@ -3113,7 +3108,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
@@ -5118,7 +5112,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);
@@ -6123,7 +6116,6 @@ [vector.bool]
 To optimize space allocation, a specialization of vector for
 \tcode{bool}
 elements is provided:
-
 \begin{codeblock}
 namespace std {
   template<class Allocator>
@@ -6274,13 +6266,11 @@ [vector.bool]
 \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 19a1ff43..174893d2 100644
--- a/source/iterators.tex
+++ b/source/iterators.tex
@@ -851,7 +851,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}@ =
@@ -909,7 +908,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
@@ -1050,7 +1048,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
@@ -2642,7 +2639,6 @@ [std.iterator.tags]
 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;
@@ -2660,7 +2656,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
@@ -3252,7 +3247,6 @@ [reverse.iter.elem]
 Iterator tmp = current;
 return *--tmp;
 \end{codeblock}
-
 \end{itemdescr}
 
 \indexlibrarymember{operator->}{reverse_iterator}%
@@ -4050,7 +4044,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}}
@@ -4571,7 +4564,6 @@ [move.sentinel]
 \begin{example}
 A \tcode{move_if} algorithm is easily implemented with
 \tcode{copy_if} using \tcode{move_iterator} and \tcode{move_sentinel}:
-
 \begin{codeblock}
 template<@\libconcept{input_iterator}@ I, @\libconcept{sentinel_for}@<I> S, @\libconcept{weakly_incrementable}@ O,
          @\libconcept{indirect_unary_predicate}@<I> Pred>
@@ -5689,7 +5681,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 15c75923..a18ef0cc 100644
--- a/source/ranges.tex
+++ b/source/ranges.tex
@@ -361,7 +361,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
@@ -427,7 +426,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
@@ -540,7 +538,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
@@ -609,7 +606,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
@@ -722,7 +718,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{dcl.array},
@@ -793,7 +788,6 @@ [range.prim.ssize]
 The expression \tcode{ranges::ssize(\brk{}E)}
 for a subexpression \tcode{E} of type \tcode{T}
 is expression-equivalent to:
-
 \begin{itemize}
 \item
 If \tcode{range_difference_t<T>} has width less than \tcode{ptrdiff_t},
@@ -815,7 +809,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{basic.compound},
@@ -866,7 +859,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
@@ -1299,7 +1291,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 @\defexposconcept{simple-view}@ =                         // \expos
@@ -2973,7 +2964,6 @@ [range.adaptor.object]
 a range adaptor closure object \tcode{C} and an expression \tcode{R} such that
 \tcode{decltype((R))} models \libconcept{viewable_range}, the following
 expressions are equivalent and yield a \libconcept{view}:
-
 \begin{codeblock}
 C(R)
 R | C
@@ -2982,7 +2972,6 @@ [range.adaptor.object]
 Given an additional range adaptor closure object \tcode{D},
 the expression \tcode{C | D} is well-formed and produces another range adaptor
 closure object such that the following two expressions are equivalent:
-
 \begin{codeblock}
 R | C | D
 R | (C | D)
@@ -3001,7 +2990,6 @@ [range.adaptor.object]
 \pnum
 If a range adaptor object accepts more than one argument,
 then the following expressions are equivalent:
-
 \begin{codeblock}
 @\placeholdernc{adaptor}@(range, args...)
 @\placeholdernc{adaptor}@(args...)(range)
@@ -4276,7 +4264,6 @@ [range.take.overview]
 \tcode{views::take(E, F)} is ill-formed.
 Otherwise, the expression \tcode{views::take(E, F)}
 is expression-equivalent to:
-
 \begin{itemize}
 \item
 If \tcode{T} is a specialization
@@ -4660,7 +4647,6 @@ [range.drop.overview]
 \tcode{views::drop(E, F)} is ill-formed.
 Otherwise, the expression \tcode{views::drop(E, F)}
 is expression-equivalent to:
-
 \begin{itemize}
 \item
 If \tcode{T} is a specialization of
@@ -5923,7 +5909,6 @@ [range.counted]
 \end{note}
 Otherwise, \tcode{views::counted(E, F)}
 is expression-equivalent to:
-
 \begin{itemize}
 \item
 If \tcode{T} models \libconcept{contiguous_iterator},
diff --git a/source/algorithms.tex b/source/algorithms.tex
index 8ac2de00..0e54e339 100644
--- a/source/algorithms.tex
+++ b/source/algorithms.tex
@@ -5988,7 +5988,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)}
@@ -6891,7 +6890,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}%
@@ -7733,7 +7731,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$,
@@ -10140,7 +10137,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{no-throw-input-iterator}@ = // \expos
diff --git a/source/numerics.tex b/source/numerics.tex
index a56f8925..e8754de2 100644
--- a/source/numerics.tex
+++ b/source/numerics.tex
@@ -663,7 +663,6 @@ [complex.ops]
 \pnum
 \returns
 \tcode{complex<T>(lhs)}.
-
 \end{itemdescr}
 
 \begin{itemdecl}
@@ -802,7 +801,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());
@@ -1387,7 +1385,6 @@ [bit.pow.two]
 \returns
 \tcode{true} if \tcode{x} is an integral power of two;
 \tcode{false} otherwise.
-
 \end{itemdescr}
 
 \indexlibraryglobal{bit_ceil}%
@@ -1439,7 +1436,6 @@ [bit.pow.two]
 If \tcode{x == 0}, \tcode{0};
 otherwise the maximal value \tcode{y}
 such that \tcode{has_single_bit(y)} is \tcode{true} and \tcode{y <= x}.
-
 \end{itemdescr}
 
 \indexlibraryglobal{bit_width}%
@@ -1458,7 +1454,6 @@ [bit.pow.two]
 If \tcode{x == 0}, \tcode{0};
 otherwise one plus the base-2 logarithm of \tcode{x},
 with any fractional part discarded.
-
 \end{itemdescr}
 
 \rSec2[bit.rotate]{Rotating}
@@ -4320,7 +4315,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,
@@ -8163,7 +8157,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}
@@ -8179,7 +8172,6 @@ [valarray.special]
 Equivalent to \tcode{x.swap(y)}.
 \end{itemdescr}
 
-
 \rSec2[class.slice]{Class \tcode{slice}}
 
 \rSec3[class.slice.overview]{Overview}
@@ -8600,7 +8592,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}
@@ -8726,7 +8717,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>&).
@@ -8843,7 +8833,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>&).
@@ -10460,7 +10449,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 42883edf..dfc7848a 100644
--- a/source/time.tex
+++ b/source/time.tex
@@ -2034,7 +2034,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},
@@ -2920,7 +2919,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
@@ -3126,7 +3124,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}
@@ -3289,7 +3286,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}
@@ -3358,7 +3354,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@>
@@ -3367,9 +3362,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@>
@@ -3838,7 +3831,6 @@ [time.clock.cast.fn]
 \constraints
 At least one of the following clock time conversion expressions
 is well-formed:
-
 \begin{itemize}
 \item
 \begin{codeblock}
@@ -7884,7 +7876,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}}@
@@ -7892,7 +7883,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}}@]
@@ -7905,7 +7895,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;
@@ -9094,7 +9083,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"
@@ -9124,7 +9112,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
@@ -9169,7 +9156,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"
@@ -9197,7 +9183,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
@@ -9251,7 +9236,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}
@@ -9556,7 +9540,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*> {
@@ -10136,7 +10119,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
@@ -10435,7 +10417,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{chrono-specs}
diff --git a/source/locales.tex b/source/locales.tex
index d2b9e86c..5e825aca 100644
--- a/source/locales.tex
+++ b/source/locales.tex
@@ -185,7 +185,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>&
@@ -229,7 +228,6 @@ [locale.general]
 and
 \tcode{has_facet<>},
 except that:
-
 \begin{itemize}
 \item
 A member operator template
@@ -823,7 +821,6 @@ [locale.operators]
 can be collated according to collation rules in locale
 \tcode{loc}
 simply by~(\ref{alg.sort}, \ref{vector}):
-
 \begin{codeblock}
 std::sort(v.begin(), v.end(), loc);
 \end{codeblock}
@@ -2488,7 +2485,6 @@ [facet.num.get.virtuals]
 
 \pnum
 The details of this operation occur in three stages
-
 \begin{itemize}
 \item
 Stage 1:
@@ -2606,7 +2602,6 @@ [facet.num.get.virtuals]
 
 \stage{3}
 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}.
 
@@ -2638,7 +2633,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
@@ -2840,7 +2834,6 @@ [facet.num.put.virtuals]
 
 \pnum
 The details of this operation occur in several stages:
-
 \begin{itemize}
 \item
 Stage 1:
@@ -3728,7 +3721,6 @@ [locale.time.get.members]
 \tcode{err = ios_base::goodbit}. It then enters a loop, 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}.
 
@@ -4703,7 +4695,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 461e1724..a4f71b45 100644
--- a/source/iostreams.tex
+++ b/source/iostreams.tex
@@ -2065,14 +2065,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;
 
@@ -6949,7 +6947,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
@@ -6988,7 +6985,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
@@ -7034,7 +7030,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}
@@ -7077,7 +7072,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) {
@@ -7118,7 +7112,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
@@ -7164,7 +7157,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
@@ -7214,7 +7206,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) {
@@ -7253,7 +7244,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) {
@@ -7289,7 +7279,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, struct tm* tmb, const charT* fmt) {
@@ -7328,7 +7317,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 struct tm* tmb, const charT* fmt) {
@@ -9762,7 +9750,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;
@@ -12159,7 +12146,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}.
@@ -15144,7 +15130,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 4d87c740..d797c784 100644
--- a/source/regex.tex
+++ b/source/regex.tex
@@ -3655,7 +3655,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:]]
 
@@ -3750,7 +3749,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:
-
 \indextext{regular expression traits!\idxcode{translate}}%
 \indextext{\idxcode{translate}!regular expression traits}%
 \indextext{regular expression traits!\idxcode{translate_nocase}}%
diff --git a/source/atomics.tex b/source/atomics.tex
index 68133bff..7ba3ee37 100644
--- a/source/atomics.tex
+++ b/source/atomics.tex
@@ -390,7 +390,6 @@ [atomics.order]
 (non-atomic) memory synchronization order as defined in
 \ref{intro.multithread} and may provide for operation ordering. Its
 enumerated values and their meanings are as follows:
-
 \begin{itemize}
 \item \tcode{memory_order::relaxed}: no operation orders memory.
 
@@ -538,7 +537,6 @@ [atomics.order]
 \begin{note}
 The recommendation similarly disallows \tcode{r1 == r2 == 42} in the
 following example, with \tcode{x} and \tcode{y} again initially zero:
-
 \begin{codeblock}
 // Thread 1:
 r1 = x.load(memory_order::relaxed);
@@ -2294,7 +2292,6 @@ [atomics.types.int]
 \begin{note}
 There are no undefined results arising from the computation.
 \end{note}
-
 \end{itemdescr}
 
 \indexlibrarymember{operator+=}{atomic<T*>}%
@@ -2572,7 +2569,6 @@ [atomics.types.pointer]
 \pnum
 The following operations perform pointer arithmetic. The key, operator,
 and computation correspondence is:
-
 \begin{floattable}
 {Atomic pointer computations}{atomic.types.pointer.comp}{lll|lll}
 \hline
diff --git a/source/threads.tex b/source/threads.tex
index b39aeff7..8a3c036d 100644
--- a/source/threads.tex
+++ b/source/threads.tex
@@ -2034,7 +2034,6 @@ [thread.mutex.requirements.mutex.general]
 
 \pnum
 The expression \tcode{m.lock()} is well-formed and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -2077,7 +2076,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
@@ -2123,7 +2121,6 @@ [thread.mutex.requirements.mutex.general]
 
 \pnum
 The expression \tcode{m.unlock()} is well-formed and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -2278,7 +2275,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
@@ -2320,7 +2316,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
@@ -2503,7 +2498,6 @@ [thread.sharedmutex.requirements.general]
 \pnum
 The expression \tcode{m.lock_shared()} is well-formed and has the
 following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -2540,7 +2534,6 @@ [thread.sharedmutex.requirements.general]
 
 \pnum
 The expression \tcode{m.unlock_shared()} is well-formed and has the following semantics:
-
 \begin{itemdescr}
 \pnum
 \expects
@@ -2565,7 +2558,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
@@ -2664,7 +2656,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
@@ -2709,7 +2700,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
@@ -4862,7 +4852,6 @@ [thread.condvarany.wait]
 \begin{itemdescr}
 \pnum
 \effects
-
 \begin{itemize}
 \item
 \indextext{block (execution)}%
@@ -6269,7 +6258,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}.
@@ -6332,7 +6320,6 @@ [futures.promise]
 
 \pnum
 \errors
-
 \begin{itemize}
 \item \tcode{promise_already_satisfied} if its shared state
 already has a stored value or exception.
@@ -6665,7 +6652,6 @@ [futures.unique.future]
 
 \pnum
 \returns
-
 \begin{itemize}
 \item \tcode{future_status::deferred} if the shared state contains a deferred
 function.
@@ -7000,7 +6986,6 @@ [futures.shared.future]
 
 \pnum
 \returns
-
 \begin{itemize}
 \item \tcode{future_status::deferred} if the shared state contains a deferred
 function.
@@ -7035,7 +7020,6 @@ [futures.shared.future]
 
 \pnum
 \returns
-
 \begin{itemize}
 \item \tcode{future_status::deferred} if the shared state contains a deferred
 function.
@@ -7097,7 +7081,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 a6af201a..047b2006 100644
--- a/source/limits.tex
+++ b/source/limits.tex
@@ -130,5 +130,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 7a7ffb4e..230ec81a 100644
--- a/source/compatibility.tex
+++ b/source/compatibility.tex
@@ -1095,7 +1095,6 @@ [diff.cpp11.lex]
 this revision of \Cpp{}, but the macro invocation produces different outcomes
 because the single quotes delimit a \grammarterm{character-literal} in \CppXI{}, whereas they are digit
 separators in this revision of \Cpp{}:
-
 \begin{codeblock}
 #define M(x, ...) __VA_ARGS__
 int x[2] = { M(1'2,3'4, 5) };
@@ -1138,7 +1137,6 @@ [diff.cpp11.expr]
 \effect
 Valid \CppXI{} code that relies on the conversions may behave differently
 in this revision of \Cpp{}:
-
 \begin{codeblock}
 struct S {
   int x = 1;
@@ -1666,7 +1664,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}
@@ -1728,7 +1725,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};
@@ -1807,7 +1803,6 @@ [diff.lex]
 This is needed for improved overloaded function argument type
 matching.
 For example:
-
 \begin{codeblock}
 int function( int i );
 int function( char c );
@@ -1820,11 +1815,9 @@ [diff.lex]
 \effect
 Change to semantics of well-defined feature.
 ISO C programs which depend on
-
 \begin{codeblock}
 sizeof('x') == sizeof(int)
 \end{codeblock}
-
 will not work the same as \Cpp{} programs.
 \difficulty
 Simple.
@@ -1856,7 +1849,6 @@ [diff.lex]
 Change to semantics of well-defined feature.
 \difficulty
 Syntactic transformation. The fix is to add a cast:
-
 \begin{codeblock}
 char* p = "abc";                // valid in C, invalid in \Cpp{}
 void f(char*) {
@@ -2070,12 +2062,10 @@ [diff.expr]
 Change to semantics of well-defined feature.  Some C
 expressions that implicitly rely on lvalue-to-rvalue
 conversions will yield different results.  For example,
-
 \begin{codeblock}
 char arr[100];
 sizeof(0, arr)
 \end{codeblock}
-
 yields
 \tcode{100}
 in \Cpp{} and
@@ -2235,7 +2225,6 @@ [diff.dcl]
 left-hand column presents valid C;
 the right-hand column presents
 equivalent \Cpp{}:
-
 \begin{codeblock}
 void f(const parm);            void f(const int parm);
 const n = 3;                   const int n = 3;
@@ -2286,7 +2275,6 @@ [diff.dcl]
 In C, an empty parameter list means that the number and type of the function arguments are unknown.
 
 Example:
-
 \begin{codeblock}
 int f();            // means   \tcode{int f(void)} in \Cpp{}
                     // \tcode{int f(} unknown \tcode{)} in C
@@ -2314,7 +2302,6 @@ [diff.dcl]
 In C, these type definitions are allowed.
 
 Example:
-
 \begin{codeblock}
 void f( struct S { int a; } arg ) {}    // valid C, invalid \Cpp{}
 enum E { A, B, C } f() {}               // valid C, invalid \Cpp{}
@@ -2767,7 +2754,6 @@ [diff.mods.to.declarations]
 \pnum
 Header \libheaderref{cstring}:
 The following functions have different declarations:
-
 \begin{itemize}
 \item \tcode{strchr}
 \item \tcode{strpbrk}
@@ -2781,7 +2767,6 @@ [diff.mods.to.declarations]
 \pnum
 Header \libheaderref{cwchar}:
 The following functions have different declarations:
-
 \begin{itemize}
 \item \tcode{wcschr}
 \item \tcode{wcspbrk}
@@ -2806,7 +2791,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 7c2a18ce..1aa70344 100644
--- a/source/future.tex
+++ b/source/future.tex
@@ -409,7 +409,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&);
@@ -423,7 +422,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);
@@ -716,14 +714,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);
@@ -1157,7 +1153,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.
@@ -1251,7 +1246,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.
@@ -1281,7 +1275,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
@@ -1397,7 +1390,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.
@@ -1512,7 +1504,6 @@ [depr.meta.types]
 \pnum
 The header \libheaderrefx{type_traits}{meta.type.synop}
 has the following addition:
-
 \indexlibraryglobal{is_literal_type}%
 \begin{codeblock}
 namespace std {
@@ -1556,7 +1547,6 @@ [depr.tuple]
 
 \pnum
 The header \libheaderref{tuple} has the following additions:
-
 \begin{codeblock}
 namespace std {
   template<class T> class tuple_size<volatile T>;
@@ -1626,7 +1616,6 @@ [depr.variant]
 
 \pnum
 The header \libheaderref{variant} has the following additions:
-
 \begin{codeblock}
 namespace std {
   template<class T> struct variant_size<volatile T>;
@@ -1673,7 +1662,6 @@ [depr.iterator]
 
 \pnum
 The header \libheaderrefx{iterator}{iterator.synopsis} has the following addition:
-
 \indexlibraryglobal{iterator}%
 \begin{codeblock}
 namespace std {
@@ -1707,7 +1695,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&> {
@@ -1721,7 +1708,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>
@@ -1747,7 +1733,6 @@ [depr.util.smartptr.shared.atomic]
 
 \pnum
 The header \libheaderref{memory} has the following additions:
-
 \indexlibraryglobal{shared_ptr}%
 \begin{codeblock}
 namespace std {
@@ -2011,7 +1996,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 {
@@ -2163,7 +2147,6 @@ [depr.conversions.general]
 
 \pnum
 The header \libheaderref{locale} has the following additions:
-
 \begin{codeblock}
 namespace std {
   template<class Codecvt, class Elem = wchar_t,
@@ -2257,7 +2240,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
@@ -2308,7 +2290,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
@@ -2375,7 +2356,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
@@ -2689,7 +2668,6 @@ [depr.atomics.general]
 
 \pnum
 The header \libheaderrefx{atomic}{atomics.syn} has the following additions.
-
 \begin{codeblock}
 namespace std {
   template<class T>
-- 
2.17.1


From 84d207749cb0fc07c02bb567b1da79c7e632597b Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Thu, 30 Jul 2020 03:30:25 +0200
Subject: [PATCH 24/29] Mark fake ellipsis.

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

diff --git a/source/atomics.tex b/source/atomics.tex
index 7ba3ee37..bd208390 100644
--- a/source/atomics.tex
+++ b/source/atomics.tex
@@ -607,7 +607,7 @@ [atomics.lockfree]
 \end{codeblock}
 
 \pnum
-The \tcode{ATOMIC_..._LOCK_FREE} macros indicate the lock-free property of the
+The \tcode{ATOMIC_\ldots{}_LOCK_FREE} macros indicate the lock-free property of the
 corresponding atomic types, with the signed and unsigned variants grouped
 together. The properties also apply to the corresponding (partial) specializations of the
 \tcode{atomic} template. A value of 0 indicates that the types are never
@@ -1680,7 +1680,7 @@ [atomics.types.operations]
 if the atomic type's operations are always lock-free, and \tcode{false} otherwise.
 \begin{note}
 The value of \tcode{is_always_lock_free} is consistent with the value of
-the corresponding \tcode{ATOMIC_..._LOCK_FREE} macro, if defined.
+the corresponding \tcode{ATOMIC_\ldots{}_LOCK_FREE} macro, if defined.
 \end{note}
 \end{itemdescr}
 
-- 
2.17.1


From 78194a086e1f98cdb9f8e3e750bfe43fea161317 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 25/29] 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 0c2f8187..8974ceec 100644
--- a/source/templates.tex
+++ b/source/templates.tex
@@ -1927,9 +1927,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.17.1


From a7f1556bc7a723ce348bf223b1bc66d5dd4b73ea Mon Sep 17 00:00:00 2001
From: Eelis van der Weegen <eelis@eelis.net>
Date: Thu, 27 Aug 2020 03:57:14 +0200
Subject: [PATCH 26/29] Use \libheaderdef where appropriate.

---
 source/future.tex | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/source/future.tex b/source/future.tex
index 1aa70344..f51e6d6d 100644
--- a/source/future.tex
+++ b/source/future.tex
@@ -253,13 +253,12 @@ [depr.c.headers.general]
 
 \rSec2[depr.complex.h.syn]{Header \tcode{<complex.h>} synopsis}
 
-\indexheader{complex.h}%
 \begin{codeblock}
 #include <complex>
 \end{codeblock}
 
 \pnum
-The header \libheader{complex.h}
+The header \libheaderdef{complex.h}
 behaves as if it simply includes the header
 \libheaderref{complex}.
 
@@ -271,9 +270,8 @@ [depr.complex.h.syn]
 
 \rSec2[depr.iso646.h.syn]{Header \tcode{<iso646.h>} synopsis}
 
-\indexheader{iso646.h}%
 \pnum
-The \Cpp{} header \libheader{iso646.h} is empty.
+The \Cpp{} header \libheaderdef{iso646.h} is empty.
 \begin{note}
 \tcode{and},
 \tcode{and_eq},
-- 
2.17.1


From 3a2e40f11a391122f8c8deb0a1302b588bdced89 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 27/29] Remove duplicate index entry.

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

diff --git a/source/utilities.tex b/source/utilities.tex
index 800f2917..2ef0cee1 100644
--- a/source/utilities.tex
+++ b/source/utilities.tex
@@ -19090,7 +19090,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.17.1


From 70dd8e09072405d8c826e2f1284f634cc8020fc3 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 28/29] [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 edc53cfc..9262fff4 100644
--- a/source/classes.tex
+++ b/source/classes.tex
@@ -63,7 +63,7 @@ [class.pre]
 a partial specialization\iref{temp.class.spec}.
 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.17.1


From 09617ecda55b8a6967b01d026c94ebc2aa591b21 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 29/29] Use monospace font for code in figures.

---
 source/figdag.dot         |  8 ++++----
 source/figname.dot        | 14 +++++++-------
 source/fignonvirt.dot     | 12 ++++++------
 source/figstreampos.dot   | 14 +++++++++-----
 source/figvirt.dot        | 10 +++++-----
 source/figvirtnonvirt.dot | 14 +++++++-------
 6 files changed, 38 insertions(+), 34 deletions(-)

diff --git a/source/figdag.dot b/source/figdag.dot
index b29593a9..797d8f2b 100644
--- a/source/figdag.dot
+++ b/source/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/figname.dot b/source/figname.dot
index 8cb94e93..9878984d 100644
--- a/source/figname.dot
+++ b/source/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/fignonvirt.dot b/source/fignonvirt.dot
index fac23dcf..ee3a3d9b 100644
--- a/source/fignonvirt.dot
+++ b/source/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/figstreampos.dot b/source/figstreampos.dot
index 819d2462..420f88a0 100644
--- a/source/figstreampos.dot
+++ b/source/figstreampos.dot
@@ -1,14 +1,18 @@
 digraph figstreampos
 {
-  traits_pos_type_char [label="char_traits<char>\n::pos_type"];
-  traits_pos_type_wchar_t [label="char_traits<wchar_t>\n::pos_type"];
+  streampos [fontname="Courier New"];
+  wstreampos [fontname="Courier New"];
+  streamoff [fontname="Courier New"];
+  streamsize [fontname="Courier New"];
+  traits_pos_type_char [label="char_traits<char>\n::pos_type",fontname="Courier New"];
+  traits_pos_type_wchar_t [label="char_traits<wchar_t>\n::pos_type",fontname="Courier New"];
   traits_pos_type_char -> streampos [label=" iostreams.limits.pos"]; 
   traits_pos_type_wchar_t -> wstreampos [label=" iostreams.limits.pos"]; 
   streampos -> fpos [label=" iostream.forward"];
-  fpos [label="fpos<mbstate_t>"];
+  fpos [label="fpos<mbstate_t>",fontname="Courier New"];
   
-  traits_off_type_char [label="char_traits<char>\n::off_type"];
-  traits_off_type_wchar_t [label="char_traits<wchar_t>\n::off_type"];
+  traits_off_type_char [label="char_traits<char>\n::off_type",fontname="Courier New"];
+  traits_off_type_wchar_t [label="char_traits<wchar_t>\n::off_type",fontname="Courier New"];
   traits_off_type_char -> streamoff [label=" iostreams.limits.pos"];
   traits_off_type_wchar_t -> streamoff [label=" iostreams.limits.pos"];
   wstreampos -> fpos [label=" iostream.forward"];
diff --git a/source/figvirt.dot b/source/figvirt.dot
index 4c9fa775..e1caa157 100644
--- a/source/figvirt.dot
+++ b/source/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/figvirtnonvirt.dot b/source/figvirtnonvirt.dot
index b3c04d48..1ab8e364 100644
--- a/source/figvirtnonvirt.dot
+++ b/source/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.17.1