Don't abuse \term to get italic.

Author: Eelis

source/atomics.tex

@@ -240,10 +240,10 @@
 to all other atomic accesses to that object. \end{note}
 
 \pnum
-An atomic operation \term{A} that performs a release operation on an atomic
-object \term{M} synchronizes with an atomic operation \term{B} that performs
-an acquire operation on \term{M} and takes its value from any side effect in the
-release sequence headed by \term{A}.
+An atomic operation \textit{A} that performs a release operation on an atomic
+object \textit{M} synchronizes with an atomic operation \textit{B} that performs
+an acquire operation on \textit{M} and takes its value from any side effect in the
+release sequence headed by \textit{A}.
 
 \pnum
 There shall be a single total order \textit{S} on all \tcode{memory_order_seq_cst}

source/basic.tex

@@ -411,7 +411,7 @@
 type \tcode{T} (Clause~\ref{conv}, \ref{expr.type.conv},
 \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 \term{cv} \tcode{void*}, is converted to the type pointer to \tcode{T}
+other than \cv\ \tcode{void*}, is converted to the type pointer to \tcode{T}
 or reference to \tcode{T} using a standard conversion
 (Clause~\ref{conv}), a \tcode{dynamic_cast}~(\ref{expr.dynamic.cast}) or
 a \tcode{static_cast}~(\ref{expr.static.cast}), or
@@ -1551,9 +1551,9 @@
 \grammarterm{template-argument}{s}.
 
 \pnum
-Let \term{X} be the lookup set produced by unqualified
-lookup~(\ref{basic.lookup.unqual}) and let \term{Y} be the lookup set produced
-by argument dependent lookup (defined as follows). If \term{X} contains
+Let \textit{X} be the lookup set produced by unqualified
+lookup~(\ref{basic.lookup.unqual}) and let \textit{Y} be the lookup set produced
+by argument dependent lookup (defined as follows). If \textit{X} contains
 \begin{itemize}
 \item a declaration of a class member, or
 
@@ -1563,10 +1563,10 @@
 \item a declaration that is neither a function nor a function template
 
 \end{itemize}
-then \term{Y} is empty. Otherwise \term{Y} is the set of declarations
+then \textit{Y} is empty. Otherwise \textit{Y} is the set of declarations
 found in the namespaces associated with the argument types as described
 below. The set of declarations found by the lookup of the name is the
-union of \term{X} and \term{Y}. \begin{note} The namespaces and classes
+union of \textit{X} and \textit{Y}. \begin{note} The namespaces and classes
 associated with the argument types can include namespaces and classes
 already considered by the ordinary unqualified lookup. \end{note}
 \begin{example}
@@ -3358,9 +3358,8 @@
 
 \item the pointer is used as the operand of a
 \tcode{static_cast}~(\ref{expr.static.cast}), except when the conversion
-is to pointer to \term{cv} \tcode{void}, or to pointer to \term{cv}
-\tcode{void} and subsequently to pointer to either \term{cv}
-\tcode{char} or \term{cv} \tcode{unsigned char}, or
+is to pointer to \cv\ \tcode{void}, or to pointer to \cv\ \tcode{void}
+and subsequently to pointer to either \cv\ \tcode{char} or \cv\ \tcode{unsigned char}, or
 
 \item the pointer is used as the operand of a
 \tcode{dynamic_cast}~(\ref{expr.dynamic.cast}). \begin{example}
@@ -4203,8 +4202,8 @@
 \end{floattable}
 
 \pnum
-In this International Standard, the notation \term{cv} (or
-\term{cv1}, \term{cv2}, etc.), used in the description of types,
+In this International Standard, the notation \cv\ (or
+\cvqual{cv1}, \cvqual{cv2}, etc.), used in the description of types,
 represents an arbitrary set of cv-qualifiers, i.e., one of
 \{\tcode{const}\}, \{\tcode{volatile}\}, \{\tcode{const},
 \tcode{volatile}\}, or the empty set.
@@ -4227,7 +4226,7 @@
 \pnum
 Cv-qualifiers applied to an array
 type attach to the underlying element type, so the notation
-``\term{cv} \tcode{T}'', where \tcode{T} is an array type, refers to
+``\cv\ \tcode{T}'', where \tcode{T} is an array type, refers to
 an array whose elements are so-qualified. An array type whose elements
 are cv-qualified is also considered to have the same cv-qualifications
 as its elements.%

source/declarators.tex

@@ -1375,8 +1375,7 @@
 non-dependent type \tcode{void} is equivalent to an empty parameter
 list.
 \indextext{parameter!\idxcode{void}}%
-Except for this special case, a parameter shall not have type \term{cv}
-\tcode{void}.
+Except for this special case, a parameter shall not have type \cv\ \tcode{void}.
 If the
 \grammarterm{parameter-declaration-clause}
 \indextext{argument~type!unknown}%

source/lex.tex

@@ -1482,7 +1482,7 @@
 also referred to as narrow
 string literals. A narrow string literal has type
 \indextext{literal!string!type~of}%
-``array of \term{n} \tcode{const char}'', where \term{n} is the size of
+``array of \textit{n} \tcode{const char}'', where \textit{n} is the size of
 the string as defined below, and has static storage
 duration~(\ref{basic.stc}).
 
@@ -1495,7 +1495,7 @@
 \indextext{literal!string!\idxcode{char16_t}}%
 A \grammarterm{string-literal} that begins with \tcode{u}, such as \tcode{u"asdf"}, is
 a \tcode{char16_t} string literal. A \tcode{char16_t} string literal has
-type ``array of \term{n} \tcode{const char16_t}'', where \term{n} is the
+type ``array of \textit{n} \tcode{const char16_t}'', where \textit{n} is the
 size of the string as defined below; it
 is initialized with the given characters. A single \grammarterm{c-char} may
 produce more than one \tcode{char16_t} character in the form of
@@ -1505,7 +1505,7 @@
 \indextext{literal!string!\idxcode{char32_t}}%
 A \grammarterm{string-literal} that begins with \tcode{U}, such as \tcode{U"asdf"}, is
 a \tcode{char32_t} string literal. A \tcode{char32_t} string literal has
-type ``array of \term{n} \tcode{const char32_t}'', where \term{n} is the
+type ``array of \textit{n} \tcode{const char32_t}'', where \textit{n} is the
 size of the string as defined below; it
 is initialized with the given characters.
 
@@ -1519,8 +1519,8 @@
 \indextext{\idxcode{wchar_t}}%
 \indextext{literal!string!wide}%
 \indextext{prefix!\idxcode{L}}%
-A wide string literal has type ``array of \term{n} \tcode{const
-wchar_t}'', where \term{n} is the size of the string as defined below; it
+A wide string literal has type ``array of \textit{n} \tcode{const
+wchar_t}'', where \textit{n} is the size of the string as defined below; it
 is initialized with the given characters.
 
 \pnum
@@ -1707,93 +1707,93 @@
 \pnum
 A \grammarterm{user-defined-literal} is treated as a call to a literal operator or
 literal operator template~(\ref{over.literal}). To determine the form of this call for a
-given \grammarterm{user-defined-literal} \term{L} with \grammarterm{ud-suffix} \term{X},
-the \grammarterm{literal-operator-id} whose literal suffix identifier is \term{X} is
-looked up in the context of \term{L} using the rules for unqualified name
-lookup~(\ref{basic.lookup.unqual}). Let \term{S} be the set of declarations found by
-this lookup. \term{S} shall not be empty.
+given \grammarterm{user-defined-literal} \textit{L} with \grammarterm{ud-suffix} \textit{X},
+the \grammarterm{literal-operator-id} whose literal suffix identifier is \textit{X} is
+looked up in the context of \textit{L} using the rules for unqualified name
+lookup~(\ref{basic.lookup.unqual}). Let \textit{S} be the set of declarations found by
+this lookup. \textit{S} shall not be empty.
 
 \pnum
-If \term{L} is a \grammarterm{user-defined-integer-literal}, let \term{n} be the literal
-without its \grammarterm{ud-suffix}. If \term{S} contains a literal operator with
-parameter type \tcode{unsigned long long}, the literal \term{L} is treated as a call of
+If \textit{L} is a \grammarterm{user-defined-integer-literal}, let \textit{n} be the literal
+without its \grammarterm{ud-suffix}. If \textit{S} contains a literal operator with
+parameter type \tcode{unsigned long long}, the literal \textit{L} is treated as a call of
 the form
 
 \begin{codeblock}
-operator "" @\term{X}@(@\term{n}@ULL)
+operator "" @\textit{X}@(@\textit{n}@ULL)
 \end{codeblock}
 
-Otherwise, \term{S} shall contain a raw literal operator or a literal operator
-template~(\ref{over.literal}) but not both. If \term{S} contains a raw literal operator,
-the literal \term{L} is treated as a call of the form
+Otherwise, \textit{S} shall contain a raw literal operator or a literal operator
+template~(\ref{over.literal}) but not both. If \textit{S} contains a raw literal operator,
+the literal \textit{L} is treated as a call of the form
 
 \begin{codeblock}
-operator "" @\term{X}@(@"\term{n}{"}@)
+operator "" @\textit{X}@(@"\textit{n}{"}@)
 \end{codeblock}
 
