Replace \indextext + \term pairs with \defnx (or \defn).

Author: Eelis

source/classes.tex

@@ -144,9 +144,8 @@
 virtual functions or virtual base classes.\end{note}
 
 \indextext{class!standard-layout}%
-\indextext{standard-layout~class}%
 \pnum
-A class \tcode{S} is a \grammarterm{standard-layout class} if it:
+A class \tcode{S} is a \defnx{standard-layout class}{standard-layout~class} if it:
 \begin{itemize}
 \item has no non-static data members of type non-standard-layout class
 (or array of such types) or reference,
@@ -211,14 +210,12 @@
 \end{example}
 
 \indextext{struct!standard-layout}%
-\indextext{standard-layout~struct}%
 \indextext{union!standard-layout}%
-\indextext{standard-layout~union}%
 \pnum
-A \grammarterm{standard-layout struct} is a standard-layout class
+A \defnx{standard-layout struct}{standard-layout~struct} is a standard-layout class
 defined with the \grammarterm{class-key} \tcode{struct} or the
 \grammarterm{class-key} \tcode{class}.
-A \grammarterm{standard-layout union} is a standard-layout class
+A \defnx{standard-layout union}{standard-layout~union} is a standard-layout class
 defined with the
 \grammarterm{class-key} \tcode{union}.
 
@@ -228,14 +225,13 @@
 in~\ref{class.mem}.\end{note}
 
 \pnum
-\indextext{POD struct}\indextext{POD class}\indextext{POD union}%
-A \term{POD struct}\footnote{The acronym POD stands for ``plain old data''.}
+A \defn{POD struct}\footnote{The acronym POD stands for ``plain old data''.}
 is a non-union class that is both a trivial class and a
 standard-layout class, and has no non-static data members of type non-POD struct,
 non-POD union (or array of such types). Similarly, a
-\term{POD union} is a union that is both a trivial class and a standard-layout
+\defn{POD union} is a union that is both a trivial class and a standard-layout
 class, and has no non-static data members of type non-POD struct, non-POD
-union (or array of such types). A \term{POD class} is a
+union (or array of such types). A \defn{POD class} is a
 class that is either a POD struct or a POD union.
 
 \begin{example}

source/declarations.tex

@@ -2013,14 +2013,12 @@
 \pnum
 \indextext{constant!enumeration}%
 \indextext{enumeration}%
-\indextext{enumeration!unscoped}%
-\indextext{enumeration!scoped}%
 The enumeration type declared with an \grammarterm{enum-key}
-of only \tcode{enum} is an \term{}{unscoped enumeration},
+of only \tcode{enum} is an \defnx{unscoped enumeration}{enumeration!unscoped},
 and its \grammarterm{enumerator}{s} are \term{unscoped enumerators}.
 The \grammarterm{enum-key}{s} \tcode{enum class} and
 \tcode{enum struct} are semantically equivalent; an enumeration
-type declared with one of these is a \term{scoped enumeration},
+type declared with one of these is a \defnx{scoped enumeration}{enumeration!scoped},
 and its \grammarterm{enumerator}{s} are \term{scoped enumerators}.
 The optional \grammarterm{identifier} shall not be omitted in the declaration of a scoped enumeration.
 The \grammarterm{type-specifier-seq} of an \grammarterm{enum-base}

source/expressions.tex

@@ -153,11 +153,10 @@
 applied to convert the expression to an xvalue.
 
 \pnum
-\indextext{conversion!usual arithmetic}%
 Many binary operators that expect operands of arithmetic or enumeration
 type cause conversions and yield result types in a similar way. The
 purpose is to yield a common type, which is also the type of the result.
-This pattern is called the \term{usual arithmetic conversions},
+This pattern is called the \defnx{usual arithmetic conversions}{conversion!usual arithmetic},
 which are defined as follows:
 
 \begin{itemize}

source/lex.tex

@@ -870,26 +870,21 @@
 \pnum
 \indextext{literal!\idxcode{unsigned}}%
 \indextext{literal!\idxcode{long}}%
-\indextext{literal!integer}%
-\indextext{literal!binary}%
-\indextext{literal!octal}%
-\indextext{literal!decimal}%
-\indextext{literal!hexadecimal}%
 \indextext{literal!base~of integer}%
-An \term{integer literal} is a sequence of digits that has no period
+An \defnx{integer literal}{literal!integer} is a sequence of digits that has no period
 or exponent part, with optional separating single quotes that are ignored
 when determining its value. An integer literal may have a prefix that specifies
 its base and a suffix that specifies its type. The lexically first digit
 of the sequence of digits is the most significant.
-A \term{binary} integer literal (base two) begins with
+A \defnx{binary}{literal!binary} integer literal (base two) begins with
 \tcode{0b} or \tcode{0B} and consists of a sequence of binary digits.
