[std] Fix multiply-defined term.* labels by creating unique index entries

Author: jensmaurer

source/basic.tex

@@ -867,8 +867,9 @@
 \end{note}
 
 \pnum
+\indexdefnadj{corresponding}{object parameter}%
 Two non-static member functions have
-\defnadjx{corresponding}{object parameters}{object parameter} if:
+\defnx{corresponding object parameters}{object parameter!corresponding!function} if:
 \begin{itemize}
 \item
 exactly one is an implicit object member function
@@ -879,8 +880,9 @@
 \item
 their object parameters have the same type.
 \end{itemize}
+\indexdefnadj{corresponding}{object parameter}%
 Two non-static member function templates have
-\defnadjx{corresponding}{object parameters}{object parameter} if:
+\defnx{corresponding object parameters}{object parameter!corresponding!function template} if:
 \begin{itemize}
 \item
 exactly one is an implicit object member function
@@ -2814,7 +2816,7 @@
 \indextext{linkage|)}
 
 \pnum
-A declaration $D$ \defnx{names}{name} an entity $E$ if
+A declaration $D$ \defnx{names}{name (verb)} an entity $E$ if
 \begin{itemize}
 \item
 $D$ contains a \grammarterm{lambda-expression} whose closure type is $E$,
@@ -4761,7 +4763,7 @@
 \defnadjx{signed integer}{types}{type}.
 The range of representable values for a signed integer type is
 $-2^{N-1}$ to $2^{N-1}-1$ (inclusive),
-where \placeholder{N} is called the \defn{width} of the type.
+where \placeholder{N} is called the \defnx{width}{width!of integer type} of the type.
 \indextext{integral type!implementation-defined \tcode{sizeof}}%
 \begin{note}
 Plain \tcode{int}s are intended to have
@@ -5061,7 +5063,7 @@
 on the access to these entities\iref{class.access};
 
 \item
-\defnx{unions}{\idxcode{union}}, which are classes capable of containing objects of
+\emph{unions}, which are classes capable of containing objects of
 different types at different times, \ref{class.union};
 
 \item

source/classes.tex

@@ -2787,7 +2787,7 @@
 the bit-field semantic property is not part of the type of the class member.
 The \grammarterm{constant-expression} shall be an integral constant expression
 with a value greater than or equal to zero and
-is called the \defn{width} of the bit-field.
+is called the \defnx{width}{width!of bit-field} of the bit-field.
 If the width of a bit-field is larger than
 the width of the bit-field's type
 (or, in case of an enumeration type, of its underlying type),

source/declarations.tex

@@ -3175,7 +3175,6 @@
 
 \pnum
 \indextext{declaration!array}%
-\label{term.array.type}%
 A type of the form ``array of \tcode{N} \tcode{U}'' or
 ``array of unknown bound of \tcode{U}'' is an \defn{array type}.
 The optional \grammarterm{attribute-specifier-seq}

source/expressions.tex

@@ -426,7 +426,6 @@
 \rSec2[expr.context]{Context dependence}
 
 \pnum