-Otherwise (\term{S} contains a literal operator template), \term{L} is treated as a call
+Otherwise (\textit{S} contains a literal operator template), \textit{L} is treated as a call
 of the form
 
 
 \begin{codeblock}
-operator "" @\term{X}@<'@$c_1$@', '@$c_2$@', ... '@$c_k$@'>()
+operator "" @\textit{X}@<'@$c_1$@', '@$c_2$@', ... '@$c_k$@'>()
 \end{codeblock}
 
-where \term{n} is the source character sequence $c_1c_2...c_k$. \begin{note} The sequence
+where \textit{n} is the source character sequence $c_1c_2...c_k$. \begin{note} The sequence
 $c_1c_2...c_k$ can only contain characters from the basic source character set.
 \end{note}
 
 \pnum
-If \term{L} is a \grammarterm{user-defined-floating-literal}, let \term{f} be the
-literal without its \grammarterm{ud-suffix}. If \term{S} contains a literal operator
-with parameter type \tcode{long double}, the literal \term{L} is treated as a call of
+If \textit{L} is a \grammarterm{user-defined-floating-literal}, let \textit{f} be the
+literal without its \grammarterm{ud-suffix}. If \textit{S} contains a literal operator
+with parameter type \tcode{long double}, the literal \textit{L} is treated as a call of
 the form
 
 \begin{codeblock}
