[std] Use \keyword for 'new', 'delete', 'this', 'nullptr'.

Author: jensmaurer

source/atomics.tex

@@ -1735,7 +1735,7 @@
 
 \pnum
 \effects
-Atomically replaces the value pointed to by \tcode{this}
+Atomically replaces the value pointed to by \keyword{this}
 with the value of \tcode{desired}. Memory is affected according to the value of
 \tcode{order}.
 \end{itemdescr}
@@ -1791,7 +1791,7 @@
 
 \pnum
 \returns
-Atomically returns the value pointed to by \tcode{this}.
+Atomically returns the value pointed to by \keyword{this}.
 \end{itemdescr}
 
 \indexlibrarymember{operator \placeholder{type}}{atomic}%
@@ -1834,14 +1834,14 @@
 
 \pnum
 \effects
-Atomically replaces the value pointed to by \tcode{this}
+Atomically replaces the value pointed to by \keyword{this}
 with \tcode{desired}.
 Memory is affected according to the value of \tcode{order}.
 These operations are atomic read-modify-write operations\iref{intro.multithread}.
 
 \pnum
 \returns
-Atomically returns the value pointed to by \tcode{this} immediately before the effects.
+Atomically returns the value pointed to by \keyword{this} immediately before the effects.
 \end{itemdescr}
 
 \indexlibraryglobal{atomic_compare_exchange_weak}%
@@ -1889,10 +1889,10 @@
 \pnum
 \effects
 Retrieves the value in \tcode{expected}. It then atomically
-compares the value representation of the value pointed to by \tcode{this}
+compares the value representation of the value pointed to by \keyword{this}
 for equality with that previously retrieved from \tcode{expected},
 and if true, replaces the value pointed to
-by \tcode{this} with that in \tcode{desired}.
+by \keyword{this} with that in \tcode{desired}.
 If and only if the comparison is \tcode{true}, memory is affected according to the
 value of \tcode{success}, and if the comparison is false, memory is affected according
 to the value of \tcode{failure}. When only one \tcode{memory_order} argument is
@@ -1903,11 +1903,11 @@
 \tcode{memory_order::relaxed}.
 If and only if the comparison is false then, after the atomic operation,
 the value in \tcode{expected} is replaced by the value
-pointed to by \tcode{this} during the atomic comparison.
+pointed to by \keyword{this} during the atomic comparison.
 If the operation returns \tcode{true}, these
 operations are atomic read-modify-write
 operations\iref{intro.multithread} on the memory
-pointed to by \tcode{this}.
+pointed to by \keyword{this}.
 Otherwise, these operations are atomic load operations on that memory.
 
 \pnum
@@ -1958,7 +1958,7 @@
 \pnum
 \remarks
 A weak compare-and-exchange operation may fail spuriously. That is, even when
-the contents of memory referred to by \tcode{expected} and \tcode{this} are
+the contents of memory referred to by \tcode{expected} and \keyword{this} are
 equal, it may return \tcode{false} and store back to \tcode{expected} the same memory
 contents that were originally there.
 \begin{note}
@@ -2277,14 +2277,14 @@
 \pnum
 \effects
 Atomically replaces the value pointed to by
-\tcode{this} with the result of the computation applied to the
-value pointed to by \tcode{this} and the given \tcode{operand}.
+\keyword{this} with the result of the computation applied to the
+value pointed to by \keyword{this} and the given \tcode{operand}.
 Memory is affected according to the value of \tcode{order}.
 These operations are atomic read-modify-write operations\iref{intro.multithread}.
 
 \pnum
 \returns
