Mark definitions more consistently with defn/defnx.

Author: Eelis

source/exceptions.tex

@@ -258,7 +258,7 @@
 Throwing an exception
 copy-initializes~(\ref{dcl.init}, \ref{class.copy}) a temporary object,
 called the
-\indextext{exception handling!exception object}\term{exception object}.
+\defnx{exception object}{exception handling!exception object}.
 The temporary is an lvalue and is used to initialize the
 variable declared in the matching
 \term{handler}~(\ref{except.handle}).

source/expressions.tex

@@ -1030,7 +1030,7 @@
 A member of an anonymous union shall not be captured by copy.
 
 \pnum
-An entity is \indexdefn{captured!by reference}\term{captured by reference} if it is implicitly or explicitly
+An entity is \defnx{captured by reference}{captured!by reference} if it is implicitly or explicitly
 captured but not captured by copy. It is unspecified whether additional unnamed
 non-static data members are declared in the closure type for entities captured by
 reference. A member of an anonymous union shall not be captured by reference.

source/intro.tex

@@ -39,7 +39,7 @@
 \Cpp is a general purpose programming language based on the C
 programming language as described in ISO/IEC 9899:1999
 \doccite{Programming languages --- C} (hereinafter referred to as the
-\indexdefn{C!standard}\term{C standard}). In addition to
+\defnx{C standard}{C!standard}). In addition to
 the facilities provided by C, \Cpp provides additional data types,
 classes, templates, exceptions, namespaces, operator
 overloading, function name overloading, references, free store
@@ -82,14 +82,14 @@
 The library described in Clause 7 of ISO/IEC 9899:1999 and Clause 7 of
 ISO/IEC 9899:1999/Cor.1:2001 and Clause 7 of ISO/IEC
 9899:1999/Cor.2:2003 is hereinafter called the
-\indexdefn{C!standard library}\term{C standard
-library}.\footnote{With the qualifications noted in Clauses~\ref{\firstlibchapter}
+\defnx{C standard library}{C!standard library}.
+\footnote{With the qualifications noted in Clauses~\ref{\firstlibchapter}
 through~\ref{\lastlibchapter} and in~\ref{diff.library}, the C standard
 library is a subset of the \Cpp standard library.}
 
 \pnum
 The library described in ISO/IEC TR 19769:2004 is hereinafter called the
-\indexdefn{C!Unicode TR}\term{C Unicode TR}.
+\defnx{C Unicode TR}{C!Unicode TR}.
 
 \pnum
 The operating system interface described in ISO/IEC 9945:2003 is
@@ -968,7 +968,7 @@
 Executions of atomic functions
 that are either defined to be lock-free~(\ref{atomics.flag})
 or indicated as lock-free~(\ref{atomics.lockfree})
-are \indexdefn{lock-free executions}\term{lock-free executions}.
+are \defn{lock-free executions}.
 \begin{itemize}
 \item
   If there is only one unblocked thread,

source/lex.tex

@@ -28,7 +28,7 @@
 \indextext{conventions!lexical|(}%
 \indextext{compilation!separate|(}%
 The text of the program is kept in units called
-\indextext{source file}\term{source files} in this International
+\defnx{source files}{source file} in this International
 Standard. A source file together with all the headers~(\ref{headers})
 and source files included~(\ref{cpp.include}) via the preprocessing
 directive \tcode{\#include}, less any source lines skipped by any of the

source/preprocessor.tex

@@ -572,9 +572,8 @@
 The identifier immediately following the
 \tcode{define}
 is called the
-\indextext{macro!name}%
 \indextext{name!macro|see{macro, name}}%
-\term{macro name}.
+\defnx{macro name}{macro!name}.
 There is one name space for macro names.
 Any white-space characters preceding or following the
 replacement list of preprocessing tokens are not considered

source/strings.tex

@@ -6,9 +6,9 @@
 \pnum
 This Clause describes components for manipulating sequences of
 any non-array POD~(\ref{basic.types}) type.
-In this Clause such types are called \term{char-like types},\indextext{char-like type}
+In this Clause such types are called \defn{char-like types}{char-like type},
 and objects of
-char-like types are called \term{char-like objects}\indextext{char-like object} or
+char-like types are called \defnx{char-like objects}{char-like object} or
 simply \term{characters}.
 
 \pnum

source/utilities.tex

@@ -7066,7 +7066,7 @@
 \rSec1[function.objects]{Function objects}
 
 \pnum
-A \indexdefn{function object!type}\term{function object type} is an object
+A \defnx{function object type}{function object!type} is an object
 type~(\ref{basic.types}) that can be the type of the
 \grammarterm{postfix-expression} in a function call
 (\ref{expr.call},~\ref{over.match.call}).\footnote{Such a type is a function
@@ -7260,30 +7260,24 @@
 The following definitions apply to this Clause:
 
 \pnum
-\indexdefn{call signature}%
-A \term{call signature} is the name of a return type followed by a
+A \defn{call signature} is the name of a return type followed by a
 parenthesized comma-separated list of zero or more argument types.
 
 \pnum
-\indexdefn{callable type}%
-A \term{callable type} is a function object type~(\ref{function.objects}) or a pointer to member.
+A \defn{callable type} is a function object type~(\ref{function.objects}) or a pointer to member.
 
 \pnum
-\indexdefn{callable object}%
-A \term{callable object} is an object of a callable type.
+A \defn{callable object} is an object of a callable type.
 
 \pnum
-\indexdefn{call wrapper!type}%
-A \term{call wrapper type} is a type that holds a callable object
+A \defnx{call wrapper type}{call wrapper!type} is a type that holds a callable object
 and supports a call operation that forwards to that object.
 
 \pnum
-\indexdefn{call wrapper}%
-A \term{call wrapper} is an object of a call wrapper type.
+A \defn{call wrapper} is an object of a call wrapper type.
 
 \pnum
-\indexdefn{target object}%
-A \term{target object} is the callable object held by a call wrapper.
+A \defn{target object} is the callable object held by a call wrapper.
 
 \rSec2[func.require]{Requirements}
 
@@ -7351,13 +7345,11 @@
 \indextext{call wrapper}%
 \indextext{call wrapper!simple}%
 \indextext{call wrapper!forwarding}%
-\indextext{simple call wrapper}%
-\indextext{forwarding call wrapper}%
 Every call wrapper~(\ref{func.def}) shall be
-\tcode{MoveConstructible}. A \term{simple call wrapper} is a call wrapper
+\tcode{MoveConstructible}. A \defn{simple call wrapper} is a call wrapper
 that is \tcode{CopyConstructible} and \tcode{CopyAssignable} and whose copy
 constructor, move constructor, and assignment operator
-do not throw exceptions. A \term{forwarding call wrapper} is a
+do not throw exceptions. A \defn{forwarding call wrapper} is a
 call wrapper that can be called with an arbitrary argument list
 and delivers the arguments to the wrapped callable object as references.
 This forwarding step shall ensure that rvalue arguments are delivered as rvalue references