[except] Use \keyword throughout.

Author: jensmaurer

source/exceptions.tex

@@ -21,14 +21,14 @@
 %
 \begin{bnf}
 \nontermdef{try-block}\br
-    \terminal{try} compound-statement handler-seq
+    \keyword{try} compound-statement handler-seq
 \end{bnf}
 
 \indextext{\idxcode{try}}%
 %
 \begin{bnf}
 \nontermdef{function-try-block}\br
-    \terminal{try} \opt{ctor-initializer} compound-statement handler-seq
+    \keyword{try} \opt{ctor-initializer} compound-statement handler-seq
 \end{bnf}
 
 \begin{bnf}
@@ -40,7 +40,7 @@
 %
 \begin{bnf}
 \nontermdef{handler}\br
-    \terminal{catch} \terminal{(} exception-declaration \terminal{)} compound-statement
+    \keyword{catch} \terminal{(} exception-declaration \terminal{)} compound-statement
 \end{bnf}
 
 \begin{bnf}
@@ -101,11 +101,11 @@
 \indextext{\idxcode{return}!and handler}%
 \indextext{\idxcode{continue}!and handler}%
 A
-\tcode{goto},
-\tcode{break},
-\tcode{return},
+\keyword{goto},
+\keyword{break},
+\keyword{return},
 or
-\tcode{continue}
+\keyword{continue}
 statement can be used to transfer control out of
 a try block or handler.
 When this happens, each variable declared in the try block
@@ -197,7 +197,7 @@
 \grammarterm{throw-expression}{s}\iref{expr.throw},
 allocation functions\iref{basic.stc.dynamic.allocation},
 \keyword{dynamic_cast}\iref{expr.dynamic.cast},
-\tcode{typeid}\iref{expr.typeid},
+\keyword{typeid}\iref{expr.typeid},
 \grammarterm{new-expression}{s}\iref{expr.new}, and standard library
 functions\iref{structure.specifications}.
 \end{note}
@@ -210,8 +210,8 @@
 can be caught by a
 \grammarterm{handler}
 of
-\tcode{const}
-\tcode{char*}
+\keyword{const}
+\tcode{\keyword{char}*}
 type:
 \begin{codeblock}
 try {
@@ -252,7 +252,7 @@
 \grammarterm{compound-statement} or
 \grammarterm{ctor-initializer}
 following the
-\tcode{try}
+\keyword{try}
 keyword was most recently entered by the thread of control and not yet exited.
 
 \pnum
@@ -266,7 +266,7 @@
 If the type of the exception object would be
 an incomplete type,
 an abstract class type\iref{class.abstract},
-or a pointer to an incomplete type other than \cv{}~\tcode{void}
+or a pointer to an incomplete type other than \cv{}~\keyword{void}
 the program is ill-formed.
 
 \pnum
@@ -377,7 +377,7 @@
 constructed, but not yet destroyed,
 since the try block was entered.
 If an exception is thrown during the destruction of temporaries or
-local variables for a \tcode{return} statement\iref{stmt.return},
+local variables for a \keyword{return} statement\iref{stmt.return},
 the destructor for the returned object (if any) is also invoked.
 The objects are destroyed in the reverse order of the completion
 of their construction.
@@ -468,7 +468,7 @@
 The
 \grammarterm{exception-declaration}
 shall not denote a pointer or reference to an
-incomplete type, other than ``pointer to \cv{}~\tcode{void}''.
+incomplete type, other than ``pointer to \cv{}~\keyword{void}''.
 
 \pnum
 A handler of type
@@ -631,7 +631,7 @@
 on the initial function of the thread.
 
 \pnum
-If a \tcode{return} statement\iref{stmt.return} appears in a handler of the
+If a \keyword{return} statement\iref{stmt.return} appears in a handler of the
 \grammarterm{function-try-block}
 of a
 constructor, the program is ill-formed.
@@ -697,25 +697,25 @@
 
 \begin{bnf}
 \nontermdef{noexcept-specifier}\br
-    \terminal{noexcept} \terminal{(} constant-expression \terminal{)}\br
-    \terminal{noexcept}\br
+    \keyword{noexcept} \terminal{(} constant-expression \terminal{)}\br
+    \keyword{noexcept}\br
 \end{bnf}
 
 \pnum
 \indextext{exception specification!noexcept!constant expression and}%
 In a \grammarterm{noexcept-specifier}, the \grammarterm{constant-expression},
 if supplied, shall be a contextually converted constant expression
-of type \tcode{bool}\iref{expr.const};
+of type \keyword{bool}\iref{expr.const};
 that constant expression is the exception specification of
 the function type in which the \grammarterm{noexcept-specifier} appears.
-A \tcode{(} token that follows \tcode{noexcept} is part of the
+A \tcode{(} token that follows \keyword{noexcept} is part of the
 \grammarterm{noexcept-specifier} and does not commence an
 initializer\iref{dcl.init}.
-The \grammarterm{noexcept-specifier} \tcode{noexcept}
+The \grammarterm{noexcept-specifier} \keyword{noexcept}
 without a \grammarterm{constant-expression}
 is
 equivalent to the \grammarterm{noexcept-specifier}
-\tcode{noexcept(true)}.
+\tcode{\keyword{noexcept}(\keyword{true})}.
 
 \pnum
 If a declaration of a function
@@ -827,7 +827,7 @@
 requires a runtime check\iref{expr.dynamic.cast},
 or
 \item
-$E$ is a \tcode{typeid} expression applied to a
+$E$ is a \keyword{typeid} expression applied to a
 (possibly parenthesized) built-in unary \tcode{*} operator
 applied to a pointer to a
 polymorphic class type\iref{expr.typeid},
@@ -909,14 +909,14 @@
 };
 struct B {
   B() noexcept;
-  B(const B&) = default;        // implicit exception specification is \tcode{noexcept(true)}
+  B(const B&) = default;        // implicit exception specification is \tcode{\keyword{noexcept}(\keyword{true})}
   B(B&&, int = (throw 42, 0)) noexcept;
   ~B() noexcept(false);
 };
 int n = 7;
 struct D : public A, public B {
     int * p = new int[n];
-    // \tcode{D::D()} potentially-throwing, as the \tcode{new} operator may throw \tcode{bad_alloc} or \tcode{bad_array_new_length}
+    // \tcode{D::D()} potentially-throwing, as the \keyword{new} operator may throw \tcode{bad_alloc} or \tcode{bad_array_new_length}
     // \tcode{D::D(const D\&)} non-throwing
     // \tcode{D::D(D\&\&)} potentially-throwing, as the default argument for \tcode{B}'s constructor may throw
     // \tcode{D::\~D()} potentially-throwing