-Atomically, the value pointed to by \tcode{this} immediately before the effects.
+Atomically, the value pointed to by \keyword{this} immediately before the effects.
 
 \pnum
 \indextext{signed integer representation!two's complement}%
@@ -2439,15 +2439,15 @@
 
 \pnum
 \effects
-Atomically replaces the value pointed to by \tcode{this}
+Atomically replaces the value pointed to by \keyword{this}
 with the result of the computation applied to the value pointed
-to by \tcode{this} and the given \tcode{operand}.
+to by \keyword{this} and the given \tcode{operand}.
 Memory is affected according to the value of \tcode{order}.
 These operations are atomic read-modify-write operations\iref{intro.multithread}.
 
 \pnum
 \returns
-Atomically, the value pointed to by \tcode{this} immediately before the effects.
+Atomically, the value pointed to by \keyword{this} immediately before the effects.
 
 \pnum
 \remarks
@@ -2620,14 +2620,14 @@
 \pnum
 \effects
 Atomically replaces the value pointed to by
-\tcode{this} with the result of the computation applied to the
-value pointed to by \tcode{this} and the given \tcode{operand}.
+\keyword{this} with the result of the computation applied to the
+value pointed to by \keyword{this} and the given \tcode{operand}.
 Memory is affected according to the value of \tcode{order}.
 These operations are atomic read-modify-write operations\iref{intro.multithread}.
 
 \pnum
 \returns
-Atomically, the value pointed to by \tcode{this} immediately before the effects.
+Atomically, the value pointed to by \keyword{this} immediately before the effects.
 
 \pnum
 \remarks
@@ -2876,7 +2876,7 @@
 
 \pnum
 \effects
-Atomically replaces the value pointed to by \tcode{this} with
+Atomically replaces the value pointed to by \keyword{this} with
 the value of \tcode{desired} as if by \tcode{p.swap(desired)}.
 Memory is affected according to the value of \tcode{order}.
 \end{itemdescr}
@@ -2980,7 +2980,7 @@
 If the operation returns \tcode{true},
 \tcode{expected} is not accessed after the atomic update and
 the operation is an atomic read-modify-write operation\iref{intro.multithread}
-on the memory pointed to by \tcode{this}.
+on the memory pointed to by \keyword{this}.
 Otherwise, the operation is an atomic load operation on that memory, and
 \tcode{expected} is updated with the existing value
 read from the atomic object in the attempted atomic update.
@@ -3183,7 +3183,7 @@
 
 \pnum
 \effects
-Atomically replaces the value pointed to by \tcode{this} with
+Atomically replaces the value pointed to by \keyword{this} with
 the value of \tcode{desired} as if by \tcode{p.swap(desired)}.
 Memory is affected according to the value of \tcode{order}.
 \end{itemdescr}
@@ -3286,7 +3286,7 @@
 If the operation returns \tcode{true},
 \tcode{expected} is not accessed after the atomic update and
 the operation is an atomic read-modify-write operation\iref{intro.multithread}
-on the memory pointed to by \tcode{this}.
+on the memory pointed to by \keyword{this}.
 Otherwise, the operation is an atomic load operation on that memory, and
 \tcode{expected} is updated with the existing value
 read from the atomic object in the attempted atomic update.
@@ -3498,7 +3498,7 @@
 
 \pnum
 \returns
-Atomically returns the value pointed to by \tcode{object} or \tcode{this}.
+Atomically returns the value pointed to by \tcode{object} or \keyword{this}.
 \end{itemdescr}
 
 \indexlibraryglobal{atomic_flag_test_and_set}%
@@ -3516,7 +3516,7 @@
 \begin{itemdescr}
 \pnum
 \effects
-Atomically sets the value pointed to by \tcode{object} or by \tcode{this} to \tcode{true}. Memory is affected according to the value of
+Atomically sets the value pointed to by \tcode{object} or by \keyword{this} to \tcode{true}. Memory is affected according to the value of
 \tcode{order}. These operations are atomic read-modify-write operations\iref{intro.multithread}.
 
 \pnum
@@ -3544,7 +3544,7 @@
 
 \pnum
 \effects
-Atomically sets the value pointed to by \tcode{object} or by \tcode{this} to
+Atomically sets the value pointed to by \tcode{object} or by \keyword{this} to
 \tcode{false}. Memory is affected according to the value of \tcode{order}.
 \end{itemdescr}
 
@@ -3569,7 +3569,7 @@
 For \tcode{atomic_flag_wait},
 let \tcode{order} be \tcode{memory_order::seq_cst}.
 Let \tcode{flag} be \tcode{object} for the non-member functions and
-\tcode{this} for the member functions.
+\keyword{this} for the member functions.
 
 \pnum
 \expects

source/basic.tex

@@ -3419,7 +3419,7 @@
 void B::mutate() {
   new (this) D2;    // reuses storage --- ends the lifetime of \tcode{*this}
   f();              // undefined behavior
-  ... = this;       // OK, \tcode{this} points to valid memory
+  ... = this;       // OK, \keyword{this} points to valid memory
 }
 
 void g() {

source/classes.tex

@@ -1003,7 +1003,7 @@
 \indextext{member function!const volatile}%
 \begin{note}
 A non-static member function can be declared with
-\grammarterm{cv-qualifier}{s}, which affect the type of the \tcode{this}
+\grammarterm{cv-qualifier}{s}, which affect the type of the \keyword{this}
 pointer\iref{expr.prim.this},
 and/or a \grammarterm{ref-qualifier}\iref{dcl.fct};
 both affect overload resolution\iref{over.match.funcs}
@@ -2257,7 +2257,7 @@
 the destructor is invoked via a null pointer value), the program has
 undefined behavior.
 \begin{note}
-Invoking \tcode{delete} on a null pointer does not call the
+Invoking \keyword{delete} on a null pointer does not call the
 destructor; see \ref{expr.delete}.
 \end{note}
 \begin{example}
@@ -2671,7 +2671,7 @@
 
 \pnum
 \begin{note}
-A static member function does not have a \tcode{this}
+A static member function does not have a \keyword{this}
 pointer\iref{expr.prim.this}.
 A static member function cannot be qualified with \keyword{const},
 \tcode{volatile}, or \keyword{virtual}\iref{dcl.fct}.
@@ -4962,8 +4962,8 @@
 void D2::mem(B* pb, D1* p1) {
   pb->i = 1;                    // error
   p1->i = 2;                    // error
-  i = 3;                        // OK (access through \tcode{this})
-  B::i = 4;                     // OK (access through \tcode{this}, qualification ignored)
+  i = 3;                        // OK (access through \keyword{this})
+  B::i = 4;                     // OK (access through \keyword{this}, qualification ignored)
   int B::* pmi_B = &B::i;       // error
   int B::* pmi_B2 = &D2::i;     // OK
   j = 5;                        // OK (because \tcode{j} refers to static member)
@@ -5845,7 +5845,7 @@
 if the value of the object or any of its subobjects is
 accessed through a glvalue that is not obtained, directly or indirectly, from
 the constructor's
-\tcode{this}
+\keyword{this}
 pointer, the value of the object or subobject thus obtained is unspecified.
 \begin{example}
 \begin{codeblock}

source/compatibility.tex

@@ -1288,7 +1288,7 @@
 \keyword{constexpr},
 \tcode{decltype},
 \keyword{noexcept},
-\tcode{nullptr},
+\keyword{nullptr},
 \tcode{static_assert},
 and
 \tcode{thread_local}.

source/containers.tex

@@ -1352,7 +1352,7 @@
 \effects
 Constructs a \exposid{node-handle} object initializing
 \tcode{ptr_} with \tcode{nh.ptr_}.  Move constructs \tcode{alloc_} with
-\tcode{nh.alloc_}.  Assigns \tcode{nullptr} to \tcode{nh.ptr_} and assigns
+\tcode{nh.alloc_}.  Assigns \keyword{nullptr} to \tcode{nh.ptr_} and assigns
 \tcode{nullopt} to \tcode{nh.alloc_}.
 \end{itemdescr}
 
@@ -1383,7 +1383,7 @@
 move assigns \tcode{nh.alloc_} to \tcode{alloc_}.
 \item
 Assigns
-\tcode{nullptr} to \tcode{nh.ptr_} and assigns \tcode{nullopt} to
+\keyword{nullptr} to \tcode{nh.ptr_} and assigns \tcode{nullopt} to
 \tcode{nh.alloc_}.
 \end{itemize}
 

source/declarations.tex

@@ -2263,7 +2263,7 @@
 and as an argument of
 \tcode{sizeof},
 \tcode{alignof},
-\tcode{new},
+\keyword{new},
 or
 \tcode{typeid},
 the name of a type shall be specified.
@@ -4042,7 +4042,7 @@
 \pnum
 \begin{note}
 The keyword
-\tcode{this}
+\keyword{this}
 cannot appear in a default argument of a member function;
 see~\ref{expr.prim.this}.
 \begin{example}
@@ -6042,7 +6042,7 @@
 
 \pnum
 \begin{note}
-A \grammarterm{cv-qualifier-seq} affects the type of \tcode{this}
+A \grammarterm{cv-qualifier-seq} affects the type of \keyword{this}
 in the body of a member function; see~\ref{expr.prim.this}.
 \end{note}
 
@@ -6471,12 +6471,12 @@
 in the scope of the promise type\iref{class.member.lookup} finds
 any declarations, then the result
 of a call to an allocation function used to obtain storage for the coroutine
-state is assumed to return \tcode{nullptr} if it fails to obtain storage,
+state is assumed to return \keyword{nullptr} if it fails to obtain storage,
 and if a global allocation function is selected,
 the \tcode{::operator new(size_t, nothrow_t)} form is used.
 The allocation function used in this case shall have a non-throwing
 \grammarterm{noexcept-specifier}.
-If the allocation function returns \tcode{nullptr}, the coroutine returns
+If the allocation function returns \keyword{nullptr}, the coroutine returns
 control to the caller of the coroutine and the return value is obtained by a
 call to \tcode{T::get_return_object_on_allocation_failure()}, where \tcode{T}
 is the promise type.

source/expressions.tex

@@ -1240,7 +1240,7 @@
 
 \pnum
 Otherwise, if a \grammarterm{member-declarator} declares a non-static data
-member\iref{class.mem} of a class \tcode{X}, the expression \tcode{this} is
+member\iref{class.mem} of a class \tcode{X}, the expression \keyword{this} is
 a prvalue of type ``pointer to \tcode{X}''
 wherever \tcode{X} is the current class
 within the
@@ -2000,7 +2000,7 @@
   void f() {
     [=]()->int {
       return operator()(this->x + y);   // equivalent to \tcode{S1::operator()(this->x + (*this).y)}
-                                        // \tcode{this} has type \tcode{S1*}
+                                        // \keyword{this} has type \tcode{S1*}
     };
   }
 };
@@ -2109,7 +2109,7 @@
   [=, *this]{ };    // OK
   [=, this]{ };     // OK, equivalent to \tcode{[=]}
   [i, i]{ };        // error: \tcode{i} repeated
-  [this, *this]{ }; // error: \tcode{this} appears twice
+  [this, *this]{ }; // error: \keyword{this} appears twice
 }
 \end{codeblock}
 \end{example}
