From 749139854cb8a9de7162ce27411ec7f3ca22499e Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Fri, 13 Aug 2021 12:51:00 -0400 Subject: [PATCH 01/40] Updates from Overleaf --- tools/check-output.sh | 0 1 file changed, 0 insertions(+), 0 deletions(-) mode change 100755 => 100644 tools/check-output.sh diff --git a/tools/check-output.sh b/tools/check-output.sh old mode 100755 new mode 100644 From bbc9d74c169ba18f0ac3b7f87a36d57f976571df Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Mon, 27 Sep 2021 13:15:14 -0400 Subject: [PATCH 02/40] Update README.md --- README.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index b7aeb51..5fd4205 100644 --- a/README.md +++ b/README.md @@ -1,17 +1,17 @@ - is the repository for -the C++ Technical Specification "Concurrency TS 2". + is the repository for +the C++ Technical Specification "Trannsactional Memory TS 2021". The draft Technical Specification is found in the `src` directory and is written in LaTeX. There is a Makefile that can be used to compile the sources, or you can use the `latexmk` program e.g. `latexmk -pdf ts` will generate a PDF. -\textbf{Concurrency TS2 Editor's Report} -\textbf{pre-Oct 2021 virtual Plenary meeting} +\textbf{TM TS2021 Editor's Report} +\textbf{pre-Feb 2022 virtual Plenary meeting} -N4895 is the proposed working draft of Concurrency TS Version 2. It contains changes to the Concurrency TS as directed by the committee at the June 2021 virtual plenary meeting, and editorial changes. +Nxxxx is the proposed working draft of Concurrency TS Version 2. It contains changes to the TM TS2021 as directed by the committee at the June 2021 virtual plenary meeting, and editorial changes. -N4895 contains P1121R3 and P1122R4 from the June 2021 virtual plenary. +N4895 contains P2066R9 from Oct 2021 virtual plenary. \textbf{Technical Changes} None @@ -21,4 +21,4 @@ None \textbf{Acknowledgement} -Thank you to the Editing team of Michael Wong, Paul McKenney, Maged Michael, and Jens Maurer. +Thank you to the Editing team of Michael Wong, Hans Boehm, and Jens Maurer. From d83e55afb3d9592f2a137e42cdcfc2ef396b1dc6 Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Mon, 27 Sep 2021 19:24:55 -0400 Subject: [PATCH 03/40] Initial changes to TMV2 --- src/config.tex | 6 +++--- src/cover-wd.tex | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/config.tex b/src/config.tex index 8a41179..0a3b692 100644 --- a/src/config.tex +++ b/src/config.tex @@ -1,14 +1,14 @@ %!TEX root = ts.tex %%-------------------------------------------------- %% Version numbers -\newcommand{\docno}{N4895} +\newcommand{\docno}{Nxxx} \newcommand{\isodocno}{ISO/IEC ?????:2021(E)} \newcommand{\prevdocno}{None} \newcommand{\cppver}{201703L @@@} %% MW: need update -\newcommand{\tsver}{202108} +\newcommand{\tsver}{202110} %% Title -\newcommand{\doctitle}{Extensions to \Cpp for Concurrency Version 2 @@@} +\newcommand{\doctitle}{Extensions to \Cpp for Transactional Memory Version 2 @@@} % \newcommand{\frtitle}{\Cpp Extensions for Concurrency} %% Release date diff --git a/src/cover-wd.tex b/src/cover-wd.tex index d5294c4..9247beb 100644 --- a/src/cover-wd.tex +++ b/src/cover-wd.tex @@ -22,7 +22,7 @@ \vspace{2.5cm} \begin{center} \textbf{\Huge -Working Draft, Extensions to \Cpp for Concurrency Version 2} +Working Draft, Extensions to \Cpp for Transactional Memory Version 2} \end{center} \vfill \textbf{Note: this is an early draft. It's known to be incomplet and From 4e8510da7a7e067a1bd72c75966af7506cb81e65 Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Mon, 27 Sep 2021 19:40:01 -0400 Subject: [PATCH 04/40] Fix macros. --- src/general.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/general.tex b/src/general.tex index eda9065..564f61b 100644 --- a/src/general.tex +++ b/src/general.tex @@ -126,7 +126,7 @@ \rSec1[general.ack]{Acknowledgments} This work is the result of a collaboration of researchers in industry and academia. We wish to thank the -original authors of this document, Michael Wong, Paul McKenney, and Maged Michael. We also wish to thank people +original authors of this document, Michael Wong, Hans Boehm, and Michael Spears. We also wish to thank people who made valuable contributions within and outside these groups, including Jens Maurer, and many others not named here who contributed to the discussion. From 1e19814325e97ab7c70fca7588ebd7a1ffd6f18a Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Mon, 27 Sep 2021 21:13:53 -0400 Subject: [PATCH 05/40] updated clause 4 --- src/general.tex | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/general.tex b/src/general.tex index 564f61b..a16d6c0 100644 --- a/src/general.tex +++ b/src/general.tex @@ -58,7 +58,7 @@ \begin{itemize} \item modify an existing interface in the C++ Standard Library in-place, - \item are declared in a namespace whose name appends \tcode{::experimental::concurrency\_v2} to a namespace defined in the C++ Standard Library, such as \tcode{std}, or + \item are declared in a namespace whose name appends \tcode{::experimental::transactional\_memory\_v2} to a namespace defined in the C++ Standard Library, such as \tcode{std}, or \item are declared in a subnamespace of a namespace described in the previous bullet, whose name is not the same as an existing subnamespace of namespace \tcode{std}. \end{itemize} @@ -105,7 +105,7 @@ \lhdr{Macro name} & \chdr{Value} & \rhdr{Header} \\ \capsep %%\tcode{__cpp_concurrency\_v2} & \tcode{\tsver} & none \\ -\tcode{__cpp_lib_concurrency\_v2} & \tcode{\tsver} & \tcode{} \\ +\tcode{__cpp_lib_transactional\_memory\_v2} & \tcode{\tsver} & \tcode{} \\ \end{floattable} \rSec1[general.plans]{Future plans (Informative)} \pnum @@ -114,13 +114,13 @@ \pnum The C++ committee intends to release a new version of this technical specification approximately every few years, containing -the concurrency extensions we hope to add to a near-future version of the C++ Standard. Future versions will define their -contents in \tcode{std::experimental::concurrency\_v3}, \tcode{std::experimental::concurrency\_v4}, etc., with the most recent +the transactional\_memory extensions we hope to add to a near-future version of the C++ Standard. Future versions will define their +contents in \tcode{std::experimental::transactional\_memory\_v3}, \tcode{std::experimental::transactional\_memory\_v4}, etc., with the most recent implemented version inlined into \tcode{std::ex\-perimental}. \pnum When an extension defined in this or a future version of this technical specification represents enough existing practice, it -will be moved into the next version of the C++ Standard by removing the \tcode{experimental::con\-currency\_v$N$} segment of its +will be moved into the next version of the C++ Standard by removing the \tcode{experimental::transactional\_memory\_v$N$} segment of its namespace and by removing the \tcode{experimental/} prefix from its header's path. \rSec1[general.ack]{Acknowledgments} From fc62b2d2c3396fab104a587dca7fb2151824e4a4 Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Mon, 27 Sep 2021 23:48:12 -0400 Subject: [PATCH 06/40] Updated 5 --- src/cxx.tex | 90 +++++++++++++++++++++++++++++++++++++++++++++++ src/srgeneral.tex | 15 +++++--- 2 files changed, 101 insertions(+), 4 deletions(-) create mode 100644 src/cxx.tex diff --git a/src/cxx.tex b/src/cxx.tex new file mode 100644 index 0000000..cb93b0a --- /dev/null +++ b/src/cxx.tex @@ -0,0 +1,90 @@ +% Define section from the C++ standard that can be indexed +% using its dotted identifer. That is: +% +% \cxxsec{basic.def.odr}{3.2} +% +% This is used to make references to sections of the C++ Standard +% that are not labeled within this document. +\newcommand{\cxxsec}[2]{% + \expandafter\def\csname #1 \endcsname{#2}% +} + +% Generate a reference to the section with the given id. This +% expands to the full chapter/section/subsection number declared +% by \cxxsec. For example: +% +% \cxxref{basic.def.odr} +% +% Expands to the string 3.2. +\newcommand{\cxxref}[1]{% + \csname #1 \endcsname% +} + +\cxxsec{lex.key}{2.12} +\cxxsec{tab:keywords}{4} + + +\cxxsec{basic}{3} +\cxxsec{basic.def.odr}{3.2} +\cxxsec{basic.def.odr.odrparagraph1}{3} +\cxxsec{basic.def.odr.odrparagraph2}{6} + +\cxxsec{basic.scope.block}{3.3.3} +\cxxsec{basic.scope.temp}{3.3.9} +\cxxsec{basic.lookup}{3.4} +\cxxsec{basic.lookup.unqual}{3.4.1} +\cxxsec{basic.lookup.qual}{3.4.3} +\cxxsec{basic.stc.dynamic}{3.7.4} +\cxxsec{basic.fundamental}{3.9.1} +\cxxsec{basic.fundamental.paragraph1}{9} + +\cxxsec{expr}{5} +\cxxsec{expr.prim.general}{5.1.1} +\cxxsec{expr.prim.lambda.paragraph0}{12} +\cxxsec{expr.prim.lambda.paragraph1}{18} +\cxxsec{expr.call}{5.2.2} +\cxxsec{expr.type.conv}{5.2.3} +\cxxsec{expr.typeid}{5.2.8} +\cxxsec{expr.cond}{5.16} +\cxxsec{expr.comma}{5.18} +\cxxsec{expr.const}{5.19} +\cxxsec{stmt.expr}{6.2} +\cxxsec{stmt.return}{6.6.3} + +\cxxsec{dcl.fct.spec}{7.1.2} +\cxxsec{dcl.type.simple}{7.1.6.2} +\cxxsec{dcl.spec.concept}{7.1.7} +\cxxsec{tref:simple.type.specifiers}{10} +\cxxsec{dcl.enum}{7.2} +\cxxsec{namespace.udecl}{7.3.3} + +\cxxsec{dcl.ambig.res}{8.2} +\cxxsec{dcl.fct}{8.3.5} + + +\cxxsec{class}{9} +\cxxsec{class.nest}{9.7} +\cxxsec{class.access.base}{11.2} +\cxxsec{special}{12} +\cxxsec{class.conv.fct}{12.3.2} +\cxxsec{over.call.object}{13.3.1.1.2} +\cxxsec{over.oper}{13.5} +\cxxsec{temp.dep.expr}{14.6.2.2} +\cxxsec{temp.dep.type.paragraph1}{8} +\cxxsec{temp.deduct}{14.8.2} +\cxxsec{except.spec}{15.4} +\cxxsec{cpp.predefined}{16.8} +\cxxsec{tab:cpp.library.headers}{14} +\cxxsec{tab:cpp.headers.freestanding}{16} +\cxxsec{support.types}{18.2} +\cxxsec{support.limits}{18.3} +\cxxsec{cstdint}{18.4} +\cxxsec{support.start.term}{18.5} +\cxxsec{support.dynamic}{18.6} +\cxxsec{support.rtti}{18.7} +\cxxsec{support.exception}{18.8} +\cxxsec{support.initlist}{18.9} +\cxxsec{support.runtime}{18.10} +\cxxsec{atomics}{20} +\cxxsec{meta}{20.10} +\cxxsec{meta.rqmts}{20.10.1} diff --git a/src/srgeneral.tex b/src/srgeneral.tex index 2c47292..c7e4453 100644 --- a/src/srgeneral.tex +++ b/src/srgeneral.tex @@ -1,8 +1,15 @@ %!TEX root = ts.tex -\rSec0[saferecl]{Safe reclamation} +\rSec0[lex]{Lexical conventions} + +\setcounter{section}{9} +\rSec1[lex.name]{Identifiers} + +\pnum +In 5.10 {[}lex.name{]}, add \uline{\texttt{atomic}} to table 4 +{[}tab:lex.name.special{]}. + + + -\rSec1[saferecl.general]{General} -This clause adds safe-reclamation techniques, which are most frequently -used to straightforwardly resolve access-deletion races. From 9264c4d08286d47ca808996d669a6f4cb43fc448 Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Sun, 9 Jan 2022 12:13:01 -0700 Subject: [PATCH 07/40] added all of P2066R10 content: Remaining issues: 1. underline new text in 8,1 2. tab in 5 3. No 16.4.6 4. miscellaneous other imperfections --- src/general.tex | 3 + src/srHP.tex | 525 ---------------------------------------------- src/srgeneral.tex | 298 +++++++++++++++++++++++++- src/srrcu.tex | 354 ------------------------------- 4 files changed, 299 insertions(+), 881 deletions(-) delete mode 100644 src/srHP.tex delete mode 100644 src/srrcu.tex diff --git a/src/general.tex b/src/general.tex index a16d6c0..81f15a9 100644 --- a/src/general.tex +++ b/src/general.tex @@ -31,6 +31,9 @@ \pnum Unless otherwise specified, the whole of the C++ Standard's Library introduction (\CppXref{16}) is included into this Technical Specification by reference. +\pnum +Unless otherwise specified, these wording changes applies P2066R10 relative to the current C++ Working Draft,N4849. + \rSec0[defs]{Terms and definitions} \pnum diff --git a/src/srHP.tex b/src/srHP.tex deleted file mode 100644 index ae593ae..0000000 --- a/src/srHP.tex +++ /dev/null @@ -1,525 +0,0 @@ -%!TEX root = ts.tex - -\rSec1[saferecl.hp]{Hazard pointers} - -\rSec2[saferecl.hp.general]{General} - -\pnum -A hazard pointer is a single-writer multi-reader pointer that can be owned by at most one thread at any time. Only the owner of the hazard pointer can set its value, while any number of threads may read its value. The owner thread sets the value of a hazard pointer to point to an object in order to indicate to concurrent threads\textemdash that may delete such an object\textemdash that the object is not yet safe to delete. - -\pnum -A class type \tcode{T} is \defn{hazard-protectable} if it has exactly one public base class of type \tcode{hazard_pointer_obj_base} for some \tcode{D} and no base classes of type \tcode{hazard_pointer_obj_base} for any other combination \tcode{T’}, \tcode{D’}. An object is \defn{hazard-protectable} if it is of hazard-protectable type. - -\pnum -The span between creation and destruction of a hazard pointer $h$ is partitioned into a series of \defn{protection epochs}; in each protection epoch, $h$ either is \defn{associated with} a hazard-protectable object, or is \defn{unassociated}. Upon creation, a hazard pointer is unassociated. Changing the association (possibly to the same object) initiates a new protection epoch and ends the preceding one. - -\pnum -A hazard pointer \defn{belongs to} exactly one \defn{domain}. - -\pnum -An object of type \tcode{hazard_pointer} is either empty or \defn{owns} a hazard pointer. Each hazard pointer is owned by exactly one object of type \tcode{hazard_pointer}. \begin{note} An empty \tcode{hazard_pointer} object is different from a \tcode{hazard_pointer} object that owns an unassociated hazard pointer. An empty \tcode{hazard_pointer} object does not own any hazard pointers. \end{note} - -\pnum -An object \tcode{x} of hazard-protectable type \tcode{T} is \defn{retired} to a domain with a deleter of type \tcode{D} when the member function \tcode{hazard_pointer_obj_base::retire} is invoked on \tcode{x}. Any given object \tcode{x} shall be retired at most once. - -\pnum -A retired object \tcode{x} is \defn{reclaimed} by invoking its deleter with a pointer to \tcode{x}. - -\pnum -A hazard-protectable object \tcode{x} is \defn{definitely reclaimable} in a domain $dom$ with respect to -an evaluation $A$ if: - -\begin{itemize} -\item \tcode{x} is not reclaimed, and -\item \tcode{x} is retired to $dom$ in an evaluation that happens before $A$, and -\item for all hazard pointers $h$ that belong to $dom$, the end of any protection epoch where $h$ is associated with \tcode{x} happens before $A$. -\end{itemize} - -\pnum -A hazard-protectable object \tcode{x} is \defn{possibly reclaimable} in domain $dom$ with respect to an -evaluation $A$ if: -\begin{itemize} -\item \tcode{x} is not reclaimed; and -\item \tcode{x} is retired to $dom$ in an evaluation $R$ and $A$ does not happen before $R$; and -\item for all hazard pointers $h$ that belong to $dom$, $A$ does not happen before the end of -any protection epoch where $h$ is associated with \tcode{x}; and -\item for all hazard pointers $h$ belonging to $dom$ and for every protection epoch $E$ of $h$ -during which $h$ is associated with \tcode{x}: -\begin{itemize} - \item $A$ does not happen before the end of $E$, and - \item if the beginning of $E$ happens before \tcode{x} is retired, the end of $E$ strongly -happens before $A$, and - \item if $E$ began by an evaluation of \tcode{try_protect} with argument \tcode{src}, label its -atomic load operation $L$. If there exists an atomic modification $B$ on \tcode{src} such that $L$ observes a modification that is modification-ordered before $B$, and $B$ happens before \tcode{x} is retired, the end of $E$ strongly happens before $A$. \begin{note} In typical use, a store to \tcode{src} sequenced before retiring \tcode{x} will be such an atomic operation $B$. \end{note} -\end{itemize} -\begin{note} The latter two conditions convey the informal notion that a protection epoch that began before retiring \tcode{x}, as implied either by the happens-before relation or the coherence order of some source, delays the reclamation of \tcode{x}. \end{note} -\end{itemize} - -\begin{example} The following example shows how hazard pointers allow updates to be carried out in the presence of concurrent readers. The object of type \tcode{hazard_pointer} in \tcode{print_name} protects the object \tcode{*ptr} from being reclaimed by \tcode{ptr->retire} until the end of the protection epoch. - -\begin{codeblock} -struct Name : public hazard_pointer_obj_base { /* details */ }; -atomic name; - -// called often and in parallel! -void print_name() { - hazard_pointer h = make_hazard_pointer(); - Name* ptr = h.protect(name); /* Protection epoch starts */ - /* ... safe to access *ptr ... */ -} /* Protection epoch ends. */ - -// called rarely, but possibly concurrently with print_name -void update_name(Name* new_name) { - Name* ptr = name.exchange(new_name); - ptr->retire(); -} -\end{codeblock} -\end{example} - -\rSec2[saferecl.hp.syn]{Header \tcode{} synopsis} - -\begin{codeblock} -namespace std::experimental::inline concurrency_v2 { - // \ref{saferecl.hp.domain}, class \tcode{hazard_pointer_domain} - class hazard_pointer_domain; - - // \ref{saferecl.hp.domain.default}, Default \tcode{hazard_pointer_domain} - hazard_pointer_domain& hazard_pointer_default_domain() noexcept; - - // \ref{saferecl.hp.cleanup}, Clean up - void hazard_pointer_clean_up(hazard_pointer_domain& domain = hazard_pointer_default_domain()) - noexcept; - - // \ref{saferecl.hp.base}, class template \tcode{hazard_pointer_obj_base} - template > class hazard_pointer_obj_base; - - // \ref{saferecl.hp.holder}, class \tcode{hazard_pointer} - class hazard_pointer; - - // \ref{saferecl.hp.make}, Construct non-empty \tcode{hazard_pointer} - hazard_pointer make_hazard_pointer( - hazard_pointer_domain& domain = hazard_pointer_default_domain()); - - // \ref{saferecl.hp.special}, Hazard pointer swap - void swap(hazard_pointer&, hazard_pointer&) noexcept; -} -\end{codeblock} - -\rSec2[saferecl.hp.domain]{Class \tcode{hazard_pointer_domain}} - -\rSec3[saferecl.hp.domain.general]{General} - -\pnum -The number of unreclaimed possibly-reclaimable objects retired to a domain is bounded. -The bound is implementation-defined. \begin{note} The bound can be independent of other -domains and can be a function of the number of hazard pointers belonging to the -domain, the number of threads that retire objects to the domain, and the number of -threads that use hazard pointers belonging to the domain. \end{note} - -\pnum -Concurrent access to a domain does not incur a data race (\CppXref{6.9.2.1}). - -\begin{codeblock} -class hazard_pointer_domain { -public: - hazard_pointer_domain() noexcept; - explicit hazard_pointer_domain(pmr::polymorphic_allocator poly_alloc) noexcept; - - hazard_pointer_domain(const hazard_pointer_domain&) = delete; - hazard_pointer_domain& operator=(const hazard_pointer_domain&) = delete; - - ~hazard_pointer_domain(); -}; -\end{codeblock} - -\rSec3[saferecl.hp.domain.mem]{Member functions} - -\begin{itemdecl} -hazard_pointer_domain() noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\effects -Equivalent to \tcode{hazard_pointer_domain(\{\})}. - -\end{itemdescr} - -\begin{itemdecl} -explicit hazard_pointer_domain(pmr::polymorphic_allocator poly_alloc) noexcept;} -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\remarks -All allocation and deallocation related to hazard pointers belonging to this -domain use a copy of \tcode{poly_alloc}. - -\end{itemdescr} - -\begin{itemdecl} -~hazard_pointer_domain(); -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\expects -All hazard pointers belonging to \tcode{*this} have been destroyed. - -\pnum -\effects -Reclaims all objects retired to this domain that have not yet been reclaimed. - -\end{itemdescr} - -\rSec2[saferecl.hp.domain.default]{Default \tcode{hazard_pointer_domain}} - -\begin{itemdecl} -hazard_pointer_domain& hazard_pointer_default_domain() noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\returns -A reference to the default \tcode{hazard_pointer_domain}. - -\pnum -\remarks -The default domain has an unspecified allocator and has static storage -duration. The initialization of the default domain strongly happens before this function -returns; the sequencing is otherwise unspecified. - -\end{itemdescr} - -\rSec2[saferecl.hp.cleanup]{Clean up} - -\begin{itemdecl} -void hazard_pointer_clean_up(hazard_pointer_domain& domain = hazard_pointer_default_domain()) - noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\effects -May reclaim possibly-reclaimable objects retired to \tcode{domain}. - -\pnum -\ensures -All definitely-reclaimable objects retired to \tcode{domain} have been reclaimed. - -\pnum -\sync -The completion of the deleter for each reclaimed object synchronizes with the return from this function call. - -\end{itemdescr} - -\rSec2[saferecl.hp.base]{Class template \tcode{hazard_pointer_obj_base}} - -\begin{codeblock} -template > -class hazard_pointer_obj_base { -public: - void retire( - D d = D(), - hazard_pointer_domain& domain = hazard_pointer_default_domain()) noexcept; - void retire(hazard_pointer_domain& domain) noexcept; -protected: - hazard_pointer_obj_base() = default; -private: - D @\exposid{deleter}@; // exposition only -}; -\end{codeblock} - -\pnum -A client-supplied template argument \tcode{D} shall be a function object type (\CppXref{20.14}) -for which, given a value \tcode{d} of type \tcode{D} and a value \tcode{ptr} of type \tcode{T*}, the expression \tcode{d(ptr)} is valid and has the effect of disposing of the pointer as appropriate for that deleter. - -\pnum -The behavior of a program that adds specializations for \tcode{hazard_pointer_obj_base} is undefined. - -\pnum -\tcode{D} shall meet the requirements for \oldconcept{DefaultConstructible} and \oldconcept{MoveAssignable}. - -\pnum -\tcode{T} may be an incomplete type. - -\begin{itemdecl} -void retire(D d = D(), hazard_pointer_domain& domain = hazard_pointer_default_domain()) noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\mandates -\tcode{T} is a hazard-protectable type. - -\pnum -\expects -\tcode{*this} is a base class subobject of an object \tcode{x} of type \tcode{T}. \tcode{x} is not retired. -Move-assigning \tcode{D} from \tcode{d} does not throw an exception. The expression \tcode{d(addressof(x))} has well-defined behavior and does not throw an exception. - -\pnum -\effects -Move-assigns \tcode{d} to \exposid{deleter}, thereby setting it as the deleter of \tcode{x}, then retires \tcode{x} -to \tcode{domain}. - -\pnum -Invoking the retire function may reclaim possibly-reclaimable objects retired to \tcode{domain}. - -\end{itemdescr} - -\begin{itemdecl} -void retire(hazard_pointer_domain& domain) noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\effects -Equivalent to \tcode{retire(D(), domain)}. - -\end{itemdescr} - -\rSec2[saferecl.hp.holder]{Class \tcode{hazard_pointer}} - -\rSec3[saferecl.hp.holder.syn]{Synopsis} - -\begin{codeblock} -class hazard_pointer { -public: - hazard_pointer() noexcept; - hazard_pointer(hazard_pointer&&) noexcept; - hazard_pointer& operator=(hazard_pointer&&) noexcept; - ~hazard_pointer(); - - [[nodiscard]] bool empty() const noexcept; - template T* protect(const atomic& src) noexcept; - template bool try_protect(T*& ptr, const atomic& src) noexcept; - template void reset_protection(const T* ptr) noexcept; - void reset_protection(nullptr_t = nullptr) noexcept; - void swap(hazard_pointer&) noexcept; -}; -\end{codeblock} - -\rSec3[saferecl.hp.holder.ctor]{Constructors} - -\begin{itemdecl} -hazard_pointer() noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\ensures -\tcode{*this} is empty. - -\end{itemdescr} - -\begin{itemdecl} -hazard_pointer(hazard_pointer&& other) noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\ensures -If \tcode{other} is empty, \tcode{*this} is empty. Otherwise, \tcode{*this} owns the hazard pointer originally owned by \tcode{other}; \tcode{other} is empty. - -\end{itemdescr} - -\rSec3[saferecl.hp.holder.dtor]{Destructor} - -\begin{itemdecl} -~hazard_pointer(); -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\effects -If \tcode{*this} is not empty, destroys the hazard pointer owned by \tcode{*this}, thereby ending its current protection epoch. - -\end{itemdescr} - -\rSec3[saferecl.hp.holder.assign]{Assignment} - -\begin{itemdecl} -hazard_pointer& operator=(hazard_pointer&& other) noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\effects -If \tcode{this == \&other} is true, no effect. Otherwise, if \tcode{*this} is not empty, destroys -the hazard pointer owned by \tcode{*this}, thereby ending its current protection epoch. - -\pnum -\ensures -If \tcode{other} was empty, \tcode{*this} is empty. Otherwise, \tcode{*this} owns the hazard -pointer originally owned by other. If \tcode{this != \&other} is true, \tcode{other} is empty. - -\pnum -\returns -\tcode{*this}. - -\end{itemdescr} - -\rSec3[saferecl.hp.holder.mem]{Member functions} - -\begin{itemdecl} -[[nodiscard]] bool empty() const noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\returns -\tcode{true} if and only if \tcode{*this} is empty. - -\end{itemdescr} - - -\begin{itemdecl} -template T* protect(const atomic& src) noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\effects -Equivalent to -\begin{codeblock} -T* ptr = src.load(memory_order_relaxed); -while (!try_protect(ptr, src)) {} -return ptr; -\end{codeblock} - -\end{itemdescr} - -\begin{itemdecl} -template bool try_protect(T*& ptr, const atomic& src) noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\mandates -\tcode{T} is a hazard-protectable type. - -\pnum -\expects -\tcode{*this} is not empty. - -\pnum -\effects -\begin{itemize} -\item Initializes a variable \tcode{old} of type \tcode{T*} with the value of \tcode{ptr}. -\item Evaluates the function call \tcode{reset_protection(old)}. -\item Assigns the value of \tcode{src.load(std::memory_order_acquire)} to \tcode{ptr}. -\item If \tcode{old == ptr} is false, evaluates the function call \tcode{reset_protection()}. -\end{itemize} - -\pnum -\returns -\tcode{old == ptr}. \begin{note} It is possible for \tcode{try_protect} to return \tcode{true} when \tcode{ptr} is a null pointer. \end{note} - -\pnum -\complexity -Constant. - -\end{itemdescr} - -\begin{itemdecl} -template void reset_protection(const T* ptr) noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\mandates -\tcode{T} is a hazard-protectable type. - -\pnum -\defn{Preconditions}: -\tcode{*this} is not empty. - -\pnum -\effects -If \tcode{ptr} is a null pointer value, invokes \tcode{reset_protection()}. Otherwise, associates the hazard pointer owned by \tcode{*this} with \tcode{*ptr}, thereby ending the current protection epoch. - -\end{itemdescr} - -\begin{itemdecl} -void reset_protection(nullptr_t = nullptr) noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\expects -\tcode{*this} is not empty. - -\pnum -\ensures -The hazard pointer owned by \tcode{*this} is unassociated. - -\end{itemdescr} - -\begin{itemdecl} -void swap(hazard_pointer& other) noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\effects -Swaps the hazard pointer ownership of this object with that of other. \begin{note} The owned hazard pointers, if any, remain unchanged during the swap and continue to be associated with the respective objects that they were protecting before the swap, if any. No protection epochs are ended or initiated. \end{note} - -\pnum -\complexity -Constant. - -\end{itemdescr} - -\rSec2[saferecl.hp.make]{\tcode{make_hazard_pointer}} - -\begin{itemdecl} -hazard_pointer make_hazard_pointer( - hazard_pointer_domain& domain = hazard_pointer_default_domain()); -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\effects -Constructs a hazard pointer belonging to \tcode{domain}. - -\pnum -\returns -A \tcode{hazard_pointer} object that owns the newly-constructed hazard pointer. - -\pnum -\throws -Any exception thrown by the allocator of \tcode{domain}. - -\end{itemdescr} - -\rSec2[saferecl.hp.special]{\tcode{hazard_pointer} specialized algorithms} - -\begin{itemdecl} -void swap(hazard_pointer& a, hazard_pointer& b) noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\effects -Equivalent to \tcode{a.swap(b)}. - -\end{itemdescr} diff --git a/src/srgeneral.tex b/src/srgeneral.tex index c7e4453..4528758 100644 --- a/src/srgeneral.tex +++ b/src/srgeneral.tex @@ -1,15 +1,309 @@ %!TEX root = ts.tex - +\setcounter{section}{9} \rSec0[lex]{Lexical conventions} -\setcounter{section}{9} + \rSec1[lex.name]{Identifiers} \pnum In 5.10 {[}lex.name{]}, add \uline{\texttt{atomic}} to table 4 {[}tab:lex.name.special{]}. +\rSec0[basic]{Basics} +\rSec1[basic.exec]{Program execution} +\rSec2[intro.execution]{Sequential execution} + +\pnum +Change in 6.9.1 {[}intro.execution{]} paragraph 5: + +\begin{quote} +A \emph{full-expression} is + +\begin{itemize} +\tightlist +\item + ... +\item + an invocation of a destructor generated at the end of the lifetime of + an object other than a temporary object (6.7.7) whose lifetime has not + been extended, \sout{or} +\item + \uline{the start and the end of an atomic block (8.8 {[}stmt.tx{]}), + or} +\item + an expression that is not a subexpression of another expression and + that is not otherwise part of a full-expression. +\end{itemize} +\end{quote} + +\rSec2[intro.multithread]{Multi-threaded executions and data races} +\rSec3[intro.races]{Data races} +\pnum +Change in 6.9.2.1 {[}intro.races{]} paragraph 6: + +\begin{quote} +\uline{Atomic blocks as well as} \sout{Certain} \uline{certain} library +calls \uline{may} \emph{synchronize with} other \uline{atomic blocks +and} library calls performed by another thread. +\end{quote} + +\pnum +Add a new paragraph after 6.9.2.1 {[}intro.races{]} paragraph 20: + +\begin{quote} +An atomic block that is not dynamically nested within another atomic +block is termed a transaction. {[}Note: Due to syntactic constraints, +blocks cannot overlap unless one is nested within the other.{]} There is +a global total order of execution for all transactions. If, in that +total order, a transaction T1 is ordered before a transaction T2, then + +\begin{itemize} +\tightlist +\item + no evaluation in T2 happens before any evaluation in T1 and +\item + if T1 and T2 perform conflicting expression evaluations, then the end + of T1 synchronizes with the start of T2. +\end{itemize} + +{[} Note: If the evaluations in T1 and T2 do not conflict, they might be +executed concurrently. -\/- end note {]} +\end{quote} + +\begin{quote} +Two actions are \emph{potentially concurrent} if ... +\end{quote} + +\pnum +Change in 6.9.2.1 {[}intro.races{]} paragraph 21: + +\begin{quote} +... {[}Note: It can be shown that programs that correctly use +mutexes\uline{, atomic blocks,} and \texttt{memory\_order::seq\_cst} +operations to prevent all data races and use no other synchronization +operations behave as if the operations executed by their constituent +threads were simply interleaved, with each value computation of an +object being taken from the last side effect on that object in that +interleaving. This is normally referred to as "sequential consistency". +... +\end{quote} + +\pnum +Add a new paragraph after 6.9.2.1 {[}intro.races{]} paragraph 21: + +\begin{quote} +{[} Note: The following holds for a data-race-free program: If the start +of an atomic block T is sequenced before an evaluation A, A is sequenced +before the end of T, A strongly happens before some evaluation B, and B +is not sequenced before the end of T, then the end of T strongly happens +before B. If an evaluation C strongly happens before that evaluation A +and C is not sequenced after the start of T, then C strongly happens +before the start of T. These properties in turn imply that in any simple +interleaved (sequentially consistent) execution, the operations of each +atomic block appear to be contiguous in the interleaving. -\/- end note +{]} +\end{quote} + +\rSec3[intro.progress]{Forward progress} + +\pnum +Change in 6.9.2.2 {[}intro.progress{]} paragraph 1: + +\begin{quote} +\sout{The implementation may assume that any thread will eventually do} +\uline{An \emph{inter-thread side effect} is} one of the following: + +\begin{itemize} +\tightlist +\item + \sout{terminate,} +\item + a call to a library I/O function, +\item + an access through a volatile glvalue, or +\item + a synchronization operation or an atomic operation + \uline{({[}atomics{]})}. +\end{itemize} + +\uline{The implementation may assume that any thread will eventually +terminate or evaluate an inter-thread side effect.} {[}Note: This is +intended to allow compiler transformations such as removal of empty +loops, even when termination cannot be proven. --- end note{]} +\end{quote} + +\rSec0[stmt.stmt]{Statements} +\rSec1[stmt.pre]{Preamble} +\pnum +Add a production to the grammar in 8.1 {[}expr.pre{]}: + +\begin{quote} +\begin{verbatim} +statement: + labeled-statement + attribute-specifier-seqopt expression-statement + attribute-specifier-seqopt compound-statement + attribute-specifier-seqopt selection-statement + attribute-specifier-seqopt iteration-statement + attribute-specifier-seqopt jump-statement + declaration-statement + attribute-specifier-seqopt try-block + \uline{atomic-statement} +\end{verbatim} +\end{quote} + +\rSec1[stmt.dcl]{Declaration statement} + +\pnum +Add a new subclause before 8.8 {[}stmt.dcl{]}: + +\begin{quote} +\textbf{8.8 Atomic statement {[}stmt.tx{]}} + +\begin{verbatim} +atomic-statement: + atomic do compound-statement +\end{verbatim} + +An \emph{atomic-statement} is also called an \emph{atomic block}. + +The start of the atomic block is immediately before the opening +\texttt{\{} of the \emph{compound-statement}. The end of the atomic +block is immediately after the closing \texttt{\}} of the +\emph{compound-statement}. {[} Note: Thus, variables with automatic +storage duration declared in the \emph{compound-statement} are destroyed +prior to reaching the end of the atomic block; see 8.7 {[}stmt.jump{]}. +-\/- end note {]} + +A goto or switch statement shall not be used to transfer control into an +atomic block. + +If the execution of an atomic block evaluates an inter-thread side +effect (6.9.2.2 {[}intro.progress{]}) or if an atomic block is exited +via an exception, the behavior is undefined. + +\emph{Recommended practice:} In case an atomic block is exited via an +exception, the program should be terminated without invoking a terminate +handler (17.9.5 {[}exception.terminate{]}) or destroying any objects +with static or thread storage duration (6.9.3.4 {[}basic.start.term{]}). + +If the execution of an atomic block evaluates any of the following +outside of a manifestly constant-evaluated context (7.7 +{[}expr.const{]}), the behavior is implementation-defined: + +\begin{itemize} +\tightlist +\item + an \emph{asm-declaration} (9.10 {[}dcl.asm{]}); +\item + an invocation of a function \textbf{other than one of the standard + library functions specified in (16.4.6.17 {[}atomic.use{]}), unless + the function is inline} with a reachable definition; +\item + a virtual function call (7.6.1.3 {[}expr.call{]}); +\item + a function call, \textbf{unless overload resolution selects} + + \begin{itemize} + \tightlist + \item + \textbf{a named function (12.2.2.2.2 {[}over.call.func{]}) or} + \item + \textbf{a function call operator (12.2.2.2.3 + {[}over.call.object{]}), but not a surrogate call function;} + \end{itemize} +\item + a \texttt{co\_await} expression (7.6.2.3 {[}expr.await{]}), a + \emph{yield-expression} (7.6.17 {[}expr.yield{]}), or a + \texttt{co\_return} statement (8.7.4 {[}stmt.return.coroutine{]}); +\item + dynamic initialization of a block-scope variable with static storage + duration; or +\item + dynamic initialization of a variable with thread storage duration. +\end{itemize} + +{[} Note: The implementation \textbf{can} define that the behavior is +undefined in some or all of the cases above. {]} + +{[} Example: + +\begin{verbatim} +unsigned int f() +{ + static unsigned int i = 0; + atomic do { + ++i; + return i; + } +} +\end{verbatim} + +Each invocation of f (even when called from several threads +simultaneously) retrieves a unique value (ignoring +\textbf{wrap-around}). -\/- end example {]} + +{[} Note: Atomic blocks are likely to perform best where they execute +quickly and touch little data. -\/- end note {]} +\end{quote} + +\rSec1[library]{Library introduction} +\rSec2[description]{Method of description} +%\rsec2[description]{Method of description} + +\pnum +Add 16.4.6.17 {[}atomic.use{]}: +\begin{quote} +\hypertarget{functions-usable-in-an-atomic-block-atomic.use}{% +\subsection{16.4.6.17 Functions usable in an atomic block +{[}atomic.use{]}}\label{functions-usable-in-an-atomic-block-atomic.use}} +All library functions may be used in an atomic block (8.8 +{[}stmt.tx{]}), except +\begin{itemize} +\tightlist +\item + \textbf{error category objects ({[}syserr.errcat.objects{]})} +\item + time zone database ({[}time.zone.db{]}) +\item + clocks ({[}time.clock{]}) +\item + \texttt{signal} ({[}support.signal{]}) \textbf{and \texttt{raise} + ({[}csignal.syn{]})} +\item + \texttt{set\_new\_handler}, \texttt{set\_terminate}, + \texttt{get\_new\_handler}, \texttt{get\_terminate} + ({[}handler.functions{]}, {[}alloc.errors{]}, {[}exception.syn{]}) +\item + \textbf{\texttt{system} ({[}cstdlib.syn{]})} +\item + \textbf{startup and termination {[}support.start.term{]} except + \texttt{abort}} +\item + \texttt{shared\_ptr} ({[}util.smartptr.shared{]}) and + \texttt{weak\_ptr} ({[}util.smartptr.weak{]}) +\item + \texttt{synchronized\_pool\_resource} ({[}mem.res.pool{]}) +\item + \textbf{program-wide \texttt{memory\_resource} objects + ({[}mem.res.global{]})} +\item + \texttt{setjmp} / \texttt{longjmp} ({[}csetjmp.syn{]}) +\item + \textbf{parallel algorithms ({[}algorithms.parallel{]})} +\item + \textbf{\texttt{random\_device} ({[}rand.device{]})} +\item + \texttt{locale} construction ({[}locale.cons{]}) +\item + input/output ({[}input.output{]}) +\item + atomic operations ({[}atomics{]}) +\item + thread support ({[}thread{]}) +\end{itemize} +\end{quote} diff --git a/src/srrcu.tex b/src/srrcu.tex deleted file mode 100644 index 165d58b..0000000 --- a/src/srrcu.tex +++ /dev/null @@ -1,354 +0,0 @@ -%!TEX root = ts.tex - -\rSec1[saferecl.rcu]{Read-copy update (RCU)} - -\rSec2[saferecl.rcu.general]{General} - -\pnum -RCU is a synchronization mechanism that can be used for linked data -structures that are frequently read, but seldom updated. RCU does -not provide mutual exclusion, but instead allows the user to schedule -specified actions such as deletion at some later time. - -\pnum -A class type \tcode{T} is \defn{rcu-protectable} if it has exactly one -public base class of type \tcode{rcu_obj_base} for some \tcode{D} -and no base classes of type \tcode{rcu_obj_base} for any other -combination \tcode{X}, \tcode{Y}. An object is rcu-protectable if it is -of rcu-protectable type. - -\pnum -An invocation of \tcode{unlock} $U$ on an \tcode{rcu_domain dom} corresponds -to an invocation of \tcode{lock} $L$ on \tcode{dom} if $L$ is -sequenced before $U$ and either - -\begin{itemize} -\item no other invocation of \tcode{lock} on \tcode{dom} is sequenced - after $L$ and before $U$ or -\item every invocation of \tcode{unlock} $U'$ on \tcode{dom} such - that $L$ is sequenced before $U'$ and $U'$ - is sequenced before $U$ corresponds to an invocation of - \tcode{lock} $L'$ on \tcode{dom} such that $L$ is sequenced - before $L'$ and $L'$ is sequenced before $U'$. -\end{itemize} -\begin{note} -This pairs nested locks and unlocks on a given domain in each thread. -\end{note} - -\pnum -A \defn{region of RCU protection} on a domain \tcode{dom} starts -with a \tcode{lock} $L$ on \tcode{dom} and ends with its corresponding -\tcode{unlock} $U$. - -\pnum -Given a region of RCU protection $R$ on a domain \tcode{dom} -and given an evaluation $E$ that scheduled another evaluation -$F$ in \tcode{dom}, if $E$ does not strongly happen before -the start of $R$, the end of $R$ strongly happens before -evaluating $F$. - -\pnum -The evaluation of a scheduled evaluation is potentially concurrent with -any other such evaluation. Each scheduled evaluation is evaluated at -most once. - -\rSec2[saferecl.rcu.syn]{Header \tcode{} synopsis} - -% \indexheader{rcu} -\begin{codeblock} -namespace std::experimental::inline concurrency_v2 { - // \ref{saferecl.rcu.base}, class template \tcode{rcu_obj_base} - template> - class rcu_obj_base; - - // \ref{saferecl.rcu.domain}, class \tcode{rcu_domain} - class rcu_domain; - - // \ref{saferecl.rcu.default.domain}, \tcode{rcu_default_domain} - rcu_domain& rcu_default_domain() noexcept; - - // \ref{saferecl.rcu.synchronize}, \tcode{rcu_synchronize} - void rcu_synchronize(rcu_domain& dom = rcu_default_domain()) noexcept; - - // \ref{saferecl.rcu.barrier}, \tcode{rcu_barrier} - void rcu_barrier(rcu_domain& dom = rcu_default_domain()) noexcept; - - // \ref{saferecl.rcu.retire}, \tcode{rcu_retire} - template> - void rcu_retire(T* p, D d = D(), rcu_domain& dom = rcu_default_domain()); -} -\end{codeblock} - -\rSec2[saferecl.rcu.base]{Class \tcode{rcu_obj_base}} - -% @@@ Added missing "of" in following sentence. - -Objects of type \tcode{T} to be protected by RCU inherit from a -specialization of \tcode{rcu_obj_base}. - -% @@@ Removed obsolete in-code reference to the now-nonexistent -% @@@ separate section for rcu_obj_base::retire. - -\begin{codeblock} -template> -class rcu_obj_base { -public: - void retire(D d = D(), rcu_domain& dom = rcu_default_domain()) noexcept; -protected: - rcu_obj_base() = default; -private: - D @\exposid{deleter}@; // exposition only -}; -\end{codeblock} - -\pnum -A client-supplied template argument \tcode{D} shall be a -function object type \CppXref{20.14} for which, -given a value \tcode{d} of type \tcode{D} and a value \tcode{ptr} -of type \tcode{T*}, the expression \tcode{d(ptr)} is valid and -has the effect of disposing of the pointer as appropriate for -that deleter. - -\pnum -The behavior of a program that adds specializations for -\tcode{rcu_obj_base} is undefined. - -\pnum -\tcode{D} shall meet the requirements for -\oldconcept{DefaultConstructible} and \oldconcept{MoveAssignable}. - -\pnum -\tcode{T} may be an incomplete type. - -\pnum -If \tcode{D} is trivially copyable, all specializations of -\tcode{rcu_obj_base} are trivially copyable. - -\begin{itemdecl} -void retire(D d = D(), rcu_domain& dom = rcu_default_domain()) noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\mandates -\tcode{T} is an rcu-protectable type. - -\pnum -\expects -\tcode{*this} is a base class subobject of -an object \tcode{x} of type \tcode{T}. The member function -\tcode{rcu_obj_base::retire} was not invoked on \tcode{x} -before. The assignment to \exposid{deleter} does not throw an -exception. The expression \tcode{\exposid{deleter}(addressof(x))} has -well-defined behavior and does not throw an exception. - -\pnum -\effects -Evaluates \tcode{\exposid{deleter} = std::move(d)} and schedules -the evaluation of the expression \tcode{de\-let\-er(ad\-dress\-of(x))} in the domain \tcode{dom}. - -\pnum -\remarks -It is implementation-defined whether or not scheduled -evaluations in \tcode{dom} can be invoked by the \tcode{retire} -function. -\begin{note} -If such evaluations acquire resources held across any invocation of -retire on \tcode{dom}, deadlock can occur. -\end{note} - -\end{itemdescr} - -\rSec2[saferecl.rcu.domain]{Class \tcode{rcu_domain}} - -% @@@ Removed the obsolete reference comments. - -This class meets the requirements of \oldconcept{BasicLockable} \CppXref{32.2.5.2} and provides regions of RCU protection. - -\begin{example} -\begin{codeblock} -std::scoped_lock rlock(rcu_default_domain()); -\end{codeblock} -\end{example} - -\begin{codeblock} -class rcu_domain { -public: - rcu_domain(const rcu_domain&) = delete; - rcu_domain& operator=(const rcu_domain&) = delete; - - void lock() noexcept; - void unlock() noexcept; -}; -\end{codeblock} - -The functions \tcode{lock} and \tcode{unlock} establish (possibly nested) -regions of RCU protection. - -\rSec3[saferecl.rcu.domain.lock]{\tcode{rcu_domain::lock}} - -\begin{itemdecl} -void lock() noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\effects -Opens a region of RCU protection. - -\pnum -\remarks -Calls to the function lock do not introduce a data race -(\CppXref{6.9.2.1}) involving \tcode{*this}. - -\end{itemdescr} - -\rSec3[saferecl.rcu.domain.unlock]{\tcode{rcu_domain::unlock}} - -\begin{itemdecl} -void unlock() noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\expects -A call to the function \tcode{lock} that opened -an unclosed region of RCU protection is sequenced before the -call to \tcode{unlock}. - -\pnum -\effects -Closes the unclosed region of RCU protection that was -most recently opened. - -\pnum -\remarks -It is implementation-defined whether or not scheduled -evaluations in \tcode{*this} can be invoked by the \tcode{unlock} -function. -\begin{note} -If such evaluations acquire resources held across any invocation -of \tcode{unlock} on \tcode{*this}, deadlock can occur. -\end{note} -Calls to the function \tcode{unlock} do not introduce a data race -involving \tcode{*this}. -\begin{note} -Evaluation of scheduled evaluations can still cause a data race. -\end{note} - -\end{itemdescr} - -\rSec2[saferecl.rcu.default.domain]{\tcode{rcu_default_domain}} - -\begin{itemdecl} -rcu_domain& rcu_default_domain() noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\returns -A reference to the default object of type \tcode{rcu_domain}. -A reference to the same object is returned every time this -function is called. - -\end{itemdescr} - -\rSec2[saferecl.rcu.synchronize]{\tcode{rcu_synchronize}} - -\begin{itemdecl} -void rcu_synchronize(rcu_domain& dom = rcu_default_domain()) noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\effects -If the call to \tcode{rcu_synchronize} does not strongly -happen before the lock opening an RCU protection region \tcode{R} -on \tcode{dom}, blocks until the \tcode{unlock} closing \tcode{R} -happens. - -\pnum -\sync -The \tcode{unlock} closing \tcode{R} strongly -happens before the return from \tcode{rcu_synchronize}. - -\end{itemdescr} - -\rSec2[saferecl.rcu.barrier]{\tcode{rcu_barrier}} - -\begin{itemdecl} -void rcu_barrier(rcu_domain& dom = rcu_default_domain()) noexcept; -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\effects -May evaluate any scheduled evaluations in -\tcode{dom}. For any evaluation that happens before the call -to \tcode{rcu_barrier} and that schedules an evaluation $E$ -in \tcode{dom}, blocks until $E$ has been evaluated. - -\pnum -\sync -The evaluation of any such $E$ strongly -happens before the return from \tcode{rcu_barrier}. - -\end{itemdescr} - -\rSec2[saferecl.rcu.retire]{Template \tcode{rcu_retire}} - -\begin{itemdecl} -template> -void rcu_retire(T* p, D d = D(), rcu_domain& dom = rcu_default_domain()); -\end{itemdecl} - -\begin{itemdescr} - -\pnum -\mandates -\tcode{is_move_constructible_v} is true. - -\pnum -\expects -\tcode{D} meets the \oldconcept{MoveConstructible} and -\oldconcept{Destructible} requirements. -The expression \tcode{d1(p)}, where \tcode{d1} is defined below, is -well-formed and its evaluation does not exit via an exception. - -\pnum -\effects -May allocate memory. -It is unspecified whether the memory allocation is performed by -invoking \tcode{operator} \tcode{new}. -Initializes an object \tcode{d1} of type \tcode{D} from -\tcode{std::move(d)}. -Schedules the evaluation of \tcode{d1(p)} in the domain -\tcode{dom}. -\begin{note} -If \tcode{rcu_retire} exits via an exception, no evaluation -is scheduled. -\end{note} - -\pnum -\throws -Any exception that would be caught by a handler of type -\tcode{bad_alloc}. -Any exception thrown by the initialization of \tcode{d1}. - -\pnum -\remarks -It is implementation-defined whether or not scheduled -evaluations in dom can be invoked by the \tcode{rcu_retire} -function. -\begin{note} -If such evaluations acquire resources held across any invocation -of \tcode{rcu_retire} on \tcode{dom}, deadlock can occur. -\end{note} - -\end{itemdescr} From 0b33c5cfa88b1f720b1b55df99faa9c1d7379ffd Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Sun, 9 Jan 2022 12:29:25 -0700 Subject: [PATCH 08/40] update file to tm.tex --- src/{srgeneral.tex => tm.tex} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename src/{srgeneral.tex => tm.tex} (100%) diff --git a/src/srgeneral.tex b/src/tm.tex similarity index 100% rename from src/srgeneral.tex rename to src/tm.tex From f261a120388738c8261582422cbd377c206d7154 Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Sun, 9 Jan 2022 12:34:59 -0700 Subject: [PATCH 09/40] update attribution to Oct 2021 plenary and tm file --- README.md | 2 +- src/ts.tex | 4 +--- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 5fd4205..bd8107e 100644 --- a/README.md +++ b/README.md @@ -11,7 +11,7 @@ will generate a PDF. Nxxxx is the proposed working draft of Concurrency TS Version 2. It contains changes to the TM TS2021 as directed by the committee at the June 2021 virtual plenary meeting, and editorial changes. -N4895 contains P2066R9 from Oct 2021 virtual plenary. +N4895 contains P2066R10 from Oct 2021 virtual plenary. \textbf{Technical Changes} None diff --git a/src/ts.tex b/src/ts.tex index 0180829..4921857 100644 --- a/src/ts.tex +++ b/src/ts.tex @@ -116,9 +116,7 @@ \include{general} %%\include{modifications} -\include{srgeneral} -\include{srHP} -\include{srrcu} +\include{tm} % \include{classes} % \include{overloading} % \include{templates} From a7c5c1d1b678792c14755381d0b0a55183e224b4 Mon Sep 17 00:00:00 2001 From: Mike Spear Date: Tue, 11 Jan 2022 11:25:53 -0500 Subject: [PATCH 10/40] Update general.tex Corrected last name for Michael Spear --- src/general.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/general.tex b/src/general.tex index 81f15a9..95f7cce 100644 --- a/src/general.tex +++ b/src/general.tex @@ -129,7 +129,7 @@ \rSec1[general.ack]{Acknowledgments} This work is the result of a collaboration of researchers in industry and academia. We wish to thank the -original authors of this document, Michael Wong, Hans Boehm, and Michael Spears. We also wish to thank people +original authors of this document, Michael Wong, Hans Boehm, and Michael Spear. We also wish to thank people who made valuable contributions within and outside these groups, including Jens Maurer, and many others not named here who contributed to the discussion. From 3ce7db9ac13dd6c3460eaf006385e53a41efb350 Mon Sep 17 00:00:00 2001 From: Mike Spear Date: Tue, 11 Jan 2022 11:35:47 -0500 Subject: [PATCH 11/40] Updated README.md to fix a typo --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index bd8107e..9c795cc 100644 --- a/README.md +++ b/README.md @@ -9,7 +9,7 @@ will generate a PDF. \textbf{TM TS2021 Editor's Report} \textbf{pre-Feb 2022 virtual Plenary meeting} -Nxxxx is the proposed working draft of Concurrency TS Version 2. It contains changes to the TM TS2021 as directed by the committee at the June 2021 virtual plenary meeting, and editorial changes. +Nxxxx is the proposed working draft of Transactional Memory TS Version 2. It contains changes to the TM TS2021 as directed by the committee at the June 2021 virtual plenary meeting, and editorial changes. N4895 contains P2066R10 from Oct 2021 virtual plenary. From 43e046b5d0eecff0e0256edf822c5639e62412c2 Mon Sep 17 00:00:00 2001 From: Mike Spear Date: Tue, 11 Jan 2022 11:39:16 -0500 Subject: [PATCH 12/40] Formatting changes to README.md --- README.md | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 9c795cc..0617680 100644 --- a/README.md +++ b/README.md @@ -6,19 +6,25 @@ written in LaTeX. There is a Makefile that can be used to compile the sources, or you can use the `latexmk` program e.g. `latexmk -pdf ts` will generate a PDF. -\textbf{TM TS2021 Editor's Report} -\textbf{pre-Feb 2022 virtual Plenary meeting} +# TM TS2021 Editor's Report + +## pre-Feb 2022 virtual Plenary meeting Nxxxx is the proposed working draft of Transactional Memory TS Version 2. It contains changes to the TM TS2021 as directed by the committee at the June 2021 virtual plenary meeting, and editorial changes. N4895 contains P2066R10 from Oct 2021 virtual plenary. -\textbf{Technical Changes} +## Technical Changes None -\textbf{Notes} +## Notes None -\textbf{Acknowledgement} +## Acknowledgement -Thank you to the Editing team of Michael Wong, Hans Boehm, and Jens Maurer. +Michael Wong +Hans Boehm +Jens Maurer +Victor Luchangco +Michael Spear +Michael Scott From eb41ae70405e29e905c0aff78efd053312995348 Mon Sep 17 00:00:00 2001 From: Mike Spear Date: Tue, 11 Jan 2022 11:39:56 -0500 Subject: [PATCH 13/40] Fixed a typo in README.md --- README.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 0617680..272d62d 100644 --- a/README.md +++ b/README.md @@ -15,12 +15,14 @@ Nxxxx is the proposed working draft of Transactional Memory TS Version 2. It con N4895 contains P2066R10 from Oct 2021 virtual plenary. ## Technical Changes + None ## Notes + None -## Acknowledgement +## Acknowledgements Michael Wong Hans Boehm From 223e2e8dd639fdc04862daf1862c627e95a55d82 Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Tue, 11 Jan 2022 19:09:47 +0100 Subject: [PATCH 14/40] fix 'Nxxxx' placeholder to use four 'x' --- src/config.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/config.tex b/src/config.tex index 0a3b692..7d79fdb 100644 --- a/src/config.tex +++ b/src/config.tex @@ -1,7 +1,7 @@ %!TEX root = ts.tex %%-------------------------------------------------- %% Version numbers -\newcommand{\docno}{Nxxx} +\newcommand{\docno}{Nxxxx} \newcommand{\isodocno}{ISO/IEC ?????:2021(E)} \newcommand{\prevdocno}{None} \newcommand{\cppver}{201703L @@@} %% MW: need update From e293b7e1b2a79c9884875e77f76d8a16e8d17864 Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Tue, 11 Jan 2022 19:15:36 +0100 Subject: [PATCH 15/40] Remove special care for the standard library and avoid reference to WG21-internal PxxxxRy papers. --- src/general.tex | 6 ------ 1 file changed, 6 deletions(-) diff --git a/src/general.tex b/src/general.tex index 95f7cce..cc3e00c 100644 --- a/src/general.tex +++ b/src/general.tex @@ -28,12 +28,6 @@ \pnum ISO/IEC 14882:2020 is herein called the C++ Standard. References to clauses within the C++ Standard are written as ``\CppXref{3.2}''. The library described in \CppXref{16-32} is herein called the C++ Standard Library. -\pnum -Unless otherwise specified, the whole of the C++ Standard's Library introduction (\CppXref{16}) is included into this Technical Specification by reference. - -\pnum -Unless otherwise specified, these wording changes applies P2066R10 relative to the current C++ Working Draft,N4849. - \rSec0[defs]{Terms and definitions} \pnum From b19992dd184951abfba665cb7423bf836c2fc5ad Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Tue, 11 Jan 2022 20:57:57 +0100 Subject: [PATCH 16/40] Fix formatting in main text body --- src/tm.tex | 299 +++++++++++++++++++++++++++++------------------------ src/ts.tex | 2 - 2 files changed, 165 insertions(+), 136 deletions(-) diff --git a/src/tm.tex b/src/tm.tex index 4528758..592775d 100644 --- a/src/tm.tex +++ b/src/tm.tex @@ -6,29 +6,32 @@ \rSec1[lex.name]{Identifiers} \pnum -In 5.10 {[}lex.name{]}, add \uline{\texttt{atomic}} to table 4 -{[}tab:lex.name.special{]}. +In \CppXref{5.11}, +add \added{\tcode{atomic}} to the table of keywords (Table 5). \rSec0[basic]{Basics} -\rSec1[basic.exec]{Program execution} + +\setcounter{section}{9} + \rSec2[intro.execution]{Sequential execution} -\pnum -Change in 6.9.1 {[}intro.execution{]} paragraph 5: +Change in \CppXref{6.9.1} as indicated: \begin{quote} -A \emph{full-expression} is +\setcounter{Paras}{4} +\setcounter{Bullets1}{3} +\pnum +A \defn{full-expression} is \begin{itemize} -\tightlist \item ... \item an invocation of a destructor generated at the end of the lifetime of an object other than a temporary object (6.7.7) whose lifetime has not - been extended, \sout{or} + been extended, \removed{or} \item - \uline{the start and the end of an atomic block (8.8 {[}stmt.tx{]}), + \added{the start and the end of an atomic block (8.8 {[}stmt.tx{]}), or} \item an expression that is not a subexpression of another expression and @@ -38,27 +41,33 @@ \rSec2[intro.multithread]{Multi-threaded executions and data races} \rSec3[intro.races]{Data races} -\pnum -Change in 6.9.2.1 {[}intro.races{]} paragraph 6: + +Change in \CppXref{6.9.2.1} as indicated: \begin{quote} -\uline{Atomic blocks as well as} \sout{Certain} \uline{certain} library -calls \uline{may} \emph{synchronize with} other \uline{atomic blocks +\setcounter{Paras}{5} +\pnum +\removed{Certain} \added{Atomic blocks as well as certain} library +calls \added{may} \emph{synchronize with} other \added{atomic blocks and} library calls performed by another thread. \end{quote} -\pnum -Add a new paragraph after 6.9.2.1 {[}intro.races{]} paragraph 20: +Add a new paragraph after \CppXref{6.9.2.1} paragraph 20: \begin{quote} +\pnum +\setcounter{Paras}{20} An atomic block that is not dynamically nested within another atomic -block is termed a transaction. {[}Note: Due to syntactic constraints, -blocks cannot overlap unless one is nested within the other.{]} There is -a global total order of execution for all transactions. If, in that -total order, a transaction T1 is ordered before a transaction T2, then +block is termed a \defn{transaction}. +\begin{note} +Due to syntactic constraints, +blocks cannot overlap unless one is nested within the other. +\end{note} +There is a global total order of execution for all transactions. +If, in that total order, a transaction T1 is ordered before a transaction T2, +then \begin{itemize} -\tightlist \item no evaluation in T2 happens before any evaluation in T1 and \item @@ -66,33 +75,40 @@ of T1 synchronizes with the start of T2. \end{itemize} -{[} Note: If the evaluations in T1 and T2 do not conflict, they might be -executed concurrently. -\/- end note {]} -\end{quote} +\begin{note} +If the evaluations in T1 and T2 do not conflict, they might be +executed concurrently. +\end{note} -\begin{quote} -Two actions are \emph{potentially concurrent} if ... +\pnum +Two actions are \defn{potentially concurrent} if ... \end{quote} -\pnum -Change in 6.9.2.1 {[}intro.races{]} paragraph 21: +Change in \CppXref{6.9.2.1} paragraph 21: \begin{quote} -... {[}Note: It can be shown that programs that correctly use -mutexes\uline{, atomic blocks,} and \texttt{memory\_order::seq\_cst} +\setcounter{Paras}{20} +\pnum +... +\begin{note} +It can be shown that programs that correctly use +mutexes\added{, atomic blocks,} and \tcode{memory\_order::seq\_cst} operations to prevent all data races and use no other synchronization operations behave as if the operations executed by their constituent threads were simply interleaved, with each value computation of an object being taken from the last side effect on that object in that interleaving. This is normally referred to as "sequential consistency". ... +\end{note} \end{quote} -\pnum -Add a new paragraph after 6.9.2.1 {[}intro.races{]} paragraph 21: +Add a new paragraph after \CppXref{6.9.2.1} paragraph 21: \begin{quote} -{[} Note: The following holds for a data-race-free program: If the start +\setcounter{Paras}{21} +\pnum +\begin{note} +The following holds for a data-race-free program: If the start of an atomic block T is sequenced before an evaluation A, A is sequenced before the end of T, A strongly happens before some evaluation B, and B is not sequenced before the end of T, then the end of T strongly happens @@ -100,122 +116,134 @@ and C is not sequenced after the start of T, then C strongly happens before the start of T. These properties in turn imply that in any simple interleaved (sequentially consistent) execution, the operations of each -atomic block appear to be contiguous in the interleaving. -\/- end note -{]} +atomic block appear to be contiguous in the interleaving. +\end{note} \end{quote} \rSec3[intro.progress]{Forward progress} -\pnum -Change in 6.9.2.2 {[}intro.progress{]} paragraph 1: +Change in \CppXref{6.9.2.2} as indicated: \begin{quote} -\sout{The implementation may assume that any thread will eventually do} -\uline{An \emph{inter-thread side effect} is} one of the following: +\pnum +\removed{The implementation may assume that any thread will eventually do} +\added{An \defn{inter-thread side effect} is} one of the following: \begin{itemize} \tightlist \item - \sout{terminate,} + \removed{terminate,} \item a call to a library I/O function, \item an access through a volatile glvalue, or \item a synchronization operation or an atomic operation - \uline{({[}atomics{]})}. + \added{({[}atomics{]})}. \end{itemize} -\uline{The implementation may assume that any thread will eventually -terminate or evaluate an inter-thread side effect.} {[}Note: This is -intended to allow compiler transformations such as removal of empty -loops, even when termination cannot be proven. --- end note{]} +\added{The implementation may assume that any thread will eventually +terminate or evaluate an inter-thread side effect.} +\begin{note} +This is intended to allow compiler transformations +such as removal of empty loops, even when termination cannot be proven. +\end{note} \end{quote} +\setcounter{chapter}{7} + \rSec0[stmt.stmt]{Statements} \rSec1[stmt.pre]{Preamble} \pnum -Add a production to the grammar in 8.1 {[}expr.pre{]}: +Add a production to the grammar in \CppXref{8.1} as indicated: \begin{quote} -\begin{verbatim} -statement: - labeled-statement - attribute-specifier-seqopt expression-statement - attribute-specifier-seqopt compound-statement - attribute-specifier-seqopt selection-statement - attribute-specifier-seqopt iteration-statement - attribute-specifier-seqopt jump-statement - declaration-statement - attribute-specifier-seqopt try-block - \uline{atomic-statement} -\end{verbatim} +\begin{bnf} +\nontermdef{statement}\br + labeled-statement\br + \opt{attribute-specifier-seq} expression-statement\br + \opt{attribute-specifier-seq} compound-statement\br + \opt{attribute-specifier-seq} selection-statement\br + \opt{attribute-specifier-seq} iteration-statement\br + \opt{attribute-specifier-seq} jump-statement\br + declaration-statement\br + \opt{attribute-specifier-seq} try-block\br + \added{atomic-statement} +\end{bnf} \end{quote} -\rSec1[stmt.dcl]{Declaration statement} +\setcounter{section}{7} -\pnum -Add a new subclause before 8.8 {[}stmt.dcl{]}: +Add a new subclause before \CppXref{8.8}: \begin{quote} -\textbf{8.8 Atomic statement {[}stmt.tx{]}} +\rSec1[stmt.tx]{Atomic statement} -\begin{verbatim} -atomic-statement: - atomic do compound-statement -\end{verbatim} +\begin{bnf} +\nontermdef{atomic-statement}\br + \keyword{atomic} \keyword{do} compound-statement +\end{bnf} -An \emph{atomic-statement} is also called an \emph{atomic block}. +\pnum +An \grammarterm{atomic-statement} is also called an \emph{atomic block}. +\pnum The start of the atomic block is immediately before the opening -\texttt{\{} of the \emph{compound-statement}. The end of the atomic -block is immediately after the closing \texttt{\}} of the -\emph{compound-statement}. {[} Note: Thus, variables with automatic -storage duration declared in the \emph{compound-statement} are destroyed -prior to reaching the end of the atomic block; see 8.7 {[}stmt.jump{]}. --\/- end note {]} +\tcode{\{} of the \grammarterm{compound-statement}. +The end of the atomic block is immediately after +the closing \tcode{\}} of the \grammarterm{compound-statement}. +\begin{note} +Thus, variables with automatic storage duration +declared in the \grammarterm{compound-statement} +are destroyed prior to reaching the end of the atomic block; +see \CppXref{8.7}. +\end{note} -A goto or switch statement shall not be used to transfer control into an -atomic block. +\pnum +A goto or switch statement shall not be used to transfer control +into an atomic block. +\pnum If the execution of an atomic block evaluates an inter-thread side -effect (6.9.2.2 {[}intro.progress{]}) or if an atomic block is exited +effect\iref{intro.progress} or if an atomic block is exited via an exception, the behavior is undefined. -\emph{Recommended practice:} In case an atomic block is exited via an -exception, the program should be terminated without invoking a terminate -handler (17.9.5 {[}exception.terminate{]}) or destroying any objects -with static or thread storage duration (6.9.3.4 {[}basic.start.term{]}). +\pnum +\recommended +In case an atomic block is exited via an exception, +the program should be terminated +without invoking a terminate handler (\CppXref{17.9.5}) or +destroying any objects +with static or thread storage duration (\CppXref{6.9.3.4}). +\pnum If the execution of an atomic block evaluates any of the following -outside of a manifestly constant-evaluated context (7.7 -{[}expr.const{]}), the behavior is implementation-defined: +outside of a manifestly constant-evaluated context (\CppXref{7.7}), +the behavior is implementation-defined: \begin{itemize} -\tightlist \item - an \emph{asm-declaration} (9.10 {[}dcl.asm{]}); + an \grammarterm{asm-declaration} (\CppXref{9.10} {[}dcl.asm{]}); \item - an invocation of a function \textbf{other than one of the standard - library functions specified in (16.4.6.17 {[}atomic.use{]}), unless - the function is inline} with a reachable definition; + an invocation of a function other than one of the standard + library functions specified in \CppXref{16.4.6.17} {[}atomic.use{]}), unless + the function is inline with a reachable definition; \item - a virtual function call (7.6.1.3 {[}expr.call{]}); + a virtual function call (\CppXref{7.6.1.3} {[}expr.call{]}); \item - a function call, \textbf{unless overload resolution selects} + a function call, unless overload resolution selects \begin{itemize} - \tightlist \item - \textbf{a named function (12.2.2.2.2 {[}over.call.func{]}) or} + a named function (\CppXref{12.2.2.2.2} {[}over.call.func{]}) or \item - \textbf{a function call operator (12.2.2.2.3 - {[}over.call.object{]}), but not a surrogate call function;} + a function call operator (\CppXref{12.2.2.2.3} + {[}over.call.object{]}), but not a surrogate call function; \end{itemize} \item - a \texttt{co\_await} expression (7.6.2.3 {[}expr.await{]}), a - \emph{yield-expression} (7.6.17 {[}expr.yield{]}), or a - \texttt{co\_return} statement (8.7.4 {[}stmt.return.coroutine{]}); + a \keyword{co\_await} expression (\CppXref{7.6.2.3} {[}expr.await{]}), a + \grammarterm{yield-expression} (\CppXref{7.6.17} {[}expr.yield{]}), or a + \keyword{co\_return} statement (\CppXref{8.7.4} {[}stmt.return.coroutine{]}); \item dynamic initialization of a block-scope variable with static storage duration; or @@ -223,12 +251,13 @@ dynamic initialization of a variable with thread storage duration. \end{itemize} -{[} Note: The implementation \textbf{can} define that the behavior is -undefined in some or all of the cases above. {]} - -{[} Example: +\begin{note} +The implementation can define that the behavior is +undefined in some or all of the cases above. +\end{note} -\begin{verbatim} +\begin{example} +\begin{codeblock} unsigned int f() { static unsigned int i = 0; @@ -237,68 +266,70 @@ return i; } } -\end{verbatim} +\end{codeblock} -Each invocation of f (even when called from several threads -simultaneously) retrieves a unique value (ignoring -\textbf{wrap-around}). -\/- end example {]} +Each invocation of \tcode{f} +(even when called from several threads simultaneously) +retrieves a unique value (ignoring wrap-around). +\end{example} -{[} Note: Atomic blocks are likely to perform best where they execute -quickly and touch little data. -\/- end note {]} +\begin{note} +Atomic blocks are likely to perform best where they execute +quickly and touch little data. +\end{note} \end{quote} -\rSec1[library]{Library introduction} -\rSec2[description]{Method of description} -%\rsec2[description]{Method of description} +\setcounter{chapter}{15} -\pnum +\rSec0[library]{Library introduction} + +\setcounter{section}{4} +\setcounter{subsection}{6} +\setcounter{subsubsection}{16} -Add 16.4.6.17 {[}atomic.use{]}: +Add a new subclause after \CppXref{16.4.6.16}: \begin{quote} -\hypertarget{functions-usable-in-an-atomic-block-atomic.use}{% -\subsection{16.4.6.17 Functions usable in an atomic block -{[}atomic.use{]}}\label{functions-usable-in-an-atomic-block-atomic.use}} +\rSec3[atomic.use]{Functions usable in an atomic block} -All library functions may be used in an atomic block (8.8 -{[}stmt.tx{]}), except +\pnum +All library functions may be used in an atomic block\iref{stmt.tx}, except \begin{itemize} -\tightlist \item - \textbf{error category objects ({[}syserr.errcat.objects{]})} + error category objects ({[}syserr.errcat.objects{]}) \item time zone database ({[}time.zone.db{]}) \item clocks ({[}time.clock{]}) \item - \texttt{signal} ({[}support.signal{]}) \textbf{and \texttt{raise} - ({[}csignal.syn{]})} + \tcode{signal} ({[}support.signal{]}) and \tcode{raise} + ({[}csignal.syn{]}) \item - \texttt{set\_new\_handler}, \texttt{set\_terminate}, - \texttt{get\_new\_handler}, \texttt{get\_terminate} + \tcode{set_new\_handler}, \tcode{set\_terminate}, + \tcode{get\_new\_handler}, \tcode{get\_terminate} ({[}handler.functions{]}, {[}alloc.errors{]}, {[}exception.syn{]}) \item - \textbf{\texttt{system} ({[}cstdlib.syn{]})} + \tcode{system} ({[}cstdlib.syn{]}) \item - \textbf{startup and termination {[}support.start.term{]} except - \texttt{abort}} + startup and termination {[}support.start.term{]} except + \tcode{abort} \item - \texttt{shared\_ptr} ({[}util.smartptr.shared{]}) and - \texttt{weak\_ptr} ({[}util.smartptr.weak{]}) + \tcode{shared\_ptr} ({[}util.smartptr.shared{]}) and + \tcode{weak\_ptr} ({[}util.smartptr.weak{]}) \item - \texttt{synchronized\_pool\_resource} ({[}mem.res.pool{]}) + \tcode{synchronized\_pool\_resource} ({[}mem.res.pool{]}) \item - \textbf{program-wide \texttt{memory\_resource} objects - ({[}mem.res.global{]})} + program-wide \tcode{memory\_resource} objects + ({[}mem.res.global{]}) \item - \texttt{setjmp} / \texttt{longjmp} ({[}csetjmp.syn{]}) + \tcode{setjmp} / \tcode{longjmp} ({[}csetjmp.syn{]}) \item - \textbf{parallel algorithms ({[}algorithms.parallel{]})} + parallel algorithms ({[}algorithms.parallel{]}) \item - \textbf{\texttt{random\_device} ({[}rand.device{]})} + \tcode{random\_device} ({[}rand.device{]}) \item - \texttt{locale} construction ({[}locale.cons{]}) + \tcode{locale} construction ({[}locale.cons{]}) \item input/output ({[}input.output{]}) \item diff --git a/src/ts.tex b/src/ts.tex index 4921857..dad3aa8 100644 --- a/src/ts.tex +++ b/src/ts.tex @@ -57,8 +57,6 @@ %%-------------------------------------------------- %% macros specific to the Concurrency TS 2 -\newcommand{\completionsig}{\Fundesc{Completion signature}} -\newcommand{\DEDUCED}{\textit{\texttt{DEDUCED}}} \newcommand{\nativeref}{see~\ref{socket.reqmts.native}} \newcommand{\CppXref}[1]{\texorpdfstring{C\kern-0.05em\protect\raisebox{.35ex}{\textsmaller[2]{+\kern-0.05em+}}20}{C++20} \S#1} % Alternative formatting of cross-references, resolving stable name to number. From 430b3c25271227e7433dd8ce69e0db930734d3f3 Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Wed, 12 Jan 2022 19:51:07 +0100 Subject: [PATCH 17/40] Add cross-references to C++20 and clean up --- src/cxx-sections.tex | 2980 ++++++++++++++++++++++++++++++++++++++++++ src/cxx.tex | 68 +- src/tm.tex | 112 +- src/ts.tex | 6 +- 4 files changed, 3043 insertions(+), 123 deletions(-) create mode 100644 src/cxx-sections.tex diff --git a/src/cxx-sections.tex b/src/cxx-sections.tex new file mode 100644 index 0000000..79f1a9a --- /dev/null +++ b/src/cxx-sections.tex @@ -0,0 +1,2980 @@ +\cxxsec{algorithms}{Clause 25} +\cxxsec{algorithms.general}{25.1} +\cxxsec{tab:algorithms.summary}{91} +\cxxsec{algorithms.requirements}{25.2} +\cxxsec{algorithms.parallel}{25.3} +\cxxsec{algorithms.parallel.defns}{25.3.1} +\cxxsec{algorithms.parallel.user}{25.3.2} +\cxxsec{algorithms.parallel.exec}{25.3.3} +\cxxsec{algorithms.parallel.exceptions}{25.3.4} +\cxxsec{algorithms.parallel.overloads}{25.3.5} +\cxxsec{algorithm.syn}{25.4} +\cxxsec{algorithms.results}{25.5} +\cxxsec{alg.nonmodifying}{25.6} +\cxxsec{alg.all.of}{25.6.1} +\cxxsec{alg.any.of}{25.6.2} +\cxxsec{alg.none.of}{25.6.3} +\cxxsec{alg.foreach}{25.6.4} +\cxxsec{alg.find}{25.6.5} +\cxxsec{alg.find.end}{25.6.6} +\cxxsec{alg.find.first.of}{25.6.7} +\cxxsec{alg.adjacent.find}{25.6.8} +\cxxsec{alg.count}{25.6.9} +\cxxsec{mismatch}{25.6.10} +\cxxsec{alg.equal}{25.6.11} +\cxxsec{alg.is.permutation}{25.6.12} +\cxxsec{alg.search}{25.6.13} +\cxxsec{alg.modifying.operations}{25.7} +\cxxsec{alg.copy}{25.7.1} +\cxxsec{alg.move}{25.7.2} +\cxxsec{alg.swap}{25.7.3} +\cxxsec{alg.transform}{25.7.4} +\cxxsec{alg.replace}{25.7.5} +\cxxsec{alg.fill}{25.7.6} +\cxxsec{alg.generate}{25.7.7} +\cxxsec{alg.remove}{25.7.8} +\cxxsec{alg.unique}{25.7.9} +\cxxsec{alg.reverse}{25.7.10} +\cxxsec{alg.rotate}{25.7.11} +\cxxsec{alg.random.sample}{25.7.12} +\cxxsec{alg.random.shuffle}{25.7.13} +\cxxsec{alg.shift}{25.7.14} +\cxxsec{alg.sorting}{25.8} +\cxxsec{alg.sorting.general}{25.8.1} +\cxxsec{alg.sort}{25.8.2} +\cxxsec{sort}{25.8.2.1} +\cxxsec{stable.sort}{25.8.2.2} +\cxxsec{partial.sort}{25.8.2.3} +\cxxsec{partial.sort.copy}{25.8.2.4} +\cxxsec{is.sorted}{25.8.2.5} +\cxxsec{alg.nth.element}{25.8.3} +\cxxsec{alg.binary.search}{25.8.4} +\cxxsec{alg.binary.search.general}{25.8.4.1} +\cxxsec{lower.bound}{25.8.4.2} +\cxxsec{upper.bound}{25.8.4.3} +\cxxsec{equal.range}{25.8.4.4} +\cxxsec{binary.search}{25.8.4.5} +\cxxsec{alg.partitions}{25.8.5} +\cxxsec{alg.merge}{25.8.6} +\cxxsec{alg.set.operations}{25.8.7} +\cxxsec{alg.set.operations.general}{25.8.7.1} +\cxxsec{includes}{25.8.7.2} +\cxxsec{set.union}{25.8.7.3} +\cxxsec{set.intersection}{25.8.7.4} +\cxxsec{set.difference}{25.8.7.5} +\cxxsec{set.symmetric.difference}{25.8.7.6} +\cxxsec{alg.heap.operations}{25.8.8} +\cxxsec{alg.heap.operations.general}{25.8.8.1} +\cxxsec{push.heap}{25.8.8.2} +\cxxsec{pop.heap}{25.8.8.3} +\cxxsec{make.heap}{25.8.8.4} +\cxxsec{sort.heap}{25.8.8.5} +\cxxsec{is.heap}{25.8.8.6} +\cxxsec{alg.min.max}{25.8.9} +\cxxsec{alg.clamp}{25.8.10} +\cxxsec{alg.lex.comparison}{25.8.11} +\cxxsec{alg.three.way}{25.8.12} +\cxxsec{alg.permutation.generators}{25.8.13} +\cxxsec{numeric.ops.overview}{25.9} +\cxxsec{numeric.ops}{25.10} +\cxxsec{numeric.ops.general}{25.10.1} +\cxxsec{numerics.defns}{25.10.2} +\cxxsec{accumulate}{25.10.3} +\cxxsec{reduce}{25.10.4} +\cxxsec{inner.product}{25.10.5} +\cxxsec{transform.reduce}{25.10.6} +\cxxsec{partial.sum}{25.10.7} +\cxxsec{exclusive.scan}{25.10.8} +\cxxsec{inclusive.scan}{25.10.9} +\cxxsec{transform.exclusive.scan}{25.10.10} +\cxxsec{transform.inclusive.scan}{25.10.11} +\cxxsec{adjacent.difference}{25.10.12} +\cxxsec{numeric.iota}{25.10.13} +\cxxsec{numeric.ops.gcd}{25.10.14} +\cxxsec{numeric.ops.lcm}{25.10.15} +\cxxsec{numeric.ops.midpoint}{25.10.16} +\cxxsec{specialized.algorithms}{25.11} +\cxxsec{specialized.algorithms.general}{25.11.1} +\cxxsec{special.mem.concepts}{25.11.2} +\cxxsec{uninitialized.construct.default}{25.11.3} +\cxxsec{uninitialized.construct.value}{25.11.4} +\cxxsec{uninitialized.copy}{25.11.5} +\cxxsec{uninitialized.move}{25.11.6} +\cxxsec{uninitialized.fill}{25.11.7} +\cxxsec{specialized.construct}{25.11.8} +\cxxsec{specialized.destroy}{25.11.9} +\cxxsec{alg.c.library}{25.12} +\cxxsec{atomics}{Clause 31} +\cxxsec{atomics.general}{31.1} +\cxxsec{tab:atomics.summary}{143} +\cxxsec{atomics.syn}{31.2} +\cxxsec{atomics.alias}{31.3} +\cxxsec{atomics.order}{31.4} +\cxxsec{atomics.lockfree}{31.5} +\cxxsec{atomics.wait}{31.6} +\cxxsec{atomics.ref.generic}{31.7} +\cxxsec{atomics.ref.generic.general}{31.7.1} +\cxxsec{atomics.ref.ops}{31.7.2} +\cxxsec{atomics.ref.int}{31.7.3} +\cxxsec{atomics.ref.float}{31.7.4} +\cxxsec{atomics.ref.pointer}{31.7.5} +\cxxsec{atomics.ref.memop}{31.7.6} +\cxxsec{atomics.types.generic}{31.8} +\cxxsec{atomics.types.generic.general}{31.8.1} +\cxxsec{atomics.types.operations}{31.8.2} +\cxxsec{atomics.types.int}{31.8.3} +\cxxsec{tab:atomic.types.int.comp}{144} +\cxxsec{atomics.types.float}{31.8.4} +\cxxsec{atomics.types.pointer}{31.8.5} +\cxxsec{tab:atomic.types.pointer.comp}{145} +\cxxsec{atomics.types.memop}{31.8.6} +\cxxsec{util.smartptr.atomic}{31.8.7} +\cxxsec{util.smartptr.atomic.general}{31.8.7.1} +\cxxsec{util.smartptr.atomic.shared}{31.8.7.2} +\cxxsec{util.smartptr.atomic.weak}{31.8.7.3} +\cxxsec{atomics.nonmembers}{31.9} +\cxxsec{atomics.flag}{31.10} +\cxxsec{atomics.fences}{31.11} +\cxxsec{idx.general.Symbols}{D.25.5} +\cxxsec{idx.general.Numbers}{D.25.5} +\cxxsec{idx.general.A}{D.25.5} +\cxxsec{idx.general.B}{D.25.5} +\cxxsec{idx.general.C}{D.25.5} +\cxxsec{idx.general.D}{D.25.5} +\cxxsec{idx.general.E}{D.25.5} +\cxxsec{idx.general.F}{D.25.5} +\cxxsec{idx.general.G}{D.25.5} +\cxxsec{idx.general.H}{D.25.5} +\cxxsec{idx.general.I}{D.25.5} +\cxxsec{idx.general.J}{D.25.5} +\cxxsec{idx.general.K}{D.25.5} +\cxxsec{idx.general.L}{D.25.5} +\cxxsec{idx.general.M}{D.25.5} +\cxxsec{idx.general.N}{D.25.5} +\cxxsec{idx.general.O}{D.25.5} +\cxxsec{idx.general.P}{D.25.5} +\cxxsec{idx.general.Q}{D.25.5} +\cxxsec{idx.general.R}{D.25.5} +\cxxsec{idx.general.S}{D.25.5} +\cxxsec{idx.general.T}{D.25.5} +\cxxsec{idx.general.U}{D.25.5} +\cxxsec{idx.general.V}{D.25.5} +\cxxsec{idx.general.W}{D.25.5} +\cxxsec{idx.general.X}{D.25.5} +\cxxsec{idx.general.Y}{D.25.5} +\cxxsec{idx.general.Z}{D.25.5} +\cxxsec{idx.library.Symbols}{D.25.5} +\cxxsec{idx.library.Numbers}{D.25.5} +\cxxsec{idx.library.A}{D.25.5} +\cxxsec{idx.library.B}{D.25.5} +\cxxsec{idx.library.C}{D.25.5} +\cxxsec{idx.library.D}{D.25.5} +\cxxsec{idx.library.E}{D.25.5} +\cxxsec{idx.library.F}{D.25.5} +\cxxsec{idx.library.G}{D.25.5} +\cxxsec{idx.library.H}{D.25.5} +\cxxsec{idx.library.I}{D.25.5} +\cxxsec{idx.library.J}{D.25.5} +\cxxsec{idx.library.K}{D.25.5} +\cxxsec{idx.library.L}{D.25.5} +\cxxsec{idx.library.M}{D.25.5} +\cxxsec{idx.library.N}{D.25.5} +\cxxsec{idx.library.O}{D.25.5} +\cxxsec{idx.library.P}{D.25.5} +\cxxsec{idx.library.Q}{D.25.5} +\cxxsec{idx.library.R}{D.25.5} +\cxxsec{idx.library.S}{D.25.5} +\cxxsec{idx.library.T}{D.25.5} +\cxxsec{idx.library.U}{D.25.5} +\cxxsec{idx.library.V}{D.25.5} +\cxxsec{idx.library.W}{D.25.5} +\cxxsec{idx.library.X}{D.25.5} +\cxxsec{idx.library.Y}{D.25.5} +\cxxsec{idx.library.Z}{D.25.5} +\cxxsec{basic}{Clause 6} +\cxxsec{basic.pre}{6.1} +\cxxsec{basic.def}{6.2} +\cxxsec{basic.def.odr}{6.3} +\cxxsec{basic.scope}{6.4} +\cxxsec{basic.scope.declarative}{6.4.1} +\cxxsec{basic.scope.pdecl}{6.4.2} +\cxxsec{basic.scope.block}{6.4.3} +\cxxsec{basic.scope.param}{6.4.4} +\cxxsec{basic.funscope}{6.4.5} +\cxxsec{basic.scope.namespace}{6.4.6} +\cxxsec{basic.scope.class}{6.4.7} +\cxxsec{basic.scope.enum}{6.4.8} +\cxxsec{basic.scope.temp}{6.4.9} +\cxxsec{basic.scope.hiding}{6.4.10} +\cxxsec{basic.lookup}{6.5} +\cxxsec{basic.lookup.general}{6.5.1} +\cxxsec{basic.lookup.unqual}{6.5.2} +\cxxsec{basic.lookup.argdep}{6.5.3} +\cxxsec{basic.lookup.qual}{6.5.4} +\cxxsec{basic.lookup.qual.general}{6.5.4.1} +\cxxsec{class.qual}{6.5.4.2} +\cxxsec{namespace.qual}{6.5.4.3} +\cxxsec{basic.lookup.elab}{6.5.5} +\cxxsec{basic.lookup.classref}{6.5.6} +\cxxsec{basic.lookup.udir}{6.5.7} +\cxxsec{basic.link}{6.6} +\cxxsec{basic.memobj}{6.7} +\cxxsec{intro.memory}{6.7.1} +\cxxsec{intro.object}{6.7.2} +\cxxsec{basic.life}{6.7.3} +\cxxsec{basic.indet}{6.7.4} +\cxxsec{basic.stc}{6.7.5} +\cxxsec{basic.stc.general}{6.7.5.1} +\cxxsec{basic.stc.static}{6.7.5.2} +\cxxsec{basic.stc.thread}{6.7.5.3} +\cxxsec{basic.stc.auto}{6.7.5.4} +\cxxsec{basic.stc.dynamic}{6.7.5.5} +\cxxsec{basic.stc.dynamic.general}{6.7.5.5.1} +\cxxsec{basic.stc.dynamic.allocation}{6.7.5.5.2} +\cxxsec{basic.stc.dynamic.deallocation}{6.7.5.5.3} +\cxxsec{basic.stc.dynamic.safety}{6.7.5.5.4} +\cxxsec{basic.stc.inherit}{6.7.5.6} +\cxxsec{basic.align}{6.7.6} +\cxxsec{class.temporary}{6.7.7} +\cxxsec{basic.types}{6.8} +\cxxsec{basic.types.general}{6.8.1} +\cxxsec{basic.fundamental}{6.8.2} +\cxxsec{tab:basic.fundamental.width}{12} +\cxxsec{basic.compound}{6.8.3} +\cxxsec{basic.type.qualifier}{6.8.4} +\cxxsec{tab:basic.type.qualifier.rel}{13} +\cxxsec{conv.rank}{6.8.5} +\cxxsec{basic.exec}{6.9} +\cxxsec{intro.execution}{6.9.1} +\cxxsec{intro.multithread}{6.9.2} +\cxxsec{intro.multithread.general}{6.9.2.1} +\cxxsec{intro.races}{6.9.2.2} +\cxxsec{intro.progress}{6.9.2.3} +\cxxsec{basic.start}{6.9.3} +\cxxsec{basic.start.main}{6.9.3.1} +\cxxsec{basic.start.static}{6.9.3.2} +\cxxsec{basic.start.dynamic}{6.9.3.3} +\cxxsec{basic.start.term}{6.9.3.4} +\cxxsec{class}{Clause 11} +\cxxsec{class.pre}{11.1} +\cxxsec{class.prop}{11.2} +\cxxsec{class.name}{11.3} +\cxxsec{class.mem}{11.4} +\cxxsec{class.mem.general}{11.4.1} +\cxxsec{class.mfct}{11.4.2} +\cxxsec{class.mfct.non-static}{11.4.3} +\cxxsec{class.mfct.non-static.general}{11.4.3.1} +\cxxsec{class.this}{11.4.3.2} +\cxxsec{special}{11.4.4} +\cxxsec{class.ctor}{11.4.5} +\cxxsec{class.ctor.general}{11.4.5.1} +\cxxsec{class.default.ctor}{11.4.5.2} +\cxxsec{class.copy.ctor}{11.4.5.3} +\cxxsec{class.copy.assign}{11.4.6} +\cxxsec{class.dtor}{11.4.7} +\cxxsec{class.conv}{11.4.8} +\cxxsec{class.conv.general}{11.4.8.1} +\cxxsec{class.conv.ctor}{11.4.8.2} +\cxxsec{class.conv.fct}{11.4.8.3} +\cxxsec{class.static}{11.4.9} +\cxxsec{class.static.general}{11.4.9.1} +\cxxsec{class.static.mfct}{11.4.9.2} +\cxxsec{class.static.data}{11.4.9.3} +\cxxsec{class.bit}{11.4.10} +\cxxsec{class.nest}{11.4.11} +\cxxsec{class.nested.type}{11.4.12} +\cxxsec{class.union}{11.5} +\cxxsec{class.union.general}{11.5.1} +\cxxsec{class.union.anon}{11.5.2} +\cxxsec{class.local}{11.6} +\cxxsec{class.derived}{11.7} +\cxxsec{class.derived.general}{11.7.1} +\cxxsec{fig:class.dag}{2} +\cxxsec{class.mi}{11.7.2} +\cxxsec{fig:class.nonvirt}{3} +\cxxsec{fig:class.virt}{4} +\cxxsec{fig:class.virtnonvirt}{5} +\cxxsec{class.virtual}{11.7.3} +\cxxsec{class.abstract}{11.7.4} +\cxxsec{class.member.lookup}{11.8} +\cxxsec{fig:class.lookup}{6} +\cxxsec{class.access}{11.9} +\cxxsec{class.access.general}{11.9.1} +\cxxsec{class.access.spec}{11.9.2} +\cxxsec{class.access.base}{11.9.3} +\cxxsec{class.friend}{11.9.4} +\cxxsec{class.protected}{11.9.5} +\cxxsec{class.access.virt}{11.9.6} +\cxxsec{class.paths}{11.9.7} +\cxxsec{class.access.nest}{11.9.8} +\cxxsec{class.init}{11.10} +\cxxsec{class.init.general}{11.10.1} +\cxxsec{class.expl.init}{11.10.2} +\cxxsec{class.base.init}{11.10.3} +\cxxsec{class.inhctor.init}{11.10.4} +\cxxsec{class.cdtor}{11.10.5} +\cxxsec{class.copy.elision}{11.10.6} +\cxxsec{class.compare}{11.11} +\cxxsec{class.compare.default}{11.11.1} +\cxxsec{class.eq}{11.11.2} +\cxxsec{class.spaceship}{11.11.3} +\cxxsec{class.compare.secondary}{11.11.4} +\cxxsec{class.free}{11.12} +\cxxsec{diff}{Annex C} +\cxxsec{diff.cpp17}{C.1} +\cxxsec{diff.cpp17.general}{C.1.1} +\cxxsec{diff.cpp17.lex}{C.1.2} +\cxxsec{diff.cpp17.basic}{C.1.3} +\cxxsec{diff.cpp17.expr}{C.1.4} +\cxxsec{diff.cpp17.dcl.dcl}{C.1.5} +\cxxsec{diff.cpp17.class}{C.1.6} +\cxxsec{diff.cpp17.over}{C.1.7} +\cxxsec{diff.cpp17.temp}{C.1.8} +\cxxsec{diff.cpp17.except}{C.1.9} +\cxxsec{diff.cpp17.library}{C.1.10} +\cxxsec{diff.cpp17.containers}{C.1.11} +\cxxsec{diff.cpp17.iterators}{C.1.12} +\cxxsec{diff.cpp17.alg.reqs}{C.1.13} +\cxxsec{diff.cpp17.input.output}{C.1.14} +\cxxsec{diff.cpp17.depr}{C.1.15} +\cxxsec{diff.cpp14}{C.2} +\cxxsec{diff.cpp14.general}{C.2.1} +\cxxsec{diff.cpp14.lex}{C.2.2} +\cxxsec{diff.cpp14.expr}{C.2.3} +\cxxsec{diff.cpp14.dcl.dcl}{C.2.4} +\cxxsec{diff.cpp14.class}{C.2.5} +\cxxsec{diff.cpp14.temp}{C.2.6} +\cxxsec{diff.cpp14.except}{C.2.7} +\cxxsec{diff.cpp14.library}{C.2.8} +\cxxsec{diff.cpp14.utilities}{C.2.9} +\cxxsec{diff.cpp14.string}{C.2.10} +\cxxsec{diff.cpp14.containers}{C.2.11} +\cxxsec{diff.cpp14.depr}{C.2.12} +\cxxsec{diff.cpp11}{C.3} +\cxxsec{diff.cpp11.general}{C.3.1} +\cxxsec{diff.cpp11.lex}{C.3.2} +\cxxsec{diff.cpp11.basic}{C.3.3} +\cxxsec{diff.cpp11.expr}{C.3.4} +\cxxsec{diff.cpp11.dcl.dcl}{C.3.5} +\cxxsec{diff.cpp11.library}{C.3.6} +\cxxsec{diff.cpp11.input.output}{C.3.7} +\cxxsec{diff.cpp03}{C.4} +\cxxsec{diff.cpp03.general}{C.4.1} +\cxxsec{diff.cpp03.lex}{C.4.2} +\cxxsec{diff.cpp03.expr}{C.4.3} +\cxxsec{diff.cpp03.dcl.dcl}{C.4.4} +\cxxsec{diff.cpp03.class}{C.4.5} +\cxxsec{diff.cpp03.temp}{C.4.6} +\cxxsec{diff.cpp03.library}{C.4.7} +\cxxsec{diff.cpp03.language.support}{C.4.8} +\cxxsec{diff.cpp03.diagnostics}{C.4.9} +\cxxsec{diff.cpp03.utilities}{C.4.10} +\cxxsec{diff.cpp03.strings}{C.4.11} +\cxxsec{diff.cpp03.containers}{C.4.12} +\cxxsec{diff.cpp03.algorithms}{C.4.13} +\cxxsec{diff.cpp03.numerics}{C.4.14} +\cxxsec{diff.cpp03.input.output}{C.4.15} +\cxxsec{diff.iso}{C.5} +\cxxsec{diff.iso.general}{C.5.1} +\cxxsec{diff.lex}{C.5.2} +\cxxsec{diff.basic}{C.5.3} +\cxxsec{diff.expr}{C.5.4} +\cxxsec{diff.stat}{C.5.5} +\cxxsec{diff.dcl}{C.5.6} +\cxxsec{diff.class}{C.5.7} +\cxxsec{diff.cpp}{C.5.8} +\cxxsec{diff.library}{C.6} +\cxxsec{diff.library.general}{C.6.1} +\cxxsec{diff.mods.to.headers}{C.6.2} +\cxxsec{diff.mods.to.definitions}{C.6.3} +\cxxsec{diff.char16}{C.6.3.1} +\cxxsec{diff.wchar.t}{C.6.3.2} +\cxxsec{diff.header.assert.h}{C.6.3.3} +\cxxsec{diff.header.iso646.h}{C.6.3.4} +\cxxsec{diff.header.stdalign.h}{C.6.3.5} +\cxxsec{diff.header.stdbool.h}{C.6.3.6} +\cxxsec{diff.null}{C.6.3.7} +\cxxsec{diff.mods.to.declarations}{C.6.4} +\cxxsec{diff.mods.to.behavior}{C.6.5} +\cxxsec{diff.mods.to.behavior.general}{C.6.5.1} +\cxxsec{diff.offsetof}{C.6.5.2} +\cxxsec{diff.malloc}{C.6.5.3} +\cxxsec{concepts}{Clause 18} +\cxxsec{concepts.general}{18.1} +\cxxsec{tab:concepts.summary}{39} +\cxxsec{concepts.equality}{18.2} +\cxxsec{concepts.syn}{18.3} +\cxxsec{concepts.lang}{18.4} +\cxxsec{concepts.lang.general}{18.4.1} +\cxxsec{concept.same}{18.4.2} +\cxxsec{concept.derived}{18.4.3} +\cxxsec{concept.convertible}{18.4.4} +\cxxsec{concept.commonref}{18.4.5} +\cxxsec{concept.common}{18.4.6} +\cxxsec{concepts.arithmetic}{18.4.7} +\cxxsec{concept.assignable}{18.4.8} +\cxxsec{concept.swappable}{18.4.9} +\cxxsec{concept.destructible}{18.4.10} +\cxxsec{concept.constructible}{18.4.11} +\cxxsec{concept.default.init}{18.4.12} +\cxxsec{concept.moveconstructible}{18.4.13} +\cxxsec{concept.copyconstructible}{18.4.14} +\cxxsec{concepts.compare}{18.5} +\cxxsec{concepts.compare.general}{18.5.1} +\cxxsec{concept.booleantestable}{18.5.2} +\cxxsec{concept.equalitycomparable}{18.5.3} +\cxxsec{concept.totallyordered}{18.5.4} +\cxxsec{concepts.object}{18.6} +\cxxsec{concepts.callable}{18.7} +\cxxsec{concepts.callable.general}{18.7.1} +\cxxsec{concept.invocable}{18.7.2} +\cxxsec{concept.regularinvocable}{18.7.3} +\cxxsec{concept.predicate}{18.7.4} +\cxxsec{concept.relation}{18.7.5} +\cxxsec{concept.equiv}{18.7.6} +\cxxsec{concept.strictweakorder}{18.7.7} +\cxxsec{containers}{Clause 22} +\cxxsec{containers.general}{22.1} +\cxxsec{tab:containers.summary}{72} +\cxxsec{container.requirements}{22.2} +\cxxsec{container.requirements.general}{22.2.1} +\cxxsec{tab:container.req}{73} +\cxxsec{tab:container.rev.req}{74} +\cxxsec{tab:container.opt}{75} +\cxxsec{tab:container.alloc.req}{76} +\cxxsec{container.requirements.dataraces}{22.2.2} +\cxxsec{sequence.reqmts}{22.2.3} +\cxxsec{tab:container.seq.req}{77} +\cxxsec{tab:container.seq.opt}{78} +\cxxsec{container.node}{22.2.4} +\cxxsec{container.node.overview}{22.2.4.1} +\cxxsec{tab:container.node.compat}{79} +\cxxsec{container.node.cons}{22.2.4.2} +\cxxsec{container.node.dtor}{22.2.4.3} +\cxxsec{container.node.observers}{22.2.4.4} +\cxxsec{container.node.modifiers}{22.2.4.5} +\cxxsec{container.insert.return}{22.2.5} +\cxxsec{associative.reqmts}{22.2.6} +\cxxsec{associative.reqmts.general}{22.2.6.1} +\cxxsec{tab:container.assoc.req}{80} +\cxxsec{associative.reqmts.except}{22.2.6.2} +\cxxsec{unord.req}{22.2.7} +\cxxsec{unord.req.general}{22.2.7.1} +\cxxsec{tab:container.hash.req}{81} +\cxxsec{unord.req.except}{22.2.7.2} +\cxxsec{sequences}{22.3} +\cxxsec{sequences.general}{22.3.1} +\cxxsec{array.syn}{22.3.2} +\cxxsec{deque.syn}{22.3.3} +\cxxsec{forward.list.syn}{22.3.4} +\cxxsec{list.syn}{22.3.5} +\cxxsec{vector.syn}{22.3.6} +\cxxsec{array}{22.3.7} +\cxxsec{array.overview}{22.3.7.1} +\cxxsec{array.cons}{22.3.7.2} +\cxxsec{array.members}{22.3.7.3} +\cxxsec{array.special}{22.3.7.4} +\cxxsec{array.zero}{22.3.7.5} +\cxxsec{array.creation}{22.3.7.6} +\cxxsec{array.tuple}{22.3.7.7} +\cxxsec{deque}{22.3.8} +\cxxsec{deque.overview}{22.3.8.1} +\cxxsec{deque.cons}{22.3.8.2} +\cxxsec{deque.capacity}{22.3.8.3} +\cxxsec{deque.modifiers}{22.3.8.4} +\cxxsec{deque.erasure}{22.3.8.5} +\cxxsec{forwardlist}{22.3.9} +\cxxsec{forwardlist.overview}{22.3.9.1} +\cxxsec{forwardlist.cons}{22.3.9.2} +\cxxsec{forwardlist.iter}{22.3.9.3} +\cxxsec{forwardlist.access}{22.3.9.4} +\cxxsec{forwardlist.modifiers}{22.3.9.5} +\cxxsec{forwardlist.ops}{22.3.9.6} +\cxxsec{forward.list.erasure}{22.3.9.7} +\cxxsec{list}{22.3.10} +\cxxsec{list.overview}{22.3.10.1} +\cxxsec{list.cons}{22.3.10.2} +\cxxsec{list.capacity}{22.3.10.3} +\cxxsec{list.modifiers}{22.3.10.4} +\cxxsec{list.ops}{22.3.10.5} +\cxxsec{list.erasure}{22.3.10.6} +\cxxsec{vector}{22.3.11} +\cxxsec{vector.overview}{22.3.11.1} +\cxxsec{vector.cons}{22.3.11.2} +\cxxsec{vector.capacity}{22.3.11.3} +\cxxsec{vector.data}{22.3.11.4} +\cxxsec{vector.modifiers}{22.3.11.5} +\cxxsec{vector.erasure}{22.3.11.6} +\cxxsec{vector.bool}{22.3.12} +\cxxsec{associative}{22.4} +\cxxsec{associative.general}{22.4.1} +\cxxsec{associative.map.syn}{22.4.2} +\cxxsec{associative.set.syn}{22.4.3} +\cxxsec{map}{22.4.4} +\cxxsec{map.overview}{22.4.4.1} +\cxxsec{map.cons}{22.4.4.2} +\cxxsec{map.access}{22.4.4.3} +\cxxsec{map.modifiers}{22.4.4.4} +\cxxsec{map.erasure}{22.4.4.5} +\cxxsec{multimap}{22.4.5} +\cxxsec{multimap.overview}{22.4.5.1} +\cxxsec{multimap.cons}{22.4.5.2} +\cxxsec{multimap.modifiers}{22.4.5.3} +\cxxsec{multimap.erasure}{22.4.5.4} +\cxxsec{set}{22.4.6} +\cxxsec{set.overview}{22.4.6.1} +\cxxsec{set.cons}{22.4.6.2} +\cxxsec{set.erasure}{22.4.6.3} +\cxxsec{multiset}{22.4.7} +\cxxsec{multiset.overview}{22.4.7.1} +\cxxsec{multiset.cons}{22.4.7.2} +\cxxsec{multiset.erasure}{22.4.7.3} +\cxxsec{unord}{22.5} +\cxxsec{unord.general}{22.5.1} +\cxxsec{unord.map.syn}{22.5.2} +\cxxsec{unord.set.syn}{22.5.3} +\cxxsec{unord.map}{22.5.4} +\cxxsec{unord.map.overview}{22.5.4.1} +\cxxsec{unord.map.cnstr}{22.5.4.2} +\cxxsec{unord.map.elem}{22.5.4.3} +\cxxsec{unord.map.modifiers}{22.5.4.4} +\cxxsec{unord.map.erasure}{22.5.4.5} +\cxxsec{unord.multimap}{22.5.5} +\cxxsec{unord.multimap.overview}{22.5.5.1} +\cxxsec{unord.multimap.cnstr}{22.5.5.2} +\cxxsec{unord.multimap.modifiers}{22.5.5.3} +\cxxsec{unord.multimap.erasure}{22.5.5.4} +\cxxsec{unord.set}{22.5.6} +\cxxsec{unord.set.overview}{22.5.6.1} +\cxxsec{unord.set.cnstr}{22.5.6.2} +\cxxsec{unord.set.erasure}{22.5.6.3} +\cxxsec{unord.multiset}{22.5.7} +\cxxsec{unord.multiset.overview}{22.5.7.1} +\cxxsec{unord.multiset.cnstr}{22.5.7.2} +\cxxsec{unord.multiset.erasure}{22.5.7.3} +\cxxsec{container.adaptors}{22.6} +\cxxsec{container.adaptors.general}{22.6.1} +\cxxsec{queue.syn}{22.6.2} +\cxxsec{stack.syn}{22.6.3} +\cxxsec{queue}{22.6.4} +\cxxsec{queue.defn}{22.6.4.1} +\cxxsec{queue.cons}{22.6.4.2} +\cxxsec{queue.cons.alloc}{22.6.4.3} +\cxxsec{queue.ops}{22.6.4.4} +\cxxsec{queue.special}{22.6.4.5} +\cxxsec{priority.queue}{22.6.5} +\cxxsec{priqueue.overview}{22.6.5.1} +\cxxsec{priqueue.cons}{22.6.5.2} +\cxxsec{priqueue.cons.alloc}{22.6.5.3} +\cxxsec{priqueue.members}{22.6.5.4} +\cxxsec{priqueue.special}{22.6.5.5} +\cxxsec{stack}{22.6.6} +\cxxsec{stack.general}{22.6.6.1} +\cxxsec{stack.defn}{22.6.6.2} +\cxxsec{stack.cons}{22.6.6.3} +\cxxsec{stack.cons.alloc}{22.6.6.4} +\cxxsec{stack.ops}{22.6.6.5} +\cxxsec{stack.special}{22.6.6.6} +\cxxsec{views}{22.7} +\cxxsec{views.general}{22.7.1} +\cxxsec{span.syn}{22.7.2} +\cxxsec{views.span}{22.7.3} +\cxxsec{span.overview}{22.7.3.1} +\cxxsec{span.cons}{22.7.3.2} +\cxxsec{span.deduct}{22.7.3.3} +\cxxsec{span.sub}{22.7.3.4} +\cxxsec{span.obs}{22.7.3.5} +\cxxsec{span.elem}{22.7.3.6} +\cxxsec{span.iterators}{22.7.3.7} +\cxxsec{span.objectrep}{22.7.3.8} +\cxxsec{dcl.dcl}{Clause 9} +\cxxsec{dcl.pre}{9.1} +\cxxsec{dcl.spec}{9.2} +\cxxsec{dcl.spec.general}{9.2.1} +\cxxsec{dcl.stc}{9.2.2} +\cxxsec{dcl.fct.spec}{9.2.3} +\cxxsec{dcl.typedef}{9.2.4} +\cxxsec{dcl.friend}{9.2.5} +\cxxsec{dcl.constexpr}{9.2.6} +\cxxsec{dcl.constinit}{9.2.7} +\cxxsec{dcl.inline}{9.2.8} +\cxxsec{dcl.type}{9.2.9} +\cxxsec{dcl.type.general}{9.2.9.1} +\cxxsec{dcl.type.cv}{9.2.9.2} +\cxxsec{dcl.type.simple}{9.2.9.3} +\cxxsec{dcl.type.elab}{9.2.9.4} +\cxxsec{tab:dcl.type.simple}{14} +\cxxsec{dcl.type.decltype}{9.2.9.5} +\cxxsec{dcl.spec.auto}{9.2.9.6} +\cxxsec{dcl.spec.auto.general}{9.2.9.6.1} +\cxxsec{dcl.type.auto.deduct}{9.2.9.6.2} +\cxxsec{dcl.type.class.deduct}{9.2.9.7} +\cxxsec{dcl.decl}{9.3} +\cxxsec{dcl.decl.general}{9.3.1} +\cxxsec{dcl.name}{9.3.2} +\cxxsec{dcl.ambig.res}{9.3.3} +\cxxsec{dcl.meaning}{9.3.4} +\cxxsec{dcl.meaning.general}{9.3.4.1} +\cxxsec{dcl.ptr}{9.3.4.2} +\cxxsec{dcl.ref}{9.3.4.3} +\cxxsec{dcl.mptr}{9.3.4.4} +\cxxsec{dcl.array}{9.3.4.5} +\cxxsec{dcl.fct}{9.3.4.6} +\cxxsec{dcl.fct.default}{9.3.4.7} +\cxxsec{dcl.init}{9.4} +\cxxsec{dcl.init.general}{9.4.1} +\cxxsec{dcl.init.aggr}{9.4.2} +\cxxsec{dcl.init.string}{9.4.3} +\cxxsec{dcl.init.ref}{9.4.4} +\cxxsec{dcl.init.list}{9.4.5} +\cxxsec{dcl.fct.def}{9.5} +\cxxsec{dcl.fct.def.general}{9.5.1} +\cxxsec{dcl.fct.def.default}{9.5.2} +\cxxsec{dcl.fct.def.delete}{9.5.3} +\cxxsec{dcl.fct.def.coroutine}{9.5.4} +\cxxsec{dcl.struct.bind}{9.6} +\cxxsec{enum}{9.7} +\cxxsec{dcl.enum}{9.7.1} +\cxxsec{enum.udecl}{9.7.2} +\cxxsec{basic.namespace}{9.8} +\cxxsec{basic.namespace.general}{9.8.1} +\cxxsec{namespace.def}{9.8.2} +\cxxsec{namespace.def.general}{9.8.2.1} +\cxxsec{namespace.unnamed}{9.8.2.2} +\cxxsec{namespace.memdef}{9.8.2.3} +\cxxsec{namespace.alias}{9.8.3} +\cxxsec{namespace.udir}{9.8.4} +\cxxsec{namespace.udecl}{9.9} +\cxxsec{dcl.asm}{9.10} +\cxxsec{dcl.link}{9.11} +\cxxsec{dcl.attr}{9.12} +\cxxsec{dcl.attr.grammar}{9.12.1} +\cxxsec{dcl.align}{9.12.2} +\cxxsec{dcl.attr.depend}{9.12.3} +\cxxsec{dcl.attr.deprecated}{9.12.4} +\cxxsec{dcl.attr.fallthrough}{9.12.5} +\cxxsec{dcl.attr.likelihood}{9.12.6} +\cxxsec{dcl.attr.unused}{9.12.7} +\cxxsec{dcl.attr.nodiscard}{9.12.8} +\cxxsec{dcl.attr.noreturn}{9.12.9} +\cxxsec{dcl.attr.nouniqueaddr}{9.12.10} +\cxxsec{diagnostics}{Clause 19} +\cxxsec{diagnostics.general}{19.1} +\cxxsec{tab:diagnostics.summary}{40} +\cxxsec{std.exceptions}{19.2} +\cxxsec{std.exceptions.general}{19.2.1} +\cxxsec{stdexcept.syn}{19.2.2} +\cxxsec{logic.error}{19.2.3} +\cxxsec{domain.error}{19.2.4} +\cxxsec{invalid.argument}{19.2.5} +\cxxsec{length.error}{19.2.6} +\cxxsec{out.of.range}{19.2.7} +\cxxsec{runtime.error}{19.2.8} +\cxxsec{range.error}{19.2.9} +\cxxsec{overflow.error}{19.2.10} +\cxxsec{underflow.error}{19.2.11} +\cxxsec{assertions}{19.3} +\cxxsec{assertions.general}{19.3.1} +\cxxsec{cassert.syn}{19.3.2} +\cxxsec{assertions.assert}{19.3.3} +\cxxsec{errno}{19.4} +\cxxsec{errno.general}{19.4.1} +\cxxsec{cerrno.syn}{19.4.2} +\cxxsec{syserr}{19.5} +\cxxsec{syserr.general}{19.5.1} +\cxxsec{system.error.syn}{19.5.2} +\cxxsec{syserr.errcat}{19.5.3} +\cxxsec{syserr.errcat.overview}{19.5.3.1} +\cxxsec{syserr.errcat.virtuals}{19.5.3.2} +\cxxsec{syserr.errcat.nonvirtuals}{19.5.3.3} +\cxxsec{syserr.errcat.derived}{19.5.3.4} +\cxxsec{syserr.errcat.objects}{19.5.3.5} +\cxxsec{syserr.errcode}{19.5.4} +\cxxsec{syserr.errcode.overview}{19.5.4.1} +\cxxsec{syserr.errcode.constructors}{19.5.4.2} +\cxxsec{syserr.errcode.modifiers}{19.5.4.3} +\cxxsec{syserr.errcode.observers}{19.5.4.4} +\cxxsec{syserr.errcode.nonmembers}{19.5.4.5} +\cxxsec{syserr.errcondition}{19.5.5} +\cxxsec{syserr.errcondition.overview}{19.5.5.1} +\cxxsec{syserr.errcondition.constructors}{19.5.5.2} +\cxxsec{syserr.errcondition.modifiers}{19.5.5.3} +\cxxsec{syserr.errcondition.observers}{19.5.5.4} +\cxxsec{syserr.errcondition.nonmembers}{19.5.5.5} +\cxxsec{syserr.compare}{19.5.6} +\cxxsec{syserr.hash}{19.5.7} +\cxxsec{syserr.syserr}{19.5.8} +\cxxsec{syserr.syserr.overview}{19.5.8.1} +\cxxsec{syserr.syserr.members}{19.5.8.2} +\cxxsec{except}{Clause 14} +\cxxsec{except.pre}{14.1} +\cxxsec{except.throw}{14.2} +\cxxsec{except.ctor}{14.3} +\cxxsec{except.handle}{14.4} +\cxxsec{except.spec}{14.5} +\cxxsec{except.special}{14.6} +\cxxsec{except.special.general}{14.6.1} +\cxxsec{except.terminate}{14.6.2} +\cxxsec{except.uncaught}{14.6.3} +\cxxsec{expr}{Clause 7} +\cxxsec{expr.pre}{7.1} +\cxxsec{expr.prop}{7.2} +\cxxsec{basic.lval}{7.2.1} +\cxxsec{fig:basic.lval}{1} +\cxxsec{expr.type}{7.2.2} +\cxxsec{expr.context}{7.2.3} +\cxxsec{conv}{7.3} +\cxxsec{conv.general}{7.3.1} +\cxxsec{conv.lval}{7.3.2} +\cxxsec{conv.array}{7.3.3} +\cxxsec{conv.func}{7.3.4} +\cxxsec{conv.rval}{7.3.5} +\cxxsec{conv.qual}{7.3.6} +\cxxsec{conv.prom}{7.3.7} +\cxxsec{conv.fpprom}{7.3.8} +\cxxsec{conv.integral}{7.3.9} +\cxxsec{conv.double}{7.3.10} +\cxxsec{conv.fpint}{7.3.11} +\cxxsec{conv.ptr}{7.3.12} +\cxxsec{conv.mem}{7.3.13} +\cxxsec{conv.fctptr}{7.3.14} +\cxxsec{conv.bool}{7.3.15} +\cxxsec{expr.arith.conv}{7.4} +\cxxsec{expr.prim}{7.5} +\cxxsec{expr.prim.literal}{7.5.1} +\cxxsec{expr.prim.this}{7.5.2} +\cxxsec{expr.prim.paren}{7.5.3} +\cxxsec{expr.prim.id}{7.5.4} +\cxxsec{expr.prim.id.general}{7.5.4.1} +\cxxsec{expr.prim.id.unqual}{7.5.4.2} +\cxxsec{expr.prim.id.qual}{7.5.4.3} +\cxxsec{expr.prim.id.dtor}{7.5.4.4} +\cxxsec{expr.prim.lambda}{7.5.5} +\cxxsec{expr.prim.lambda.general}{7.5.5.1} +\cxxsec{expr.prim.lambda.closure}{7.5.5.2} +\cxxsec{expr.prim.lambda.capture}{7.5.5.3} +\cxxsec{expr.prim.fold}{7.5.6} +\cxxsec{expr.prim.req}{7.5.7} +\cxxsec{expr.prim.req.general}{7.5.7.1} +\cxxsec{expr.prim.req.simple}{7.5.7.2} +\cxxsec{expr.prim.req.type}{7.5.7.3} +\cxxsec{expr.prim.req.compound}{7.5.7.4} +\cxxsec{expr.prim.req.nested}{7.5.7.5} +\cxxsec{expr.compound}{7.6} +\cxxsec{expr.post}{7.6.1} +\cxxsec{expr.post.general}{7.6.1.1} +\cxxsec{expr.sub}{7.6.1.2} +\cxxsec{expr.call}{7.6.1.3} +\cxxsec{expr.type.conv}{7.6.1.4} +\cxxsec{expr.ref}{7.6.1.5} +\cxxsec{expr.post.incr}{7.6.1.6} +\cxxsec{expr.dynamic.cast}{7.6.1.7} +\cxxsec{expr.typeid}{7.6.1.8} +\cxxsec{expr.static.cast}{7.6.1.9} +\cxxsec{expr.reinterpret.cast}{7.6.1.10} +\cxxsec{expr.const.cast}{7.6.1.11} +\cxxsec{expr.unary}{7.6.2} +\cxxsec{expr.unary.general}{7.6.2.1} +\cxxsec{expr.unary.op}{7.6.2.2} +\cxxsec{expr.pre.incr}{7.6.2.3} +\cxxsec{expr.await}{7.6.2.4} +\cxxsec{expr.sizeof}{7.6.2.5} +\cxxsec{expr.alignof}{7.6.2.6} +\cxxsec{expr.unary.noexcept}{7.6.2.7} +\cxxsec{expr.new}{7.6.2.8} +\cxxsec{expr.delete}{7.6.2.9} +\cxxsec{expr.cast}{7.6.3} +\cxxsec{expr.mptr.oper}{7.6.4} +\cxxsec{expr.mul}{7.6.5} +\cxxsec{expr.add}{7.6.6} +\cxxsec{expr.shift}{7.6.7} +\cxxsec{expr.spaceship}{7.6.8} +\cxxsec{expr.rel}{7.6.9} +\cxxsec{expr.eq}{7.6.10} +\cxxsec{expr.bit.and}{7.6.11} +\cxxsec{expr.xor}{7.6.12} +\cxxsec{expr.or}{7.6.13} +\cxxsec{expr.log.and}{7.6.14} +\cxxsec{expr.log.or}{7.6.15} +\cxxsec{expr.cond}{7.6.16} +\cxxsec{expr.yield}{7.6.17} +\cxxsec{expr.throw}{7.6.18} +\cxxsec{expr.ass}{7.6.19} +\cxxsec{expr.comma}{7.6.20} +\cxxsec{expr.const}{7.7} +\cxxsec{depr}{Annex D} +\cxxsec{depr.general}{D.1} +\cxxsec{depr.arith.conv.enum}{D.2} +\cxxsec{depr.capture.this}{D.3} +\cxxsec{depr.comma.subscript}{D.4} +\cxxsec{depr.array.comp}{D.5} +\cxxsec{depr.volatile.type}{D.6} +\cxxsec{depr.static.constexpr}{D.7} +\cxxsec{depr.local}{D.8} +\cxxsec{depr.impldec}{D.9} +\cxxsec{depr.c.headers}{D.10} +\cxxsec{depr.c.headers.general}{D.10.1} +\cxxsec{tab:depr.c.headers}{147} +\cxxsec{depr.complex.h.syn}{D.10.2} +\cxxsec{depr.iso646.h.syn}{D.10.3} +\cxxsec{depr.stdalign.h.syn}{D.10.4} +\cxxsec{depr.stdbool.h.syn}{D.10.5} +\cxxsec{depr.tgmath.h.syn}{D.10.6} +\cxxsec{depr.c.headers.other}{D.10.7} +\cxxsec{depr.res.on.required}{D.11} +\cxxsec{depr.relops}{D.12} +\cxxsec{depr.str.strstreams}{D.13} +\cxxsec{depr.strstream.syn}{D.13.1} +\cxxsec{depr.strstreambuf}{D.13.2} +\cxxsec{depr.strstreambuf.general}{D.13.2.1} +\cxxsec{depr.strstreambuf.cons}{D.13.2.2} +\cxxsec{tab:depr.strstreambuf.cons.sz}{148} +\cxxsec{tab:depr.strstreambuf.cons.alloc}{149} +\cxxsec{tab:depr.strstreambuf.cons.ptr}{150} +\cxxsec{depr.strstreambuf.members}{D.13.2.3} +\cxxsec{depr.strstreambuf.virtuals}{D.13.2.4} +\cxxsec{tab:depr.strstreambuf.seekoff.pos}{151} +\cxxsec{tab:depr.strstreambuf.seekoff.newoff}{152} +\cxxsec{depr.istrstream}{D.13.3} +\cxxsec{depr.istrstream.general}{D.13.3.1} +\cxxsec{depr.istrstream.cons}{D.13.3.2} +\cxxsec{depr.istrstream.members}{D.13.3.3} +\cxxsec{depr.ostrstream}{D.13.4} +\cxxsec{depr.ostrstream.general}{D.13.4.1} +\cxxsec{depr.ostrstream.cons}{D.13.4.2} +\cxxsec{depr.ostrstream.members}{D.13.4.3} +\cxxsec{depr.strstream}{D.13.5} +\cxxsec{depr.strstream.general}{D.13.5.1} +\cxxsec{depr.strstream.cons}{D.13.5.2} +\cxxsec{depr.strstream.dest}{D.13.5.3} +\cxxsec{depr.strstream.oper}{D.13.5.4} +\cxxsec{depr.meta.types}{D.14} +\cxxsec{depr.tuple}{D.15} +\cxxsec{depr.variant}{D.16} +\cxxsec{depr.iterator}{D.17} +\cxxsec{depr.move.iter.elem}{D.18} +\cxxsec{depr.util.smartptr.shared.atomic}{D.19} +\cxxsec{depr.string.capacity}{D.20} +\cxxsec{depr.locale.stdcvt}{D.21} +\cxxsec{depr.locale.stdcvt.general}{D.21.1} +\cxxsec{depr.codecvt.syn}{D.21.2} +\cxxsec{depr.locale.stdcvt.req}{D.21.3} +\cxxsec{depr.conversions}{D.22} +\cxxsec{depr.conversions.general}{D.22.1} +\cxxsec{depr.conversions.string}{D.22.2} +\cxxsec{depr.conversions.buffer}{D.22.3} +\cxxsec{depr.locale.category}{D.23} +\cxxsec{depr.fs.path.factory}{D.24} +\cxxsec{depr.atomics}{D.25} +\cxxsec{depr.atomics.general}{D.25.1} +\cxxsec{depr.atomics.volatile}{D.25.2} +\cxxsec{depr.atomics.nonmembers}{D.25.3} +\cxxsec{depr.atomics.types.operations}{D.25.4} +\cxxsec{depr.atomics.flag}{D.25.5} +\cxxsec{gram}{Annex A} +\cxxsec{gram.general}{A.1} +\cxxsec{gram.key}{A.2} +\cxxsec{gram.lex}{A.3} +\cxxsec{gram.basic}{A.4} +\cxxsec{gram.expr}{A.5} +\cxxsec{gram.stmt}{A.6} +\cxxsec{gram.dcl}{A.7} +\cxxsec{gram.module}{A.8} +\cxxsec{gram.class}{A.9} +\cxxsec{gram.over}{A.10} +\cxxsec{gram.temp}{A.11} +\cxxsec{gram.except}{A.12} +\cxxsec{gram.cpp}{A.13} +\cxxsec{intro.scope}{Clause 1} +\cxxsec{intro.refs}{Clause 2} +\cxxsec{intro.defs}{Clause 3} +\cxxsec{defns.access}{3.1} +\cxxsec{defns.arbitrary.stream}{3.2} +\cxxsec{defns.argument}{3.3} +\cxxsec{defns.argument.macro}{3.4} +\cxxsec{defns.argument.throw}{3.5} +\cxxsec{defns.argument.templ}{3.6} +\cxxsec{defns.block}{3.7} +\cxxsec{defns.block.stmt}{3.8} +\cxxsec{defns.character}{3.9} +\cxxsec{defns.character.container}{3.10} +\cxxsec{defns.component}{3.11} +\cxxsec{defns.cond.supp}{3.12} +\cxxsec{defns.const.subexpr}{3.13} +\cxxsec{defns.deadlock}{3.14} +\cxxsec{defns.default.behavior.impl}{3.15} +\cxxsec{defns.diagnostic}{3.16} +\cxxsec{defns.direct-non-list-init}{3.17} +\cxxsec{defns.dynamic.type}{3.18} +\cxxsec{defns.dynamic.type.prvalue}{3.19} +\cxxsec{defns.expression-equivalent}{3.20} +\cxxsec{defns.handler}{3.21} +\cxxsec{defns.ill.formed}{3.22} +\cxxsec{defns.impl.defined}{3.23} +\cxxsec{defns.order.ptr}{3.24} +\cxxsec{defns.impl.limits}{3.25} +\cxxsec{defns.iostream.templates}{3.26} +\cxxsec{defns.locale.specific}{3.27} +\cxxsec{defns.modifier}{3.28} +\cxxsec{defns.move.assign}{3.29} +\cxxsec{defns.move.constr}{3.30} +\cxxsec{defns.multibyte}{3.31} +\cxxsec{defns.ntcts}{3.32} +\cxxsec{defns.observer}{3.33} +\cxxsec{defns.parameter}{3.34} +\cxxsec{defns.parameter.macro}{3.35} +\cxxsec{defns.parameter.templ}{3.36} +\cxxsec{defns.prog.def.spec}{3.37} +\cxxsec{defns.prog.def.type}{3.38} +\cxxsec{defns.projection}{3.39} +\cxxsec{defns.referenceable}{3.40} +\cxxsec{defns.replacement}{3.41} +\cxxsec{defns.repositional.stream}{3.42} +\cxxsec{defns.required.behavior}{3.43} +\cxxsec{defns.reserved.function}{3.44} +\cxxsec{defns.signature}{3.45} +\cxxsec{defns.signature.friend}{3.46} +\cxxsec{defns.signature.templ}{3.47} +\cxxsec{defns.signature.templ.friend}{3.48} +\cxxsec{defns.signature.spec}{3.49} +\cxxsec{defns.signature.member}{3.50} +\cxxsec{defns.signature.member.templ}{3.51} +\cxxsec{defns.signature.member.spec}{3.52} +\cxxsec{defns.stable}{3.53} +\cxxsec{defns.static.type}{3.54} +\cxxsec{defns.traits}{3.55} +\cxxsec{defns.unblock}{3.56} +\cxxsec{defns.undefined}{3.57} +\cxxsec{defns.unspecified}{3.58} +\cxxsec{defns.valid}{3.59} +\cxxsec{defns.well.formed}{3.60} +\cxxsec{intro}{Clause 4} +\cxxsec{intro.compliance}{4.1} +\cxxsec{intro.compliance.general}{4.1.1} +\cxxsec{intro.abstract}{4.1.2} +\cxxsec{intro.structure}{4.2} +\cxxsec{syntax}{4.3} +\cxxsec{input.output}{Clause 29} +\cxxsec{input.output.general}{29.1} +\cxxsec{tab:iostreams.summary}{115} +\cxxsec{fig:iostreams.streampos}{7} +\cxxsec{iostreams.requirements}{29.2} +\cxxsec{iostream.limits.imbue}{29.2.1} +\cxxsec{iostreams.limits.pos}{29.2.2} +\cxxsec{iostreams.threadsafety}{29.2.3} +\cxxsec{iostream.forward}{29.3} +\cxxsec{iosfwd.syn}{29.3.1} +\cxxsec{iostream.forward.overview}{29.3.2} +\cxxsec{iostream.objects}{29.4} +\cxxsec{iostream.syn}{29.4.1} +\cxxsec{iostream.objects.overview}{29.4.2} +\cxxsec{narrow.stream.objects}{29.4.3} +\cxxsec{wide.stream.objects}{29.4.4} +\cxxsec{iostreams.base}{29.5} +\cxxsec{ios.syn}{29.5.1} +\cxxsec{stream.types}{29.5.2} +\cxxsec{ios.base}{29.5.3} +\cxxsec{ios.base.general}{29.5.3.1} +\cxxsec{ios.types}{29.5.3.2} +\cxxsec{ios.failure}{29.5.3.2.1} +\cxxsec{ios.fmtflags}{29.5.3.2.2} +\cxxsec{ios.iostate}{29.5.3.2.3} +\cxxsec{ios.openmode}{29.5.3.2.4} +\cxxsec{ios.seekdir}{29.5.3.2.5} +\cxxsec{tab:ios.fmtflags}{116} +\cxxsec{tab:ios.fmtflags.const}{117} +\cxxsec{tab:ios.iostate}{118} +\cxxsec{tab:ios.openmode}{119} +\cxxsec{tab:ios.seekdir}{120} +\cxxsec{ios.init}{29.5.3.2.6} +\cxxsec{fmtflags.state}{29.5.3.3} +\cxxsec{ios.base.locales}{29.5.3.4} +\cxxsec{ios.members.static}{29.5.3.5} +\cxxsec{ios.base.storage}{29.5.3.6} +\cxxsec{ios.base.callback}{29.5.3.7} +\cxxsec{ios.base.cons}{29.5.3.8} +\cxxsec{fpos}{29.5.4} +\cxxsec{fpos.members}{29.5.4.1} +\cxxsec{fpos.operations}{29.5.4.2} +\cxxsec{tab:fpos.operations}{121} +\cxxsec{ios}{29.5.5} +\cxxsec{ios.overview}{29.5.5.1} +\cxxsec{basic.ios.cons}{29.5.5.2} +\cxxsec{tab:basic.ios.cons}{122} +\cxxsec{basic.ios.members}{29.5.5.3} +\cxxsec{tab:basic.ios.copyfmt}{123} +\cxxsec{iostate.flags}{29.5.5.4} +\cxxsec{std.ios.manip}{29.5.6} +\cxxsec{fmtflags.manip}{29.5.6.1} +\cxxsec{adjustfield.manip}{29.5.6.2} +\cxxsec{basefield.manip}{29.5.6.3} +\cxxsec{floatfield.manip}{29.5.6.4} +\cxxsec{error.reporting}{29.5.7} +\cxxsec{stream.buffers}{29.6} +\cxxsec{streambuf.syn}{29.6.1} +\cxxsec{streambuf.reqts}{29.6.2} +\cxxsec{streambuf}{29.6.3} +\cxxsec{streambuf.general}{29.6.3.1} +\cxxsec{streambuf.cons}{29.6.3.2} +\cxxsec{streambuf.members}{29.6.3.3} +\cxxsec{streambuf.locales}{29.6.3.3.1} +\cxxsec{streambuf.buffer}{29.6.3.3.2} +\cxxsec{streambuf.pub.get}{29.6.3.3.3} +\cxxsec{streambuf.pub.pback}{29.6.3.3.4} +\cxxsec{streambuf.pub.put}{29.6.3.3.5} +\cxxsec{streambuf.protected}{29.6.3.4} +\cxxsec{streambuf.assign}{29.6.3.4.1} +\cxxsec{streambuf.get.area}{29.6.3.4.2} +\cxxsec{streambuf.put.area}{29.6.3.4.3} +\cxxsec{streambuf.virtuals}{29.6.3.5} +\cxxsec{streambuf.virt.locales}{29.6.3.5.1} +\cxxsec{streambuf.virt.buffer}{29.6.3.5.2} +\cxxsec{streambuf.virt.get}{29.6.3.5.3} +\cxxsec{streambuf.virt.pback}{29.6.3.5.4} +\cxxsec{streambuf.virt.put}{29.6.3.5.5} +\cxxsec{iostream.format}{29.7} +\cxxsec{istream.syn}{29.7.1} +\cxxsec{ostream.syn}{29.7.2} +\cxxsec{iomanip.syn}{29.7.3} +\cxxsec{input.streams}{29.7.4} +\cxxsec{input.streams.general}{29.7.4.1} +\cxxsec{istream}{29.7.4.2} +\cxxsec{istream.general}{29.7.4.2.1} +\cxxsec{istream.cons}{29.7.4.2.2} +\cxxsec{istream.assign}{29.7.4.2.3} +\cxxsec{istream.sentry}{29.7.4.2.4} +\cxxsec{istream.formatted}{29.7.4.3} +\cxxsec{istream.formatted.reqmts}{29.7.4.3.1} +\cxxsec{istream.formatted.arithmetic}{29.7.4.3.2} +\cxxsec{istream.extractors}{29.7.4.3.3} +\cxxsec{istream.unformatted}{29.7.4.4} +\cxxsec{istream.manip}{29.7.4.5} +\cxxsec{istream.rvalue}{29.7.4.6} +\cxxsec{iostreamclass}{29.7.4.7} +\cxxsec{iostreamclass.general}{29.7.4.7.1} +\cxxsec{iostream.cons}{29.7.4.7.2} +\cxxsec{iostream.dest}{29.7.4.7.3} +\cxxsec{iostream.assign}{29.7.4.7.4} +\cxxsec{output.streams}{29.7.5} +\cxxsec{output.streams.general}{29.7.5.1} +\cxxsec{ostream}{29.7.5.2} +\cxxsec{ostream.general}{29.7.5.2.1} +\cxxsec{ostream.cons}{29.7.5.2.2} +\cxxsec{ostream.assign}{29.7.5.2.3} +\cxxsec{ostream.sentry}{29.7.5.2.4} +\cxxsec{ostream.seeks}{29.7.5.2.5} +\cxxsec{ostream.formatted}{29.7.5.3} +\cxxsec{ostream.formatted.reqmts}{29.7.5.3.1} +\cxxsec{ostream.inserters.arithmetic}{29.7.5.3.2} +\cxxsec{ostream.inserters}{29.7.5.3.3} +\cxxsec{ostream.inserters.character}{29.7.5.3.4} +\cxxsec{ostream.unformatted}{29.7.5.4} +\cxxsec{ostream.manip}{29.7.5.5} +\cxxsec{ostream.rvalue}{29.7.5.6} +\cxxsec{std.manip}{29.7.6} +\cxxsec{ext.manip}{29.7.7} +\cxxsec{quoted.manip}{29.7.8} +\cxxsec{string.streams}{29.8} +\cxxsec{sstream.syn}{29.8.1} +\cxxsec{stringbuf}{29.8.2} +\cxxsec{stringbuf.general}{29.8.2.1} +\cxxsec{stringbuf.cons}{29.8.2.2} +\cxxsec{stringbuf.assign}{29.8.2.3} +\cxxsec{stringbuf.members}{29.8.2.4} +\cxxsec{stringbuf.virtuals}{29.8.2.5} +\cxxsec{tab:stringbuf.seekoff.pos}{124} +\cxxsec{tab:stringbuf.seekoff.newoff}{125} +\cxxsec{istringstream}{29.8.3} +\cxxsec{istringstream.general}{29.8.3.1} +\cxxsec{istringstream.cons}{29.8.3.2} +\cxxsec{istringstream.assign}{29.8.3.3} +\cxxsec{istringstream.members}{29.8.3.4} +\cxxsec{ostringstream}{29.8.4} +\cxxsec{ostringstream.general}{29.8.4.1} +\cxxsec{ostringstream.cons}{29.8.4.2} +\cxxsec{ostringstream.assign}{29.8.4.3} +\cxxsec{ostringstream.members}{29.8.4.4} +\cxxsec{stringstream}{29.8.5} +\cxxsec{stringstream.general}{29.8.5.1} +\cxxsec{stringstream.cons}{29.8.5.2} +\cxxsec{stringstream.assign}{29.8.5.3} +\cxxsec{stringstream.members}{29.8.5.4} +\cxxsec{file.streams}{29.9} +\cxxsec{fstream.syn}{29.9.1} +\cxxsec{filebuf}{29.9.2} +\cxxsec{filebuf.general}{29.9.2.1} +\cxxsec{filebuf.cons}{29.9.2.2} +\cxxsec{filebuf.assign}{29.9.2.3} +\cxxsec{filebuf.members}{29.9.2.4} +\cxxsec{tab:filebuf.open.modes}{126} +\cxxsec{filebuf.virtuals}{29.9.2.5} +\cxxsec{tab:filebuf.seekoff}{127} +\cxxsec{ifstream}{29.9.3} +\cxxsec{ifstream.general}{29.9.3.1} +\cxxsec{ifstream.cons}{29.9.3.2} +\cxxsec{ifstream.assign}{29.9.3.3} +\cxxsec{ifstream.members}{29.9.3.4} +\cxxsec{ofstream}{29.9.4} +\cxxsec{ofstream.general}{29.9.4.1} +\cxxsec{ofstream.cons}{29.9.4.2} +\cxxsec{ofstream.assign}{29.9.4.3} +\cxxsec{ofstream.members}{29.9.4.4} +\cxxsec{fstream}{29.9.5} +\cxxsec{fstream.general}{29.9.5.1} +\cxxsec{fstream.cons}{29.9.5.2} +\cxxsec{fstream.assign}{29.9.5.3} +\cxxsec{fstream.members}{29.9.5.4} +\cxxsec{syncstream}{29.10} +\cxxsec{syncstream.syn}{29.10.1} +\cxxsec{syncstream.syncbuf}{29.10.2} +\cxxsec{syncstream.syncbuf.overview}{29.10.2.1} +\cxxsec{syncstream.syncbuf.cons}{29.10.2.2} +\cxxsec{syncstream.syncbuf.assign}{29.10.2.3} +\cxxsec{syncstream.syncbuf.members}{29.10.2.4} +\cxxsec{syncstream.syncbuf.virtuals}{29.10.2.5} +\cxxsec{syncstream.syncbuf.special}{29.10.2.6} +\cxxsec{syncstream.osyncstream}{29.10.3} +\cxxsec{syncstream.osyncstream.overview}{29.10.3.1} +\cxxsec{syncstream.osyncstream.cons}{29.10.3.2} +\cxxsec{syncstream.osyncstream.members}{29.10.3.3} +\cxxsec{filesystems}{29.11} +\cxxsec{fs.general}{29.11.1} +\cxxsec{fs.conformance}{29.11.2} +\cxxsec{fs.conformance.general}{29.11.2.1} +\cxxsec{fs.conform.9945}{29.11.2.2} +\cxxsec{fs.conform.os}{29.11.2.3} +\cxxsec{fs.race.behavior}{29.11.2.4} +\cxxsec{fs.req}{29.11.3} +\cxxsec{fs.req.general}{29.11.3.1} +\cxxsec{fs.req.namespace}{29.11.3.2} +\cxxsec{fs.filesystem.syn}{29.11.4} +\cxxsec{fs.err.report}{29.11.5} +\cxxsec{fs.class.path}{29.11.6} +\cxxsec{fs.class.path.general}{29.11.6.1} +\cxxsec{fs.path.generic}{29.11.6.2} +\cxxsec{fs.path.cvt}{29.11.6.3} +\cxxsec{fs.path.fmt.cvt}{29.11.6.3.1} +\cxxsec{fs.path.type.cvt}{29.11.6.3.2} +\cxxsec{fs.path.req}{29.11.6.4} +\cxxsec{fs.path.member}{29.11.6.5} +\cxxsec{fs.path.construct}{29.11.6.5.1} +\cxxsec{fs.path.assign}{29.11.6.5.2} +\cxxsec{fs.path.append}{29.11.6.5.3} +\cxxsec{fs.path.concat}{29.11.6.5.4} +\cxxsec{fs.path.modifiers}{29.11.6.5.5} +\cxxsec{fs.path.native.obs}{29.11.6.5.6} +\cxxsec{fs.path.generic.obs}{29.11.6.5.7} +\cxxsec{fs.path.compare}{29.11.6.5.8} +\cxxsec{fs.path.decompose}{29.11.6.5.9} +\cxxsec{fs.path.query}{29.11.6.5.10} +\cxxsec{fs.path.gen}{29.11.6.5.11} +\cxxsec{fs.path.itr}{29.11.6.6} +\cxxsec{fs.path.io}{29.11.6.7} +\cxxsec{fs.path.nonmember}{29.11.6.8} +\cxxsec{fs.class.filesystem.error}{29.11.7} +\cxxsec{fs.class.filesystem.error.general}{29.11.7.1} +\cxxsec{fs.filesystem.error.members}{29.11.7.2} +\cxxsec{fs.enum}{29.11.8} +\cxxsec{fs.enum.path.format}{29.11.8.1} +\cxxsec{tab:fs.enum.path.format}{128} +\cxxsec{fs.enum.file.type}{29.11.8.2} +\cxxsec{tab:fs.enum.file.type}{129} +\cxxsec{fs.enum.copy.opts}{29.11.8.3} +\cxxsec{tab:fs.enum.copy.opts}{130} +\cxxsec{tab:fs.enum.perms}{131} +\cxxsec{fs.enum.perms}{29.11.8.4} +\cxxsec{fs.enum.perm.opts}{29.11.8.5} +\cxxsec{tab:fs.enum.perm.opts}{132} +\cxxsec{fs.enum.dir.opts}{29.11.8.6} +\cxxsec{tab:fs.enum.dir.opts}{133} +\cxxsec{fs.class.file.status}{29.11.9} +\cxxsec{fs.class.file.status.general}{29.11.9.1} +\cxxsec{fs.file.status.cons}{29.11.9.2} +\cxxsec{fs.file.status.obs}{29.11.9.3} +\cxxsec{fs.file.status.mods}{29.11.9.4} +\cxxsec{fs.class.directory.entry}{29.11.10} +\cxxsec{fs.class.directory.entry.general}{29.11.10.1} +\cxxsec{fs.dir.entry.cons}{29.11.10.2} +\cxxsec{fs.dir.entry.mods}{29.11.10.3} +\cxxsec{fs.dir.entry.obs}{29.11.10.4} +\cxxsec{fs.class.directory.iterator}{29.11.11} +\cxxsec{fs.class.directory.iterator.general}{29.11.11.1} +\cxxsec{fs.dir.itr.members}{29.11.11.2} +\cxxsec{fs.dir.itr.nonmembers}{29.11.11.3} +\cxxsec{fs.class.rec.dir.itr}{29.11.12} +\cxxsec{fs.class.rec.dir.itr.general}{29.11.12.1} +\cxxsec{fs.rec.dir.itr.members}{29.11.12.2} +\cxxsec{fs.rec.dir.itr.nonmembers}{29.11.12.3} +\cxxsec{fs.op.funcs}{29.11.13} +\cxxsec{fs.op.funcs.general}{29.11.13.1} +\cxxsec{fs.op.absolute}{29.11.13.2} +\cxxsec{fs.op.canonical}{29.11.13.3} +\cxxsec{fs.op.copy}{29.11.13.4} +\cxxsec{fs.op.copy.file}{29.11.13.5} +\cxxsec{fs.op.copy.symlink}{29.11.13.6} +\cxxsec{fs.op.create.directories}{29.11.13.7} +\cxxsec{fs.op.create.directory}{29.11.13.8} +\cxxsec{fs.op.create.dir.symlk}{29.11.13.9} +\cxxsec{fs.op.create.hard.lk}{29.11.13.10} +\cxxsec{fs.op.create.symlink}{29.11.13.11} +\cxxsec{fs.op.current.path}{29.11.13.12} +\cxxsec{fs.op.equivalent}{29.11.13.13} +\cxxsec{fs.op.exists}{29.11.13.14} +\cxxsec{fs.op.file.size}{29.11.13.15} +\cxxsec{fs.op.hard.lk.ct}{29.11.13.16} +\cxxsec{fs.op.is.block.file}{29.11.13.17} +\cxxsec{fs.op.is.char.file}{29.11.13.18} +\cxxsec{fs.op.is.directory}{29.11.13.19} +\cxxsec{fs.op.is.empty}{29.11.13.20} +\cxxsec{fs.op.is.fifo}{29.11.13.21} +\cxxsec{fs.op.is.other}{29.11.13.22} +\cxxsec{fs.op.is.regular.file}{29.11.13.23} +\cxxsec{fs.op.is.socket}{29.11.13.24} +\cxxsec{fs.op.is.symlink}{29.11.13.25} +\cxxsec{fs.op.last.write.time}{29.11.13.26} +\cxxsec{fs.op.permissions}{29.11.13.27} +\cxxsec{fs.op.proximate}{29.11.13.28} +\cxxsec{fs.op.read.symlink}{29.11.13.29} +\cxxsec{fs.op.relative}{29.11.13.30} +\cxxsec{fs.op.remove}{29.11.13.31} +\cxxsec{fs.op.remove.all}{29.11.13.32} +\cxxsec{fs.op.rename}{29.11.13.33} +\cxxsec{fs.op.resize.file}{29.11.13.34} +\cxxsec{fs.op.space}{29.11.13.35} +\cxxsec{fs.op.status}{29.11.13.36} +\cxxsec{fs.op.status.known}{29.11.13.37} +\cxxsec{fs.op.symlink.status}{29.11.13.38} +\cxxsec{fs.op.temp.dir.path}{29.11.13.39} +\cxxsec{fs.op.weakly.canonical}{29.11.13.40} +\cxxsec{c.files}{29.12} +\cxxsec{cstdio.syn}{29.12.1} +\cxxsec{cinttypes.syn}{29.12.2} +\cxxsec{iterators}{Clause 23} +\cxxsec{iterators.general}{23.1} +\cxxsec{tab:iterators.summary}{82} +\cxxsec{iterator.synopsis}{23.2} +\cxxsec{iterator.requirements}{23.3} +\cxxsec{iterator.requirements.general}{23.3.1} +\cxxsec{tab:iterators.relations}{83} +\cxxsec{iterator.assoc.types}{23.3.2} +\cxxsec{incrementable.traits}{23.3.2.1} +\cxxsec{readable.traits}{23.3.2.2} +\cxxsec{iterator.traits}{23.3.2.3} +\cxxsec{iterator.cust}{23.3.3} +\cxxsec{iterator.cust.move}{23.3.3.1} +\cxxsec{iterator.cust.swap}{23.3.3.2} +\cxxsec{iterator.concepts}{23.3.4} +\cxxsec{iterator.concepts.general}{23.3.4.1} +\cxxsec{iterator.concept.readable}{23.3.4.2} +\cxxsec{iterator.concept.writable}{23.3.4.3} +\cxxsec{iterator.concept.winc}{23.3.4.4} +\cxxsec{iterator.concept.inc}{23.3.4.5} +\cxxsec{iterator.concept.iterator}{23.3.4.6} +\cxxsec{iterator.concept.sentinel}{23.3.4.7} +\cxxsec{iterator.concept.sizedsentinel}{23.3.4.8} +\cxxsec{iterator.concept.input}{23.3.4.9} +\cxxsec{iterator.concept.output}{23.3.4.10} +\cxxsec{iterator.concept.forward}{23.3.4.11} +\cxxsec{iterator.concept.bidir}{23.3.4.12} +\cxxsec{iterator.concept.random.access}{23.3.4.13} +\cxxsec{iterator.concept.contiguous}{23.3.4.14} +\cxxsec{iterator.cpp17}{23.3.5} +\cxxsec{iterator.cpp17.general}{23.3.5.1} +\cxxsec{iterator.iterators}{23.3.5.2} +\cxxsec{tab:iterator}{84} +\cxxsec{input.iterators}{23.3.5.3} +\cxxsec{tab:inputiterator}{85} +\cxxsec{output.iterators}{23.3.5.4} +\cxxsec{tab:outputiterator}{86} +\cxxsec{forward.iterators}{23.3.5.5} +\cxxsec{tab:forwarditerator}{87} +\cxxsec{bidirectional.iterators}{23.3.5.6} +\cxxsec{random.access.iterators}{23.3.5.7} +\cxxsec{tab:bidirectionaliterator}{88} +\cxxsec{tab:randomaccessiterator}{89} +\cxxsec{indirectcallable}{23.3.6} +\cxxsec{indirectcallable.general}{23.3.6.1} +\cxxsec{indirectcallable.indirectinvocable}{23.3.6.2} +\cxxsec{projected}{23.3.6.3} +\cxxsec{alg.req}{23.3.7} +\cxxsec{alg.req.general}{23.3.7.1} +\cxxsec{alg.req.ind.move}{23.3.7.2} +\cxxsec{alg.req.ind.copy}{23.3.7.3} +\cxxsec{alg.req.ind.swap}{23.3.7.4} +\cxxsec{alg.req.ind.cmp}{23.3.7.5} +\cxxsec{alg.req.permutable}{23.3.7.6} +\cxxsec{alg.req.mergeable}{23.3.7.7} +\cxxsec{alg.req.sortable}{23.3.7.8} +\cxxsec{iterator.primitives}{23.4} +\cxxsec{iterator.primitives.general}{23.4.1} +\cxxsec{std.iterator.tags}{23.4.2} +\cxxsec{iterator.operations}{23.4.3} +\cxxsec{range.iter.ops}{23.4.4} +\cxxsec{range.iter.ops.general}{23.4.4.1} +\cxxsec{range.iter.op.advance}{23.4.4.2} +\cxxsec{range.iter.op.distance}{23.4.4.3} +\cxxsec{range.iter.op.next}{23.4.4.4} +\cxxsec{range.iter.op.prev}{23.4.4.5} +\cxxsec{predef.iterators}{23.5} +\cxxsec{reverse.iterators}{23.5.1} +\cxxsec{reverse.iterators.general}{23.5.1.1} +\cxxsec{reverse.iterator}{23.5.1.2} +\cxxsec{reverse.iter.requirements}{23.5.1.3} +\cxxsec{reverse.iter.cons}{23.5.1.4} +\cxxsec{reverse.iter.conv}{23.5.1.5} +\cxxsec{reverse.iter.elem}{23.5.1.6} +\cxxsec{reverse.iter.nav}{23.5.1.7} +\cxxsec{reverse.iter.cmp}{23.5.1.8} +\cxxsec{reverse.iter.nonmember}{23.5.1.9} +\cxxsec{insert.iterators}{23.5.2} +\cxxsec{insert.iterators.general}{23.5.2.1} +\cxxsec{back.insert.iterator}{23.5.2.2} +\cxxsec{back.insert.iter.ops}{23.5.2.2.1} +\cxxsec{back.inserter}{23.5.2.2.2} +\cxxsec{front.insert.iterator}{23.5.2.3} +\cxxsec{front.insert.iter.ops}{23.5.2.3.1} +\cxxsec{front.inserter}{23.5.2.3.2} +\cxxsec{insert.iterator}{23.5.2.4} +\cxxsec{insert.iter.ops}{23.5.2.4.1} +\cxxsec{inserter}{23.5.2.4.2} +\cxxsec{move.iterators}{23.5.3} +\cxxsec{move.iterators.general}{23.5.3.1} +\cxxsec{move.iterator}{23.5.3.2} +\cxxsec{move.iter.requirements}{23.5.3.3} +\cxxsec{move.iter.cons}{23.5.3.4} +\cxxsec{move.iter.op.conv}{23.5.3.5} +\cxxsec{move.iter.elem}{23.5.3.6} +\cxxsec{move.iter.nav}{23.5.3.7} +\cxxsec{move.iter.op.comp}{23.5.3.8} +\cxxsec{move.iter.nonmember}{23.5.3.9} +\cxxsec{move.sentinel}{23.5.3.10} +\cxxsec{move.sent.ops}{23.5.3.11} +\cxxsec{iterators.common}{23.5.4} +\cxxsec{common.iterator}{23.5.4.1} +\cxxsec{common.iter.types}{23.5.4.2} +\cxxsec{common.iter.const}{23.5.4.3} +\cxxsec{common.iter.access}{23.5.4.4} +\cxxsec{common.iter.nav}{23.5.4.5} +\cxxsec{common.iter.cmp}{23.5.4.6} +\cxxsec{common.iter.cust}{23.5.4.7} +\cxxsec{default.sentinel}{23.5.5} +\cxxsec{iterators.counted}{23.5.6} +\cxxsec{counted.iterator}{23.5.6.1} +\cxxsec{counted.iter.const}{23.5.6.2} +\cxxsec{counted.iter.access}{23.5.6.3} +\cxxsec{counted.iter.elem}{23.5.6.4} +\cxxsec{counted.iter.nav}{23.5.6.5} +\cxxsec{counted.iter.cmp}{23.5.6.6} +\cxxsec{counted.iter.cust}{23.5.6.7} +\cxxsec{unreachable.sentinel}{23.5.7} +\cxxsec{stream.iterators}{23.6} +\cxxsec{stream.iterators.general}{23.6.1} +\cxxsec{istream.iterator}{23.6.2} +\cxxsec{istream.iterator.general}{23.6.2.1} +\cxxsec{istream.iterator.cons}{23.6.2.2} +\cxxsec{istream.iterator.ops}{23.6.2.3} +\cxxsec{ostream.iterator}{23.6.3} +\cxxsec{ostream.iterator.general}{23.6.3.1} +\cxxsec{ostream.iterator.cons.des}{23.6.3.2} +\cxxsec{ostream.iterator.ops}{23.6.3.3} +\cxxsec{istreambuf.iterator}{23.6.4} +\cxxsec{istreambuf.iterator.general}{23.6.4.1} +\cxxsec{istreambuf.iterator.proxy}{23.6.4.2} +\cxxsec{istreambuf.iterator.cons}{23.6.4.3} +\cxxsec{istreambuf.iterator.ops}{23.6.4.4} +\cxxsec{ostreambuf.iterator}{23.6.5} +\cxxsec{ostreambuf.iterator.general}{23.6.5.1} +\cxxsec{ostreambuf.iter.cons}{23.6.5.2} +\cxxsec{ostreambuf.iter.ops}{23.6.5.3} +\cxxsec{iterator.range}{23.7} +\cxxsec{lex}{Clause 5} +\cxxsec{lex.separate}{5.1} +\cxxsec{lex.phases}{5.2} +\cxxsec{lex.charset}{5.3} +\cxxsec{lex.pptoken}{5.4} +\cxxsec{lex.digraph}{5.5} +\cxxsec{tab:lex.digraph}{1} +\cxxsec{lex.token}{5.6} +\cxxsec{lex.comment}{5.7} +\cxxsec{lex.header}{5.8} +\cxxsec{lex.ppnumber}{5.9} +\cxxsec{lex.name}{5.10} +\cxxsec{tab:lex.name.allowed}{2} +\cxxsec{tab:lex.name.disallowed}{3} +\cxxsec{tab:lex.name.special}{4} +\cxxsec{lex.key}{5.11} +\cxxsec{tab:lex.key}{5} +\cxxsec{tab:lex.key.digraph}{6} +\cxxsec{lex.operators}{5.12} +\cxxsec{lex.literal}{5.13} +\cxxsec{lex.literal.kinds}{5.13.1} +\cxxsec{lex.icon}{5.13.2} +\cxxsec{tab:lex.icon.base}{7} +\cxxsec{tab:lex.icon.type}{8} +\cxxsec{lex.ccon}{5.13.3} +\cxxsec{tab:lex.ccon.esc}{9} +\cxxsec{lex.fcon}{5.13.4} +\cxxsec{tab:lex.fcon.type}{10} +\cxxsec{lex.string}{5.13.5} +\cxxsec{tab:lex.string.concat}{11} +\cxxsec{lex.bool}{5.13.6} +\cxxsec{lex.nullptr}{5.13.7} +\cxxsec{lex.ext}{5.13.8} +\cxxsec{library}{Clause 16} +\cxxsec{library.general}{16.1} +\cxxsec{tab:library.categories}{20} +\cxxsec{library.c}{16.2} +\cxxsec{description}{16.3} +\cxxsec{description.general}{16.3.1} +\cxxsec{structure}{16.3.2} +\cxxsec{structure.elements}{16.3.2.1} +\cxxsec{structure.summary}{16.3.2.2} +\cxxsec{structure.requirements}{16.3.2.3} +\cxxsec{structure.specifications}{16.3.2.4} +\cxxsec{structure.see.also}{16.3.2.5} +\cxxsec{conventions}{16.3.3} +\cxxsec{conventions.general}{16.3.3.1} +\cxxsec{expos.only.func}{16.3.3.2} +\cxxsec{type.descriptions}{16.3.3.3} +\cxxsec{type.descriptions.general}{16.3.3.3.1} +\cxxsec{expos.only.types}{16.3.3.3.2} +\cxxsec{enumerated.types}{16.3.3.3.3} +\cxxsec{bitmask.types}{16.3.3.3.4} +\cxxsec{character.seq}{16.3.3.3.5} +\cxxsec{character.seq.general}{16.3.3.3.5.1} +\cxxsec{byte.strings}{16.3.3.3.5.2} +\cxxsec{multibyte.strings}{16.3.3.3.5.3} +\cxxsec{customization.point.object}{16.3.3.3.6} +\cxxsec{functions.within.classes}{16.3.3.4} +\cxxsec{objects.within.classes}{16.3.3.5} +\cxxsec{requirements}{16.4} +\cxxsec{requirements.general}{16.4.1} +\cxxsec{organization}{16.4.2} +\cxxsec{organization.general}{16.4.2.1} +\cxxsec{contents}{16.4.2.2} +\cxxsec{headers}{16.4.2.3} +\cxxsec{tab:headers.cpp}{21} +\cxxsec{tab:headers.cpp.c}{22} +\cxxsec{tab:c.annex.k.names}{23} +\cxxsec{compliance}{16.4.2.4} +\cxxsec{using}{16.4.3} +\cxxsec{using.overview}{16.4.3.1} +\cxxsec{tab:headers.cpp.fs}{24} +\cxxsec{using.headers}{16.4.3.2} +\cxxsec{using.linkage}{16.4.3.3} +\cxxsec{utility.requirements}{16.4.4} +\cxxsec{utility.requirements.general}{16.4.4.1} +\cxxsec{utility.arg.requirements}{16.4.4.2} +\cxxsec{tab:cpp17.equalitycomparable}{25} +\cxxsec{tab:cpp17.lessthancomparable}{26} +\cxxsec{tab:cpp17.defaultconstructible}{27} +\cxxsec{tab:cpp17.moveconstructible}{28} +\cxxsec{swappable.requirements}{16.4.4.3} +\cxxsec{tab:cpp17.copyconstructible}{29} +\cxxsec{tab:cpp17.moveassignable}{30} +\cxxsec{tab:cpp17.copyassignable}{31} +\cxxsec{tab:cpp17.destructible}{32} +\cxxsec{nullablepointer.requirements}{16.4.4.4} +\cxxsec{hash.requirements}{16.4.4.5} +\cxxsec{tab:cpp17.nullablepointer}{33} +\cxxsec{tab:cpp17.hash}{34} +\cxxsec{allocator.requirements}{16.4.4.6} +\cxxsec{allocator.requirements.general}{16.4.4.6.1} +\cxxsec{tab:cpp17.allocator}{36} +\cxxsec{tab:allocator.req.var}{35} +\cxxsec{allocator.requirements.completeness}{16.4.4.6.2} +\cxxsec{constraints}{16.4.5} +\cxxsec{constraints.overview}{16.4.5.1} +\cxxsec{namespace.constraints}{16.4.5.2} +\cxxsec{namespace.std}{16.4.5.2.1} +\cxxsec{namespace.posix}{16.4.5.2.2} +\cxxsec{namespace.future}{16.4.5.2.3} +\cxxsec{reserved.names}{16.4.5.3} +\cxxsec{reserved.names.general}{16.4.5.3.1} +\cxxsec{zombie.names}{16.4.5.3.2} +\cxxsec{macro.names}{16.4.5.3.3} +\cxxsec{extern.names}{16.4.5.3.4} +\cxxsec{extern.types}{16.4.5.3.5} +\cxxsec{usrlit.suffix}{16.4.5.3.6} +\cxxsec{alt.headers}{16.4.5.4} +\cxxsec{derived.classes}{16.4.5.5} +\cxxsec{replacement.functions}{16.4.5.6} +\cxxsec{handler.functions}{16.4.5.7} +\cxxsec{res.on.functions}{16.4.5.8} +\cxxsec{res.on.arguments}{16.4.5.9} +\cxxsec{res.on.objects}{16.4.5.10} +\cxxsec{res.on.requirements}{16.4.5.11} +\cxxsec{conforming}{16.4.6} +\cxxsec{conforming.overview}{16.4.6.1} +\cxxsec{res.on.headers}{16.4.6.2} +\cxxsec{res.on.macro.definitions}{16.4.6.3} +\cxxsec{global.functions}{16.4.6.4} +\cxxsec{member.functions}{16.4.6.5} +\cxxsec{hidden.friends}{16.4.6.6} +\cxxsec{constexpr.functions}{16.4.6.7} +\cxxsec{algorithm.stable}{16.4.6.8} +\cxxsec{reentrancy}{16.4.6.9} +\cxxsec{res.on.data.races}{16.4.6.10} +\cxxsec{protection.within.classes}{16.4.6.11} +\cxxsec{derivation}{16.4.6.12} +\cxxsec{res.on.exception.handling}{16.4.6.13} +\cxxsec{res.on.pointer.storage}{16.4.6.14} +\cxxsec{value.error.codes}{16.4.6.15} +\cxxsec{lib.types.movedfrom}{16.4.6.16} +\cxxsec{implimits}{Annex B} +\cxxsec{localization}{Clause 28} +\cxxsec{localization.general}{28.1} +\cxxsec{tab:localization.summary}{101} +\cxxsec{locale.syn}{28.2} +\cxxsec{locales}{28.3} +\cxxsec{locale}{28.3.1} +\cxxsec{locale.general}{28.3.1.1} +\cxxsec{locale.types}{28.3.1.2} +\cxxsec{locale.category}{28.3.1.2.1} +\cxxsec{tab:locale.category.facets}{102} +\cxxsec{tab:locale.spec}{103} +\cxxsec{locale.facet}{28.3.1.2.2} +\cxxsec{locale.id}{28.3.1.2.3} +\cxxsec{locale.cons}{28.3.1.3} +\cxxsec{locale.members}{28.3.1.4} +\cxxsec{locale.operators}{28.3.1.5} +\cxxsec{locale.statics}{28.3.1.6} +\cxxsec{locale.global.templates}{28.3.2} +\cxxsec{locale.convenience}{28.3.3} +\cxxsec{classification}{28.3.3.1} +\cxxsec{conversions.character}{28.3.3.2} +\cxxsec{locale.categories}{28.4} +\cxxsec{locale.categories.general}{28.4.1} +\cxxsec{category.ctype}{28.4.2} +\cxxsec{category.ctype.general}{28.4.2.1} +\cxxsec{locale.ctype}{28.4.2.2} +\cxxsec{locale.ctype.general}{28.4.2.2.1} +\cxxsec{locale.ctype.members}{28.4.2.2.2} +\cxxsec{locale.ctype.virtuals}{28.4.2.2.3} +\cxxsec{locale.ctype.byname}{28.4.2.3} +\cxxsec{facet.ctype.special}{28.4.2.4} +\cxxsec{facet.ctype.special.general}{28.4.2.4.1} +\cxxsec{facet.ctype.char.dtor}{28.4.2.4.2} +\cxxsec{facet.ctype.char.members}{28.4.2.4.3} +\cxxsec{facet.ctype.char.statics}{28.4.2.4.4} +\cxxsec{facet.ctype.char.virtuals}{28.4.2.4.5} +\cxxsec{locale.codecvt}{28.4.2.5} +\cxxsec{locale.codecvt.general}{28.4.2.5.1} +\cxxsec{locale.codecvt.members}{28.4.2.5.2} +\cxxsec{locale.codecvt.virtuals}{28.4.2.5.3} +\cxxsec{tab:locale.codecvt.inout}{104} +\cxxsec{tab:locale.codecvt.unshift}{105} +\cxxsec{locale.codecvt.byname}{28.4.2.6} +\cxxsec{category.numeric}{28.4.3} +\cxxsec{category.numeric.general}{28.4.3.1} +\cxxsec{locale.num.get}{28.4.3.2} +\cxxsec{locale.num.get.general}{28.4.3.2.1} +\cxxsec{facet.num.get.members}{28.4.3.2.2} +\cxxsec{facet.num.get.virtuals}{28.4.3.2.3} +\cxxsec{tab:facet.num.get.int}{106} +\cxxsec{tab:facet.num.get.length}{107} +\cxxsec{locale.nm.put}{28.4.3.3} +\cxxsec{locale.nm.put.general}{28.4.3.3.1} +\cxxsec{facet.num.put.members}{28.4.3.3.2} +\cxxsec{facet.num.put.virtuals}{28.4.3.3.3} +\cxxsec{tab:facet.num.put.int}{108} +\cxxsec{tab:facet.num.put.fp}{109} +\cxxsec{tab:facet.num.put.length}{110} +\cxxsec{tab:facet.num.put.conv}{111} +\cxxsec{tab:facet.num.put.fill}{112} +\cxxsec{facet.numpunct}{28.4.4} +\cxxsec{locale.numpunct}{28.4.4.1} +\cxxsec{locale.numpunct.general}{28.4.4.1.1} +\cxxsec{facet.numpunct.members}{28.4.4.1.2} +\cxxsec{facet.numpunct.virtuals}{28.4.4.1.3} +\cxxsec{locale.numpunct.byname}{28.4.4.2} +\cxxsec{category.collate}{28.4.5} +\cxxsec{locale.collate}{28.4.5.1} +\cxxsec{locale.collate.general}{28.4.5.1.1} +\cxxsec{locale.collate.members}{28.4.5.1.2} +\cxxsec{locale.collate.virtuals}{28.4.5.1.3} +\cxxsec{locale.collate.byname}{28.4.5.2} +\cxxsec{category.time}{28.4.6} +\cxxsec{category.time.general}{28.4.6.1} +\cxxsec{locale.time.get}{28.4.6.2} +\cxxsec{locale.time.get.general}{28.4.6.2.1} +\cxxsec{locale.time.get.members}{28.4.6.2.2} +\cxxsec{locale.time.get.virtuals}{28.4.6.2.3} +\cxxsec{tab:locale.time.get.dogetdate}{113} +\cxxsec{locale.time.get.byname}{28.4.6.3} +\cxxsec{locale.time.put}{28.4.6.4} +\cxxsec{locale.time.put.members}{28.4.6.4.1} +\cxxsec{locale.time.put.virtuals}{28.4.6.4.2} +\cxxsec{locale.time.put.byname}{28.4.6.5} +\cxxsec{category.monetary}{28.4.7} +\cxxsec{category.monetary.general}{28.4.7.1} +\cxxsec{locale.money.get}{28.4.7.2} +\cxxsec{locale.money.get.members}{28.4.7.2.1} +\cxxsec{locale.money.get.virtuals}{28.4.7.2.2} +\cxxsec{locale.money.put}{28.4.7.3} +\cxxsec{locale.money.put.members}{28.4.7.3.1} +\cxxsec{locale.money.put.virtuals}{28.4.7.3.2} +\cxxsec{locale.moneypunct}{28.4.7.4} +\cxxsec{locale.moneypunct.general}{28.4.7.4.1} +\cxxsec{locale.moneypunct.members}{28.4.7.4.2} +\cxxsec{locale.moneypunct.virtuals}{28.4.7.4.3} +\cxxsec{locale.moneypunct.byname}{28.4.7.5} +\cxxsec{category.messages}{28.4.8} +\cxxsec{category.messages.general}{28.4.8.1} +\cxxsec{locale.messages}{28.4.8.2} +\cxxsec{locale.messages.general}{28.4.8.2.1} +\cxxsec{locale.messages.members}{28.4.8.2.2} +\cxxsec{locale.messages.virtuals}{28.4.8.2.3} +\cxxsec{locale.messages.byname}{28.4.8.3} +\cxxsec{c.locales}{28.5} +\cxxsec{clocale.syn}{28.5.1} +\cxxsec{clocale.data.races}{28.5.2} +\cxxsec{tab:setlocale.data.races}{114} +\cxxsec{module}{Clause 10} +\cxxsec{module.unit}{10.1} +\cxxsec{module.interface}{10.2} +\cxxsec{module.import}{10.3} +\cxxsec{module.global.frag}{10.4} +\cxxsec{module.private.frag}{10.5} +\cxxsec{module.context}{10.6} +\cxxsec{module.reach}{10.7} +\cxxsec{numerics}{Clause 26} +\cxxsec{numerics.general}{26.1} +\cxxsec{tab:numerics.summary}{92} +\cxxsec{numeric.requirements}{26.2} +\cxxsec{cfenv}{26.3} +\cxxsec{cfenv.syn}{26.3.1} +\cxxsec{cfenv.thread}{26.3.2} +\cxxsec{complex.numbers}{26.4} +\cxxsec{complex.numbers.general}{26.4.1} +\cxxsec{complex.syn}{26.4.2} +\cxxsec{complex}{26.4.3} +\cxxsec{complex.special}{26.4.4} +\cxxsec{complex.members}{26.4.5} +\cxxsec{complex.member.ops}{26.4.6} +\cxxsec{complex.ops}{26.4.7} +\cxxsec{complex.value.ops}{26.4.8} +\cxxsec{complex.transcendentals}{26.4.9} +\cxxsec{cmplx.over}{26.4.10} +\cxxsec{complex.literals}{26.4.11} +\cxxsec{bit}{26.5} +\cxxsec{bit.general}{26.5.1} +\cxxsec{bit.syn}{26.5.2} +\cxxsec{bit.cast}{26.5.3} +\cxxsec{bit.pow.two}{26.5.4} +\cxxsec{bit.rotate}{26.5.5} +\cxxsec{bit.count}{26.5.6} +\cxxsec{bit.endian}{26.5.7} +\cxxsec{rand}{26.6} +\cxxsec{rand.general}{26.6.1} +\cxxsec{rand.synopsis}{26.6.2} +\cxxsec{rand.req}{26.6.3} +\cxxsec{rand.req.genl}{26.6.3.1} +\cxxsec{rand.req.seedseq}{26.6.3.2} +\cxxsec{tab:rand.req.seedseq}{93} +\cxxsec{rand.req.urng}{26.6.3.3} +\cxxsec{rand.req.eng}{26.6.3.4} +\cxxsec{tab:rand.req.eng}{94} +\cxxsec{rand.req.adapt}{26.6.3.5} +\cxxsec{rand.req.dist}{26.6.3.6} +\cxxsec{tab:rand.req.dist}{95} +\cxxsec{rand.eng}{26.6.4} +\cxxsec{rand.eng.general}{26.6.4.1} +\cxxsec{rand.eng.lcong}{26.6.4.2} +\cxxsec{rand.eng.mers}{26.6.4.3} +\cxxsec{rand.eng.sub}{26.6.4.4} +\cxxsec{rand.adapt}{26.6.5} +\cxxsec{rand.adapt.general}{26.6.5.1} +\cxxsec{rand.adapt.disc}{26.6.5.2} +\cxxsec{rand.adapt.ibits}{26.6.5.3} +\cxxsec{rand.adapt.shuf}{26.6.5.4} +\cxxsec{rand.predef}{26.6.6} +\cxxsec{rand.device}{26.6.7} +\cxxsec{rand.util}{26.6.8} +\cxxsec{rand.util.seedseq}{26.6.8.1} +\cxxsec{rand.util.canonical}{26.6.8.2} +\cxxsec{rand.dist}{26.6.9} +\cxxsec{rand.dist.general}{26.6.9.1} +\cxxsec{rand.dist.uni}{26.6.9.2} +\cxxsec{rand.dist.uni.int}{26.6.9.2.1} +\cxxsec{rand.dist.uni.real}{26.6.9.2.2} +\cxxsec{rand.dist.bern}{26.6.9.3} +\cxxsec{rand.dist.bern.bernoulli}{26.6.9.3.1} +\cxxsec{rand.dist.bern.bin}{26.6.9.3.2} +\cxxsec{rand.dist.bern.geo}{26.6.9.3.3} +\cxxsec{rand.dist.bern.negbin}{26.6.9.3.4} +\cxxsec{rand.dist.pois}{26.6.9.4} +\cxxsec{rand.dist.pois.poisson}{26.6.9.4.1} +\cxxsec{rand.dist.pois.exp}{26.6.9.4.2} +\cxxsec{rand.dist.pois.gamma}{26.6.9.4.3} +\cxxsec{rand.dist.pois.weibull}{26.6.9.4.4} +\cxxsec{rand.dist.pois.extreme}{26.6.9.4.5} +\cxxsec{rand.dist.norm}{26.6.9.5} +\cxxsec{rand.dist.norm.normal}{26.6.9.5.1} +\cxxsec{rand.dist.norm.lognormal}{26.6.9.5.2} +\cxxsec{rand.dist.norm.chisq}{26.6.9.5.3} +\cxxsec{rand.dist.norm.cauchy}{26.6.9.5.4} +\cxxsec{rand.dist.norm.f}{26.6.9.5.5} +\cxxsec{rand.dist.norm.t}{26.6.9.5.6} +\cxxsec{rand.dist.samp}{26.6.9.6} +\cxxsec{rand.dist.samp.discrete}{26.6.9.6.1} +\cxxsec{rand.dist.samp.pconst}{26.6.9.6.2} +\cxxsec{rand.dist.samp.plinear}{26.6.9.6.3} +\cxxsec{c.math.rand}{26.6.10} +\cxxsec{numarray}{26.7} +\cxxsec{valarray.syn}{26.7.1} +\cxxsec{template.valarray}{26.7.2} +\cxxsec{template.valarray.overview}{26.7.2.1} +\cxxsec{valarray.cons}{26.7.2.2} +\cxxsec{valarray.assign}{26.7.2.3} +\cxxsec{valarray.access}{26.7.2.4} +\cxxsec{valarray.sub}{26.7.2.5} +\cxxsec{valarray.unary}{26.7.2.6} +\cxxsec{valarray.cassign}{26.7.2.7} +\cxxsec{valarray.members}{26.7.2.8} +\cxxsec{valarray.nonmembers}{26.7.3} +\cxxsec{valarray.binary}{26.7.3.1} +\cxxsec{valarray.comparison}{26.7.3.2} +\cxxsec{valarray.transcend}{26.7.3.3} +\cxxsec{valarray.special}{26.7.3.4} +\cxxsec{class.slice}{26.7.4} +\cxxsec{class.slice.overview}{26.7.4.1} +\cxxsec{cons.slice}{26.7.4.2} +\cxxsec{slice.access}{26.7.4.3} +\cxxsec{slice.ops}{26.7.4.4} +\cxxsec{template.slice.array}{26.7.5} +\cxxsec{template.slice.array.overview}{26.7.5.1} +\cxxsec{slice.arr.assign}{26.7.5.2} +\cxxsec{slice.arr.comp.assign}{26.7.5.3} +\cxxsec{slice.arr.fill}{26.7.5.4} +\cxxsec{class.gslice}{26.7.6} +\cxxsec{class.gslice.overview}{26.7.6.1} +\cxxsec{gslice.cons}{26.7.6.2} +\cxxsec{gslice.access}{26.7.6.3} +\cxxsec{template.gslice.array}{26.7.7} +\cxxsec{template.gslice.array.overview}{26.7.7.1} +\cxxsec{gslice.array.assign}{26.7.7.2} +\cxxsec{gslice.array.comp.assign}{26.7.7.3} +\cxxsec{gslice.array.fill}{26.7.7.4} +\cxxsec{template.mask.array}{26.7.8} +\cxxsec{template.mask.array.overview}{26.7.8.1} +\cxxsec{mask.array.assign}{26.7.8.2} +\cxxsec{mask.array.comp.assign}{26.7.8.3} +\cxxsec{mask.array.fill}{26.7.8.4} +\cxxsec{template.indirect.array}{26.7.9} +\cxxsec{template.indirect.array.overview}{26.7.9.1} +\cxxsec{indirect.array.assign}{26.7.9.2} +\cxxsec{indirect.array.comp.assign}{26.7.9.3} +\cxxsec{indirect.array.fill}{26.7.9.4} +\cxxsec{valarray.range}{26.7.10} +\cxxsec{c.math}{26.8} +\cxxsec{cmath.syn}{26.8.1} +\cxxsec{c.math.abs}{26.8.2} +\cxxsec{c.math.hypot3}{26.8.3} +\cxxsec{c.math.lerp}{26.8.4} +\cxxsec{c.math.fpclass}{26.8.5} +\cxxsec{sf.cmath}{26.8.6} +\cxxsec{sf.cmath.general}{26.8.6.1} +\cxxsec{sf.cmath.assoc.laguerre}{26.8.6.2} +\cxxsec{sf.cmath.assoc.legendre}{26.8.6.3} +\cxxsec{sf.cmath.beta}{26.8.6.4} +\cxxsec{sf.cmath.comp.ellint.1}{26.8.6.5} +\cxxsec{sf.cmath.comp.ellint.2}{26.8.6.6} +\cxxsec{sf.cmath.comp.ellint.3}{26.8.6.7} +\cxxsec{sf.cmath.cyl.bessel.i}{26.8.6.8} +\cxxsec{sf.cmath.cyl.bessel.j}{26.8.6.9} +\cxxsec{sf.cmath.cyl.bessel.k}{26.8.6.10} +\cxxsec{sf.cmath.cyl.neumann}{26.8.6.11} +\cxxsec{sf.cmath.ellint.1}{26.8.6.12} +\cxxsec{sf.cmath.ellint.2}{26.8.6.13} +\cxxsec{sf.cmath.ellint.3}{26.8.6.14} +\cxxsec{sf.cmath.expint}{26.8.6.15} +\cxxsec{sf.cmath.hermite}{26.8.6.16} +\cxxsec{sf.cmath.laguerre}{26.8.6.17} +\cxxsec{sf.cmath.legendre}{26.8.6.18} +\cxxsec{sf.cmath.riemann.zeta}{26.8.6.19} +\cxxsec{sf.cmath.sph.bessel}{26.8.6.20} +\cxxsec{sf.cmath.sph.legendre}{26.8.6.21} +\cxxsec{sf.cmath.sph.neumann}{26.8.6.22} +\cxxsec{numbers}{26.9} +\cxxsec{numbers.syn}{26.9.1} +\cxxsec{math.constants}{26.9.2} +\cxxsec{over}{Clause 12} +\cxxsec{over.pre}{12.1} +\cxxsec{over.load}{12.2} +\cxxsec{over.dcl}{12.3} +\cxxsec{over.match}{12.4} +\cxxsec{over.match.general}{12.4.1} +\cxxsec{over.match.funcs}{12.4.2} +\cxxsec{over.match.funcs.general}{12.4.2.1} +\cxxsec{over.match.call}{12.4.2.2} +\cxxsec{over.match.call.general}{12.4.2.2.1} +\cxxsec{over.call.func}{12.4.2.2.2} +\cxxsec{over.call.object}{12.4.2.2.3} +\cxxsec{over.match.oper}{12.4.2.3} +\cxxsec{tab:over.match.oper}{15} +\cxxsec{over.match.ctor}{12.4.2.4} +\cxxsec{over.match.copy}{12.4.2.5} +\cxxsec{over.match.conv}{12.4.2.6} +\cxxsec{over.match.ref}{12.4.2.7} +\cxxsec{over.match.list}{12.4.2.8} +\cxxsec{over.match.class.deduct}{12.4.2.9} +\cxxsec{over.match.viable}{12.4.3} +\cxxsec{over.match.best}{12.4.4} +\cxxsec{over.match.best.general}{12.4.4.1} +\cxxsec{over.best.ics}{12.4.4.2} +\cxxsec{over.best.ics.general}{12.4.4.2.1} +\cxxsec{over.ics.scs}{12.4.4.2.2} +\cxxsec{tab:over.ics.scs}{16} +\cxxsec{over.ics.user}{12.4.4.2.3} +\cxxsec{over.ics.ellipsis}{12.4.4.2.4} +\cxxsec{over.ics.ref}{12.4.4.2.5} +\cxxsec{over.ics.list}{12.4.4.2.6} +\cxxsec{over.ics.rank}{12.4.4.3} +\cxxsec{over.over}{12.5} +\cxxsec{over.oper}{12.6} +\cxxsec{over.oper.general}{12.6.1} +\cxxsec{over.unary}{12.6.2} +\cxxsec{over.binary}{12.6.3} +\cxxsec{over.binary.general}{12.6.3.1} +\cxxsec{over.ass}{12.6.3.2} +\cxxsec{over.call}{12.6.4} +\cxxsec{over.sub}{12.6.5} +\cxxsec{over.ref}{12.6.6} +\cxxsec{over.inc}{12.6.7} +\cxxsec{over.built}{12.7} +\cxxsec{over.literal}{12.8} +\cxxsec{cpp}{Clause 15} +\cxxsec{cpp.pre}{15.1} +\cxxsec{cpp.cond}{15.2} +\cxxsec{tab:cpp.cond.ha}{18} +\cxxsec{cpp.include}{15.3} +\cxxsec{cpp.module}{15.4} +\cxxsec{cpp.import}{15.5} +\cxxsec{cpp.replace}{15.6} +\cxxsec{cpp.replace.general}{15.6.1} +\cxxsec{cpp.subst}{15.6.2} +\cxxsec{cpp.stringize}{15.6.3} +\cxxsec{cpp.concat}{15.6.4} +\cxxsec{cpp.rescan}{15.6.5} +\cxxsec{cpp.scope}{15.6.6} +\cxxsec{cpp.line}{15.7} +\cxxsec{cpp.error}{15.8} +\cxxsec{cpp.pragma}{15.9} +\cxxsec{cpp.null}{15.10} +\cxxsec{cpp.predefined}{15.11} +\cxxsec{tab:cpp.predefined.ft}{19} +\cxxsec{cpp.pragma.op}{15.12} +\cxxsec{ranges}{Clause 24} +\cxxsec{ranges.general}{24.1} +\cxxsec{tab:range.summary}{90} +\cxxsec{ranges.syn}{24.2} +\cxxsec{range.access}{24.3} +\cxxsec{range.access.general}{24.3.1} +\cxxsec{range.access.begin}{24.3.2} +\cxxsec{range.access.end}{24.3.3} +\cxxsec{range.access.cbegin}{24.3.4} +\cxxsec{range.access.cend}{24.3.5} +\cxxsec{range.access.rbegin}{24.3.6} +\cxxsec{range.access.rend}{24.3.7} +\cxxsec{range.access.crbegin}{24.3.8} +\cxxsec{range.access.crend}{24.3.9} +\cxxsec{range.prim.size}{24.3.10} +\cxxsec{range.prim.ssize}{24.3.11} +\cxxsec{range.prim.empty}{24.3.12} +\cxxsec{range.prim.data}{24.3.13} +\cxxsec{range.prim.cdata}{24.3.14} +\cxxsec{range.req}{24.4} +\cxxsec{range.req.general}{24.4.1} +\cxxsec{range.range}{24.4.2} +\cxxsec{range.sized}{24.4.3} +\cxxsec{range.view}{24.4.4} +\cxxsec{range.refinements}{24.4.5} +\cxxsec{range.utility}{24.5} +\cxxsec{range.utility.general}{24.5.1} +\cxxsec{range.utility.helpers}{24.5.2} +\cxxsec{view.interface}{24.5.3} +\cxxsec{view.interface.general}{24.5.3.1} +\cxxsec{view.interface.members}{24.5.3.2} +\cxxsec{range.subrange}{24.5.4} +\cxxsec{range.subrange.general}{24.5.4.1} +\cxxsec{range.subrange.ctor}{24.5.4.2} +\cxxsec{range.subrange.access}{24.5.4.3} +\cxxsec{range.dangling}{24.5.5} +\cxxsec{range.factories}{24.6} +\cxxsec{range.factories.general}{24.6.1} +\cxxsec{range.empty}{24.6.2} +\cxxsec{range.empty.overview}{24.6.2.1} +\cxxsec{range.empty.view}{24.6.2.2} +\cxxsec{range.single}{24.6.3} +\cxxsec{range.single.overview}{24.6.3.1} +\cxxsec{range.single.view}{24.6.3.2} +\cxxsec{range.iota}{24.6.4} +\cxxsec{range.iota.overview}{24.6.4.1} +\cxxsec{range.iota.view}{24.6.4.2} +\cxxsec{range.iota.iterator}{24.6.4.3} +\cxxsec{range.iota.sentinel}{24.6.4.4} +\cxxsec{range.istream}{24.6.5} +\cxxsec{range.istream.overview}{24.6.5.1} +\cxxsec{range.istream.view}{24.6.5.2} +\cxxsec{range.istream.iterator}{24.6.5.3} +\cxxsec{range.adaptors}{24.7} +\cxxsec{range.adaptors.general}{24.7.1} +\cxxsec{range.adaptor.object}{24.7.2} +\cxxsec{range.semi.wrap}{24.7.3} +\cxxsec{range.all}{24.7.4} +\cxxsec{range.all.general}{24.7.4.1} +\cxxsec{range.ref.view}{24.7.4.2} +\cxxsec{range.filter}{24.7.5} +\cxxsec{range.filter.overview}{24.7.5.1} +\cxxsec{range.filter.view}{24.7.5.2} +\cxxsec{range.filter.iterator}{24.7.5.3} +\cxxsec{range.filter.sentinel}{24.7.5.4} +\cxxsec{range.transform}{24.7.6} +\cxxsec{range.transform.overview}{24.7.6.1} +\cxxsec{range.transform.view}{24.7.6.2} +\cxxsec{range.transform.iterator}{24.7.6.3} +\cxxsec{range.transform.sentinel}{24.7.6.4} +\cxxsec{range.take}{24.7.7} +\cxxsec{range.take.overview}{24.7.7.1} +\cxxsec{range.take.view}{24.7.7.2} +\cxxsec{range.take.sentinel}{24.7.7.3} +\cxxsec{range.take.while}{24.7.8} +\cxxsec{range.take.while.overview}{24.7.8.1} +\cxxsec{range.take.while.view}{24.7.8.2} +\cxxsec{range.take.while.sentinel}{24.7.8.3} +\cxxsec{range.drop}{24.7.9} +\cxxsec{range.drop.overview}{24.7.9.1} +\cxxsec{range.drop.view}{24.7.9.2} +\cxxsec{range.drop.while}{24.7.10} +\cxxsec{range.drop.while.overview}{24.7.10.1} +\cxxsec{range.drop.while.view}{24.7.10.2} +\cxxsec{range.join}{24.7.11} +\cxxsec{range.join.overview}{24.7.11.1} +\cxxsec{range.join.view}{24.7.11.2} +\cxxsec{range.join.iterator}{24.7.11.3} +\cxxsec{range.join.sentinel}{24.7.11.4} +\cxxsec{range.split}{24.7.12} +\cxxsec{range.split.overview}{24.7.12.1} +\cxxsec{range.split.view}{24.7.12.2} +\cxxsec{range.split.outer}{24.7.12.3} +\cxxsec{range.split.outer.value}{24.7.12.4} +\cxxsec{range.split.inner}{24.7.12.5} +\cxxsec{range.counted}{24.7.13} +\cxxsec{range.common}{24.7.14} +\cxxsec{range.common.overview}{24.7.14.1} +\cxxsec{range.common.view}{24.7.14.2} +\cxxsec{range.reverse}{24.7.15} +\cxxsec{range.reverse.overview}{24.7.15.1} +\cxxsec{range.reverse.view}{24.7.15.2} +\cxxsec{range.elements}{24.7.16} +\cxxsec{range.elements.overview}{24.7.16.1} +\cxxsec{range.elements.view}{24.7.16.2} +\cxxsec{range.elements.iterator}{24.7.16.3} +\cxxsec{range.elements.sentinel}{24.7.16.4} +\cxxsec{re}{Clause 30} +\cxxsec{re.general}{30.1} +\cxxsec{tab:re.summary}{134} +\cxxsec{re.def}{30.2} +\cxxsec{defns.regex.collating.element}{30.2.1} +\cxxsec{defns.regex.finite.state.machine}{30.2.2} +\cxxsec{defns.regex.format.specifier}{30.2.3} +\cxxsec{defns.regex.matched}{30.2.4} +\cxxsec{defns.regex.primary.equivalence.class}{30.2.5} +\cxxsec{defns.regex.regular.expression}{30.2.6} +\cxxsec{defns.regex.subexpression}{30.2.7} +\cxxsec{re.req}{30.3} +\cxxsec{tab:re.req}{135} +\cxxsec{re.syn}{30.4} +\cxxsec{re.const}{30.5} +\cxxsec{re.const.general}{30.5.1} +\cxxsec{re.synopt}{30.5.2} +\cxxsec{re.matchflag}{30.5.3} +\cxxsec{tab:re.synopt}{136} +\cxxsec{tab:re.matchflag}{137} +\cxxsec{re.err}{30.5.4} +\cxxsec{tab:re.err}{138} +\cxxsec{re.badexp}{30.6} +\cxxsec{re.traits}{30.7} +\cxxsec{re.regex}{30.8} +\cxxsec{re.regex.general}{30.8.1} +\cxxsec{tab:re.traits.classnames}{139} +\cxxsec{re.regex.construct}{30.8.2} +\cxxsec{re.regex.assign}{30.8.3} +\cxxsec{re.regex.operations}{30.8.4} +\cxxsec{re.regex.locale}{30.8.5} +\cxxsec{re.regex.swap}{30.8.6} +\cxxsec{re.regex.nonmemb}{30.8.7} +\cxxsec{re.submatch}{30.9} +\cxxsec{re.submatch.general}{30.9.1} +\cxxsec{re.submatch.members}{30.9.2} +\cxxsec{re.submatch.op}{30.9.3} +\cxxsec{re.results}{30.10} +\cxxsec{re.results.general}{30.10.1} +\cxxsec{re.results.const}{30.10.2} +\cxxsec{tab:re.results.const}{140} +\cxxsec{re.results.state}{30.10.3} +\cxxsec{re.results.size}{30.10.4} +\cxxsec{re.results.acc}{30.10.5} +\cxxsec{re.results.form}{30.10.6} +\cxxsec{re.results.all}{30.10.7} +\cxxsec{re.results.swap}{30.10.8} +\cxxsec{re.results.nonmember}{30.10.9} +\cxxsec{re.alg}{30.11} +\cxxsec{re.except}{30.11.1} +\cxxsec{re.alg.match}{30.11.2} +\cxxsec{tab:re.alg.match}{141} +\cxxsec{re.alg.search}{30.11.3} +\cxxsec{tab:re.alg.search}{142} +\cxxsec{re.alg.replace}{30.11.4} +\cxxsec{re.iter}{30.12} +\cxxsec{re.regiter}{30.12.1} +\cxxsec{re.regiter.general}{30.12.1.1} +\cxxsec{re.regiter.cnstr}{30.12.1.2} +\cxxsec{re.regiter.comp}{30.12.1.3} +\cxxsec{re.regiter.deref}{30.12.1.4} +\cxxsec{re.regiter.incr}{30.12.1.5} +\cxxsec{re.tokiter}{30.12.2} +\cxxsec{re.tokiter.general}{30.12.2.1} +\cxxsec{re.tokiter.cnstr}{30.12.2.2} +\cxxsec{re.tokiter.comp}{30.12.2.3} +\cxxsec{re.tokiter.deref}{30.12.2.4} +\cxxsec{re.tokiter.incr}{30.12.2.5} +\cxxsec{re.grammar}{30.13} +\cxxsec{stmt.stmt}{Clause 8} +\cxxsec{stmt.pre}{8.1} +\cxxsec{stmt.label}{8.2} +\cxxsec{stmt.expr}{8.3} +\cxxsec{stmt.block}{8.4} +\cxxsec{stmt.select}{8.5} +\cxxsec{stmt.select.general}{8.5.1} +\cxxsec{stmt.if}{8.5.2} +\cxxsec{stmt.switch}{8.5.3} +\cxxsec{stmt.iter}{8.6} +\cxxsec{stmt.iter.general}{8.6.1} +\cxxsec{stmt.while}{8.6.2} +\cxxsec{stmt.do}{8.6.3} +\cxxsec{stmt.for}{8.6.4} +\cxxsec{stmt.ranged}{8.6.5} +\cxxsec{stmt.jump}{8.7} +\cxxsec{stmt.jump.general}{8.7.1} +\cxxsec{stmt.break}{8.7.2} +\cxxsec{stmt.cont}{8.7.3} +\cxxsec{stmt.return}{8.7.4} +\cxxsec{stmt.return.coroutine}{8.7.5} +\cxxsec{stmt.goto}{8.7.6} +\cxxsec{stmt.dcl}{8.8} +\cxxsec{stmt.ambig}{8.9} +\cxxsec{strings}{Clause 21} +\cxxsec{strings.general}{21.1} +\cxxsec{tab:strings.summary}{68} +\cxxsec{char.traits}{21.2} +\cxxsec{char.traits.general}{21.2.1} +\cxxsec{char.traits.require}{21.2.2} +\cxxsec{tab:char.traits.req}{69} +\cxxsec{char.traits.typedefs}{21.2.3} +\cxxsec{char.traits.specializations}{21.2.4} +\cxxsec{char.traits.specializations.general}{21.2.4.1} +\cxxsec{char.traits.specializations.char}{21.2.4.2} +\cxxsec{char.traits.specializations.char8.t}{21.2.4.3} +\cxxsec{char.traits.specializations.char16.t}{21.2.4.4} +\cxxsec{char.traits.specializations.char32.t}{21.2.4.5} +\cxxsec{char.traits.specializations.wchar.t}{21.2.4.6} +\cxxsec{string.classes}{21.3} +\cxxsec{string.classes.general}{21.3.1} +\cxxsec{string.syn}{21.3.2} +\cxxsec{basic.string}{21.3.3} +\cxxsec{basic.string.general}{21.3.3.1} +\cxxsec{string.require}{21.3.3.2} +\cxxsec{string.cons}{21.3.3.3} +\cxxsec{string.iterators}{21.3.3.4} +\cxxsec{string.capacity}{21.3.3.5} +\cxxsec{string.access}{21.3.3.6} +\cxxsec{string.modifiers}{21.3.3.7} +\cxxsec{string.op.append}{21.3.3.7.1} +\cxxsec{string.append}{21.3.3.7.2} +\cxxsec{string.assign}{21.3.3.7.3} +\cxxsec{string.insert}{21.3.3.7.4} +\cxxsec{string.erase}{21.3.3.7.5} +\cxxsec{string.replace}{21.3.3.7.6} +\cxxsec{string.copy}{21.3.3.7.7} +\cxxsec{string.swap}{21.3.3.7.8} +\cxxsec{string.ops}{21.3.3.8} +\cxxsec{string.accessors}{21.3.3.8.1} +\cxxsec{string.find}{21.3.3.8.2} +\cxxsec{string.substr}{21.3.3.8.3} +\cxxsec{string.compare}{21.3.3.8.4} +\cxxsec{string.starts.with}{21.3.3.8.5} +\cxxsec{string.ends.with}{21.3.3.8.6} +\cxxsec{string.nonmembers}{21.3.4} +\cxxsec{string.op.plus}{21.3.4.1} +\cxxsec{string.cmp}{21.3.4.2} +\cxxsec{string.special}{21.3.4.3} +\cxxsec{string.io}{21.3.4.4} +\cxxsec{string.erasure}{21.3.4.5} +\cxxsec{string.conversions}{21.3.5} +\cxxsec{basic.string.hash}{21.3.6} +\cxxsec{basic.string.literals}{21.3.7} +\cxxsec{string.view}{21.4} +\cxxsec{string.view.general}{21.4.1} +\cxxsec{string.view.synop}{21.4.2} +\cxxsec{string.view.template}{21.4.3} +\cxxsec{string.view.template.general}{21.4.3.1} +\cxxsec{string.view.cons}{21.4.3.2} +\cxxsec{string.view.iterators}{21.4.3.3} +\cxxsec{string.view.capacity}{21.4.3.4} +\cxxsec{string.view.access}{21.4.3.5} +\cxxsec{string.view.modifiers}{21.4.3.6} +\cxxsec{string.view.ops}{21.4.3.7} +\cxxsec{tab:string.view.compare}{70} +\cxxsec{string.view.find}{21.4.3.8} +\cxxsec{string.view.deduct}{21.4.4} +\cxxsec{string.view.comparison}{21.4.5} +\cxxsec{tab:string.view.comparison.overloads}{71} +\cxxsec{string.view.io}{21.4.6} +\cxxsec{string.view.hash}{21.4.7} +\cxxsec{string.view.literals}{21.4.8} +\cxxsec{c.strings}{21.5} +\cxxsec{cctype.syn}{21.5.1} +\cxxsec{cwctype.syn}{21.5.2} +\cxxsec{cstring.syn}{21.5.3} +\cxxsec{cwchar.syn}{21.5.4} +\cxxsec{cuchar.syn}{21.5.5} +\cxxsec{c.mb.wcs}{21.5.6} +\cxxsec{support}{Clause 17} +\cxxsec{support.general}{17.1} +\cxxsec{tab:support.summary}{37} +\cxxsec{support.types}{17.2} +\cxxsec{cstddef.syn}{17.2.1} +\cxxsec{cstdlib.syn}{17.2.2} +\cxxsec{support.types.nullptr}{17.2.3} +\cxxsec{support.types.layout}{17.2.4} +\cxxsec{support.types.byteops}{17.2.5} +\cxxsec{support.limits}{17.3} +\cxxsec{support.limits.general}{17.3.1} +\cxxsec{version.syn}{17.3.2} +\cxxsec{limits.syn}{17.3.3} +\cxxsec{fp.style}{17.3.4} +\cxxsec{round.style}{17.3.4.1} +\cxxsec{denorm.style}{17.3.4.2} +\cxxsec{numeric.limits}{17.3.5} +\cxxsec{numeric.limits.general}{17.3.5.1} +\cxxsec{numeric.limits.members}{17.3.5.2} +\cxxsec{numeric.special}{17.3.5.3} +\cxxsec{climits.syn}{17.3.6} +\cxxsec{cfloat.syn}{17.3.7} +\cxxsec{cstdint}{17.4} +\cxxsec{cstdint.general}{17.4.1} +\cxxsec{cstdint.syn}{17.4.2} +\cxxsec{support.start.term}{17.5} +\cxxsec{support.dynamic}{17.6} +\cxxsec{support.dynamic.general}{17.6.1} +\cxxsec{new.syn}{17.6.2} +\cxxsec{new.delete}{17.6.3} +\cxxsec{new.delete.general}{17.6.3.1} +\cxxsec{new.delete.single}{17.6.3.2} +\cxxsec{new.delete.array}{17.6.3.3} +\cxxsec{new.delete.placement}{17.6.3.4} +\cxxsec{new.delete.dataraces}{17.6.3.5} +\cxxsec{alloc.errors}{17.6.4} +\cxxsec{bad.alloc}{17.6.4.1} +\cxxsec{new.badlength}{17.6.4.2} +\cxxsec{new.handler}{17.6.4.3} +\cxxsec{set.new.handler}{17.6.4.4} +\cxxsec{get.new.handler}{17.6.4.5} +\cxxsec{ptr.launder}{17.6.5} +\cxxsec{hardware.interference}{17.6.6} +\cxxsec{support.rtti}{17.7} +\cxxsec{support.rtti.general}{17.7.1} +\cxxsec{typeinfo.syn}{17.7.2} +\cxxsec{type.info}{17.7.3} +\cxxsec{bad.cast}{17.7.4} +\cxxsec{bad.typeid}{17.7.5} +\cxxsec{support.srcloc}{17.8} +\cxxsec{source.location.syn}{17.8.1} +\cxxsec{support.srcloc.class}{17.8.2} +\cxxsec{support.srcloc.class.general}{17.8.2.1} +\cxxsec{support.srcloc.cons}{17.8.2.2} +\cxxsec{tab:support.srcloc.current}{38} +\cxxsec{support.srcloc.obs}{17.8.2.3} +\cxxsec{support.exception}{17.9} +\cxxsec{support.exception.general}{17.9.1} +\cxxsec{exception.syn}{17.9.2} +\cxxsec{exception}{17.9.3} +\cxxsec{bad.exception}{17.9.4} +\cxxsec{exception.terminate}{17.9.5} +\cxxsec{terminate.handler}{17.9.5.1} +\cxxsec{set.terminate}{17.9.5.2} +\cxxsec{get.terminate}{17.9.5.3} +\cxxsec{terminate}{17.9.5.4} +\cxxsec{uncaught.exceptions}{17.9.6} +\cxxsec{propagation}{17.9.7} +\cxxsec{except.nested}{17.9.8} +\cxxsec{support.initlist}{17.10} +\cxxsec{support.initlist.general}{17.10.1} +\cxxsec{initializer.list.syn}{17.10.2} +\cxxsec{support.initlist.cons}{17.10.3} +\cxxsec{support.initlist.access}{17.10.4} +\cxxsec{support.initlist.range}{17.10.5} +\cxxsec{cmp}{17.11} +\cxxsec{compare.syn}{17.11.1} +\cxxsec{cmp.categories}{17.11.2} +\cxxsec{cmp.categories.pre}{17.11.2.1} +\cxxsec{cmp.partialord}{17.11.2.2} +\cxxsec{cmp.weakord}{17.11.2.3} +\cxxsec{cmp.strongord}{17.11.2.4} +\cxxsec{cmp.common}{17.11.3} +\cxxsec{cmp.concept}{17.11.4} +\cxxsec{cmp.result}{17.11.5} +\cxxsec{cmp.alg}{17.11.6} +\cxxsec{support.coroutine}{17.12} +\cxxsec{support.coroutine.general}{17.12.1} +\cxxsec{coroutine.syn}{17.12.2} +\cxxsec{coroutine.traits}{17.12.3} +\cxxsec{coroutine.traits.general}{17.12.3.1} +\cxxsec{coroutine.traits.primary}{17.12.3.2} +\cxxsec{coroutine.handle}{17.12.4} +\cxxsec{coroutine.handle.general}{17.12.4.1} +\cxxsec{coroutine.handle.con}{17.12.4.2} +\cxxsec{coroutine.handle.export.import}{17.12.4.3} +\cxxsec{coroutine.handle.observers}{17.12.4.4} +\cxxsec{coroutine.handle.resumption}{17.12.4.5} +\cxxsec{coroutine.handle.promise}{17.12.4.6} +\cxxsec{coroutine.handle.compare}{17.12.4.7} +\cxxsec{coroutine.handle.hash}{17.12.4.8} +\cxxsec{coroutine.noop}{17.12.5} +\cxxsec{coroutine.promise.noop}{17.12.5.1} +\cxxsec{coroutine.handle.noop}{17.12.5.2} +\cxxsec{coroutine.handle.noop.observers}{17.12.5.2.1} +\cxxsec{coroutine.handle.noop.resumption}{17.12.5.2.2} +\cxxsec{coroutine.handle.noop.promise}{17.12.5.2.3} +\cxxsec{coroutine.handle.noop.address}{17.12.5.2.4} +\cxxsec{coroutine.noop.coroutine}{17.12.5.3} +\cxxsec{coroutine.trivial.awaitables}{17.12.6} +\cxxsec{support.runtime}{17.13} +\cxxsec{support.runtime.general}{17.13.1} +\cxxsec{cstdarg.syn}{17.13.2} +\cxxsec{csetjmp.syn}{17.13.3} +\cxxsec{csignal.syn}{17.13.4} +\cxxsec{support.signal}{17.13.5} +\cxxsec{temp}{Clause 13} +\cxxsec{temp.pre}{13.1} +\cxxsec{temp.param}{13.2} +\cxxsec{temp.names}{13.3} +\cxxsec{temp.arg}{13.4} +\cxxsec{temp.arg.general}{13.4.1} +\cxxsec{temp.arg.type}{13.4.2} +\cxxsec{temp.arg.nontype}{13.4.3} +\cxxsec{temp.arg.template}{13.4.4} +\cxxsec{temp.constr}{13.5} +\cxxsec{temp.constr.general}{13.5.1} +\cxxsec{temp.constr.constr}{13.5.2} +\cxxsec{temp.constr.constr.general}{13.5.2.1} +\cxxsec{temp.constr.op}{13.5.2.2} +\cxxsec{temp.constr.atomic}{13.5.2.3} +\cxxsec{temp.constr.decl}{13.5.3} +\cxxsec{temp.constr.normal}{13.5.4} +\cxxsec{temp.constr.order}{13.5.5} +\cxxsec{temp.type}{13.6} +\cxxsec{temp.decls}{13.7} +\cxxsec{temp.decls.general}{13.7.1} +\cxxsec{temp.class}{13.7.2} +\cxxsec{temp.class.general}{13.7.2.1} +\cxxsec{temp.mem.func}{13.7.2.2} +\cxxsec{temp.deduct.guide}{13.7.2.3} +\cxxsec{temp.mem.class}{13.7.2.4} +\cxxsec{temp.static}{13.7.2.5} +\cxxsec{temp.mem.enum}{13.7.2.6} +\cxxsec{temp.mem}{13.7.3} +\cxxsec{temp.variadic}{13.7.4} +\cxxsec{tab:temp.fold.empty}{17} +\cxxsec{temp.friend}{13.7.5} +\cxxsec{temp.class.spec}{13.7.6} +\cxxsec{temp.class.spec.general}{13.7.6.1} +\cxxsec{temp.class.spec.match}{13.7.6.2} +\cxxsec{temp.class.order}{13.7.6.3} +\cxxsec{temp.class.spec.mfunc}{13.7.6.4} +\cxxsec{temp.fct}{13.7.7} +\cxxsec{temp.fct.general}{13.7.7.1} +\cxxsec{temp.over.link}{13.7.7.2} +\cxxsec{temp.func.order}{13.7.7.3} +\cxxsec{temp.alias}{13.7.8} +\cxxsec{temp.concept}{13.7.9} +\cxxsec{temp.res}{13.8} +\cxxsec{temp.res.general}{13.8.1} +\cxxsec{temp.local}{13.8.2} +\cxxsec{temp.dep}{13.8.3} +\cxxsec{temp.dep.general}{13.8.3.1} +\cxxsec{temp.dep.type}{13.8.3.2} +\cxxsec{temp.dep.expr}{13.8.3.3} +\cxxsec{temp.dep.constexpr}{13.8.3.4} +\cxxsec{temp.dep.temp}{13.8.3.5} +\cxxsec{temp.nondep}{13.8.4} +\cxxsec{temp.dep.res}{13.8.5} +\cxxsec{temp.point}{13.8.5.1} +\cxxsec{temp.dep.candidate}{13.8.5.2} +\cxxsec{temp.inject}{13.8.6} +\cxxsec{temp.spec}{13.9} +\cxxsec{temp.spec.general}{13.9.1} +\cxxsec{temp.inst}{13.9.2} +\cxxsec{temp.explicit}{13.9.3} +\cxxsec{temp.expl.spec}{13.9.4} +\cxxsec{temp.fct.spec}{13.10} +\cxxsec{temp.fct.spec.general}{13.10.1} +\cxxsec{temp.arg.explicit}{13.10.2} +\cxxsec{temp.deduct}{13.10.3} +\cxxsec{temp.deduct.general}{13.10.3.1} +\cxxsec{temp.deduct.call}{13.10.3.2} +\cxxsec{temp.deduct.funcaddr}{13.10.3.3} +\cxxsec{temp.deduct.conv}{13.10.3.4} +\cxxsec{temp.deduct.partial}{13.10.3.5} +\cxxsec{temp.deduct.type}{13.10.3.6} +\cxxsec{temp.deduct.decl}{13.10.3.7} +\cxxsec{temp.over}{13.10.4} +\cxxsec{thread}{Clause 32} +\cxxsec{thread.general}{32.1} +\cxxsec{tab:thread.summary}{146} +\cxxsec{thread.req}{32.2} +\cxxsec{thread.req.paramname}{32.2.1} +\cxxsec{thread.req.exception}{32.2.2} +\cxxsec{thread.req.native}{32.2.3} +\cxxsec{thread.req.timing}{32.2.4} +\cxxsec{thread.req.lockable}{32.2.5} +\cxxsec{thread.req.lockable.general}{32.2.5.1} +\cxxsec{thread.req.lockable.basic}{32.2.5.2} +\cxxsec{thread.req.lockable.req}{32.2.5.3} +\cxxsec{thread.req.lockable.timed}{32.2.5.4} +\cxxsec{thread.stoptoken}{32.3} +\cxxsec{thread.stoptoken.intro}{32.3.1} +\cxxsec{thread.stoptoken.syn}{32.3.2} +\cxxsec{stoptoken}{32.3.3} +\cxxsec{stoptoken.general}{32.3.3.1} +\cxxsec{stoptoken.cons}{32.3.3.2} +\cxxsec{stoptoken.mem}{32.3.3.3} +\cxxsec{stoptoken.nonmembers}{32.3.3.4} +\cxxsec{stopsource}{32.3.4} +\cxxsec{stopsource.general}{32.3.4.1} +\cxxsec{stopsource.cons}{32.3.4.2} +\cxxsec{stopsource.mem}{32.3.4.3} +\cxxsec{stopsource.nonmembers}{32.3.4.4} +\cxxsec{stopcallback}{32.3.5} +\cxxsec{stopcallback.general}{32.3.5.1} +\cxxsec{stopcallback.cons}{32.3.5.2} +\cxxsec{thread.threads}{32.4} +\cxxsec{thread.threads.general}{32.4.1} +\cxxsec{thread.syn}{32.4.2} +\cxxsec{thread.thread.class}{32.4.3} +\cxxsec{thread.thread.class.general}{32.4.3.1} +\cxxsec{thread.thread.id}{32.4.3.2} +\cxxsec{thread.thread.constr}{32.4.3.3} +\cxxsec{thread.thread.destr}{32.4.3.4} +\cxxsec{thread.thread.assign}{32.4.3.5} +\cxxsec{thread.thread.member}{32.4.3.6} +\cxxsec{thread.thread.static}{32.4.3.7} +\cxxsec{thread.thread.algorithm}{32.4.3.8} +\cxxsec{thread.jthread.class}{32.4.4} +\cxxsec{thread.jthread.class.general}{32.4.4.1} +\cxxsec{thread.jthread.cons}{32.4.4.2} +\cxxsec{thread.jthread.mem}{32.4.4.3} +\cxxsec{thread.jthread.stop}{32.4.4.4} +\cxxsec{thread.jthread.special}{32.4.4.5} +\cxxsec{thread.jthread.static}{32.4.4.6} +\cxxsec{thread.thread.this}{32.4.5} +\cxxsec{thread.mutex}{32.5} +\cxxsec{thread.mutex.general}{32.5.1} +\cxxsec{mutex.syn}{32.5.2} +\cxxsec{shared.mutex.syn}{32.5.3} +\cxxsec{thread.mutex.requirements}{32.5.4} +\cxxsec{thread.mutex.requirements.general}{32.5.4.1} +\cxxsec{thread.mutex.requirements.mutex}{32.5.4.2} +\cxxsec{thread.mutex.requirements.mutex.general}{32.5.4.2.1} +\cxxsec{thread.mutex.class}{32.5.4.2.2} +\cxxsec{thread.mutex.recursive}{32.5.4.2.3} +\cxxsec{thread.timedmutex.requirements}{32.5.4.3} +\cxxsec{thread.timedmutex.requirements.general}{32.5.4.3.1} +\cxxsec{thread.timedmutex.class}{32.5.4.3.2} +\cxxsec{thread.timedmutex.recursive}{32.5.4.3.3} +\cxxsec{thread.sharedmutex.requirements}{32.5.4.4} +\cxxsec{thread.sharedmutex.requirements.general}{32.5.4.4.1} +\cxxsec{thread.sharedmutex.class}{32.5.4.4.2} +\cxxsec{thread.sharedtimedmutex.requirements}{32.5.4.5} +\cxxsec{thread.sharedtimedmutex.requirements.general}{32.5.4.5.1} +\cxxsec{thread.sharedtimedmutex.class}{32.5.4.5.2} +\cxxsec{thread.lock}{32.5.5} +\cxxsec{thread.lock.general}{32.5.5.1} +\cxxsec{thread.lock.guard}{32.5.5.2} +\cxxsec{thread.lock.scoped}{32.5.5.3} +\cxxsec{thread.lock.unique}{32.5.5.4} +\cxxsec{thread.lock.unique.general}{32.5.5.4.1} +\cxxsec{thread.lock.unique.cons}{32.5.5.4.2} +\cxxsec{thread.lock.unique.locking}{32.5.5.4.3} +\cxxsec{thread.lock.unique.mod}{32.5.5.4.4} +\cxxsec{thread.lock.unique.obs}{32.5.5.4.5} +\cxxsec{thread.lock.shared}{32.5.5.5} +\cxxsec{thread.lock.shared.general}{32.5.5.5.1} +\cxxsec{thread.lock.shared.cons}{32.5.5.5.2} +\cxxsec{thread.lock.shared.locking}{32.5.5.5.3} +\cxxsec{thread.lock.shared.mod}{32.5.5.5.4} +\cxxsec{thread.lock.shared.obs}{32.5.5.5.5} +\cxxsec{thread.lock.algorithm}{32.5.6} +\cxxsec{thread.once}{32.5.7} +\cxxsec{thread.once.onceflag}{32.5.7.1} +\cxxsec{thread.once.callonce}{32.5.7.2} +\cxxsec{thread.condition}{32.6} +\cxxsec{thread.condition.general}{32.6.1} +\cxxsec{condition.variable.syn}{32.6.2} +\cxxsec{thread.condition.nonmember}{32.6.3} +\cxxsec{thread.condition.condvar}{32.6.4} +\cxxsec{thread.condition.condvarany}{32.6.5} +\cxxsec{thread.condition.condvarany.general}{32.6.5.1} +\cxxsec{thread.condvarany.wait}{32.6.5.2} +\cxxsec{thread.condvarany.intwait}{32.6.5.3} +\cxxsec{thread.sema}{32.7} +\cxxsec{thread.sema.general}{32.7.1} +\cxxsec{semaphore.syn}{32.7.2} +\cxxsec{thread.sema.cnt}{32.7.3} +\cxxsec{thread.coord}{32.8} +\cxxsec{thread.coord.general}{32.8.1} +\cxxsec{thread.latch}{32.8.2} +\cxxsec{thread.latch.general}{32.8.2.1} +\cxxsec{latch.syn}{32.8.2.2} +\cxxsec{thread.latch.class}{32.8.2.3} +\cxxsec{thread.barrier}{32.8.3} +\cxxsec{thread.barrier.general}{32.8.3.1} +\cxxsec{barrier.syn}{32.8.3.2} +\cxxsec{thread.barrier.class}{32.8.3.3} +\cxxsec{futures}{32.9} +\cxxsec{futures.overview}{32.9.1} +\cxxsec{future.syn}{32.9.2} +\cxxsec{futures.errors}{32.9.3} +\cxxsec{futures.future.error}{32.9.4} +\cxxsec{futures.state}{32.9.5} +\cxxsec{futures.promise}{32.9.6} +\cxxsec{futures.unique.future}{32.9.7} +\cxxsec{futures.shared.future}{32.9.8} +\cxxsec{futures.async}{32.9.9} +\cxxsec{futures.task}{32.9.10} +\cxxsec{futures.task.general}{32.9.10.1} +\cxxsec{futures.task.members}{32.9.10.2} +\cxxsec{futures.task.nonmembers}{32.9.10.3} +\cxxsec{time}{Clause 27} +\cxxsec{time.general}{27.1} +\cxxsec{tab:time.summary}{96} +\cxxsec{time.syn}{27.2} +\cxxsec{time.clock.req}{27.3} +\cxxsec{tab:time.clock}{97} +\cxxsec{time.traits}{27.4} +\cxxsec{time.traits.is.fp}{27.4.1} +\cxxsec{time.traits.duration.values}{27.4.2} +\cxxsec{time.traits.specializations}{27.4.3} +\cxxsec{time.traits.is.clock}{27.4.4} +\cxxsec{time.duration}{27.5} +\cxxsec{time.duration.general}{27.5.1} +\cxxsec{time.duration.cons}{27.5.2} +\cxxsec{time.duration.observer}{27.5.3} +\cxxsec{time.duration.arithmetic}{27.5.4} +\cxxsec{time.duration.special}{27.5.5} +\cxxsec{time.duration.nonmember}{27.5.6} +\cxxsec{time.duration.comparisons}{27.5.7} +\cxxsec{time.duration.cast}{27.5.8} +\cxxsec{time.duration.literals}{27.5.9} +\cxxsec{time.duration.alg}{27.5.10} +\cxxsec{time.duration.io}{27.5.11} +\cxxsec{time.point}{27.6} +\cxxsec{time.point.general}{27.6.1} +\cxxsec{time.point.cons}{27.6.2} +\cxxsec{time.point.observer}{27.6.3} +\cxxsec{time.point.arithmetic}{27.6.4} +\cxxsec{time.point.special}{27.6.5} +\cxxsec{time.point.nonmember}{27.6.6} +\cxxsec{time.point.comparisons}{27.6.7} +\cxxsec{time.point.cast}{27.6.8} +\cxxsec{time.clock}{27.7} +\cxxsec{time.clock.general}{27.7.1} +\cxxsec{time.clock.system}{27.7.2} +\cxxsec{time.clock.system.overview}{27.7.2.1} +\cxxsec{time.clock.system.members}{27.7.2.2} +\cxxsec{time.clock.system.nonmembers}{27.7.2.3} +\cxxsec{time.clock.utc}{27.7.3} +\cxxsec{time.clock.utc.overview}{27.7.3.1} +\cxxsec{time.clock.utc.members}{27.7.3.2} +\cxxsec{time.clock.utc.nonmembers}{27.7.3.3} +\cxxsec{time.clock.tai}{27.7.4} +\cxxsec{time.clock.tai.overview}{27.7.4.1} +\cxxsec{time.clock.tai.members}{27.7.4.2} +\cxxsec{time.clock.tai.nonmembers}{27.7.4.3} +\cxxsec{time.clock.gps}{27.7.5} +\cxxsec{time.clock.gps.overview}{27.7.5.1} +\cxxsec{time.clock.gps.members}{27.7.5.2} +\cxxsec{time.clock.gps.nonmembers}{27.7.5.3} +\cxxsec{time.clock.file}{27.7.6} +\cxxsec{time.clock.file.overview}{27.7.6.1} +\cxxsec{time.clock.file.members}{27.7.6.2} +\cxxsec{time.clock.file.nonmembers}{27.7.6.3} +\cxxsec{time.clock.steady}{27.7.7} +\cxxsec{time.clock.hires}{27.7.8} +\cxxsec{time.clock.local}{27.7.9} +\cxxsec{time.clock.cast}{27.7.10} +\cxxsec{time.clock.conv}{27.7.10.1} +\cxxsec{time.clock.cast.id}{27.7.10.2} +\cxxsec{time.clock.cast.sys.utc}{27.7.10.3} +\cxxsec{time.clock.cast.sys}{27.7.10.4} +\cxxsec{time.clock.cast.utc}{27.7.10.5} +\cxxsec{time.clock.cast.fn}{27.7.10.6} +\cxxsec{time.cal}{27.8} +\cxxsec{time.cal.general}{27.8.1} +\cxxsec{time.cal.last}{27.8.2} +\cxxsec{time.cal.day}{27.8.3} +\cxxsec{time.cal.day.overview}{27.8.3.1} +\cxxsec{time.cal.day.members}{27.8.3.2} +\cxxsec{time.cal.day.nonmembers}{27.8.3.3} +\cxxsec{time.cal.month}{27.8.4} +\cxxsec{time.cal.month.overview}{27.8.4.1} +\cxxsec{time.cal.month.members}{27.8.4.2} +\cxxsec{time.cal.month.nonmembers}{27.8.4.3} +\cxxsec{time.cal.year}{27.8.5} +\cxxsec{time.cal.year.overview}{27.8.5.1} +\cxxsec{time.cal.year.members}{27.8.5.2} +\cxxsec{time.cal.year.nonmembers}{27.8.5.3} +\cxxsec{time.cal.wd}{27.8.6} +\cxxsec{time.cal.wd.overview}{27.8.6.1} +\cxxsec{time.cal.wd.members}{27.8.6.2} +\cxxsec{time.cal.wd.nonmembers}{27.8.6.3} +\cxxsec{time.cal.wdidx}{27.8.7} +\cxxsec{time.cal.wdidx.overview}{27.8.7.1} +\cxxsec{time.cal.wdidx.members}{27.8.7.2} +\cxxsec{time.cal.wdidx.nonmembers}{27.8.7.3} +\cxxsec{time.cal.wdlast}{27.8.8} +\cxxsec{time.cal.wdlast.overview}{27.8.8.1} +\cxxsec{time.cal.wdlast.members}{27.8.8.2} +\cxxsec{time.cal.wdlast.nonmembers}{27.8.8.3} +\cxxsec{time.cal.md}{27.8.9} +\cxxsec{time.cal.md.overview}{27.8.9.1} +\cxxsec{time.cal.md.members}{27.8.9.2} +\cxxsec{time.cal.md.nonmembers}{27.8.9.3} +\cxxsec{time.cal.mdlast}{27.8.10} +\cxxsec{time.cal.mwd}{27.8.11} +\cxxsec{time.cal.mwd.overview}{27.8.11.1} +\cxxsec{time.cal.mwd.members}{27.8.11.2} +\cxxsec{time.cal.mwd.nonmembers}{27.8.11.3} +\cxxsec{time.cal.mwdlast}{27.8.12} +\cxxsec{time.cal.mwdlast.overview}{27.8.12.1} +\cxxsec{time.cal.mwdlast.members}{27.8.12.2} +\cxxsec{time.cal.mwdlast.nonmembers}{27.8.12.3} +\cxxsec{time.cal.ym}{27.8.13} +\cxxsec{time.cal.ym.overview}{27.8.13.1} +\cxxsec{time.cal.ym.members}{27.8.13.2} +\cxxsec{time.cal.ym.nonmembers}{27.8.13.3} +\cxxsec{time.cal.ymd}{27.8.14} +\cxxsec{time.cal.ymd.overview}{27.8.14.1} +\cxxsec{time.cal.ymd.members}{27.8.14.2} +\cxxsec{time.cal.ymd.nonmembers}{27.8.14.3} +\cxxsec{time.cal.ymdlast}{27.8.15} +\cxxsec{time.cal.ymdlast.overview}{27.8.15.1} +\cxxsec{time.cal.ymdlast.members}{27.8.15.2} +\cxxsec{time.cal.ymdlast.nonmembers}{27.8.15.3} +\cxxsec{time.cal.ymwd}{27.8.16} +\cxxsec{time.cal.ymwd.overview}{27.8.16.1} +\cxxsec{time.cal.ymwd.members}{27.8.16.2} +\cxxsec{time.cal.ymwd.nonmembers}{27.8.16.3} +\cxxsec{time.cal.ymwdlast}{27.8.17} +\cxxsec{time.cal.ymwdlast.overview}{27.8.17.1} +\cxxsec{time.cal.ymwdlast.members}{27.8.17.2} +\cxxsec{time.cal.ymwdlast.nonmembers}{27.8.17.3} +\cxxsec{time.cal.operators}{27.8.18} +\cxxsec{time.hms}{27.9} +\cxxsec{time.hms.overview}{27.9.1} +\cxxsec{time.hms.members}{27.9.2} +\cxxsec{tab:time.hms.width}{98} +\cxxsec{time.hms.nonmembers}{27.9.3} +\cxxsec{time.12}{27.10} +\cxxsec{time.zone}{27.11} +\cxxsec{time.zone.general}{27.11.1} +\cxxsec{time.zone.db}{27.11.2} +\cxxsec{time.zone.db.tzdb}{27.11.2.1} +\cxxsec{time.zone.db.list}{27.11.2.2} +\cxxsec{time.zone.db.access}{27.11.2.3} +\cxxsec{time.zone.db.remote}{27.11.2.4} +\cxxsec{time.zone.exception}{27.11.3} +\cxxsec{time.zone.exception.nonexist}{27.11.3.1} +\cxxsec{time.zone.exception.ambig}{27.11.3.2} +\cxxsec{time.zone.info}{27.11.4} +\cxxsec{time.zone.info.sys}{27.11.4.1} +\cxxsec{time.zone.info.local}{27.11.4.2} +\cxxsec{time.zone.timezone}{27.11.5} +\cxxsec{time.zone.overview}{27.11.5.1} +\cxxsec{time.zone.members}{27.11.5.2} +\cxxsec{time.zone.nonmembers}{27.11.5.3} +\cxxsec{time.zone.zonedtraits}{27.11.6} +\cxxsec{time.zone.zonedtime}{27.11.7} +\cxxsec{time.zone.zonedtime.overview}{27.11.7.1} +\cxxsec{time.zone.zonedtime.ctor}{27.11.7.2} +\cxxsec{time.zone.zonedtime.members}{27.11.7.3} +\cxxsec{time.zone.zonedtime.nonmembers}{27.11.7.4} +\cxxsec{time.zone.leap}{27.11.8} +\cxxsec{time.zone.leap.overview}{27.11.8.1} +\cxxsec{time.zone.leap.members}{27.11.8.2} +\cxxsec{time.zone.leap.nonmembers}{27.11.8.3} +\cxxsec{time.zone.link}{27.11.9} +\cxxsec{time.zone.link.overview}{27.11.9.1} +\cxxsec{time.zone.link.members}{27.11.9.2} +\cxxsec{time.zone.link.nonmembers}{27.11.9.3} +\cxxsec{time.format}{27.12} +\cxxsec{tab:time.format.spec}{99} +\cxxsec{time.parse}{27.13} +\cxxsec{tab:time.parse.spec}{100} +\cxxsec{ctime.syn}{27.14} +\cxxsec{utilities}{Clause 20} +\cxxsec{utilities.general}{20.1} +\cxxsec{tab:utilities.summary}{41} +\cxxsec{utility}{20.2} +\cxxsec{utility.syn}{20.2.1} +\cxxsec{utility.swap}{20.2.2} +\cxxsec{utility.exchange}{20.2.3} +\cxxsec{forward}{20.2.4} +\cxxsec{utility.as.const}{20.2.5} +\cxxsec{declval}{20.2.6} +\cxxsec{utility.intcmp}{20.2.7} +\cxxsec{intseq}{20.3} +\cxxsec{intseq.general}{20.3.1} +\cxxsec{intseq.intseq}{20.3.2} +\cxxsec{intseq.make}{20.3.3} +\cxxsec{pairs}{20.4} +\cxxsec{pairs.general}{20.4.1} +\cxxsec{pairs.pair}{20.4.2} +\cxxsec{pairs.spec}{20.4.3} +\cxxsec{pair.astuple}{20.4.4} +\cxxsec{pair.piecewise}{20.4.5} +\cxxsec{tuple}{20.5} +\cxxsec{tuple.general}{20.5.1} +\cxxsec{tuple.syn}{20.5.2} +\cxxsec{tuple.tuple}{20.5.3} +\cxxsec{tuple.cnstr}{20.5.3.1} +\cxxsec{tuple.assign}{20.5.3.2} +\cxxsec{tuple.swap}{20.5.3.3} +\cxxsec{tuple.creation}{20.5.4} +\cxxsec{tuple.apply}{20.5.5} +\cxxsec{tuple.helper}{20.5.6} +\cxxsec{tuple.elem}{20.5.7} +\cxxsec{tuple.rel}{20.5.8} +\cxxsec{tuple.traits}{20.5.9} +\cxxsec{tuple.special}{20.5.10} +\cxxsec{optional}{20.6} +\cxxsec{optional.general}{20.6.1} +\cxxsec{optional.syn}{20.6.2} +\cxxsec{optional.optional}{20.6.3} +\cxxsec{optional.optional.general}{20.6.3.1} +\cxxsec{optional.ctor}{20.6.3.2} +\cxxsec{optional.dtor}{20.6.3.3} +\cxxsec{optional.assign}{20.6.3.4} +\cxxsec{tab:optional.assign.copy}{42} +\cxxsec{tab:optional.assign.move}{43} +\cxxsec{tab:optional.assign.copy.templ}{44} +\cxxsec{tab:optional.assign.move.templ}{45} +\cxxsec{optional.swap}{20.6.3.5} +\cxxsec{tab:optional.swap}{46} +\cxxsec{optional.observe}{20.6.3.6} +\cxxsec{optional.mod}{20.6.3.7} +\cxxsec{optional.nullopt}{20.6.4} +\cxxsec{optional.bad.access}{20.6.5} +\cxxsec{optional.relops}{20.6.6} +\cxxsec{optional.nullops}{20.6.7} +\cxxsec{optional.comp.with.t}{20.6.8} +\cxxsec{optional.specalg}{20.6.9} +\cxxsec{optional.hash}{20.6.10} +\cxxsec{variant}{20.7} +\cxxsec{variant.general}{20.7.1} +\cxxsec{variant.syn}{20.7.2} +\cxxsec{variant.variant}{20.7.3} +\cxxsec{variant.variant.general}{20.7.3.1} +\cxxsec{variant.ctor}{20.7.3.2} +\cxxsec{variant.dtor}{20.7.3.3} +\cxxsec{variant.assign}{20.7.3.4} +\cxxsec{variant.mod}{20.7.3.5} +\cxxsec{variant.status}{20.7.3.6} +\cxxsec{variant.swap}{20.7.3.7} +\cxxsec{variant.helper}{20.7.4} +\cxxsec{variant.get}{20.7.5} +\cxxsec{variant.relops}{20.7.6} +\cxxsec{variant.visit}{20.7.7} +\cxxsec{variant.monostate}{20.7.8} +\cxxsec{variant.monostate.relops}{20.7.9} +\cxxsec{variant.specalg}{20.7.10} +\cxxsec{variant.bad.access}{20.7.11} +\cxxsec{variant.hash}{20.7.12} +\cxxsec{any}{20.8} +\cxxsec{any.general}{20.8.1} +\cxxsec{any.synop}{20.8.2} +\cxxsec{any.bad.any.cast}{20.8.3} +\cxxsec{any.class}{20.8.4} +\cxxsec{any.class.general}{20.8.4.1} +\cxxsec{any.cons}{20.8.4.2} +\cxxsec{any.assign}{20.8.4.3} +\cxxsec{any.modifiers}{20.8.4.4} +\cxxsec{any.observers}{20.8.4.5} +\cxxsec{any.nonmembers}{20.8.5} +\cxxsec{bitset}{20.9} +\cxxsec{bitset.syn}{20.9.1} +\cxxsec{template.bitset}{20.9.2} +\cxxsec{template.bitset.general}{20.9.2.1} +\cxxsec{bitset.cons}{20.9.2.2} +\cxxsec{bitset.members}{20.9.2.3} +\cxxsec{bitset.hash}{20.9.3} +\cxxsec{bitset.operators}{20.9.4} +\cxxsec{memory}{20.10} +\cxxsec{memory.general}{20.10.1} +\cxxsec{memory.syn}{20.10.2} +\cxxsec{pointer.traits}{20.10.3} +\cxxsec{pointer.traits.general}{20.10.3.1} +\cxxsec{pointer.traits.types}{20.10.3.2} +\cxxsec{pointer.traits.functions}{20.10.3.3} +\cxxsec{pointer.traits.optmem}{20.10.3.4} +\cxxsec{pointer.conversion}{20.10.4} +\cxxsec{util.dynamic.safety}{20.10.5} +\cxxsec{ptr.align}{20.10.6} +\cxxsec{allocator.tag}{20.10.7} +\cxxsec{allocator.uses}{20.10.8} +\cxxsec{allocator.uses.trait}{20.10.8.1} +\cxxsec{allocator.uses.construction}{20.10.8.2} +\cxxsec{allocator.traits}{20.10.9} +\cxxsec{allocator.traits.general}{20.10.9.1} +\cxxsec{allocator.traits.types}{20.10.9.2} +\cxxsec{allocator.traits.members}{20.10.9.3} +\cxxsec{default.allocator}{20.10.10} +\cxxsec{default.allocator.general}{20.10.10.1} +\cxxsec{allocator.members}{20.10.10.2} +\cxxsec{allocator.globals}{20.10.10.3} +\cxxsec{specialized.addressof}{20.10.11} +\cxxsec{c.malloc}{20.10.12} +\cxxsec{smartptr}{20.11} +\cxxsec{unique.ptr}{20.11.1} +\cxxsec{unique.ptr.general}{20.11.1.1} +\cxxsec{unique.ptr.dltr}{20.11.1.2} +\cxxsec{unique.ptr.dltr.general}{20.11.1.2.1} +\cxxsec{unique.ptr.dltr.dflt}{20.11.1.2.2} +\cxxsec{unique.ptr.dltr.dflt1}{20.11.1.2.3} +\cxxsec{unique.ptr.single}{20.11.1.3} +\cxxsec{unique.ptr.single.general}{20.11.1.3.1} +\cxxsec{unique.ptr.single.ctor}{20.11.1.3.2} +\cxxsec{unique.ptr.single.dtor}{20.11.1.3.3} +\cxxsec{unique.ptr.single.asgn}{20.11.1.3.4} +\cxxsec{unique.ptr.single.observers}{20.11.1.3.5} +\cxxsec{unique.ptr.single.modifiers}{20.11.1.3.6} +\cxxsec{unique.ptr.runtime}{20.11.1.4} +\cxxsec{unique.ptr.runtime.general}{20.11.1.4.1} +\cxxsec{unique.ptr.runtime.ctor}{20.11.1.4.2} +\cxxsec{unique.ptr.runtime.asgn}{20.11.1.4.3} +\cxxsec{unique.ptr.runtime.observers}{20.11.1.4.4} +\cxxsec{unique.ptr.runtime.modifiers}{20.11.1.4.5} +\cxxsec{unique.ptr.create}{20.11.1.5} +\cxxsec{unique.ptr.special}{20.11.1.6} +\cxxsec{unique.ptr.io}{20.11.1.7} +\cxxsec{util.smartptr.weak.bad}{20.11.2} +\cxxsec{util.smartptr.shared}{20.11.3} +\cxxsec{util.smartptr.shared.general}{20.11.3.1} +\cxxsec{util.smartptr.shared.const}{20.11.3.2} +\cxxsec{util.smartptr.shared.dest}{20.11.3.3} +\cxxsec{util.smartptr.shared.assign}{20.11.3.4} +\cxxsec{util.smartptr.shared.mod}{20.11.3.5} +\cxxsec{util.smartptr.shared.obs}{20.11.3.6} +\cxxsec{util.smartptr.shared.create}{20.11.3.7} +\cxxsec{util.smartptr.shared.cmp}{20.11.3.8} +\cxxsec{util.smartptr.shared.spec}{20.11.3.9} +\cxxsec{util.smartptr.shared.cast}{20.11.3.10} +\cxxsec{util.smartptr.getdeleter}{20.11.3.11} +\cxxsec{util.smartptr.shared.io}{20.11.3.12} +\cxxsec{util.smartptr.weak}{20.11.4} +\cxxsec{util.smartptr.weak.general}{20.11.4.1} +\cxxsec{util.smartptr.weak.const}{20.11.4.2} +\cxxsec{util.smartptr.weak.dest}{20.11.4.3} +\cxxsec{util.smartptr.weak.assign}{20.11.4.4} +\cxxsec{util.smartptr.weak.mod}{20.11.4.5} +\cxxsec{util.smartptr.weak.obs}{20.11.4.6} +\cxxsec{util.smartptr.weak.spec}{20.11.4.7} +\cxxsec{util.smartptr.ownerless}{20.11.5} +\cxxsec{util.smartptr.enab}{20.11.6} +\cxxsec{util.smartptr.hash}{20.11.7} +\cxxsec{mem.res}{20.12} +\cxxsec{mem.res.syn}{20.12.1} +\cxxsec{mem.res.class}{20.12.2} +\cxxsec{mem.res.class.general}{20.12.2.1} +\cxxsec{mem.res.public}{20.12.2.2} +\cxxsec{mem.res.private}{20.12.2.3} +\cxxsec{mem.res.eq}{20.12.2.4} +\cxxsec{mem.poly.allocator.class}{20.12.3} +\cxxsec{mem.poly.allocator.class.general}{20.12.3.1} +\cxxsec{mem.poly.allocator.ctor}{20.12.3.2} +\cxxsec{mem.poly.allocator.mem}{20.12.3.3} +\cxxsec{mem.poly.allocator.eq}{20.12.3.4} +\cxxsec{mem.res.global}{20.12.4} +\cxxsec{mem.res.pool}{20.12.5} +\cxxsec{mem.res.pool.overview}{20.12.5.1} +\cxxsec{mem.res.pool.options}{20.12.5.2} +\cxxsec{mem.res.pool.ctor}{20.12.5.3} +\cxxsec{mem.res.pool.mem}{20.12.5.4} +\cxxsec{mem.res.monotonic.buffer}{20.12.6} +\cxxsec{mem.res.monotonic.buffer.general}{20.12.6.1} +\cxxsec{mem.res.monotonic.buffer.ctor}{20.12.6.2} +\cxxsec{mem.res.monotonic.buffer.mem}{20.12.6.3} +\cxxsec{allocator.adaptor}{20.13} +\cxxsec{allocator.adaptor.syn}{20.13.1} +\cxxsec{allocator.adaptor.types}{20.13.2} +\cxxsec{allocator.adaptor.cnstr}{20.13.3} +\cxxsec{allocator.adaptor.members}{20.13.4} +\cxxsec{scoped.adaptor.operators}{20.13.5} +\cxxsec{function.objects}{20.14} +\cxxsec{function.objects.general}{20.14.1} +\cxxsec{functional.syn}{20.14.2} +\cxxsec{func.def}{20.14.3} +\cxxsec{func.require}{20.14.4} +\cxxsec{func.invoke}{20.14.5} +\cxxsec{refwrap}{20.14.6} +\cxxsec{refwrap.general}{20.14.6.1} +\cxxsec{refwrap.const}{20.14.6.2} +\cxxsec{refwrap.assign}{20.14.6.3} +\cxxsec{refwrap.access}{20.14.6.4} +\cxxsec{refwrap.invoke}{20.14.6.5} +\cxxsec{refwrap.helpers}{20.14.6.6} +\cxxsec{arithmetic.operations}{20.14.7} +\cxxsec{arithmetic.operations.general}{20.14.7.1} +\cxxsec{arithmetic.operations.plus}{20.14.7.2} +\cxxsec{arithmetic.operations.minus}{20.14.7.3} +\cxxsec{arithmetic.operations.multiplies}{20.14.7.4} +\cxxsec{arithmetic.operations.divides}{20.14.7.5} +\cxxsec{arithmetic.operations.modulus}{20.14.7.6} +\cxxsec{arithmetic.operations.negate}{20.14.7.7} +\cxxsec{comparisons}{20.14.8} +\cxxsec{comparisons.general}{20.14.8.1} +\cxxsec{comparisons.equal.to}{20.14.8.2} +\cxxsec{comparisons.not.equal.to}{20.14.8.3} +\cxxsec{comparisons.greater}{20.14.8.4} +\cxxsec{comparisons.less}{20.14.8.5} +\cxxsec{comparisons.greater.equal}{20.14.8.6} +\cxxsec{comparisons.less.equal}{20.14.8.7} +\cxxsec{comparisons.three.way}{20.14.8.8} +\cxxsec{range.cmp}{20.14.9} +\cxxsec{logical.operations}{20.14.10} +\cxxsec{logical.operations.general}{20.14.10.1} +\cxxsec{logical.operations.and}{20.14.10.2} +\cxxsec{logical.operations.or}{20.14.10.3} +\cxxsec{logical.operations.not}{20.14.10.4} +\cxxsec{bitwise.operations}{20.14.11} +\cxxsec{bitwise.operations.general}{20.14.11.1} +\cxxsec{bitwise.operations.and}{20.14.11.2} +\cxxsec{bitwise.operations.or}{20.14.11.3} +\cxxsec{bitwise.operations.xor}{20.14.11.4} +\cxxsec{bitwise.operations.not}{20.14.11.5} +\cxxsec{func.identity}{20.14.12} +\cxxsec{func.not.fn}{20.14.13} +\cxxsec{func.bind.front}{20.14.14} +\cxxsec{func.bind}{20.14.15} +\cxxsec{func.bind.general}{20.14.15.1} +\cxxsec{func.bind.isbind}{20.14.15.2} +\cxxsec{func.bind.isplace}{20.14.15.3} +\cxxsec{func.bind.bind}{20.14.15.4} +\cxxsec{func.bind.place}{20.14.15.5} +\cxxsec{func.memfn}{20.14.16} +\cxxsec{func.wrap}{20.14.17} +\cxxsec{func.wrap.general}{20.14.17.1} +\cxxsec{func.wrap.badcall}{20.14.17.2} +\cxxsec{func.wrap.func}{20.14.17.3} +\cxxsec{func.wrap.func.general}{20.14.17.3.1} +\cxxsec{func.wrap.func.con}{20.14.17.3.2} +\cxxsec{func.wrap.func.mod}{20.14.17.3.3} +\cxxsec{func.wrap.func.cap}{20.14.17.3.4} +\cxxsec{func.wrap.func.inv}{20.14.17.3.5} +\cxxsec{func.wrap.func.targ}{20.14.17.3.6} +\cxxsec{func.wrap.func.nullptr}{20.14.17.3.7} +\cxxsec{func.wrap.func.alg}{20.14.17.3.8} +\cxxsec{func.search}{20.14.18} +\cxxsec{func.search.general}{20.14.18.1} +\cxxsec{func.search.default}{20.14.18.2} +\cxxsec{func.search.bm}{20.14.18.3} +\cxxsec{func.search.bmh}{20.14.18.4} +\cxxsec{unord.hash}{20.14.19} +\cxxsec{meta}{20.15} +\cxxsec{meta.general}{20.15.1} +\cxxsec{meta.rqmts}{20.15.2} +\cxxsec{meta.type.synop}{20.15.3} +\cxxsec{meta.help}{20.15.4} +\cxxsec{meta.unary}{20.15.5} +\cxxsec{meta.unary.general}{20.15.5.1} +\cxxsec{meta.unary.cat}{20.15.5.2} +\cxxsec{tab:meta.unary.cat}{47} +\cxxsec{meta.unary.comp}{20.15.5.3} +\cxxsec{tab:meta.unary.comp}{48} +\cxxsec{meta.unary.prop}{20.15.5.4} +\cxxsec{tab:meta.unary.prop}{49} +\cxxsec{meta.unary.prop.query}{20.15.6} +\cxxsec{tab:meta.unary.prop.query}{50} +\cxxsec{meta.rel}{20.15.7} +\cxxsec{tab:meta.rel}{51} +\cxxsec{meta.trans}{20.15.8} +\cxxsec{meta.trans.general}{20.15.8.1} +\cxxsec{meta.trans.cv}{20.15.8.2} +\cxxsec{tab:meta.trans.cv}{52} +\cxxsec{meta.trans.ref}{20.15.8.3} +\cxxsec{tab:meta.trans.ref}{53} +\cxxsec{meta.trans.sign}{20.15.8.4} +\cxxsec{tab:meta.trans.sign}{54} +\cxxsec{meta.trans.arr}{20.15.8.5} +\cxxsec{tab:meta.trans.arr}{55} +\cxxsec{meta.trans.ptr}{20.15.8.6} +\cxxsec{tab:meta.trans.ptr}{56} +\cxxsec{meta.trans.other}{20.15.8.7} +\cxxsec{tab:meta.trans.other}{57} +\cxxsec{meta.logical}{20.15.9} +\cxxsec{meta.member}{20.15.10} +\cxxsec{meta.const.eval}{20.15.11} +\cxxsec{ratio}{20.16} +\cxxsec{ratio.general}{20.16.1} +\cxxsec{ratio.syn}{20.16.2} +\cxxsec{ratio.ratio}{20.16.3} +\cxxsec{ratio.arithmetic}{20.16.4} +\cxxsec{tab:ratio.arithmetic}{58} +\cxxsec{ratio.comparison}{20.16.5} +\cxxsec{ratio.si}{20.16.6} +\cxxsec{type.index}{20.17} +\cxxsec{type.index.synopsis}{20.17.1} +\cxxsec{type.index.overview}{20.17.2} +\cxxsec{type.index.members}{20.17.3} +\cxxsec{type.index.hash}{20.17.4} +\cxxsec{execpol}{20.18} +\cxxsec{execpol.general}{20.18.1} +\cxxsec{execution.syn}{20.18.2} +\cxxsec{execpol.type}{20.18.3} +\cxxsec{execpol.seq}{20.18.4} +\cxxsec{execpol.par}{20.18.5} +\cxxsec{execpol.parunseq}{20.18.6} +\cxxsec{execpol.unseq}{20.18.7} +\cxxsec{execpol.objects}{20.18.8} +\cxxsec{charconv}{20.19} +\cxxsec{charconv.syn}{20.19.1} +\cxxsec{charconv.to.chars}{20.19.2} +\cxxsec{charconv.from.chars}{20.19.3} +\cxxsec{format}{20.20} +\cxxsec{format.syn}{20.20.1} +\cxxsec{format.string}{20.20.2} +\cxxsec{format.string.general}{20.20.2.1} +\cxxsec{format.string.std}{20.20.2.2} +\cxxsec{tab:format.align}{59} +\cxxsec{tab:format.sign}{60} +\cxxsec{tab:format.type.string}{61} +\cxxsec{tab:format.type.int}{62} +\cxxsec{tab:format.type.char}{63} +\cxxsec{tab:format.type.bool}{64} +\cxxsec{format.err.report}{20.20.3} +\cxxsec{format.functions}{20.20.4} +\cxxsec{tab:format.type.float}{65} +\cxxsec{tab:format.type.ptr}{66} +\cxxsec{format.formatter}{20.20.5} +\cxxsec{formatter.requirements}{20.20.5.1} +\cxxsec{format.formatter.spec}{20.20.5.2} +\cxxsec{tab:formatter}{67} +\cxxsec{format.parse.ctx}{20.20.5.3} +\cxxsec{format.context}{20.20.5.4} +\cxxsec{format.arguments}{20.20.6} +\cxxsec{format.arg}{20.20.6.1} +\cxxsec{format.arg.store}{20.20.6.2} +\cxxsec{format.args}{20.20.6.3} +\cxxsec{format.error}{20.20.7} diff --git a/src/cxx.tex b/src/cxx.tex index cb93b0a..8617f33 100644 --- a/src/cxx.tex +++ b/src/cxx.tex @@ -20,71 +20,5 @@ \csname #1 \endcsname% } -\cxxsec{lex.key}{2.12} -\cxxsec{tab:keywords}{4} +\input{cxx-sections} - -\cxxsec{basic}{3} -\cxxsec{basic.def.odr}{3.2} -\cxxsec{basic.def.odr.odrparagraph1}{3} -\cxxsec{basic.def.odr.odrparagraph2}{6} - -\cxxsec{basic.scope.block}{3.3.3} -\cxxsec{basic.scope.temp}{3.3.9} -\cxxsec{basic.lookup}{3.4} -\cxxsec{basic.lookup.unqual}{3.4.1} -\cxxsec{basic.lookup.qual}{3.4.3} -\cxxsec{basic.stc.dynamic}{3.7.4} -\cxxsec{basic.fundamental}{3.9.1} -\cxxsec{basic.fundamental.paragraph1}{9} - -\cxxsec{expr}{5} -\cxxsec{expr.prim.general}{5.1.1} -\cxxsec{expr.prim.lambda.paragraph0}{12} -\cxxsec{expr.prim.lambda.paragraph1}{18} -\cxxsec{expr.call}{5.2.2} -\cxxsec{expr.type.conv}{5.2.3} -\cxxsec{expr.typeid}{5.2.8} -\cxxsec{expr.cond}{5.16} -\cxxsec{expr.comma}{5.18} -\cxxsec{expr.const}{5.19} -\cxxsec{stmt.expr}{6.2} -\cxxsec{stmt.return}{6.6.3} - -\cxxsec{dcl.fct.spec}{7.1.2} -\cxxsec{dcl.type.simple}{7.1.6.2} -\cxxsec{dcl.spec.concept}{7.1.7} -\cxxsec{tref:simple.type.specifiers}{10} -\cxxsec{dcl.enum}{7.2} -\cxxsec{namespace.udecl}{7.3.3} - -\cxxsec{dcl.ambig.res}{8.2} -\cxxsec{dcl.fct}{8.3.5} - - -\cxxsec{class}{9} -\cxxsec{class.nest}{9.7} -\cxxsec{class.access.base}{11.2} -\cxxsec{special}{12} -\cxxsec{class.conv.fct}{12.3.2} -\cxxsec{over.call.object}{13.3.1.1.2} -\cxxsec{over.oper}{13.5} -\cxxsec{temp.dep.expr}{14.6.2.2} -\cxxsec{temp.dep.type.paragraph1}{8} -\cxxsec{temp.deduct}{14.8.2} -\cxxsec{except.spec}{15.4} -\cxxsec{cpp.predefined}{16.8} -\cxxsec{tab:cpp.library.headers}{14} -\cxxsec{tab:cpp.headers.freestanding}{16} -\cxxsec{support.types}{18.2} -\cxxsec{support.limits}{18.3} -\cxxsec{cstdint}{18.4} -\cxxsec{support.start.term}{18.5} -\cxxsec{support.dynamic}{18.6} -\cxxsec{support.rtti}{18.7} -\cxxsec{support.exception}{18.8} -\cxxsec{support.initlist}{18.9} -\cxxsec{support.runtime}{18.10} -\cxxsec{atomics}{20} -\cxxsec{meta}{20.10} -\cxxsec{meta.rqmts}{20.10.1} diff --git a/src/tm.tex b/src/tm.tex index 592775d..bb5925a 100644 --- a/src/tm.tex +++ b/src/tm.tex @@ -5,8 +5,7 @@ \rSec1[lex.name]{Identifiers} -\pnum -In \CppXref{5.11}, +In \CppXref{lex.key}, add \added{\tcode{atomic}} to the table of keywords (Table 5). \rSec0[basic]{Basics} @@ -15,7 +14,7 @@ \rSec2[intro.execution]{Sequential execution} -Change in \CppXref{6.9.1} as indicated: +Change in \CppXref{intro.execution} paragraph 5 as indicated: \begin{quote} \setcounter{Paras}{4} @@ -31,7 +30,7 @@ an object other than a temporary object (6.7.7) whose lifetime has not been extended, \removed{or} \item - \added{the start and the end of an atomic block (8.8 {[}stmt.tx{]}), + \added{the start and the end of an atomic block (\ref{stmt.tx}), or} \item an expression that is not a subexpression of another expression and @@ -40,9 +39,10 @@ \end{quote} \rSec2[intro.multithread]{Multi-threaded executions and data races} +\setcounter{subsubsection}{1} \rSec3[intro.races]{Data races} -Change in \CppXref{6.9.2.1} as indicated: +Change in \CppXref{intro.races} paragraph 6 as indicated: \begin{quote} \setcounter{Paras}{5} @@ -52,11 +52,12 @@ and} library calls performed by another thread. \end{quote} -Add a new paragraph after \CppXref{6.9.2.1} paragraph 20: +Add a new paragraph after \CppXref{intro.races} paragraph 20: \begin{quote} \pnum \setcounter{Paras}{20} +\setcounter{note}{20} An atomic block that is not dynamically nested within another atomic block is termed a \defn{transaction}. \begin{note} @@ -84,15 +85,16 @@ Two actions are \defn{potentially concurrent} if ... \end{quote} -Change in \CppXref{6.9.2.1} paragraph 21: +Change in \CppXref{intro.races} paragraph 21: \begin{quote} \setcounter{Paras}{20} +\setcounter{note}{20} \pnum ... \begin{note} It can be shown that programs that correctly use -mutexes\added{, atomic blocks,} and \tcode{memory\_order::seq\_cst} +mutexes\added{, atomic blocks,} and \tcode{memory_order::seq_cst} operations to prevent all data races and use no other synchronization operations behave as if the operations executed by their constituent threads were simply interleaved, with each value computation of an @@ -102,19 +104,19 @@ \end{note} \end{quote} -Add a new paragraph after \CppXref{6.9.2.1} paragraph 21: +Add a new paragraph after \CppXref{intro.multithread.general} paragraph 21: \begin{quote} \setcounter{Paras}{21} \pnum \begin{note} The following holds for a data-race-free program: If the start -of an atomic block T is sequenced before an evaluation A, A is sequenced -before the end of T, A strongly happens before some evaluation B, and B -is not sequenced before the end of T, then the end of T strongly happens -before B. If an evaluation C strongly happens before that evaluation A -and C is not sequenced after the start of T, then C strongly happens -before the start of T. These properties in turn imply that in any simple +of an atomic block $T$ is sequenced before an evaluation $A$, $A$ is sequenced +before the end of $T$, $A$ strongly happens before some evaluation $B$, and $B$ +is not sequenced before the end of $T$, then the end of $T$ strongly happens +before $B$. If an evaluation $C$ strongly happens before that evaluation $A$ +and $C$ is not sequenced after the start of $T$, then $C$ strongly happens +before the start of $T$. These properties in turn imply that in any simple interleaved (sequentially consistent) execution, the operations of each atomic block appear to be contiguous in the interleaving. \end{note} @@ -122,7 +124,7 @@ \rSec3[intro.progress]{Forward progress} -Change in \CppXref{6.9.2.2} as indicated: +Change in \CppXref{intro.progress} paragraph 1 as indicated: \begin{quote} \pnum @@ -139,7 +141,7 @@ an access through a volatile glvalue, or \item a synchronization operation or an atomic operation - \added{({[}atomics{]})}. + \added{(\cxxref{atomics})}. \end{itemize} \added{The implementation may assume that any thread will eventually @@ -155,7 +157,7 @@ \rSec0[stmt.stmt]{Statements} \rSec1[stmt.pre]{Preamble} \pnum -Add a production to the grammar in \CppXref{8.1} as indicated: +Add a production to the grammar in \CppXref{stmt.pre} as indicated: \begin{quote} \begin{bnf} @@ -174,7 +176,7 @@ \setcounter{section}{7} -Add a new subclause before \CppXref{8.8}: +Add a new subclause before \CppXref{stmt.dcl}: \begin{quote} \rSec1[stmt.tx]{Atomic statement} @@ -196,7 +198,7 @@ Thus, variables with automatic storage duration declared in the \grammarterm{compound-statement} are destroyed prior to reaching the end of the atomic block; -see \CppXref{8.7}. +see \cxxref{stmt.jump}. \end{note} \pnum @@ -212,38 +214,38 @@ \recommended In case an atomic block is exited via an exception, the program should be terminated -without invoking a terminate handler (\CppXref{17.9.5}) or +without invoking a terminate handler (\cxxref{exception.terminate}) or destroying any objects -with static or thread storage duration (\CppXref{6.9.3.4}). +with static or thread storage duration (\cxxref{basic.start.term}). \pnum If the execution of an atomic block evaluates any of the following -outside of a manifestly constant-evaluated context (\CppXref{7.7}), +outside of a manifestly constant-evaluated context (\cxxref{7.7}), the behavior is implementation-defined: \begin{itemize} \item - an \grammarterm{asm-declaration} (\CppXref{9.10} {[}dcl.asm{]}); + an \grammarterm{asm-declaration} (\cxxref{dcl.asm}); \item an invocation of a function other than one of the standard - library functions specified in \CppXref{16.4.6.17} {[}atomic.use{]}), unless + library functions specified in \ref{atomic.use}, unless the function is inline with a reachable definition; \item - a virtual function call (\CppXref{7.6.1.3} {[}expr.call{]}); + a virtual function call (\cxxref{expr.call}); \item a function call, unless overload resolution selects \begin{itemize} \item - a named function (\CppXref{12.2.2.2.2} {[}over.call.func{]}) or + a named function (\cxxref{over.call.func}) or \item - a function call operator (\CppXref{12.2.2.2.3} - {[}over.call.object{]}), but not a surrogate call function; + a function call operator (\cxxref{over.call.object}), + but not a surrogate call function; \end{itemize} \item - a \keyword{co\_await} expression (\CppXref{7.6.2.3} {[}expr.await{]}), a - \grammarterm{yield-expression} (\CppXref{7.6.17} {[}expr.yield{]}), or a - \keyword{co\_return} statement (\CppXref{8.7.4} {[}stmt.return.coroutine{]}); + a \keyword{co_await} expression (\cxxref{expr.await}), a + \grammarterm{yield-expression} (\cxxref{expr.yield}), or a + \keyword{co_return} statement (\cxxref{stmt.return.coroutine}); \item dynamic initialization of a block-scope variable with static storage duration; or @@ -287,7 +289,7 @@ \setcounter{subsection}{6} \setcounter{subsubsection}{16} -Add a new subclause after \CppXref{16.4.6.16}: +Add a new subclause after \CppXref{lib.types.movedfrom}: \begin{quote} \rSec3[atomic.use]{Functions usable in an atomic block} @@ -297,44 +299,44 @@ \begin{itemize} \item - error category objects ({[}syserr.errcat.objects{]}) + error category objects (\cxxref{syserr.errcat.objects}) \item - time zone database ({[}time.zone.db{]}) + time zone database (\cxxref{syserr.errcat.objects}) \item - clocks ({[}time.clock{]}) + clocks (\cxxref{time.clock}) \item - \tcode{signal} ({[}support.signal{]}) and \tcode{raise} - ({[}csignal.syn{]}) + \tcode{signal} (\cxxref{support.signal}) and \tcode{raise} + (\cxxref{csignal.syn}) \item - \tcode{set_new\_handler}, \tcode{set\_terminate}, - \tcode{get\_new\_handler}, \tcode{get\_terminate} - ({[}handler.functions{]}, {[}alloc.errors{]}, {[}exception.syn{]}) + \tcode{set_new_handler}, \tcode{set_terminate}, + \tcode{get_new_handler}, \tcode{get_terminate} + (\cxxref{handler.functions}, \cxxref{alloc.errors}, \cxxref{exception.syn}) \item - \tcode{system} ({[}cstdlib.syn{]}) + \tcode{system} (\cxxref{cstdlib.syn}) \item - startup and termination {[}support.start.term{]} except + startup and termination (\cxxref{support.start.term}) except \tcode{abort} \item - \tcode{shared\_ptr} ({[}util.smartptr.shared{]}) and - \tcode{weak\_ptr} ({[}util.smartptr.weak{]}) + \tcode{shared_ptr} (\cxxref{util.smartptr.shared}) and + \tcode{weak_ptr} (\cxxref{util.smartptr.weak}) \item - \tcode{synchronized\_pool\_resource} ({[}mem.res.pool{]}) + \tcode{synchronized_pool_resource} (\cxxref{mem.res.pool}) \item - program-wide \tcode{memory\_resource} objects - ({[}mem.res.global{]}) + program-wide \tcode{memory_resource} objects + (\cxxref{mem.res.global}) \item - \tcode{setjmp} / \tcode{longjmp} ({[}csetjmp.syn{]}) + \tcode{setjmp} / \tcode{longjmp} (\cxxref{csetjmp.syn}) \item - parallel algorithms ({[}algorithms.parallel{]}) + parallel algorithms (\cxxref{algorithms.parallel}) \item - \tcode{random\_device} ({[}rand.device{]}) + \tcode{random_device} (\cxxref{rand.device}) \item - \tcode{locale} construction ({[}locale.cons{]}) + \tcode{locale} construction (\cxxref{locale.cons}) \item - input/output ({[}input.output{]}) + input/output (\cxxref{input.output}) \item - atomic operations ({[}atomics{]}) + atomic operations (\cxxref{atomics}) \item - thread support ({[}thread{]}) + thread support (\cxxref{thread}) \end{itemize} \end{quote} diff --git a/src/ts.tex b/src/ts.tex index dad3aa8..17f0dc0 100644 --- a/src/ts.tex +++ b/src/ts.tex @@ -58,7 +58,7 @@ %%-------------------------------------------------- %% macros specific to the Concurrency TS 2 \newcommand{\nativeref}{see~\ref{socket.reqmts.native}} -\newcommand{\CppXref}[1]{\texorpdfstring{C\kern-0.05em\protect\raisebox{.35ex}{\textsmaller[2]{+\kern-0.05em+}}20}{C++20} \S#1} +\newcommand{\CppXref}[1]{\texorpdfstring{C\kern-0.05em\protect\raisebox{.35ex}{\textsmaller[2]{+\kern-0.05em+}}20}{C++20} \S\cxxref{#1}} % Alternative formatting of cross-references, resolving stable name to number. % Needs include{cxx} and CppXIV from cplusplus/draft/source/macros.tex. % \input{cxx} @@ -101,6 +101,10 @@ %% configuration \input{config} +%%-------------------------------------------------- +%% labels from C++20 +\input{cxx} + %%-------------------------------------------------- %% front matter \frontmatter From e895c9691d69b8307084050ea3dc3c7cf4b853da Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Thu, 13 Jan 2022 21:41:09 +0100 Subject: [PATCH 18/40] Clean up front matter and harmonize subclause headings --- src/general.tex | 81 ++----------------------------------------------- src/tm.tex | 30 ++++++++++++++++-- 2 files changed, 31 insertions(+), 80 deletions(-) diff --git a/src/general.tex b/src/general.tex index cc3e00c..da81ddf 100644 --- a/src/general.tex +++ b/src/general.tex @@ -14,7 +14,7 @@ This document is non-normative. Some of the functionality described by this document may be considered for standardization in a future version of C++, but it is not currently part of any C++ standard. Some of the functionality in this document may never be standardized, and other functionality may be standardized in a substantially changed form. \pnum -The goal of this document is to build widespread existing practice for concurrency in the C++ standard algorithms library. It gives advice on extensions to those vendors who wish to provide them. +The goal of this document is to build widespread existing practice for eventually adopting transactional memory in C++. \rSec0[refs]{Normative references} @@ -26,7 +26,7 @@ \end{itemize} \pnum -ISO/IEC 14882:2020 is herein called the C++ Standard. References to clauses within the C++ Standard are written as ``\CppXref{3.2}''. The library described in \CppXref{16-32} is herein called the C++ Standard Library. +ISO/IEC 14882:2020 is herein called the C++ Standard. References to clauses within the C++ Standard are written as ``\CppXref{defns.arbitrary.stream}''. \rSec0[defs]{Terms and definitions} @@ -44,89 +44,14 @@ \rSec1[general.compliance]{Implementation compliance} \pnum -Conformance requirements for this document are those defined in \CppXref{4.1}, as applied to a merged document consisting of C++20 amended by this document. +Conformance requirements for this document are those defined in \CppXref{intro.compliance}, as applied to a merged document consisting of C++20 amended by this document. \begin{note} Conformance is defined in terms of the behavior of programs. \end{note} -\rSec1[general.namespaces]{Namespaces and headers and modifications to standard classes} -\pnum -Since the extensions described in this technical specification are experimental and not part of the C++ standard library, they are not declared directly within namespace \tcode{std}. Unless otherwise specified, all components described in this technical specification either: - -\begin{itemize} - \item modify an existing interface in the C++ Standard Library in-place, - \item are declared in a namespace whose name appends \tcode{::experimental::transactional\_memory\_v2} to a namespace defined in the C++ Standard Library, such as \tcode{std}, or - \item are declared in a subnamespace of a namespace described in the previous bullet, whose name is not the same as an existing subnamespace of namespace \tcode{std}. -\end{itemize} - -\pnum -Whenever an unqualified name is used -in the specification of a declaration \tcode{D}, -its meaning is established -as-if by performing unqualified name lookup -in the context of \tcode{D}. -\begin{note} -Argument-dependent lookup is not performed. -\end{note} -Similarly, the meaning of a \grammarterm{qualified-id} is established -as-if by performing qualified name lookup -in the context of \tcode{D}. -\begin{note} -Operators in expressions are not so constrained. -\end{note} - -%%The header described in this document (see Table~\ref{tab:info.headers}) -%%shall import the contents of \tcode{::std::experimental::concurrency::v2} into -%%\tcode{::std::experimental::concurrency_v1} as if by: - -%%\begin{codeblock} -%%namespace std::experimental::concurrency_v1 { -%% inline namespace v2 {} -%%} -%%\end{codeblock} - - -%%\begin{floattable}{Concurrency\_v2 library headers}{tab:info.headers} -%%{l} -%%\topline -%%\tcode{} \\ -%%\end{floattable} - -\rSec1[general.feature.test]{Feature-testing recommendations (Informative)} -\pnum -An implementation that provides support for this document should define each feature test macro defined in \tref{intro.features} if no associated headers are indicated for that macro, and if associated headers are indicated for a macro, that macro is defined after inclusion of one of the corresponding headers specified in the table. - -\begin{floattable}{Feature-test macros}{tab:intro.features} -{lll} -\topline -\lhdr{Macro name} & \chdr{Value} & \rhdr{Header} \\ -\capsep -%%\tcode{__cpp_concurrency\_v2} & \tcode{\tsver} & none \\ -\tcode{__cpp_lib_transactional\_memory\_v2} & \tcode{\tsver} & \tcode{} \\ -\end{floattable} -\rSec1[general.plans]{Future plans (Informative)} -\pnum -This section describes tentative plans for future versions of this technical specification and plans for moving content into -future versions of the C++ Standard. - -\pnum - The C++ committee intends to release a new version of this technical specification approximately every few years, containing -the transactional\_memory extensions we hope to add to a near-future version of the C++ Standard. Future versions will define their -contents in \tcode{std::experimental::transactional\_memory\_v3}, \tcode{std::experimental::transactional\_memory\_v4}, etc., with the most recent -implemented version inlined into \tcode{std::ex\-perimental}. - -\pnum -When an extension defined in this or a future version of this technical specification represents enough existing practice, it -will be moved into the next version of the C++ Standard by removing the \tcode{experimental::transactional\_memory\_v$N$} segment of its -namespace and by removing the \tcode{experimental/} prefix from its header's path. - \rSec1[general.ack]{Acknowledgments} This work is the result of a collaboration of researchers in industry and academia. We wish to thank the original authors of this document, Michael Wong, Hans Boehm, and Michael Spear. We also wish to thank people who made valuable contributions within and outside these groups, including Jens Maurer, and many others not named here who contributed to the discussion. - - - - diff --git a/src/tm.tex b/src/tm.tex index bb5925a..4054f43 100644 --- a/src/tm.tex +++ b/src/tm.tex @@ -10,6 +10,10 @@ \rSec0[basic]{Basics} +\setcounter{section}{8} + +\rSec1[basic.exec]{Program execution} + \setcounter{section}{9} \rSec2[intro.execution]{Sequential execution} @@ -281,11 +285,33 @@ \end{note} \end{quote} -\setcounter{chapter}{15} +\setcounter{chapter}{14} + +\rSec0[cpp]{Preprocessor} + +\setcounter{section}{10} + +\rSec1[cpp.predefined]{Predefined macro names} + +Add a row to Table \cxxref{tab:cpp.predefined.ft} in \CppXref{cpp.predefined}: + +\setcounter{table}{18} + +\begin{floattable}{Feature-test macros}{tab:intro.features} +{ll} +\topline +\lhdr{Macro name} & \rhdr{Value} \\ +\capsep +\tcode{__cpp_transactional_memory} & \tcode{\tsver} \\ +\end{floattable} + \rSec0[library]{Library introduction} -\setcounter{section}{4} +\setcounter{section}{3} + +\rSec1[requirements]{Library-wide requirements} + \setcounter{subsection}{6} \setcounter{subsubsection}{16} From 91dcc03983e8dee9c4b9d24db8fc79960c4a51db Mon Sep 17 00:00:00 2001 From: Jens Maurer Date: Sat, 5 Feb 2022 09:35:30 +0100 Subject: [PATCH 19/40] Fix: 'atomic' is not a full keyword, but a context-sensitive one --- src/tm.tex | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/tm.tex b/src/tm.tex index 4054f43..6fa1ef3 100644 --- a/src/tm.tex +++ b/src/tm.tex @@ -5,8 +5,8 @@ \rSec1[lex.name]{Identifiers} -In \CppXref{lex.key}, -add \added{\tcode{atomic}} to the table of keywords (Table 5). +In \CppXref{lex.name}, +add \added{\tcode{atomic}} to the table of identifiers with special meaning (Table 4). \rSec0[basic]{Basics} From 33a219dc61008e960e812046b96eda86b271ad85 Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Tue, 8 Feb 2022 12:34:26 -0500 Subject: [PATCH 20/40] updated acknowledgement to add Michael Scott, Victor Luchangco + sg5 and original TM; also fixed space in title. --- src/cover-wd.tex | 2 +- src/general.tex | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/cover-wd.tex b/src/cover-wd.tex index 9247beb..bd10ded 100644 --- a/src/cover-wd.tex +++ b/src/cover-wd.tex @@ -22,7 +22,7 @@ \vspace{2.5cm} \begin{center} \textbf{\Huge -Working Draft, Extensions to \Cpp for Transactional Memory Version 2} +Working Draft, Extensions to {\Cpp} for Transactional Memory Version 2} \end{center} \vfill \textbf{Note: this is an early draft. It's known to be incomplet and diff --git a/src/general.tex b/src/general.tex index da81ddf..e4bef20 100644 --- a/src/general.tex +++ b/src/general.tex @@ -52,6 +52,6 @@ \rSec1[general.ack]{Acknowledgments} This work is the result of a collaboration of researchers in industry and academia. We wish to thank the -original authors of this document, Michael Wong, Hans Boehm, and Michael Spear. We also wish to thank people -who made valuable contributions within and outside these groups, including Jens Maurer, and many others not named +original authors of this document, Michael Wong, Jens Maurer, Hans Boehm, Michael Spear, Michael Scott, and Victor Luchangco. We also wish to thank people +who made valuable contributions within and outside these groups, including all SG 5 members and the original TM group, and many others not named here who contributed to the discussion. From 462c47518c2946c1d778c80c314e74f5f48f5da6 Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Tue, 15 Feb 2022 10:23:17 -0500 Subject: [PATCH 21/40] update paper number N4906 --- src/config.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/config.tex b/src/config.tex index 7d79fdb..cb512c0 100644 --- a/src/config.tex +++ b/src/config.tex @@ -1,7 +1,7 @@ %!TEX root = ts.tex %%-------------------------------------------------- %% Version numbers -\newcommand{\docno}{Nxxxx} +\newcommand{\docno}{N4906} \newcommand{\isodocno}{ISO/IEC ?????:2021(E)} \newcommand{\prevdocno}{None} \newcommand{\cppver}{201703L @@@} %% MW: need update From 95e3a3dcd711f8586f0d765c985eea833621d2bd Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Mon, 10 Oct 2022 11:14:27 -0600 Subject: [PATCH 22/40] Update README.md initial info --- README.md | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 272d62d..d234c8d 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,8 @@ - is the repository for -the C++ Technical Specification "Trannsactional Memory TS 2021". + which was the repository for +the C++ Technical Specification "Trannsactional Memory TS 2021" for N4906, the TM-TS2 from 2022-02-14: +https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/n4906.pdf +It was moved here on Oct 10, 2022 where it will be edited for the DTS changes from P2617 +https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2617r0.html The draft Technical Specification is found in the `src` directory and is written in LaTeX. There is a Makefile that can be used to compile the @@ -10,7 +13,7 @@ will generate a PDF. ## pre-Feb 2022 virtual Plenary meeting -Nxxxx is the proposed working draft of Transactional Memory TS Version 2. It contains changes to the TM TS2021 as directed by the committee at the June 2021 virtual plenary meeting, and editorial changes. +N4906 is the proposed working draft of Transactional Memory TS Version 2. It contains changes to the TM TS2021 as directed by the committee at the June 2021 virtual plenary meeting, and editorial changes. N4895 contains P2066R10 from Oct 2021 virtual plenary. From 0b4cbb51a58fe218ac0b895d782b62ab1937f601 Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Mon, 10 Oct 2022 11:15:32 -0600 Subject: [PATCH 23/40] Update README.md change to DTS --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index d234c8d..deaea26 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,7 @@ which was the repository for the C++ Technical Specification "Trannsactional Memory TS 2021" for N4906, the TM-TS2 from 2022-02-14: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/n4906.pdf -It was moved here on Oct 10, 2022 where it will be edited for the DTS changes from P2617 +It was moved here on Oct 10, 2022 where it will be edited for the DTS ballot comments from P2617 https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2617r0.html The draft Technical Specification is found in the `src` directory and is From 0b1a44ed63aa0e08474ea4d0f54d7248be5d0090 Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Mon, 10 Oct 2022 11:42:22 -0600 Subject: [PATCH 24/40] CA-001: Transferring control into an atomic block --- src/tm.tex | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/tm.tex b/src/tm.tex index 6fa1ef3..17e0e75 100644 --- a/src/tm.tex +++ b/src/tm.tex @@ -206,8 +206,11 @@ \end{note} \pnum -A goto or switch statement shall not be used to transfer control -into an atomic block. +A \keyword{case} or \keyword{default} label +appearing within an atomic block shall be associated with a +\keyword{switch} statement (\cxxref{stmt.switch}) within the same +atomic block. A label (\cxxref{stmt.label}) declared in an atomic block +shall only be referred to by a statement in the same atomic block. \pnum If the execution of an atomic block evaluates an inter-thread side From c476ac451a53640f899d300d85f307942fc57c2a Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Mon, 10 Oct 2022 12:37:27 -0600 Subject: [PATCH 25/40] CA-003: Cross-reference to manifest-constant evaluated --- src/tm.tex | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/src/tm.tex b/src/tm.tex index 17e0e75..9fd8e0e 100644 --- a/src/tm.tex +++ b/src/tm.tex @@ -194,10 +194,13 @@ An \grammarterm{atomic-statement} is also called an \emph{atomic block}. \pnum -The start of the atomic block is immediately before the opening -\tcode{\{} of the \grammarterm{compound-statement}. -The end of the atomic block is immediately after -the closing \tcode{\}} of the \grammarterm{compound-statement}. +The start of the atomic block is immediately after the +opening \tcode{\{} of the \grammarterm{compound-statement}. +Evaluation of the end of the atomic block occurs +when the invocation of the destructor for a hypothetical automatic +variable of class type declared at the start of the atomic block would +happen (\cxxref{stmt.jump.general}). + \begin{note} Thus, variables with automatic storage duration declared in the \grammarterm{compound-statement} @@ -227,7 +230,7 @@ \pnum If the execution of an atomic block evaluates any of the following -outside of a manifestly constant-evaluated context (\cxxref{7.7}), +outside of a manifestly constant-evaluated context (\cxxref{expr.const}), the behavior is implementation-defined: \begin{itemize} From 86405dd3e72762670cd7400aafc53c2e43eac5a1 Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Mon, 10 Oct 2022 12:42:22 -0600 Subject: [PATCH 26/40] CA-004: Implementation-defined behavior for library functions --- src/tm.tex | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/src/tm.tex b/src/tm.tex index 9fd8e0e..a8e285d 100644 --- a/src/tm.tex +++ b/src/tm.tex @@ -237,9 +237,16 @@ \item an \grammarterm{asm-declaration} (\cxxref{dcl.asm}); \item - an invocation of a function other than one of the standard - library functions specified in \ref{atomic.use}, unless - the function is inline with a reachable definition; + an invocation of a function, unless + \begin{itemize} + \tightlist + \item + {the function is inline with a reachable definition or} + \item + {the function is a library function that may be used in an atomic + block \ref{atomic.use};} + \end{itemize} + \item a virtual function call (\cxxref{expr.call}); \item From d773281af78c79543c7f22a5eefaf656f63ee9f6 Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Mon, 10 Oct 2022 12:46:02 -0600 Subject: [PATCH 27/40] CA-005: Setting the global locale in an atomic block --- src/tm.tex | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/tm.tex b/src/tm.tex index a8e285d..24e4ce9 100644 --- a/src/tm.tex +++ b/src/tm.tex @@ -371,6 +371,8 @@ \tcode{random_device} (\cxxref{rand.device}) \item \tcode{locale} construction (\cxxref{locale.cons}) +\item + {\tcode{locale::global} (\cxxref {locale.statics})} \item input/output (\cxxref{input.output}) \item From 3b8fd023224f425ae2fa4984730483a0beb7d3b5 Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Mon, 10 Oct 2022 12:54:03 -0600 Subject: [PATCH 28/40] CA-006: Scope Additional change: Initialization of variables with thread storage duration --- src/general.tex | 7 ++++++- src/tm.tex | 4 ++++ 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/src/general.tex b/src/general.tex index e4bef20..fed6c21 100644 --- a/src/general.tex +++ b/src/general.tex @@ -3,7 +3,12 @@ \rSec0[scope]{Scope} \pnum -This document describes requirements for implementations of an interface that computer programs written in the C++ programming language may use to invoke algorithms with concurrent execution. The algorithms described by this document are realizable across a broad class of computer architectures. +This document describes requirements for implementations of an interface +that computer programs written in the C++ programming language +can use to express groups of +operations (known as transactions) that appear to execute atomically in +relation to other transactions (concurrent or otherwise). + \pnum {\cppstddocno} provide important context and specification for diff --git a/src/tm.tex b/src/tm.tex index 24e4ce9..8c70067 100644 --- a/src/tm.tex +++ b/src/tm.tex @@ -268,6 +268,10 @@ duration; or \item dynamic initialization of a variable with thread storage duration. + {{[} Note: That includes the case when such an initialization is + evaluated within an atomic block because the initialization was + deferred (\cxxref{basic.start.dynamic}). -\/- end note {]}} + \end{itemize} \begin{note} From 3c2a8e74d930dcc64bd79a7e3151223a108178e7 Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Mon, 10 Oct 2022 12:58:20 -0600 Subject: [PATCH 29/40] Update README.md Update from P2516R0 from DTS ballot comment resolution. --- README.md | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/README.md b/README.md index deaea26..1d1fbee 100644 --- a/README.md +++ b/README.md @@ -11,6 +11,13 @@ will generate a PDF. # TM TS2021 Editor's Report +## pre-Kona Nov 2022 Plenary meeting + +NXXXX is the DTS of Transactional Memory TS Version 2. It contains changes to the TM TS2021 as directed by the committee at the July-25 2022 virtual plenary meeting, and editorial changes. + +NXXXX contains P2617R0 from TM-TS2 DTS ballot comments resolution. + + ## pre-Feb 2022 virtual Plenary meeting N4906 is the proposed working draft of Transactional Memory TS Version 2. It contains changes to the TM TS2021 as directed by the committee at the June 2021 virtual plenary meeting, and editorial changes. From e0c11e223f20e5318e580279b0ebf8af5c5d1734 Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Mon, 10 Oct 2022 13:07:05 -0600 Subject: [PATCH 30/40] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 1d1fbee..0fce70c 100644 --- a/README.md +++ b/README.md @@ -15,7 +15,7 @@ will generate a PDF. NXXXX is the DTS of Transactional Memory TS Version 2. It contains changes to the TM TS2021 as directed by the committee at the July-25 2022 virtual plenary meeting, and editorial changes. -NXXXX contains P2617R0 from TM-TS2 DTS ballot comments resolution. +NXXXX contains P2617R0 Responses to NB comments on TM-TS2 DTS 12907. ## pre-Feb 2022 virtual Plenary meeting From a41dacfd3ac0c1d04140d0c647cde84a38f747ca Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Mon, 10 Oct 2022 13:08:57 -0600 Subject: [PATCH 31/40] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 0fce70c..9d92cc0 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ - which was the repository for +This came from which was the repository for the C++ Technical Specification "Trannsactional Memory TS 2021" for N4906, the TM-TS2 from 2022-02-14: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/n4906.pdf It was moved here on Oct 10, 2022 where it will be edited for the DTS ballot comments from P2617 From 722cadad84b87d37ac1380be6b4e0fb503797b8b Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Fri, 14 Oct 2022 11:10:17 -0400 Subject: [PATCH 32/40] Update README.md update N4923 --- README.md | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 9d92cc0..37d5e7b 100644 --- a/README.md +++ b/README.md @@ -11,14 +11,19 @@ will generate a PDF. # TM TS2021 Editor's Report -## pre-Kona Nov 2022 Plenary meeting +## pre-Kona Nov 2022 Plenary meeting N4923 -NXXXX is the DTS of Transactional Memory TS Version 2. It contains changes to the TM TS2021 as directed by the committee at the July-25 2022 virtual plenary meeting, and editorial changes. +1. N4923 revises N4906 and is the DTS of Transactional Memory TS Version 2. It contains changes to the N4906 as directed by the committee at the July-25 2022 virtual plenary meeting, and editorial changes. +2. N4923 revises N4906 with P2617R0 Responses to NB comments on TM-TS2 DTS 12907. It omits the symbolic references in P2517R0 in cross-references as is conventional in these documents and just use the numeric references. -NXXXX contains P2617R0 Responses to NB comments on TM-TS2 DTS 12907. +3. Other then the front matter changes, it also contain the following editorial changes: +in Sec. 4.2: Michael Scott->Michael L. Scotts +In 6.9.1 (Line 5.3), “start and the end of an atomic block” -> “start or the end of an atomic block” +In 6.9.2.2 (Line 21), “An atomic block” -> “The execution of an atomic block” -## pre-Feb 2022 virtual Plenary meeting + +## pre-Feb 2022 virtual Plenary meeting N4906 N4906 is the proposed working draft of Transactional Memory TS Version 2. It contains changes to the TM TS2021 as directed by the committee at the June 2021 virtual plenary meeting, and editorial changes. From ccf16863cb27c523aed1d67f6b8dc835624b2e26 Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Fri, 14 Oct 2022 11:15:12 -0400 Subject: [PATCH 33/40] Added changes from SG5 --- src/config.tex | 6 +++--- src/general.tex | 2 +- src/tm.tex | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/config.tex b/src/config.tex index cb512c0..87d2460 100644 --- a/src/config.tex +++ b/src/config.tex @@ -1,9 +1,9 @@ %!TEX root = ts.tex %%-------------------------------------------------- %% Version numbers -\newcommand{\docno}{N4906} -\newcommand{\isodocno}{ISO/IEC ?????:2021(E)} -\newcommand{\prevdocno}{None} +\newcommand{\docno}{N4923} +\newcommand{\isodocno}{ISO/IEC 12907:2021(E)} +\newcommand{\prevdocno}{N4906} \newcommand{\cppver}{201703L @@@} %% MW: need update \newcommand{\tsver}{202110} diff --git a/src/general.tex b/src/general.tex index fed6c21..a92edab 100644 --- a/src/general.tex +++ b/src/general.tex @@ -57,6 +57,6 @@ \rSec1[general.ack]{Acknowledgments} This work is the result of a collaboration of researchers in industry and academia. We wish to thank the -original authors of this document, Michael Wong, Jens Maurer, Hans Boehm, Michael Spear, Michael Scott, and Victor Luchangco. We also wish to thank people +original authors of this document, Michael Wong, Jens Maurer, Hans Boehm, Michael Spear, Michael L. Scotts, and Victor Luchangco. We also wish to thank people who made valuable contributions within and outside these groups, including all SG 5 members and the original TM group, and many others not named here who contributed to the discussion. diff --git a/src/tm.tex b/src/tm.tex index 8c70067..c350306 100644 --- a/src/tm.tex +++ b/src/tm.tex @@ -34,7 +34,7 @@ an object other than a temporary object (6.7.7) whose lifetime has not been extended, \removed{or} \item - \added{the start and the end of an atomic block (\ref{stmt.tx}), + \added{the start or the end of an atomic block (\ref{stmt.tx}), or} \item an expression that is not a subexpression of another expression and @@ -62,7 +62,7 @@ \pnum \setcounter{Paras}{20} \setcounter{note}{20} -An atomic block that is not dynamically nested within another atomic +The execution of an atomic block that is not dynamically nested within another atomic block is termed a \defn{transaction}. \begin{note} Due to syntactic constraints, From da5d402609330352ada15f5e5f179b3b9c288d3e Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Fri, 14 Oct 2022 11:18:22 -0400 Subject: [PATCH 34/40] Update README.md --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 37d5e7b..c5119e8 100644 --- a/README.md +++ b/README.md @@ -19,7 +19,9 @@ will generate a PDF. 3. Other then the front matter changes, it also contain the following editorial changes: in Sec. 4.2: Michael Scott->Michael L. Scotts + In 6.9.1 (Line 5.3), “start and the end of an atomic block” -> “start or the end of an atomic block” + In 6.9.2.2 (Line 21), “An atomic block” -> “The execution of an atomic block” From af8edcf905a37a77a98b0e7e6c7a7af003606c70 Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Fri, 14 Oct 2022 11:23:54 -0400 Subject: [PATCH 35/40] Update README.md --- README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index c5119e8..b307f0c 100644 --- a/README.md +++ b/README.md @@ -16,13 +16,13 @@ will generate a PDF. 1. N4923 revises N4906 and is the DTS of Transactional Memory TS Version 2. It contains changes to the N4906 as directed by the committee at the July-25 2022 virtual plenary meeting, and editorial changes. 2. N4923 revises N4906 with P2617R0 Responses to NB comments on TM-TS2 DTS 12907. It omits the symbolic references in P2517R0 in cross-references as is conventional in these documents and just use the numeric references. -3. Other then the front matter changes, it also contain the following editorial changes: +3. Other then the front matter changes, it also contains the following editorial changes: -in Sec. 4.2: Michael Scott->Michael L. Scotts + in Sec. 4.2: Michael Scott->Michael L. Scotts -In 6.9.1 (Line 5.3), “start and the end of an atomic block” -> “start or the end of an atomic block” + In 6.9.1 (Line 5.3), “start and the end of an atomic block” -> “start or the end of an atomic block” -In 6.9.2.2 (Line 21), “An atomic block” -> “The execution of an atomic block” + In 6.9.2.2 (Line 21), “An atomic block” -> “The execution of an atomic block” ## pre-Feb 2022 virtual Plenary meeting N4906 From 5fd668a28af31dfe454abcc5ab95eacddd0623f0 Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Fri, 14 Oct 2022 11:24:19 -0400 Subject: [PATCH 36/40] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index b307f0c..a7bd81b 100644 --- a/README.md +++ b/README.md @@ -16,7 +16,7 @@ will generate a PDF. 1. N4923 revises N4906 and is the DTS of Transactional Memory TS Version 2. It contains changes to the N4906 as directed by the committee at the July-25 2022 virtual plenary meeting, and editorial changes. 2. N4923 revises N4906 with P2617R0 Responses to NB comments on TM-TS2 DTS 12907. It omits the symbolic references in P2517R0 in cross-references as is conventional in these documents and just use the numeric references. -3. Other then the front matter changes, it also contains the following editorial changes: +3. Other than the front matter changes, it also contains the following editorial changes: in Sec. 4.2: Michael Scott->Michael L. Scotts From 8318af2e7453ff4f1a50a3bfeb9e470818dc12bd Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Fri, 14 Oct 2022 11:28:59 -0400 Subject: [PATCH 37/40] Update README.md --- README.md | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index a7bd81b..616516a 100644 --- a/README.md +++ b/README.md @@ -41,9 +41,10 @@ None ## Acknowledgements -Michael Wong + Hans Boehm -Jens Maurer Victor Luchangco +Jens Maurer +Michael L. Scotts Michael Spear -Michael Scott +Michael Wong From 3d3091127c4ff5625895ffedf9658848ad0fe27d Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Fri, 14 Oct 2022 13:33:30 -0400 Subject: [PATCH 38/40] Updates from Overleaf --- src/general.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/general.tex b/src/general.tex index a92edab..a066f99 100644 --- a/src/general.tex +++ b/src/general.tex @@ -57,6 +57,6 @@ \rSec1[general.ack]{Acknowledgments} This work is the result of a collaboration of researchers in industry and academia. We wish to thank the -original authors of this document, Michael Wong, Jens Maurer, Hans Boehm, Michael Spear, Michael L. Scotts, and Victor Luchangco. We also wish to thank people +original authors of this document, Michael Wong, Jens Maurer, Hans Boehm, Michael Spear, Michael L. Scott, and Victor Luchangco. We also wish to thank people who made valuable contributions within and outside these groups, including all SG 5 members and the original TM group, and many others not named here who contributed to the discussion. From e5bf058a2f6fd8cc034e25d2bdd03b2deb7d0c44 Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Fri, 14 Oct 2022 13:34:20 -0400 Subject: [PATCH 39/40] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 616516a..23f1068 100644 --- a/README.md +++ b/README.md @@ -45,6 +45,6 @@ None Hans Boehm Victor Luchangco Jens Maurer -Michael L. Scotts +Michael L. Scott Michael Spear Michael Wong From ef9fed103f96d1611d1b6b31f4c1862805f70eb5 Mon Sep 17 00:00:00 2001 From: Michael Wong Date: Sat, 22 Feb 2025 02:35:48 -0500 Subject: [PATCH 40/40] Removed pdflabel of Concurrency TS2, added Maged and Paul acknowledgement, changed to Whitepaper --- README.md | 2 ++ src/cover-wd.tex | 4 ++-- src/general.tex | 2 +- src/ts.tex | 6 +++--- 4 files changed, 8 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 23f1068..4df29d7 100644 --- a/README.md +++ b/README.md @@ -44,6 +44,8 @@ None Hans Boehm Victor Luchangco +Paul McKenney +Maged Michael Jens Maurer Michael L. Scott Michael Spear diff --git a/src/cover-wd.tex b/src/cover-wd.tex index bd10ded..f2d5c7b 100644 --- a/src/cover-wd.tex +++ b/src/cover-wd.tex @@ -10,7 +10,7 @@ \textbf{Date:} & \reldate \\ \textbf{Revises:} & \prevdocno \\ \textbf{Reply to:} & Michael Wong \\ - & Codeplay \\ +%% & Codeplay %% \\ & fraggamuffin@gmail.com \end{tabular} } @@ -22,7 +22,7 @@ \vspace{2.5cm} \begin{center} \textbf{\Huge -Working Draft, Extensions to {\Cpp} for Transactional Memory Version 2} +White Paper, Extensions to {\Cpp} for Transactional Memory Version 2} \end{center} \vfill \textbf{Note: this is an early draft. It's known to be incomplet and diff --git a/src/general.tex b/src/general.tex index a066f99..694b54e 100644 --- a/src/general.tex +++ b/src/general.tex @@ -57,6 +57,6 @@ \rSec1[general.ack]{Acknowledgments} This work is the result of a collaboration of researchers in industry and academia. We wish to thank the -original authors of this document, Michael Wong, Jens Maurer, Hans Boehm, Michael Spear, Michael L. Scott, and Victor Luchangco. We also wish to thank people +original authors of this document, Michael Wong, Jens Maurer, Hans Boehm, Michael Spear, Michael L. Scott, Victor Luchangco, Mage Michael, and Paul McKenney. We also wish to thank people who made valuable contributions within and outside these groups, including all SG 5 members and the original TM group, and many others not named here who contributed to the discussion. diff --git a/src/ts.tex b/src/ts.tex index 17f0dc0..d6d9f37 100644 --- a/src/ts.tex +++ b/src/ts.tex @@ -29,8 +29,8 @@ \usepackage[T1]{fontenc} \usepackage[pdftex, final]{graphicx} \usepackage[pdftex, - pdftitle={C++ Concurrency Technical Specification 2}, - pdfsubject={C++ Concurrency Technical Specification 2}, + pdftitle={Extensions to C++ Transactional Memory 2}, + pdfsubject={Extensions to C++ Transactional Memory 2}, pdfcreator={Michael Wong, Maged Michael, and Paul E.~McKenney}, bookmarks=true, bookmarksnumbered=true, @@ -56,7 +56,7 @@ \makeindex[impldefindex] %%-------------------------------------------------- -%% macros specific to the Concurrency TS 2 +%% macros specific to the Extensions to C++ Transactional Memory 2 \newcommand{\nativeref}{see~\ref{socket.reqmts.native}} \newcommand{\CppXref}[1]{\texorpdfstring{C\kern-0.05em\protect\raisebox{.35ex}{\textsmaller[2]{+\kern-0.05em+}}20}{C++20} \S\cxxref{#1}} % Alternative formatting of cross-references, resolving stable name to number.