-An \term{octal} integer
+An \defnx{octal}{literal!octal} integer
 literal (base eight) begins with the digit \tcode{0} and consists of a
 sequence of octal digits.\footnote{The digits \tcode{8} and \tcode{9} are not octal digits. }
-A \term{decimal}
+A \defnx{decimal}{literal!decimal}
 integer literal (base ten) begins with a digit other than \tcode{0} and
 consists of a sequence of decimal digits.
-A \term{hexadecimal} integer literal (base sixteen) begins with
+A \defnx{hexadecimal}{literal!hexadecimal} integer literal (base sixteen) begins with
 \tcode{0x} or \tcode{0X} and consists of a sequence of hexadecimal
 digits, which include the decimal digits and the letters \tcode{a}
 through \tcode{f} and \tcode{A} through \tcode{F} with decimal values
@@ -1298,10 +1293,8 @@
 The integer and fraction parts both consist of
 a sequence of decimal (base ten) digits if there is no prefix, or
 hexadecimal (base sixteen) digits if the prefix is \tcode{0x} or \tcode{0X}.
-\indextext{literal!decimal floating}%
-The literal is a \term{decimal floating literal} in the former case and
-\indextext{literal!hexadecimal floating}%
-a \term{hexadecimal floating literal} in the latter case.
+The literal is a \defnx{decimal floating literal}{literal!decimal floating} in the former case and
+a \defnx{hexadecimal floating literal}{literal!hexadecimal floating} in the latter case.
 Optional separating single quotes in
 a \grammarterm{digit-sequence} or \grammarterm{hexadecimal-digit-sequence}
 are ignored when determining its value.

source/lib-intro.tex

@@ -5,8 +5,7 @@
 
 \pnum
 This Clause describes the contents of the
-\term{\Cpp standard library},
-\indextext{library!C++ standard}%
+\defnx{\Cpp standard library}{library!C++ standard},
 how a well-formed \Cpp program makes use of the library, and
 how a conforming implementation may provide the entities in the library.
 
@@ -597,8 +596,7 @@
 
 \pnum
 Several types defined in Clause~\ref{input.output} are
-\term{enumerated types}.
-\indextext{type!enumerated}%
+\defnx{enumerated types}{type!enumerated}.
 Each enumerated type may be implemented as an enumeration or as a synonym for
 an enumeration.\footnote{Such as an integer type, with constant integer
 values~(\ref{basic.fundamental}).}
@@ -687,8 +685,7 @@
 All such elements have distinct, nonzero values such that, for any pair \placeholder{Ci}
 and \placeholder{Cj} where \placeholder{i} != \placeholder{j}, \placeholder{Ci} \& \placeholder{Ci} is nonzero and
 \placeholder{Ci} \& \placeholder{Cj} is zero.
-\indextext{bitmask!empty}%
-Additionally, the value 0 is used to represent an \term{empty bitmask}, in which no
+Additionally, the value 0 is used to represent an \defnx{empty bitmask}{bitmask!empty}, in which no
 bitmask elements are set.
 
 \pnum
@@ -729,10 +726,7 @@
 \indextext{uppercase}%
 uppercase letters in the basic execution character set.
 \item
-The
-\term{decimal-point character}
-is the
-\indextext{character!decimal-point}%
+The \defnx{decimal-point character}{character!decimal-point} is the
 (single-byte) character used by functions that convert between a (single-byte)
 character sequence and a value of one of the floating-point types.
 It is used
@@ -780,9 +774,8 @@
 
 \pnum
 A
-\indextext{string!null-terminated byte}%
 \indextext{NTBS}%
-\term{null-terminated byte string},
+\defnx{null-terminated byte string}{string!null-terminated byte},
 or \ntbs,
 is a character sequence whose highest-addressed element
 with defined content has the value zero
@@ -819,8 +812,7 @@
 \pnum
 A
 \indextext{NTBS}%
