[std] Use \keyword for character types.

Author: jensmaurer

source/atomics.tex

@@ -1138,10 +1138,10 @@
 \tcode{unsigned long},
 \tcode{long long},
 \tcode{unsigned long long},
-\tcode{char8_t},
-\tcode{char16_t},
-\tcode{char32_t},
-\tcode{wchar_t},
+\keyword{char8_t},
+\keyword{char16_t},
+\keyword{char32_t},
+\keyword{wchar_t},
 and any other types needed by the typedefs in the header \libheaderref{cstdint}.
 For each such type \tcode{\placeholder{integral}},
 the specialization \tcode{atomic_ref<\placeholder{integral}>} provides
@@ -2114,10 +2114,10 @@
 \tcode{unsigned long},
 \tcode{long long},
 \tcode{unsigned long long},
-\tcode{char8_t},
-\tcode{char16_t},
-\tcode{char32_t},
-\tcode{wchar_t},
+\keyword{char8_t},
+\keyword{char16_t},
+\keyword{char32_t},
+\keyword{wchar_t},
 and any other types needed by the typedefs in the header \libheaderref{cstdint}.
 For each such type \tcode{\placeholder{integral}}, the specialization
 \tcode{atomic<\placeholder{integral}>} provides additional atomic operations appropriate to integral types.

source/basic.tex

@@ -4927,7 +4927,7 @@
 The three types \tcode{char}, \tcode{signed char}, and \tcode{unsigned char}
 are collectively called
 \defnx{ordinary character types}{type!ordinary character}.
-The ordinary character types and \tcode{char8_t}
+The ordinary character types and \keyword{char8_t}
 are collectively called \defnx{narrow character types}{narrow character type}.
 For narrow character types,
 each possible bit pattern of the object representation represents
@@ -4944,26 +4944,26 @@
 \indextext{\idxcode{wchar_t}|see{type, \tcode{wchar_t}}}%
 \indextext{type!\idxcode{wchar_t}}%
 \indextext{type!underlying!\idxcode{wchar_t}}%
-Type \tcode{wchar_t} is a distinct type that has
+Type \keyword{wchar_t} is a distinct type that has
 an \impldef{underlying type of \tcode{wchar_t}}
 signed or unsigned integer type as its underlying type.
-The values of type \tcode{wchar_t} can represent
+The values of type \keyword{wchar_t} can represent
 distinct codes for all members of the largest extended character set
 specified among the supported locales\iref{locale}.
 
 \pnum
 \indextext{\idxcode{char8_t}|see{type, \tcode{char8_t}}}%
 \indextext{type!\idxcode{char8_t}}%
 \indextext{type!underlying!\idxcode{char8_t}}%
-Type \tcode{char8_t} denotes a distinct type
+Type \keyword{char8_t} denotes a distinct type
 whose underlying type is \tcode{unsigned char}.
 \indextext{\idxcode{char16_t}|see{type, \tcode{char16_t}}}%
 \indextext{\idxcode{char32_t}|see{type, \tcode{char32_t}}}%
 \indextext{type!\idxcode{char16_t}}%
 \indextext{type!\idxcode{char32_t}}%
 \indextext{type!underlying!\idxcode{char16_t}}%
 \indextext{type!underlying!\idxcode{char32_t}}%
-Types \tcode{char16_t} and \tcode{char32_t} denote distinct types
+Types \keyword{char16_t} and \keyword{char32_t} denote distinct types
 whose underlying types are \tcode{uint_least16_t} and \tcode{uint_least32_t},
 respectively, in \libheaderref{cstdint}.
 
@@ -4986,8 +4986,8 @@
 \indextext{type!integral}%
 Types
 \tcode{bool},
-\tcode{char}, \tcode{wchar_t},
-\tcode{char8_t}, \tcode{char16_t}, \tcode{char32_t},
+\tcode{char}, \keyword{wchar_t},
+\keyword{char8_t}, \keyword{char16_t}, \keyword{char32_t},
 and the signed and unsigned integer types are
 collectively called
 \defnx{integral types}{integral type}.