-operator "" @\term{X}@(@\term{f}@L)
+operator "" @\textit{X}@(@\textit{f}@L)
 \end{codeblock}
 
-Otherwise, \term{S} shall contain a raw literal operator or a literal operator
-template~(\ref{over.literal}) but not both. If \term{S} contains a raw literal operator,
-the \term{literal} \term{L} is treated as a call of the form
+Otherwise, \textit{S} shall contain a raw literal operator or a literal operator
+template~(\ref{over.literal}) but not both. If \textit{S} contains a raw literal operator,
+the \textit{literal} \textit{L} is treated as a call of the form
 
 \begin{codeblock}
-operator "" @\term{X}@(@"\term{f}{"}@)
+operator "" @\textit{X}@(@"\textit{f}{"}@)
 \end{codeblock}
 
-Otherwise (\term{S} contains a literal operator template), \term{L} is treated as a call
+Otherwise (\textit{S} contains a literal operator template), \textit{L} is treated as a call
 of the form
 
 \begin{codeblock}
-operator "" @\term{X}@<'@$c_1$@', '@$c_2$@', ... '@$c_k$@'>()
+operator "" @\textit{X}@<'@$c_1$@', '@$c_2$@', ... '@$c_k$@'>()
 \end{codeblock}
 
-where \term{f} is the source character sequence $c_1c_2...c_k$. \begin{note} The sequence
+where \textit{f} is the source character sequence $c_1c_2...c_k$. \begin{note} The sequence
 $c_1c_2...c_k$ can only contain characters from the basic source character set.
 \end{note}
 
 \pnum