-\indextext{NTBS!static}%
-\term{static} \ntbs
+\defnx{static}{NTBS!static} \ntbs
 is an \ntbs with
 static storage duration.\footnote{A string literal, such as
 \tcode{"abc"},
@@ -832,9 +824,8 @@
 A
 \indextext{NTBS}%
 \indextext{NTMBS}%
-\term{null-terminated multibyte string,}
+\defnx{null-terminated multibyte string}{string!null-terminated multibyte},
 or \ntmbs,
-\indextext{string!null-terminated multibyte}%
 is an \ntbs that constitutes a
 sequence of valid multibyte characters, beginning and ending in the initial
 shift state.\footnote{An \ntbs that contains characters only from the
@@ -843,10 +834,8 @@
 consists of a single byte.}
 
 \pnum
-A
-\term{static} \ntmbs
+A \defnx{static}{NTMBS!static} \ntmbs
 is an \ntmbs with static storage duration.
-\indextext{NTMBS!static}%
 \indextext{NTMBS}%
 
 \rSec3[functions.within.classes]{Functions within classes}
@@ -967,8 +956,7 @@
 \pnum
 The \Cpp standard library provides
 61
-\term{\Cpp library headers},
-\indextext{header!C++ library}%
+\defnx{\Cpp library headers}{header!C++ library},
 as shown in Table~\ref{tab:cpp.library.headers}.
 
 \begin{floattable}{\Cpp library headers}{tab:cpp.library.headers}
@@ -1272,11 +1260,10 @@
 
 \pnum
 Two kinds of implementations are defined:
-\term{hosted}
+\defnx{hosted}{implementation!hosted}
 and
 \term{freestanding}~(\ref{intro.compliance}).
 For a hosted implementation, this International Standard
-\indextext{implementation!hosted}%
 describes the set of available headers.
 
 \pnum

source/special.tex

@@ -733,8 +733,7 @@
 the types of its parameters (if any)
 to the type of its class.
 Such a constructor is called a
-\indexdefn{constructor!converting}%
-\term{converting constructor}.
+\defnx{converting constructor}{constructor!converting}.
 \begin{example}
 
 \indextext{Jessie}%

source/templates.tex

@@ -56,10 +56,8 @@
 if its \grammarterm{declaration} defines a function, a class, a variable, or a
 static data member. A declaration introduced by a template declaration of a
 \indextext{variable template!definition~of}%
-\indextext{template!variable}%
-\indextext{template!static data member}%
-variable is a \term{variable template}. A variable template at class scope is a
-\term{static data member template}.
+variable is a \defnx{variable template}{template!variable}. A variable template at class scope is a
+\defnx{static data member template}{template!static data member}.
 
 \begin{example}
 \begin{codeblock}
@@ -2169,16 +2167,14 @@
 \rSec2[temp.class.spec]{Class template partial specializations}
 
 \pnum
-\indextext{specialization!class template partial}%
-\indextext{template!primary}%
 A
-\term{primary}
+\defnx{primary}{template!primary}
 class template declaration is one in which the class template name is an
 identifier.
 A template declaration in which the class template name is a
 \grammarterm{simple-template-id}
 is a
-\term{partial specialization}
+\defnx{partial specialization}{specialization!class template partial}
 of the class template named in the
 \grammarterm{simple-template-id}.
 A partial specialization of a class template provides an alternative definition
@@ -2403,9 +2399,8 @@
 \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 \term{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 ordering rules for function
 templates~(\ref{temp.func.order}):
@@ -2742,12 +2737,11 @@
 
 \pnum
 \indextext{overloading!resolution!template}%
-\indextext{ordering!function template partial}%
 If a function template is overloaded,
 the use of a function template specialization might be ambiguous because
 template argument deduction~(\ref{temp.deduct}) may associate the function
 template specialization with more than one function template declaration.
-\term{Partial ordering}
+\defnx{Partial ordering}{ordering!function template partial}
 of overloaded function template declarations is used in the following contexts
 to select the function template to which a function template specialization
 refers:
@@ -3581,8 +3575,7 @@
 the
 \grammarterm{unqualified-id}
 denotes a
-\indextext{name!dependent}%
-\term{dependent name}
+\defnx{dependent name}{name!dependent}
 if
 
 \begin{itemize}
@@ -3784,8 +3777,7 @@
 \end{example}
 
 \pnum
-\indextext{base class!dependent}%
-A \term{dependent base class} is a base class that is a dependent type and is
+A \defnx{dependent base class}{base class!dependent} is a base class that is a dependent type and is
 not the current instantiation.
 \begin{note}
 a base class can be the current instantiation in the case of a nested class
@@ -3808,9 +3800,8 @@
 \end{note}
 
 \pnum
-\indextext{instantiation!member of the current}%
 A name is a
-\term{member of the current instantiation}
+\defnx{member of the current instantiation}{instantiation!member of the current}
 if it is
 
 \begin{itemize}
@@ -3863,8 +3854,9 @@
 \end{codeblock}
 \end{example}
 
-\indextext{instantiation!dependent member of the current}%
-A name is a \term{dependent member of the current instantiation} if it is a
+A name is a
+\defnx{dependent member of the current instantiation}{instantiation!dependent member of the current}
+if it is a
 member of the current instantiation that, when looked up, refers to at least
 one member of a class that is the current instantiation.
 
@@ -6707,7 +6699,6 @@
 \end{itemize}
 
 \pnum
-\indextext{more~specialized!function~template}%
 \indextext{at~least~as specialized~as|see{more~specialized}}%
 Function template \tcode{F}
 is \term{at least as specialized as}
@@ -6717,7 +6708,7 @@
 is at least as specialized as
 the type from \tcode{G}.
 \tcode{F}
-is \term{more specialized than}
+is \defnx{more specialized than}{more~specialized!function~template}
 \tcode{G} if
 \tcode{F}
 is at least as specialized as