@@ -5382,8 +5382,8 @@
 \indextext{type!\idxcode{wchar_t}}%
 \indextext{type!\idxcode{char16_t}}%
 \indextext{type!\idxcode{char32_t}}%
-The ranks of \tcode{char8_t}, \tcode{char16_t}, \tcode{char32_t}, and
-\tcode{wchar_t} shall equal the ranks of their underlying
+The ranks of \keyword{char8_t}, \keyword{char16_t}, \keyword{char32_t}, and
+\keyword{wchar_t} shall equal the ranks of their underlying
 types\iref{basic.fundamental}.
 
 \item The rank of any extended signed integer type relative to another

source/compatibility.tex

@@ -69,7 +69,7 @@
 Required for new features.
 \begin{itemize}
 \item
-The \tcode{char8_t} keyword is added to differentiate
+The \keyword{char8_t} keyword is added to differentiate
 the types of ordinary and UTF-8 literals\iref{lex.string}.
 \item
 The \tcode{concept} keyword is
@@ -90,7 +90,7 @@
 \end{itemize}
 \effectafteritemize
 Valid \CppXVII{} code using
-\tcode{char8_t},
+\keyword{char8_t},
 \tcode{concept},
 \tcode{consteval},
 \tcode{constinit},
@@ -132,7 +132,7 @@
 const auto *u8s = u8"text";     // \tcode{u8s} previously deduced as \tcode{const char*}; now deduced as \tcode{const char8_t*}
 const char *ps = u8s;           // ill-formed; previously well-formed
 
-auto u8c = u8'c';               // \tcode{u8c} previously deduced as \tcode{char}; now deduced as \tcode{char8_t}
+auto u8c = u8'c';               // \tcode{u8c} previously deduced as \tcode{char}; now deduced as \keyword{char8_t}
 char *pc = &u8c;                // ill-formed; previously well-formed
 
 std::string s = u8"text";       // ill-formed; previously well-formed
@@ -591,14 +591,14 @@
 \diffref{ostream.inserters.character}
 \change
 Overload resolution for ostream inserters
-used with \tcode{wchar_t}, \tcode{char16_t}, or \tcode{char32_t} types.
+used with \keyword{wchar_t}, \keyword{char16_t}, or \keyword{char32_t} types.
 \rationale
 Removal of surprising behavior.
 \effect
 Valid \CppXVII{} code that passes
-\tcode{wchar_t}, \tcode{char16_t}, or \tcode{char32_t} characters or strings
+\keyword{wchar_t}, \keyword{char16_t}, or \keyword{char32_t} characters or strings
 to \tcode{basic_ostream<char, ...>::operator<<} or
-that passes \tcode{char16_t} or \tcode{char32_t} characters or strings
+that passes \keyword{char16_t} or \keyword{char32_t} characters or strings
 to \tcode{basic_ostream<wchar_t, ...>::operator<<} is now ill-formed.
 \begin{codeblock}
 std::cout << u"text";           // previously formatted the string as a pointer value;
@@ -1283,8 +1283,8 @@
 Added to \tref{lex.key}, the following identifiers are new keywords:
 \tcode{alignas},
 \tcode{alignof},
-\tcode{char16_t},
-\tcode{char32_t},
+\keyword{char16_t},
+\keyword{char32_t},
 \tcode{constexpr},
 \tcode{decltype},
 \tcode{noexcept},
@@ -1848,7 +1848,7 @@
 from ``array of \textit{some-integer-type}''
 to ``array of \tcode{const char32_t}''.
 The type of a wide string literal is changed
-from ``array of \tcode{wchar_t}''
+from ``array of \keyword{wchar_t}''
 to ``array of \tcode{const wchar_t}''.
 \rationale
 This avoids calling an inappropriate overloaded function,
@@ -2686,22 +2686,22 @@
 
 \rSec2[diff.mods.to.definitions]{Modifications to definitions}
 
-\rSec3[diff.char16]{Types \tcode{char16_t} and \tcode{char32_t}}
+\rSec3[diff.char16]{Types \keyword{char16_t} and \keyword{char32_t}}
 
 \pnum
-The types \tcode{char16_t} and \tcode{char32_t}
+The types \keyword{char16_t} and \keyword{char32_t}
 are distinct types rather than typedefs to existing integral types.