-If \term{L} is a \grammarterm{user-defined-string-literal}, let \term{str} be the
-literal without its \grammarterm{ud-suffix} and let \term{len} be
+If \textit{L} is a \grammarterm{user-defined-string-literal}, let \textit{str} be the
+literal without its \grammarterm{ud-suffix} and let \textit{len} be
 the number of
-code units in \term{str} (i.e., its length excluding the terminating
+code units in \textit{str} (i.e., its length excluding the terminating
 null character).
- The literal \term{L} is treated as a call of the form
+ The literal \textit{L} is treated as a call of the form
 
 \begin{codeblock}
-operator "" @\term{X}@(@\term{str}{}@, @\term{len}{}@)
+operator "" @\textit{X}@(@\textit{str}{}@, @\textit{len}{}@)
 \end{codeblock}
 
 \pnum
-If \term{L} is a \grammarterm{user-defined-character-literal}, let \term{ch} be the
+If \textit{L} is a \grammarterm{user-defined-character-literal}, let \textit{ch} be the
 literal without its \grammarterm{ud-suffix}.
-\term{S} shall contain a literal operator~(\ref{over.literal}) whose only parameter has
-the type of \term{ch} and the
-literal \term{L} is treated as a call
+\textit{S} shall contain a literal operator~(\ref{over.literal}) whose only parameter has
+the type of \textit{ch} and the
+literal \textit{L} is treated as a call
 of the form
 
 \begin{codeblock}
-operator "" @\term{X}@(@\term{ch}{}@)
+operator "" @\textit{X}@(@\textit{ch}{}@)
 \end{codeblock}
 
 \pnum

source/lib-intro.tex

@@ -606,20 +606,20 @@
 values~(\ref{basic.fundamental}).}
 
 \pnum
-The enumerated type \term{enumerated} can be written:
+The enumerated type \textit{enumerated} can be written:
 
 \begin{codeblock}
-enum @\term{enumerated}@ { @\term{V0}@, @\term{V1}@, @\term{V2}@, @\term{V3}@, ..... };
+enum @\textit{enumerated}@ { @\textit{V0}@, @\textit{V1}@, @\textit{V2}@, @\textit{V3}@, ..... };
 
-static const @\term{enumerated C0}@ (@\term{V0}@);
-static const @\term{enumerated C1}@ (@\term{V1}@);
-static const @\term{enumerated C2}@ (@\term{V2}@);
-static const @\term{enumerated C3}@ (@\term{V3}@);
+static const @\textit{enumerated C0}@ (@\textit{V0}@);
+static const @\textit{enumerated C1}@ (@\textit{V1}@);
+static const @\textit{enumerated C2}@ (@\textit{V2}@);
+static const @\textit{enumerated C3}@ (@\textit{V3}@);
   .....
 \end{codeblock}
 
 \pnum
-Here, the names \term{C0}, \term{C1}, etc. represent
+Here, the names \textit{C0}, \textit{C1}, etc. represent
 \term{enumerated elements}
 for this particular enumerated type.
 \indextext{type!enumerated}%
@@ -639,56 +639,56 @@
 \indextext{type!enumerated}%
 
 \pnum
