[except.terminate] Move the 'terminate' function to [basic.start]

Now that the terminate function is more general than
just failures of the exception machinery, it belongs
with Start and termination.

Author: AlisdairM

source/basic.tex

@@ -7194,5 +7194,126 @@
 \libheaderref{cstdlib} terminates the program without executing any destructors
 and without calling
 the functions passed to \tcode{std::atexit()} or \tcode{std::at_quick_exit()}.%
+
+\rSec3[except.terminate]{The \tcode{std::terminate} function}
+
+\pnum
+\indextext{\idxcode{terminate}}%
+Some errors in a program cannot be recovered from, such as when an exception
+is not handled or a \tcode{std::thread} object is destroyed while its thread
+function is still running. In such cases,
+the function \tcode{std::terminate}\iref{exception.terminate} is invoked.
+\begin{note}
+These situations are:
+\indextext{\idxcode{terminate}!called}%
+\begin{itemize}
+\item%
+when the exception handling mechanism, after completing
+the initialization of the exception object
+but before
+activation of a handler for the exception\iref{except.throw},
+calls a function that exits
+via an exception, or
+
+\item%
+when the exception handling mechanism cannot find a handler for a thrown exception\iref{except.handle}, or
+
+\item when the search for a handler\iref{except.handle} encounters the
+outermost block of a function
+with a non-throwing exception specification\iref{except.spec}, or
+
+\item%
+when the destruction of an object during stack unwinding\iref{except.ctor}
+terminates by throwing an exception, or
+
+\item%
+when initialization of a non-block
+variable with static or thread storage duration\iref{basic.start.dynamic}
+exits via an exception, or
+
+\item%
+when destruction of an object with static or thread storage duration exits
+via an exception\iref{basic.start.term}, or
+
+\item%
+when execution of a function registered with
+\tcode{std::atexit} or \tcode{std::at_quick_exit}
+exits via an exception\iref{support.start.term}, or
+
+\item%
+when a
+\grammarterm{throw-expression}\iref{expr.throw}
+with no operand attempts to rethrow an exception and no exception is being
+handled\iref{except.throw}, or
+
+\item%
+when the function \tcode{std::nested_exception::rethrow_nested} is called for an object
+that has captured no exception\iref{except.nested}, or
+
+\item%
+when execution of the initial function of a thread exits via
+an exception\iref{thread.thread.constr}, or
+
+\item%
+for a parallel algorithm whose \tcode{ExecutionPolicy} specifies such
+behavior\iref{execpol.seq,execpol.par,execpol.parunseq},
+when execution of an element access function\iref{algorithms.parallel.defns}
+of the parallel algorithm exits via an exception\iref{algorithms.parallel.exceptions}, or
+
+\item%
+when the destructor or the move assignment operator is invoked on an object
+of type \tcode{std::thread} that refers to
+a joinable thread\iref{thread.thread.destr,thread.thread.assign}, or
+
+\item%
+when a call to a \tcode{wait()}, \tcode{wait_until()}, or \tcode{wait_for()}
+function on a condition variable\iref{thread.condition.condvar,thread.condition.condvarany}
+fails to meet a postcondition, or
+
+\item%
+when a callback invocation exits via an exception
+when requesting stop on
+a \tcode{std::stop_source} or
+a \tcode{std::in\-place_stop_source}\iref{stopsource.mem,stopsource.inplace.mem},
+or in the constructor of
+\tcode{std::stop_callback} or
+\tcode{std::inplace_stop_callback}\iref{stopcallback.cons,stopcallback.inplace.cons}
+when a callback invocation exits via an exception, or
+
+\item%
+when a \tcode{run_loop} object is destroyed
+that is still in the \tcode{running} state\iref{exec.run.loop}, or
+
+\item%
+when \tcode{unhandled_stopped} is called on
+a \tcode{with_awaitable_senders<T>} object\iref{exec.with.awaitable.senders}
+whose continuation is not a handle to a coroutine
+whose promise type has an \tcode{unhandled_stopped} member function.
+
+\end{itemize}
+
+\end{note}
+
+\pnum
+\indextext{\idxcode{terminate}}%
+In the situation where no matching handler is found, it is
+\impldef{stack unwinding before invocation of \tcode{std::terminate}}
+whether or not the stack is unwound
+before \tcode{std::terminate} is invoked.
+In the situation where the search for a handler\iref{except.handle} encounters the
+outermost block of a function
+with a non-throwing exception specification\iref{except.spec}, it is
+\impldef{whether stack is unwound before invoking the function \tcode{std::terminate}
+when a \tcode{noexcept} specification is violated}
+whether the stack is unwound, unwound partially, or not unwound at all
+before the function \tcode{std::terminate} is invoked.
+In all other situations, the stack shall not be unwound before
+the function \tcode{std::terminate}
+is invoked.
+An implementation is not permitted to finish stack unwinding
+prematurely based on a determination that the unwind process
+will eventually cause an invocation of the function
+\tcode{std::terminate}.
+
 \indextext{program!termination|)}
 \indextext{program execution|)}

source/exceptions.tex

@@ -747,139 +747,4 @@
 exception object and will have effect should that object be rethrown.%
 \indextext{exception handling!handler!match|)}%
 \indextext{exception handling!handler|)}