-\label{term.unevaluated.operand}%
 In some contexts, \defnx{unevaluated operands}{unevaluated operand}
 appear~(\ref{expr.prim.req},
 \ref{expr.typeid},
@@ -5904,7 +5903,7 @@
 
 \pnum
 Abbreviating \grammarterm{pm-expression}\tcode{.*}\grammarterm{cast-expression} as \tcode{E1.*E2}, \tcode{E1}
-is called the \defn{object expression}.
+is called the \defnx{object expression}{object expression!pointer-to-member operator}.
 If the dynamic type of \tcode{E1} does not
 contain the member to which
 \tcode{E2} refers, the behavior is undefined.
@@ -7109,12 +7108,9 @@
 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,
-are called
-\indexdefn{expression!constant}%
-\defnx{constant expressions}{constant expression}.
+are called constant expressions.
 \begin{note}
-Constant expressions can be evaluated
-during translation.
+Constant expressions can be evaluated during translation.
 \end{note}
 
 \begin{bnf}
@@ -7151,14 +7147,14 @@
 
 \pnum
 A constant-initialized potentially-constant variable $V$ is
-\defn{usable in constant expressions} at a point $P$ if
+\defnx{usable in constant expressions}{usable in constant expressions!variable} at a point $P$ if
 $V$'s initializing declaration $D$ is reachable from $P$ and
 \begin{itemize}
 \item $V$ is constexpr,
 \item $V$ is not initialized to a TU-local value, or
 \item $P$ is in the same translation unit as $D$.
 \end{itemize}
-An object or reference is \defn{usable in constant expressions} if it is
+An object or reference is \defnx{usable in constant expressions}{usable in constant expressions!object or reference} if it is
 \begin{itemize}
 \item a variable that is usable in constant expressions, or
 \item a template parameter object\iref{temp.param}, or

source/iostreams.tex

@@ -12331,11 +12331,11 @@
 a file within a file system that acts as a container of directory entries
 that contain information about
 other files, possibly including other directory files.
-The \defn{parent directory} of a directory is
+The \defnx{parent directory}{parent directory!directory} of a directory is
 the directory that both contains a
 directory entry for the given directory and is represented by the dot-dot
 filename\iref{fs.path.generic} in the given directory.
-The \defn{parent directory}
+The \defnx{parent directory}{parent directory!file}
 of other types of files is a directory containing a directory
 entry for the file under discussion.
 
@@ -13196,10 +13196,10 @@
 \rSec4[fs.path.type.cvt]{Type and encoding conversions}
 
 \pnum
-The \defn{native encoding} of an ordinary character string is
+The \defnx{native encoding}{native encoding!ordinary character string} of an ordinary character string is
 the operating system dependent current encoding
 for pathnames\iref{fs.class.path}.
-The \defn{native encoding} for wide character strings is
+The \defnx{native encoding}{native encoding!wide character string} for wide character strings is
 the implementation-defined execution
 wide-character set encoding\iref{character.seq}.
 

source/iterators.tex

@@ -1774,7 +1774,7 @@
 
 \pnum
 Two dereferenceable iterators \tcode{a} and \tcode{b} of type \tcode{X}
-offer the \defn{multi-pass guarantee} if:
+offer the \defnx{multi-pass guarantee}{multi-pass guarantee!\detokenize{forward_iterator}} if:
 \begin{itemize}
 \item \tcode{a == b} implies \tcode{++a == ++b} and
 \item the expression
@@ -2187,7 +2187,7 @@
 
 \pnum
 Two dereferenceable iterators \tcode{a} and \tcode{b} of type \tcode{X} offer the
-\defn{multi-pass guarantee} if:
+\defnx{multi-pass guarantee}{multi-pass guarantee!\oldconcept{ForwardIterator}} if:
 \begin{itemize}
 \item \tcode{a == b} implies \tcode{++a == ++b} and
 \item \tcode{X} is a pointer type or the expression

source/macros.tex

@@ -167,6 +167,7 @@
 }
 
 \newcommand{\indexdefn}[1]{\indextext{#1}}
+\newcommand{\indexdefnadj}[2]{\indextext{#1 #2|see{#2, #1}}\indexdefn{#2!#1}}
 \newcommand{\idxbfpage}[1]{\textbf{\hyperpage{#1}}}
 \newcommand{\indexgrammar}[1]{\indextext{#1}\indexgram{#1|idxbfpage}}
 % This command uses the "cooked" \indeximpldef command to emit index
@@ -238,7 +239,7 @@
 \newcommand{\defnlibxname}[1]{\indexlibrary{\idxxname{#1}}\xname{#1}}
 
 % term.* labels
-\newcommand{\termlabel}[1]{\label{term.\temp}}
+\newcommand{\termlabel}[1]{\label{term.#1}}
 % convert space-separated phrase to dot-separated label name
 \newcommand{\newtermlabelx}[1]{%
 {% remove all formatting instructions
@@ -263,7 +264,7 @@
 \newcommand{\defnadj}[2]{\defnadjx{#1}{#2}{#2}}
 % Compound defined term with a different form for the primary noun.
 % Usage: \defnadjx{scalar}{types}{type}
-\newcommand{\defnadjx}[3]{\indextext{#1 #3|see{#3, #1}}\indexdefn{#3!#1}\newtermlabelx{#1 #3}\textit{#1 #2}}
+\newcommand{\defnadjx}[3]{\indexdefnadj{#1}{#3}\newtermlabelx{#1 #3}\textit{#1 #2}}
 
 %%--------------------------------------------------
 %% allow line break if needed for justification

source/regex.tex

@@ -1963,7 +1963,7 @@
 
 \pnum
 A default-constructed \tcode{match_results} object has no fully established result state. A
-match result is \defn{ready} when, as a consequence of a completed regular expression match
+match result is \defnx{ready}{ready!match result} when, as a consequence of a completed regular expression match
 modifying such an object, its result state becomes fully established. The effects of calling
 most member functions from a \tcode{match_results} object that is not ready are undefined.
 

source/templates.tex

@@ -3367,9 +3367,8 @@
 \rSec3[temp.spec.partial.order]{Partial ordering of partial specializations}
 
 \pnum
-\indextext{more specialized!class template}%
 For two 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 ordering rules for function
 templates\iref{temp.func.order}:
@@ -7896,9 +7895,8 @@
 \end{itemize}
 
 \pnum
-\indextext{at least as specialized as|see{more specialized}}%
 Function template \tcode{F}
-is \defnx{at least as specialized as}{more specialized}
+is \defnx{at least as specialized as}{at least as specialized as|see{more specialized}}
 function template \tcode{G} if,
 for each pair of types used to determine the ordering,
 the type from \tcode{F}

source/threads.tex

@@ -2619,7 +2619,8 @@
 \indextext{block (execution)}%
 In addition to the exclusive lock ownership mode specified
 in~\ref{thread.mutex.requirements.mutex}, shared mutex types provide a
-\defn{shared lock} ownership mode. Multiple execution agents can
+\defnx{shared lock}{shared lock!ownership mode} ownership mode.
+Multiple execution agents can
 simultaneously hold a shared lock ownership of a shared mutex type. But no
 execution agent holds a shared lock while another execution agent holds an
 exclusive lock on the same shared mutex type, and vice-versa. The maximum
@@ -6205,7 +6206,7 @@
 \end{itemize}
 
 \pnum
-A shared state is \defn{ready} only if it holds a value or an exception ready for
+A shared state is \defnx{ready}{ready!shared state} only if it holds a value or an exception ready for
 retrieval.
 Waiting for a shared state to become ready may invoke code to compute the result on
 the waiting thread if so specified in the description of the class or function that creates