@@ -2289,7 +2289,7 @@
           x += m;               // OK: \tcode{m} implicitly captured by \tcode{m4} and explicitly captured by \tcode{m3}
           x += i;               // error: \tcode{i} is odr-used but not odr-usable
                                 // due to intervening function and class scopes
-          x += f;               // OK: \tcode{this} captured implicitly by \tcode{m4} and explicitly by \tcode{m3}
+          x += f;               // OK: \keyword{this} captured implicitly by \tcode{m4} and explicitly by \tcode{m3}
         };
       };
     }
@@ -2350,7 +2350,7 @@
 the captured entity is not \tcode{*\keyword{this}}, or
 \item
 it is explicitly captured with a capture that is not of the form
-\tcode{this},
+\keyword{this},
 \tcode{\&} \grammarterm{identifier}, or
 \tcode{\&} \grammarterm{identifier} \grammarterm{initializer}.
 \end{itemize}
@@ -4906,7 +4906,7 @@
 (new int) (*[10])();            // error
 \end{codeblock}
 
-Instead, the explicitly parenthesized version of the \tcode{new}
+Instead, the explicitly parenthesized version of the \keyword{new}
 operator can be used to create objects of compound
 types\iref{basic.compound}:
 
@@ -5227,7 +5227,7 @@
 a placement allocation function, except when referencing
 the library function \tcode{operator new[](std::size_t, void*)}.
 The amount of overhead may vary from one
-invocation of \tcode{new} to another.
+invocation of \keyword{new} to another.
 \end{example}
 
 \pnum