[std] Use \keyword for 'static_cast'.

Author: jensmaurer

source/basic.tex

@@ -591,7 +591,7 @@
 other than \cv{}~\tcode{void*}, is converted to the type pointer to \tcode{T}
 or reference to \tcode{T} using a standard conversion\iref{conv},
 a \tcode{dynamic_cast}\iref{expr.dynamic.cast} or
-a \tcode{static_cast}\iref{expr.static.cast}, or
+a \keyword{static_cast}\iref{expr.static.cast}, or
 \item a class member access operator is applied to an expression of type
 \tcode{T}\iref{expr.ref}, or
 \item the \tcode{typeid} operator\iref{expr.typeid} or the
@@ -3393,7 +3393,7 @@
   to a virtual base class, or
 \item
   the pointer is used as the operand of a
-  \tcode{static_cast}\iref{expr.static.cast}, except when the conversion
+  \keyword{static_cast}\iref{expr.static.cast}, except when the conversion
   is to pointer to \cv{}~\tcode{void}, or to pointer to \cv{}~\tcode{void}
   and subsequently to pointer to
   \cv{}~\tcode{char},
@@ -4393,7 +4393,7 @@
   a
   \begin{itemize}
   \item \tcode{const_cast}\iref{expr.const.cast},
-  \item \tcode{static_cast}\iref{expr.static.cast},
+  \item \keyword{static_cast}\iref{expr.static.cast},
   \item \tcode{dynamic_cast}\iref{expr.dynamic.cast}, or
   \item \tcode{reinterpret_cast}\iref{expr.reinterpret.cast}
   \end{itemize}

source/declarations.tex

@@ -4438,7 +4438,7 @@
 \item for an \grammarterm{initializer} that is a
 parenthesized \grammarterm{expression-list} or a \grammarterm{braced-init-list},
 \item for a \grammarterm{new-initializer}\iref{expr.new},
-\item in a \tcode{static_cast} expression\iref{expr.static.cast},
+\item in a \keyword{static_cast} expression\iref{expr.static.cast},
 \item in a functional notation type conversion\iref{expr.type.conv}, and
 \item in the \grammarterm{braced-init-list} form of a \grammarterm{condition}
 \end{itemize}

source/expressions.tex

@@ -2930,7 +2930,7 @@
 \begin{note}
 The \tcode{>} token following the
 \grammarterm{type-id} in a \tcode{dynamic_cast},
-\tcode{static_cast}, \tcode{reinterpret_cast}, or
+\keyword{static_cast}, \tcode{reinterpret_cast}, or
 \tcode{const_cast} can be the product of replacing a
 \tcode{>>} token by two consecutive \tcode{>}
 tokens\iref{temp.names}.
@@ -3718,7 +3718,7 @@
 If \tcode{T} is an lvalue reference type
 or an rvalue reference to function type, the result is an lvalue;
 if \tcode{T} is an rvalue reference to object type, the result is an xvalue;
-otherwise, the result is a prvalue. The \tcode{static_cast} operator shall not cast
+otherwise, the result is a prvalue. The \keyword{static_cast} operator shall not cast
 away constness\iref{expr.const.cast}.
 
 \pnum
@@ -3759,7 +3759,7 @@
 the result refers to the object or the specified base class subobject
 thereof; otherwise, the lvalue-to-rvalue conversion\iref{conv.lval}
 is applied to the bit-field and the resulting prvalue is used as the
-\grammarterm{expression} of the \tcode{static_cast} for the remainder of this subclause.
+\grammarterm{expression} of the \keyword{static_cast} for the remainder of this subclause.
 If \tcode{T2} is an inaccessible\iref{class.access} or
 ambiguous\iref{class.member.lookup} base class of \tcode{T1},
 a program that necessitates such a cast is ill-formed.
@@ -3793,9 +3793,9 @@
 \end{note}
 
 \pnum
-Otherwise, the \tcode{static_cast} shall perform one of the conversions
+Otherwise, the \keyword{static_cast} shall perform one of the conversions
 listed below. No other conversion shall be performed explicitly using a
-\tcode{static_cast}.
+\keyword{static_cast}.
 
 \pnum
 Any expression can be explicitly converted to type \cv{}~\tcode{void},
@@ -3818,8 +3818,8 @@
 null pointer\iref{conv.ptr}, null member pointer\iref{conv.mem},
 boolean\iref{conv.bool}, or
 function pointer\iref{conv.fctptr}
-conversion, can be performed explicitly using \tcode{static_cast}. A
-program is ill-formed if it uses \tcode{static_cast} to perform the
+conversion, can be performed explicitly using \keyword{static_cast}. A
+program is ill-formed if it uses \keyword{static_cast} to perform the
 inverse of an ill-formed standard conversion sequence.
 \begin{example}
 \begin{codeblock}
@@ -3836,7 +3836,7 @@
 The lvalue-to-rvalue\iref{conv.lval},
 array-to-pointer\iref{conv.array}, and
 function-to-pointer\iref{conv.func} conversions are applied to the