-The tokens \tcode{char16_t} and \tcode{char32_t}
+The tokens \keyword{char16_t} and \keyword{char32_t}
 are keywords in \Cpp{}\iref{lex.key}.
 They do not appear as macro or type names defined in
 \libheaderref{cuchar}.
 
-\rSec3[diff.wchar.t]{Type \tcode{wchar_t}}
+\rSec3[diff.wchar.t]{Type \keyword{wchar_t}}
 
 \pnum
-The type \tcode{wchar_t} is a distinct type rather than a typedef to an
+The type \keyword{wchar_t} is a distinct type rather than a typedef to an
 existing integral type.
-The token \tcode{wchar_t}
+The token \keyword{wchar_t}
 is a keyword in \Cpp{}\iref{lex.key}.
 It does not appear as a macro or type name defined in any of
 \libheaderref{cstddef},

source/declarations.tex

@@ -1369,9 +1369,9 @@
 \tcode{char}                      & ``\tcode{char}''                  \\
 \tcode{unsigned char}             & ``\tcode{unsigned char}''         \\
 \tcode{signed char}               & ``\tcode{signed char}''           \\
-\tcode{char8_t}                   & ``\tcode{char8_t}''               \\
-\tcode{char16_t}                  & ``\tcode{char16_t}''              \\
-\tcode{char32_t}                  & ``\tcode{char32_t}''              \\
+\keyword{char8_t}                   & ``\tcode{char8_t}''               \\
+\keyword{char16_t}                  & ``\tcode{char16_t}''              \\
+\keyword{char32_t}                  & ``\tcode{char32_t}''              \\
 \tcode{bool}                      & ``\tcode{bool}''                  \\
 \tcode{unsigned}                  & ``\tcode{unsigned int}''          \\
 \tcode{unsigned int}              & ``\tcode{unsigned int}''          \\
@@ -1396,7 +1396,7 @@
 \tcode{signed short}              & ``\tcode{short int}''             \\
 \tcode{short int}                 & ``\tcode{short int}''             \\
 \tcode{short}                     & ``\tcode{short int}''             \\
-\tcode{wchar_t}                   & ``\tcode{wchar_t}''               \\
+\keyword{wchar_t}                   & ``\tcode{wchar_t}''               \\
 \tcode{float}                     & ``\tcode{float}''                 \\
 \tcode{double}                    & ``\tcode{double}''                \\
 \tcode{long double}               & ``\tcode{long double}''           \\
@@ -4466,11 +4466,11 @@
 If the destination type is a reference type, see~\ref{dcl.init.ref}.
 \item
 If the destination type is an array of characters,
-an array of \tcode{char8_t},
-an array of \tcode{char16_t},
-an array of \tcode{char32_t},
+an array of \keyword{char8_t},
+an array of \keyword{char16_t},
+an array of \keyword{char32_t},
 or an array of
-\tcode{wchar_t},
+\keyword{wchar_t},
 and the initializer is a \grammarterm{string-literal}, see~\ref{dcl.init.string}.
 \item If the initializer is \tcode{()}, the object is value-initialized.
 \indextext{ambiguity!function declaration}%
@@ -5251,10 +5251,10 @@
 
 \pnum
 An array of ordinary character type\iref{basic.fundamental},
-\tcode{char8_t} array,
-\tcode{char16_t} array,
-\tcode{char32_t} array,
-or \tcode{wchar_t} array
+\keyword{char8_t} array,
+\keyword{char16_t} array,
+\keyword{char32_t} array,
+or \keyword{wchar_t} array
 can be initialized by
 an ordinary string literal,
 UTF-8 string literal,

source/expressions.tex

@@ -827,8 +827,8 @@
 
 \pnum
 \indextext{promotion!integral}%
-A prvalue of an integer type other than \tcode{bool}, \tcode{char16_t},
-\tcode{char32_t}, or \tcode{wchar_t} whose integer conversion
+A prvalue of an integer type other than \tcode{bool}, \keyword{char16_t},
+\keyword{char32_t}, or \keyword{wchar_t} whose integer conversion
 rank\iref{conv.rank} is less than the rank of \tcode{int} can be
 converted to a prvalue of type \tcode{int} if \tcode{int} can represent
 all the values of the source type; otherwise, the source prvalue can be
