[library] Replace \term with \defnx

Author: jensmaurer

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.
 
@@ -207,16 +206,12 @@
 \indexdefn{behavior!default}%
 \defncontext{implementation}
 specific behavior provided by the implementation,
-within the scope of the
-\term{required behavior}
+within the scope of the required behavior
 
 \definition{default behavior}{defns.default.behavior.func}
 \indexdefn{behavior!default}%
 \defncontext{specification}
-description of
-\term{replacement function}
-and
-\term{handler function}
+description of replacement function and handler function
 semantics
 
 \definition{direct-non-list-initialization}{defns.direct-non-list-init}
@@ -226,8 +221,7 @@
 
 \definition{handler function}{defns.handler}
 \indexdefn{function!handler}%
-\term{non-reserved function}
-whose definition may be provided by a \Cpp{} program
+non-reserved function whose definition may be provided by a \Cpp{} program
 
 \begin{defnote}
 A \Cpp{} program may designate a handler function at various points in its execution by
@@ -318,11 +312,7 @@
 
 \definition{required behavior}{defns.required.behavior}
 \indexdefn{behavior!required}%
-description of
-\term{replacement function}
-and
-\term{handler function}
-semantics
+description of replacement function and handler function semantics
 applicable to both the behavior provided by the implementation and
 the behavior of any such function definition in the program
 
@@ -628,7 +618,7 @@
 \pnum
 Here, the names $\tcode{\placeholder{C}}_0$,
 $\tcode{\placeholder{C}}_1$, etc.\ represent
-\term{enumerated elements}
+\defnx{enumerated elements}{enumerated element}
 for this particular enumerated type.
 \indextext{type!enumerated}%
 All such elements have distinct values.
@@ -646,7 +636,7 @@
 \indextext{type!enumerated}%
 
 \pnum
-The bitmask type \term{bitmask} can be written:
+The bitmask type \tcode{\placeholder{bitmask}} can be written:
 
 \begin{codeblock}
 // For exposition only.
@@ -661,63 +651,58 @@
 inline constexpr @$\tcode{\placeholder{bitmask C}}_{3}$@(@$\tcode{\placeholder{V}}_{3}{}$@);
   .....
 