-operand. Such a \tcode{static_cast} is subject to the restriction that
+operand. Such a \keyword{static_cast} is subject to the restriction that
 the explicit conversion does not cast away
 constness\iref{expr.const.cast}, and the following additional rules
 for specific cases:
@@ -5659,7 +5659,7 @@
 \pnum
 An explicit type conversion can be expressed using functional
 notation\iref{expr.type.conv}, a type conversion operator
-(\tcode{dynamic_cast}, \tcode{static_cast}, \tcode{reinterpret_cast},
+(\tcode{dynamic_cast}, \keyword{static_cast}, \tcode{reinterpret_cast},
 \tcode{const_cast}), or the \term{cast} notation.
 
 \begin{bnf}
@@ -5679,14 +5679,14 @@
 \indextext{cast!static}%
 \indextext{cast!reinterpret}%
 \item a \tcode{const_cast}\iref{expr.const.cast},
-\item a \tcode{static_cast}\iref{expr.static.cast},
-\item a \tcode{static_cast} followed by a \tcode{const_cast},
+\item a \keyword{static_cast}\iref{expr.static.cast},
+\item a \keyword{static_cast} followed by a \tcode{const_cast},
 \item a \tcode{reinterpret_cast}\iref{expr.reinterpret.cast}, or
 \item a \tcode{reinterpret_cast} followed by a \tcode{const_cast},
 \end{itemize}
 can be performed using the cast notation of explicit type conversion.
 The same semantic restrictions and behaviors apply, with the exception
-that in performing a \tcode{static_cast} in the following situations the
+that in performing a \keyword{static_cast} in the following situations the
 conversion is valid even if the base class is inaccessible:
 \begin{itemize}
 \item a pointer to an object of derived class type or an lvalue or
@@ -5708,7 +5708,7 @@
 above, the interpretation that appears first in the list is used, even
 if a cast resulting from that interpretation is ill-formed. If a
 conversion can be interpreted in more than one way as a
-\tcode{static_cast} followed by a \tcode{const_cast}, the conversion is
+\keyword{static_cast} followed by a \tcode{const_cast}, the conversion is
 ill-formed.
 \begin{example}
 \begin{codeblock}
@@ -5717,7 +5717,7 @@
 struct I2 : A { };
 struct D : I1, I2 { };
 A* foo( D* p ) {
-  return (A*)( p );             // ill-formed \tcode{static_cast} interpretation
+  return (A*)( p );             // ill-formed \keyword{static_cast} interpretation
 }
 \end{codeblock}
 \end{example}
@@ -5728,7 +5728,7 @@
 ``pointer to incomplete class type''. The destination type of a cast
 using the cast notation can be ``pointer to incomplete class type''. If
 both the operand and destination types are class types and one or both
-are incomplete, it is unspecified whether the \tcode{static_cast} or the
+are incomplete, it is unspecified whether the \keyword{static_cast} or the
 \tcode{reinterpret_cast} interpretation is used, even if there is an
 inheritance relationship between the two classes.
 \begin{note}

source/lib-intro.tex

@@ -2070,7 +2070,7 @@
 or \tcode{X::const_pointer}. Then, \tcode{x1} and \tcode{x2} are
 \defn{equivalently-valued} pointer values, if and only if both \tcode{x1} and \tcode{x2}
 can be explicitly converted to the two corresponding objects \tcode{px1} and \tcode{px2}
-of type \tcode{X::const_pointer}, using a sequence of \tcode{static_cast}s
+of type \tcode{X::const_pointer}, using a sequence of \keyword{static_cast}s
 using only these four types, and the expression \tcode{px1 == px2}
 evaluates to \tcode{true}.
 

source/templates.tex

@@ -747,7 +747,7 @@
 \tcode{>}
 \begin{footnote}
 A \tcode{>} that encloses the \grammarterm{type-id}
-of a \tcode{dynamic_cast}, \tcode{static_cast}, \tcode{reinterpret_cast}
+of a \tcode{dynamic_cast}, \keyword{static_cast}, \tcode{reinterpret_cast}
 or \tcode{const_cast}, or which encloses the \grammarterm{template-argument}{s}
 of a subsequent \grammarterm{template-id}, is considered nested for the purpose
 of this description.
@@ -4373,7 +4373,7 @@
 template<class T> struct S {
   using Ptr = PtrTraits<T>::Ptr;        // OK, in a \grammarterm{defining-type-id}
   T::R f(T::P p) {                      // OK, class scope
-    return static_cast<T::R>(p);        // OK, \grammarterm{type-id} of a \tcode{static_cast}
+    return static_cast<T::R>(p);        // OK, \grammarterm{type-id} of a \keyword{static_cast}
   }
   auto g() -> S<T*>::Ptr;               // OK, \grammarterm{trailing-return-type}
 };

source/time.tex

@@ -1821,7 +1821,7 @@
 \pnum
 \begin{note}
 This function does not use any implicit conversions; all conversions
-are done with \tcode{static_cast}. It avoids multiplications and divisions when
+are done with \keyword{static_cast}. It avoids multiplications and divisions when
 it is known at compile time that one or more arguments is 1. Intermediate
 computations are carried out in the widest representation and only converted to
 the destination representation at the final step.