-The bitmask type \term{bitmask} can be written:
+The bitmask type \textit{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.
-enum @\term{bitmask}@ : int_type {
-  @\term{V0}@ = 1 << 0, @\term{V1}@ = 1 << 1, @\term{V2}@ = 1 << 2, @\term{V3}@ = 1 << 3, .....
+enum @\textit{bitmask}@ : int_type {
+  @\textit{V0}@ = 1 << 0, @\textit{V1}@ = 1 << 1, @\textit{V2}@ = 1 << 2, @\textit{V3}@ = 1 << 3, .....
 };
 
-constexpr @\term{bitmask C0}@(@\term{V0}{}@);
-constexpr @\term{bitmask C1}@(@\term{V1}{}@);
-constexpr @\term{bitmask C2}@(@\term{V2}{}@);
-constexpr @\term{bitmask C3}@(@\term{V3}{}@);
+constexpr @\textit{bitmask C0}@(@\textit{V0}{}@);
+constexpr @\textit{bitmask C1}@(@\textit{V1}{}@);
+constexpr @\textit{bitmask C2}@(@\textit{V2}{}@);
+constexpr @\textit{bitmask C3}@(@\textit{V3}{}@);
   .....
 
-constexpr @\term{bitmask}{}@ operator&(@\term{bitmask}{}@ X, @\term{bitmask}{}@ Y) {
-  return static_cast<@\term{bitmask}{}@>(
+constexpr @\textit{bitmask}{}@ operator&(@\textit{bitmask}{}@ X, @\textit{bitmask}{}@ Y) {
+  return static_cast<@\textit{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 @\textit{bitmask}{}@ operator|(@\textit{bitmask}{}@ X, @\textit{bitmask}{}@ Y) {
+  return static_cast<@\textit{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 @\textit{bitmask}{}@ operator^(@\textit{bitmask}{}@ X, @\textit{bitmask}{}@ Y){
+  return static_cast<@\textit{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 @\textit{bitmask}{}@ operator~(@\textit{bitmask}{}@ X){
+  return static_cast<@\textit{bitmask}{}@>(~static_cast<int_type>(X));
 }
-@\term{bitmask}{}@& operator&=(@\term{bitmask}{}@& X, @\term{bitmask}{}@ Y){
+@\textit{bitmask}{}@& operator&=(@\textit{bitmask}{}@& X, @\textit{bitmask}{}@ Y){
   X = X & Y; return X;
 }
-@\term{bitmask}{}@& operator|=(@\term{bitmask}{}@& X, @\term{bitmask}{}@ Y) {
+@\textit{bitmask}{}@& operator|=(@\textit{bitmask}{}@& X, @\textit{bitmask}{}@ Y) {
   X = X | Y; return X;
 }
-@\term{bitmask}{}@& operator^=(@\term{bitmask}{}@& X, @\term{bitmask}{}@ Y) {
+@\textit{bitmask}{}@& operator^=(@\textit{bitmask}{}@& X, @\textit{bitmask}{}@ Y) {
   X = X ^ Y; return X;
 }
 \end{codeblock}
 
 \pnum
-Here, the names \term{C0}, \term{C1}, etc. represent
+Here, the names \textit{C0}, \textit{C1}, etc. represent
 \term{bitmask elements}
 for this particular bitmask type.
 \indextext{type!bitmask}%
-All such elements have distinct, nonzero values such that, for any pair \term{Ci}
-and \term{Cj} where \term{i} != \term{j}, \term{Ci} \& \term{Ci} is nonzero and
-\term{Ci} \& \term{Cj} is zero.
+All such elements have distinct, nonzero values such that, for any pair \textit{Ci}
+and \textit{Cj} where \textit{i} != \textit{j}, \textit{Ci} \& \textit{Ci} is nonzero and
+\textit{Ci} \& \textit{Cj} is zero.
 \indextext{bitmask!empty}%
 Additionally, the value 0 is used to represent an \term{empty bitmask}, in which no
 bitmask elements are set.