-constexpr @\term{bitmask}{}@ operator&(@\term{bitmask}{}@ X, @\term{bitmask}{}@ Y) {
-  return static_cast<@\term{bitmask}{}@>(
+constexpr @\placeholder{bitmask}{}@ operator&(@\placeholder{bitmask}{}@ X, @\placeholder{bitmask}{}@ Y) {
+  return static_cast<@\placeholder{bitmask}{}@>(
     static_cast<int_type>(X) & static_cast<int_type>(Y));
 }
-constexpr @\term{bitmask}{}@ operator|(@\term{bitmask}{}@ X, @\term{bitmask}{}@ Y) {
-  return static_cast<@\term{bitmask}{}@>(
+constexpr @\placeholder{bitmask}{}@ operator|(@\placeholder{bitmask}{}@ X, @\placeholder{bitmask}{}@ Y) {
+  return static_cast<@\placeholder{bitmask}{}@>(
     static_cast<int_type>(X) | static_cast<int_type>(Y));
 }
-constexpr @\term{bitmask}{}@ operator^(@\term{bitmask}{}@ X, @\term{bitmask}{}@ Y){
-  return static_cast<@\term{bitmask}{}@>(
+constexpr @\placeholder{bitmask}{}@ operator^(@\placeholder{bitmask}{}@ X, @\placeholder{bitmask}{}@ Y){
+  return static_cast<@\placeholder{bitmask}{}@>(
     static_cast<int_type>(X) ^ static_cast<int_type>(Y));
 }
-constexpr @\term{bitmask}{}@ operator~(@\term{bitmask}{}@ X){
-  return static_cast<@\term{bitmask}{}@>(~static_cast<int_type>(X));
+constexpr @\placeholder{bitmask}{}@ operator~(@\placeholder{bitmask}{}@ X){
+  return static_cast<@\placeholder{bitmask}{}@>(~static_cast<int_type>(X));
 }
-@\term{bitmask}{}@& operator&=(@\term{bitmask}{}@& X, @\term{bitmask}{}@ Y){
+@\placeholder{bitmask}{}@& operator&=(@\placeholder{bitmask}{}@& X, @\placeholder{bitmask}{}@ Y){
   X = X & Y; return X;
 }
-@\term{bitmask}{}@& operator|=(@\term{bitmask}{}@& X, @\term{bitmask}{}@ Y) {
+@\placeholder{bitmask}{}@& operator|=(@\placeholder{bitmask}{}@& X, @\placeholder{bitmask}{}@ Y) {
   X = X | Y; return X;
 }
-@\term{bitmask}{}@& operator^=(@\term{bitmask}{}@& X, @\term{bitmask}{}@ Y) {
+@\placeholder{bitmask}{}@& operator^=(@\placeholder{bitmask}{}@& X, @\placeholder{bitmask}{}@ Y) {
   X = X ^ Y; return X;
 }
 \end{codeblock}
 
 \pnum
 Here, the names $\tcode{\placeholder{C}}_0$,
 $\tcode{\placeholder{C}}_1$, etc.\ represent
-\term{bitmask elements}
+\defnx{bitmask elements}{bitmask!element}
 for this particular bitmask type.
 \indextext{type!bitmask}%
 All such elements have distinct, nonzero values such that, for any pair $\tcode{\placeholder{C}}_i$
 and $\tcode{\placeholder{C}}_j$ where $i \neq j$, \tcode{$\placeholder{C}_i$ \& $\placeholder{C}_i$} is nonzero and
 \tcode{$\placeholder{C}_i$ \& $\placeholder{C}_j$} is zero.
-\indextext{bitmask!empty}%
-Additionally, the value \tcode{0} is used to represent an \term{empty bitmask}, in which no
+Additionally, the value \tcode{0} is used to represent an \defnx{empty bitmask}{bitmask!empty}, in which no
 bitmask elements are set.
 
 \pnum
 The following terms apply to objects and values of
 bitmask types:
 \begin{itemize}
 \item
-To
-\term{set}
+To \defnx{set}{bitmask!value!set}
 a value \textit{Y} in an object \textit{X}
 is to evaluate the expression \textit{X} \tcode{|=} \textit{Y}.
 \item
-To
-\term{clear}
+To \defnx{clear}{bitmask!value!clear}
 a value \textit{Y} in an object
 \textit{X} is to evaluate the expression \textit{X} \tcode{\&= \~}\textit{Y}.
 \item
-The value \textit{Y}
-\term{is set}
-in the object
+The value \textit{Y} \defnx{is set}{bitmask!value!is set} in the object
 \textit{X} if the expression \textit{X} \tcode{\&} \textit{Y} is nonzero.
 \end{itemize}
 
@@ -730,9 +715,7 @@
 
 \begin{itemize}
 \item
-A
-\term{letter}
-is any of the 26 lowercase or 26
+A \defn{letter} is any of the 26 lowercase or 26
 \indextext{lowercase}%
 \indextext{uppercase}%
 uppercase letters in the basic execution character set.
@@ -764,7 +747,7 @@
 object, as described in \ref{locales} and \ref{input.output}.
 \item
 A
-\term{character sequence}
+\defn{character sequence}
 is an array object\iref{dcl.array} \tcode{\placeholdernc{A}} that
 can be declared as
 \tcode{\placeholdernc{T\;A}[\placeholder{N}]},
@@ -785,56 +768,46 @@
 
 \rSec5[byte.strings]{Byte strings}
 
+\indextext{string!null-terminated byte|see{\ntbs{}}}%
 \pnum
-A
-\indextext{NTBS}%
-\defnx{null-terminated byte string}{string!null-terminated byte},
+A \defnx{null-terminated byte string}{NTBS@\ntbs{}},
 or \ntbs{},
 is a character sequence whose highest-addressed element
 with defined content has the value zero
-(the
-\term{terminating null}
-character); no other element in the sequence has the value zero.%
+(the \defnx{terminating null character}{character!terminating null});
+no other element in the sequence has the value zero.%
 \indexhdr{cstring}%
-\indextext{NTBS}\footnote{Many of the objects manipulated by
+\footnote{Many of the objects manipulated by
 function signatures declared in
 \tcode{<cstring>}\iref{c.strings} are character sequences or \ntbs{}s.
 \indexhdr{cstring}%
 The size of some of these character sequences is limited by
 a length value, maintained separately from the character sequence.}
 
 \pnum
-The
-\term{length} of an \ntbs{}
+The \defnx{length of an \ntbs{}}{NTBS@\ntbs{}!length}
 is the number of elements that
 precede the terminating null character.
-\indextext{NTBS}%
-An
-\term{empty} \ntbs{}
+An \defnx{empty \ntbs{}}{NTBS@\ntbs{}!empty}
 has a length of zero.
 
 \pnum
-The
-\term{value} of an \ntbs{}
+The \defnx{value of an \ntbs{}}{NTBS@\ntbs{}!value}
 is the sequence of values of the
 elements up to and including the terminating null character.
-\indextext{NTBS}%
 
 \pnum
-A
-\indextext{NTBS}%
-\defnx{static}{NTBS!static} \ntbs{}
+A \defnx{static \ntbs{}}{NTBS@\ntbs{}!static}
 is an \ntbs{} with
 static storage duration.\footnote{A string literal, such as
 \tcode{"abc"},
 is a static \ntbs{}.}
 
 \rSec5[multibyte.strings]{Multibyte strings}
 
+\indextext{string!null-terminated multibyte|see{\ntmbs{}}}%
 \pnum
-\indextext{NTBS}%
-\indextext{NTMBS}%
-A \defnx{null-terminated multibyte string}{string!null-terminated multibyte},
+A \defnx{null-terminated multibyte string}{NTMBS@\ntmbs{}},
 or \ntmbs{},
 is an \ntbs{} that constitutes a
 sequence of valid multibyte characters, beginning and ending in the initial
@@ -844,10 +817,8 @@
 consists of a single byte.}
 
 \pnum
-A
-\defnx{static}{NTMBS!static} \ntmbs{}
+A \defnx{static \ntmbs{}}{NTMBS@\ntmbs{}!static}
 is an \ntmbs{} with static storage duration.
-\indextext{NTMBS}%
 
 \rSec3[functions.within.classes]{Functions within classes}
 
@@ -1029,7 +1000,7 @@
 
 \pnum
 Each element of the \Cpp{} standard library is declared or defined (as appropriate) in a
-\term{header}.\footnote{A header is not necessarily a source file, nor are the
+\defn{header}.\footnote{A header is not necessarily a source file, nor are the
 sequences delimited by \tcode{<} and \tcode{>} in header names necessarily valid source
 file names\iref{cpp.include}.}
 
@@ -1338,7 +1309,7 @@
 Two kinds of implementations are defined:
 \defnx{hosted}{implementation!hosted}
 and
-\term{freestanding}\iref{intro.compliance}.
+\defnx{freestanding}{implementation!freestanding}\iref{intro.compliance}.
 For a hosted implementation, this document
 describes the set of available headers.
 
@@ -2783,7 +2754,7 @@
 Unless otherwise specified,
 calls made by functions in the standard library to non-operator, non-member functions
 do not use functions from another namespace which are found through
-\term{argument-dependent name lookup}\iref{basic.lookup.argdep}.
+argument-dependent name lookup\iref{basic.lookup.argdep}.
 \begin{note}
 The phrase ``unless otherwise specified'' applies to cases such as
 the swappable with requirements\iref{swappable.requirements}.
@@ -2838,13 +2809,13 @@
 it means:
 
 \begin{itemize}
-\item For the \term{sort} algorithms the relative order of equivalent
+\item For the sort algorithms the relative order of equivalent
 elements is preserved.
 
-\item For the \term{remove} and \term{copy} algorithms the relative order of
+\item For the remove and copy algorithms the relative order of
 the elements that are not removed is preserved.
 
-\item For the \term{merge} algorithms, for equivalent elements in
+\item For the merge algorithms, for equivalent elements in
 the original two ranges, the elements from the first range (preserving their
 original order) precede the elements from the second range (preserving their
 original order).