[atomics.ref.generic] Exposition-only style for ptr

Author: frederick-vs-ja

source/threads.tex

@@ -3200,7 +3200,7 @@
 namespace std {
   template<class T> struct atomic_ref {
   private:
-    T* ptr;             // \expos
+    T* @\exposid{ptr}@;             // \expos
 
   public:
     using value_type = remove_cv_t<T>;
@@ -3239,18 +3239,18 @@
 
 \pnum
 An \tcode{atomic_ref} object applies atomic operations\iref{atomics.general} to
-the object referenced by \tcode{*ptr} such that,
+the object referenced by \tcode{*\exposid{ptr}} such that,
 for the lifetime\iref{basic.life} of the \tcode{atomic_ref} object,
-the object referenced by \tcode{*ptr} is an atomic object\iref{intro.races}.
+the object referenced by \tcode{*\exposid{ptr}} is an atomic object\iref{intro.races}.
 
 \pnum
 The program is ill-formed if \tcode{is_trivially_copyable_v<T>} is \tcode{false}.
 
 \pnum
-The lifetime\iref{basic.life} of an object referenced by \tcode{*ptr}
+The lifetime\iref{basic.life} of an object referenced by \tcode{*\exposid{ptr}}
 shall exceed the lifetime of all \tcode{atomic_ref}s that reference the object.
 While any \tcode{atomic_ref} instances exist
-that reference the \tcode{*ptr} object,
+that reference the \tcode{*\exposid{ptr}} object,
 all accesses to that object shall exclusively occur
 through those \tcode{atomic_ref} instances.
 No subobject of the object referenced by \tcode{atomic_ref}
@@ -3390,7 +3390,7 @@
 
 \pnum
 \effects
-Atomically replaces the value referenced by \tcode{*ptr}
+Atomically replaces the value referenced by \tcode{*\exposid{ptr}}
 with the value of \tcode{desired}.
 Memory is affected according to the value of \tcode{order}.
 \end{itemdescr}
@@ -3439,7 +3439,7 @@
 
 \pnum
 \returns
-Atomically returns the value referenced by \tcode{*ptr}.
+Atomically returns the value referenced by \tcode{*\exposid{ptr}}.
 \end{itemdescr}
 
 \indexlibrarymember{operator \placeholder{type}}{atomic_ref}%
@@ -3472,14 +3472,14 @@
 
 \pnum
 \effects
-Atomically replaces the value referenced by \tcode{*ptr}
+Atomically replaces the value referenced by \tcode{*\exposid{ptr}}
 with \tcode{desired}.
 Memory is affected according to the value of \tcode{order}.
 This operation is an atomic read-modify-write operation\iref{intro.multithread}.
 
 \pnum
 \returns
-Atomically returns the value referenced by \tcode{*ptr}
+Atomically returns the value referenced by \tcode{*\exposid{ptr}}
 immediately before the effects.
 \end{itemdescr}
 
@@ -3521,9 +3521,9 @@
 \effects
 Retrieves the value in \tcode{expected}.
 It then atomically compares the value representation of
-the value referenced by \tcode{*ptr} for equality
+the value referenced by \tcode{*\exposid{ptr}} for equality
 with that previously retrieved from \tcode{expected},
-and if \tcode{true}, replaces the value referenced by \tcode{*ptr}
+and if \tcode{true}, replaces the value referenced by \tcode{*\exposid{ptr}}
 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
@@ -3539,11 +3539,11 @@
 If and only if the comparison is \tcode{false} then,
 after the atomic operation,
 the value in \tcode{expected} is replaced by
-the value read from the value referenced by \tcode{*ptr}
+the value read from the value referenced by \tcode{*\exposid{ptr}}
 during the atomic comparison.
 If the operation returns \tcode{true},
 these operations are atomic read-modify-write operations\iref{intro.races}
-on the value referenced by \tcode{*ptr}.
+on the value referenced by \tcode{*\exposid{ptr}}.
 Otherwise, these operations are atomic load operations on that memory.
 
 \pnum
@@ -3554,7 +3554,7 @@
 \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{ptr} are equal,
+by \tcode{expected} and \exposid{ptr} are equal,
 it may return \tcode{false} and
 store back to \tcode{expected} the same memory contents
 that were originally there.
@@ -3600,7 +3600,7 @@
 \pnum
 \remarks
 This function is an atomic waiting operation\iref{atomics.wait}
-on atomic object \tcode{*ptr}.
+on atomic object \tcode{*\exposid{ptr}}.
 \end{itemdescr}
 
 \indexlibrarymember{notify_one}{atomic_ref<T>}%
@@ -3615,14 +3615,14 @@
 
 \pnum
 \effects
-Unblocks the execution of at least one atomic waiting operation on \tcode{*ptr}
+Unblocks the execution of at least one atomic waiting operation on \tcode{*\exposid{ptr}}
 that is eligible to be unblocked\iref{atomics.wait} by this call,
 if any such atomic waiting operations exist.
 
 \pnum
 \remarks
 This function is an atomic notifying operation\iref{atomics.wait}
-on atomic object \tcode{*ptr}.
+on atomic object \tcode{*\exposid{ptr}}.
 \end{itemdescr}
 
 \indexlibrarymember{notify_all}{atomic_ref<T>}%
@@ -3637,13 +3637,13 @@
 
 \pnum
 \effects
-Unblocks the execution of all atomic waiting operations on \tcode{*ptr}
+Unblocks the execution of all atomic waiting operations on \tcode{*\exposid{ptr}}
 that are eligible to be unblocked\iref{atomics.wait} by this call.
 
 \pnum
 \remarks
 This function is an atomic notifying operation\iref{atomics.wait}
-on atomic object \tcode{*ptr}.
+on atomic object \tcode{*\exposid{ptr}}.
 \end{itemdescr}
 
 \indexlibrarymember{address}{atomic_ref<T>}%
@@ -3654,7 +3654,7 @@
 \begin{itemdescr}
 \pnum
 \returns
-\tcode{ptr}.
+\exposid{ptr}.
 \end{itemdescr}
 
 \rSec3[atomics.ref.int]{Specializations for integral types}
@@ -3680,7 +3680,7 @@
 namespace std {
   template<> struct atomic_ref<@\placeholder{integral-type}@> {
   private:
-    @\placeholder{integral-type}@* ptr;         // \expos
+    @\placeholder{integral-type}@* @\exposid{ptr}@;         // \expos
 
   public:
     using value_type = remove_cv_t<@\placeholder{integral-type}@>;
@@ -3786,15 +3786,15 @@
 
 \pnum
 \effects
-Atomically replaces the value referenced by \tcode{*ptr} with
-the result of the computation applied to the value referenced by \tcode{*ptr}
+Atomically replaces the value referenced by \tcode{*\exposid{ptr}} with
+the result of the computation applied to the value referenced by \tcode{*\exposid{ptr}}
 and the given operand.
 Memory is affected according to the value of \tcode{order}.
 These operations are atomic read-modify-write operations\iref{intro.races}.
 
 \pnum
 \returns
-Atomically, the value referenced by \tcode{*ptr}
+Atomically, the value referenced by \tcode{*\exposid{ptr}}
 immediately before the effects.
 
 \pnum
@@ -3836,17 +3836,17 @@
 
 \pnum
 \effects
-Atomically replaces the value referenced by \tcode{*ptr}
+Atomically replaces the value referenced by \tcode{*\exposid{ptr}}
 with the result of the computation applied to
-the value referenced by \tcode{*ptr} and the given \tcode{operand}.
+the value referenced by \tcode{*\exposid{ptr}} and the given \tcode{operand}.
 Memory is affected according to the value of \tcode{order}.
 These operations are atomic modify-write operations\iref{atomics.order}.
 
 \pnum
 \remarks
 Except for \tcode{store_max} and \tcode{store_min},
 for signed integer types,
-the result is as if \tcode{*ptr} and parameters
+the result is as if \tcode{*\exposid{ptr}} and parameters
 were converted to their corresponding unsigned types,
 the computation performed on those types, and
 the result converted back to the signed type.
@@ -3856,7 +3856,7 @@
 For \tcode{store_max} and \tcode{store_min},
 the maximum and minimum computation is performed
 as if by \tcode{max} and \tcode{min} algorithms\iref{alg.min.max}, respectively,
-with \tcode{*ptr} and the first parameter as the arguments.
+with \tcode{*\exposid{ptr}} and the first parameter as the arguments.
 \end{itemdescr}
 
 \indexlibrarymember{operator+=}{atomic_ref<\placeholder{integral-type}>}%
@@ -3898,7 +3898,7 @@
 namespace std {
   template<> struct atomic_ref<@\placeholder{floating-point-type}@> {
   private:
-    @\placeholder{floating-point-type}@* ptr;   // \expos
+    @\placeholder{floating-point-type}@* @\exposid{ptr}@;   // \expos
 
   public:
     using value_type = remove_cv_t<@\placeholder{floating-point-type}@>;
@@ -4009,15 +4009,15 @@
 
 \pnum
 \effects
-Atomically replaces the value referenced by \tcode{*ptr} with
-the result of the computation applied to the value referenced by \tcode{*ptr}
+Atomically replaces the value referenced by \tcode{*\exposid{ptr}} with
+the result of the computation applied to the value referenced by \tcode{*\exposid{ptr}}
 and the given operand.
 Memory is affected according to the value of \tcode{order}.
 These operations are atomic read-modify-write operations\iref{intro.races}.
 
 \pnum
 \returns
-Atomically, the value referenced by \tcode{*ptr}
+Atomically, the value referenced by \tcode{*\exposid{ptr}}
 immediately before the effects.
 
 \pnum
@@ -4038,27 +4038,27 @@
 For \tcode{fetch_fmaximum} and \tcode{fetch_fminimum},
 the maximum and minimum computation is performed
 as if by \tcode{fmaximum} and \tcode{fminimum}, respectively,
-with \tcode{*ptr} and the first parameter as the arguments.
+with \tcode{*\exposid{ptr}} and the first parameter as the arguments.
 \item
 For \tcode{fetch_fmaximum_num} and \tcode{fetch_fminimum_num},
 the maximum and minimum computation is performed
 as if by \tcode{fmaximum_num} and \tcode{fminimum_num}, respectively,
-with \tcode{*ptr} and the first parameter as the arguments.
+with \tcode{*\exposid{ptr}} and the first parameter as the arguments.
 \item
 For \tcode{fetch_max} and \tcode{fetch_min},
 the maximum and minimum computation is performed
 as if by \tcode{fmaximum_num} and \tcode{fminimum_num}, respectively,
-with \tcode{*ptr} and the first parameter as the arguments, except that:
+with \tcode{*\exposid{ptr}} and the first parameter as the arguments, except that:
 \begin{itemize}
 \item
-If both arguments are NaN, an unspecified NaN value is stored at \tcode{*ptr}.
+If both arguments are NaN, an unspecified NaN value is stored at \tcode{*\exposid{ptr}}.
 \item
 If exactly one argument is a NaN,
-either the other argument or an unspecified NaN value is stored at \tcode{*ptr};
+either the other argument or an unspecified NaN value is stored at \tcode{*\exposid{ptr}};
 it is unspecified which.
 \item
 If the arguments are differently signed zeros,
-which of these values is stored at \tcode{*ptr} is unspecified.
+which of these values is stored at \tcode{*\exposid{ptr}} is unspecified.
 \end{itemize}
 \end{itemize}
 
@@ -4090,9 +4090,9 @@
 
 \pnum
 \effects
-Atomically replaces the value referenced by \tcode{*ptr}
+Atomically replaces the value referenced by \tcode{*\exposid{ptr}}
 with the result of the computation applied to
-the value referenced by \tcode{*ptr} and the given \tcode{operand}.
+the value referenced by \tcode{*\exposid{ptr}} and the given \tcode{operand}.
 Memory is affected according to the value of \tcode{order}.
 These operations are atomic modify-write operations\iref{atomics.order}.
 
@@ -4120,23 +4120,23 @@
 For \tcode{store_fmaximum} and \tcode{store_fminimum},
 the maximum and minimum computation is performed
 as if by \tcode{fmaximum} and \tcode{fminimum}, respectively,
-with \tcode{*ptr} and the first parameter as the arguments.
+with \tcode{*\exposid{ptr}} and the first parameter as the arguments.
 \item
 For \tcode{store_fmaximum_num} and \tcode{store_fminimum_num},
 the maximum and minimum computation is performed
 as if by \tcode{fmaximum_num }and \tcode{fminimum_num}, respectively,
-with \tcode{*ptr} and the first parameter as the arguments.
+with \tcode{*\exposid{ptr}} and the first parameter as the arguments.
 \item
 For \tcode{store_max} and \tcode{store_min},
 the maximum and minimum computation is performed
 as if by \tcode{fmaximum_num} and \tcode{fminimum_num}, respectively,
-with \tcode{*ptr} and the first parameter as the arguments, except that:
+with \tcode{*\exposid{ptr}} and the first parameter as the arguments, except that:
 \begin{itemize}
 \item
-If both arguments are NaN, an unspecified NaN value is stored at \tcode{*ptr}.
+If both arguments are NaN, an unspecified NaN value is stored at \tcode{*\exposid{ptr}}.
 \item
 If exactly one argument is a NaN,
-either the other argument or an unspecified NaN value is stored at \tcode{*ptr},
+either the other argument or an unspecified NaN value is stored at \tcode{*\exposid{ptr}},
 it is unspecified which.
 \item
 If the arguments are differently signed zeros,
@@ -4186,7 +4186,7 @@
 namespace std {
   template<> struct atomic_ref<@\placeholder{pointer-type}@> {
   private:
-    @\placeholder{pointer-type}@* ptr;        // \expos
+    @\placeholder{pointer-type}@* @\exposid{ptr}@;        // \expos
 
   public:
     using value_type = remove_cv_t<@\placeholder{pointer-type}@>;
@@ -4278,15 +4278,15 @@
 
 \pnum
 \effects
-Atomically replaces the value referenced by \tcode{*ptr} with
-the result of the computation applied to the value referenced by \tcode{*ptr}
+Atomically replaces the value referenced by \tcode{*\exposid{ptr}} with
+the result of the computation applied to the value referenced by \tcode{*\exposid{ptr}}
 and the given operand.
 Memory is affected according to the value of \tcode{order}.
 These operations are atomic read-modify-write operations\iref{intro.races}.
 
 \pnum
 \returns
-Atomically, the value referenced by \tcode{*ptr}
+Atomically, the value referenced by \tcode{*\exposid{ptr}}
 immediately before the effects.
 
 \pnum
@@ -4329,9 +4329,9 @@
 
 \pnum
 \effects
-Atomically replaces the value referenced by \tcode{*ptr}
+Atomically replaces the value referenced by \tcode{*\exposid{ptr}}
 with the result of the computation applied to
-the value referenced by \tcode{*ptr} and the given \tcode{operand}.
+the value referenced by \tcode{*\exposid{ptr}} and the given \tcode{operand}.
 Memory is affected according to the value of \tcode{order}.
 These operations are atomic modify-write operations\iref{atomics.order}.
 
@@ -4342,7 +4342,7 @@
 For \tcode{store_max} and \tcode{store_min},
 the \tcode{maximum} and \tcode{minimum} computation is performed
 as if by \tcode{max} and \tcode{min} algorithms\iref{alg.min.max}, respectively,
-with \tcode{*ptr} and the first parameter as the arguments.
+with \tcode{*\exposid{ptr}} and the first parameter as the arguments.
 \begin{note}
 If the pointers point to different complete objects (or subobjects thereof),
 the \tcode{<} operator does not establish