@@ -838,14 +838,14 @@
 \indextext{type!underlying!\idxcode{wchar_t}}%
 \indextext{type!underlying!\idxcode{char16_t}}%
 \indextext{type!underlying!\idxcode{char32_t}}%
-A prvalue of type \tcode{char16_t}, \tcode{char32_t}, or
-\tcode{wchar_t}\iref{basic.fundamental} can be converted to a prvalue
+A prvalue of type \keyword{char16_t}, \keyword{char32_t}, or
+\keyword{wchar_t}\iref{basic.fundamental} can be converted to a prvalue
 of the first of the following types that can represent all the values of
 its underlying type: \tcode{int}, \tcode{unsigned int}, \tcode{long int},
 \tcode{unsigned long int}, \tcode{long long int},
 or \tcode{unsigned long long int}. If none of the types in that list can
 represent all the values of its underlying type, a prvalue of type
-\tcode{char16_t}, \tcode{char32_t}, or \tcode{wchar_t} can be converted
+\keyword{char16_t}, \keyword{char32_t}, or \keyword{wchar_t} can be converted
 to a prvalue of its underlying type.
 
 \pnum
@@ -1124,8 +1124,8 @@
 \item Otherwise, the integral promotions\iref{conv.prom} shall be
 performed on both operands.
 \begin{footnote}
-As a consequence, operands of type \tcode{bool}, \tcode{char8_t}, \tcode{char16_t},
-\tcode{char32_t}, \tcode{wchar_t}, or an enumerated type are converted
+As a consequence, operands of type \tcode{bool}, \keyword{char8_t}, \keyword{char16_t},
+\keyword{char32_t}, \keyword{wchar_t}, or an enumerated type are converted
 to some integral type.
 \end{footnote}
 Then the following rules shall be applied to the promoted operands:

source/future.tex

@@ -2145,7 +2145,7 @@
 \begin{itemize}
 \item
   \tcode{Elem} is the wide-character type, such as
-  \tcode{wchar_t}, \tcode{char16_t}, or \tcode{char32_t}.
+  \keyword{wchar_t}, \keyword{char16_t}, or \keyword{char32_t}.
 \item
   \tcode{Maxcode} is the largest wide-character code that the facet
   will read or write without reporting a conversion error.
@@ -2678,7 +2678,7 @@
 \pnum
 \requires The \tcode{source} and \range{first}{last}
   sequences are UTF-8 encoded. The value type of \tcode{Source}
-  and \tcode{InputIterator} is \tcode{char} or \tcode{char8_t}.
+  and \tcode{InputIterator} is \tcode{char} or \keyword{char8_t}.
   \tcode{Source} meets the requirements specified in \ref{fs.path.req}.
 
 \pnum
@@ -2688,9 +2688,9 @@
       narrow encoding\iref{fs.path.type.cvt} is UTF-8,
       return \tcode{path(source)} or \tcode{path(first, last)};
       otherwise,
-\item if \tcode{value_type} is \tcode{wchar_t} and the
+\item if \tcode{value_type} is \keyword{wchar_t} and the
       native wide encoding is UTF-16, or
-      if \tcode{value_type} is \tcode{char16_t} or \tcode{char32_t},
+      if \tcode{value_type} is \keyword{char16_t} or \keyword{char32_t},
       convert \tcode{source} or \range{first}{last}
       to a temporary, \tcode{tmp}, of type \tcode{string_type} and
       return \tcode{path(tmp)};

source/intro.tex

@@ -197,11 +197,11 @@
 \begin{defnote}
 The term does not mean only
 \tcode{char},
-\tcode{char8_t},
-\tcode{char16_t},
-\tcode{char32_t},
+\keyword{char8_t},
+\keyword{char16_t},
+\keyword{char32_t},
 and
-\tcode{wchar_t}
+\keyword{wchar_t}
 objects\iref{basic.fundamental},
 but any value that can be represented by a type
 that provides the definitions specified in