-
-\rSec1[except.special]{Special functions}
-
-\rSec2[except.special.general]{General}
-
-\pnum
-The function \tcode{std::terminate}\iref{except.terminate}
-is used by the exception
-handling mechanism for coping with errors related to the exception handling
-mechanism itself.
-The function \tcode{std::uncaught_exceptions}\iref{uncaught.exceptions}
-reports how many exceptions are uncaught in the current thread.
-The function \tcode{std::current_exception}\iref{propagation} and the class
-\tcode{std::nested_exception}\iref{except.nested} can be used by a program to
-capture the currently handled exception.
-
-\rSec2[except.terminate]{The \tcode{std::terminate} function}
-
-\pnum
-\indextext{\idxcode{terminate}}%
-Some errors in a program cannot be recovered from, such as when an exception
-is not handled or a \tcode{std::thread} object is destroyed while its thread
-function is still running. In such cases,
-the function \tcode{std::terminate}\iref{exception.terminate} is invoked.
-\begin{note}
-These situations are:
-\indextext{\idxcode{terminate}!called}%
-\begin{itemize}
-\item%
-when the exception handling mechanism, after completing
-the initialization of the exception object
-but before
-activation of a handler for the exception\iref{except.throw},
-calls a function that exits
-via an exception, or
-
-\item%
-when the exception handling mechanism cannot find a handler for a thrown exception\iref{except.handle}, or
-
-\item when the search for a handler\iref{except.handle} encounters the
-outermost block of a function
-with a non-throwing exception specification\iref{except.spec}, or
-
-\item%
-when the destruction of an object during stack unwinding\iref{except.ctor}
-terminates by throwing an exception, or
-
-\item%
-when initialization of a non-block
-variable with static or thread storage duration\iref{basic.start.dynamic}
-exits via an exception, or
-
-\item%
-when destruction of an object with static or thread storage duration exits
-via an exception\iref{basic.start.term}, or
-
-\item%
-when execution of a function registered with
-\tcode{std::atexit} or \tcode{std::at_quick_exit}
-exits via an exception\iref{support.start.term}, or
-
-\item%
-when a
-\grammarterm{throw-expression}\iref{expr.throw}
-with no operand attempts to rethrow an exception and no exception is being
-handled\iref{except.throw}, or
-
-\item%
-when the function \tcode{std::nested_exception::rethrow_nested} is called for an object
-that has captured no exception\iref{except.nested}, or
-
-\item%
-when execution of the initial function of a thread exits via
-an exception\iref{thread.thread.constr}, or
-
-\item%
-for a parallel algorithm whose \tcode{ExecutionPolicy} specifies such
-behavior\iref{execpol.seq,execpol.par,execpol.parunseq},
-when execution of an element access function\iref{algorithms.parallel.defns}
-of the parallel algorithm exits via an exception\iref{algorithms.parallel.exceptions}, or
-
-\item%
-when the destructor or the move assignment operator is invoked on an object
-of type \tcode{std::thread} that refers to
-a joinable thread\iref{thread.thread.destr,thread.thread.assign}, or
-
-\item%
-when a call to a \tcode{wait()}, \tcode{wait_until()}, or \tcode{wait_for()}
-function on a condition variable\iref{thread.condition.condvar,thread.condition.condvarany}
-fails to meet a postcondition, or
-
-\item%
-when a callback invocation exits via an exception
-when requesting stop on
-a \tcode{std::stop_source} or
-a \tcode{std::in\-place_stop_source}\iref{stopsource.mem,stopsource.inplace.mem},
-or in the constructor of
-\tcode{std::stop_callback} or
-\tcode{std::inplace_stop_callback}\iref{stopcallback.cons,stopcallback.inplace.cons}
-when a callback invocation exits via an exception, or
-
-\item%
-when a \tcode{run_loop} object is destroyed
-that is still in the \tcode{running} state\iref{exec.run.loop}, or
-
-\item%
-when \tcode{unhandled_stopped} is called on
-a \tcode{with_awaitable_senders<T>} object\iref{exec.with.awaitable.senders}
-whose continuation is not a handle to a coroutine
-whose promise type has an \tcode{unhandled_stopped} member function.
-
-\end{itemize}
-
-\end{note}
-
-\pnum
-\indextext{\idxcode{terminate}}%
-In the situation where no matching handler is found, it is
-\impldef{stack unwinding before invocation of \tcode{std::terminate}}
-whether or not the stack is unwound
-before \tcode{std::terminate} is invoked.
-In the situation where the search for a handler\iref{except.handle} encounters the
-outermost block of a function
-with a non-throwing exception specification\iref{except.spec}, it is
-\impldef{whether stack is unwound before invoking the function \tcode{std::terminate}
-when a \tcode{noexcept} specification is violated}
-whether the stack is unwound, unwound partially, or not unwound at all
-before the function \tcode{std::terminate} is invoked.
-In all other situations, the stack shall not be unwound before
-the function \tcode{std::terminate}
-is invoked.
-An implementation is not permitted to finish stack unwinding
-prematurely based on a determination that the unwind process
-will eventually cause an invocation of the function
-\tcode{std::terminate}.
 \indextext{exception handling|)}

source/xrefdelta.tex

@@ -73,6 +73,10 @@
 \removedxref{type.index.members}
 \removedxref{type.index.hash}
 
+% Dissolving [except]
+\removedxref{except.special}
+\removedxref{except.special.general}
+
 %%% Renamed sections.
 %%% Examples:
 %
@@ -98,6 +102,7 @@
 % https://github.com/cplusplus/draft/pull/7276
 \movedxref{except.uncaught}{except.throw}
 
+
 %%% Deprecated features.
 %%% Example:
 %