[diagnostics] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpp0nirck9/{from.md → to.md} +251 -154

tmp/tmpp0nirck9/{from.md → to.md} RENAMED Viewed

@@ -17,10 +17,11 @@ in [[diagnostics.summary]].
 | [[std.exceptions]] | Exception classes    | `<stdexcept>`    |
 | [[assertions]]     | Assertions           | `<cassert>`      |
 | [[errno]]          | Error numbers        | `<cerrno>`       |
 | [[syserr]]         | System error support | `<system_error>` |
 | [[stacktrace]]     | Stacktrace           | `<stacktrace>`   |
 ## Exception classes <a id="std.exceptions">[[std.exceptions]]</a>
 ### General <a id="std.exceptions.general">[[std.exceptions.general]]</a>
@@ -60,270 +61,291 @@ namespace std {
 ``` cpp
 namespace std {
   class logic_error : public exception {
   public:
-    explicit logic_error(const string& what_arg);
-    explicit logic_error(const char* what_arg);
   };
 }
 ```
 The class `logic_error` defines the type of objects thrown as exceptions
 to report errors presumably detectable before the program executes, such
 as violations of logical preconditions or class invariants.
 ``` cpp
-logic_error(const string& what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
-logic_error(const char* what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg) == 0`.
 ### Class `domain_error` <a id="domain.error">[[domain.error]]</a>
 ``` cpp
 namespace std {
   class domain_error : public logic_error {
   public:
-    explicit domain_error(const string& what_arg);
-    explicit domain_error(const char* what_arg);
   };
 }
 ```
 The class `domain_error` defines the type of objects thrown as
 exceptions by the implementation to report domain errors.
 ``` cpp
-domain_error(const string& what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
-domain_error(const char* what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg) == 0`.
 ### Class `invalid_argument` <a id="invalid.argument">[[invalid.argument]]</a>
 ``` cpp
 namespace std {
   class invalid_argument : public logic_error {
   public:
-    explicit invalid_argument(const string& what_arg);
-    explicit invalid_argument(const char* what_arg);
   };
 }
 ```
 The class `invalid_argument` defines the type of objects thrown as
 exceptions to report an invalid argument.
 ``` cpp
-invalid_argument(const string& what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
-invalid_argument(const char* what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg) == 0`.
 ### Class `length_error` <a id="length.error">[[length.error]]</a>
 ``` cpp
 namespace std {
   class length_error : public logic_error {
   public:
-    explicit length_error(const string& what_arg);
-    explicit length_error(const char* what_arg);
   };
 }
 ```
 The class `length_error` defines the type of objects thrown as
 exceptions to report an attempt to produce an object whose length
 exceeds its maximum allowable size.
 ``` cpp
-length_error(const string& what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
-length_error(const char* what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg) == 0`.
 ### Class `out_of_range` <a id="out.of.range">[[out.of.range]]</a>
 ``` cpp
 namespace std {
   class out_of_range : public logic_error {
   public:
-    explicit out_of_range(const string& what_arg);
-    explicit out_of_range(const char* what_arg);
   };
 }
 ```
 The class `out_of_range` defines the type of objects thrown as
 exceptions to report an argument value not in its expected range.
 ``` cpp
-out_of_range(const string& what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
-out_of_range(const char* what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg) == 0`.
 ### Class `runtime_error` <a id="runtime.error">[[runtime.error]]</a>
 ``` cpp
 namespace std {
   class runtime_error : public exception {
   public:
-    explicit runtime_error(const string& what_arg);
-    explicit runtime_error(const char* what_arg);
   };
 }
 ```
 The class `runtime_error` defines the type of objects thrown as
 exceptions to report errors presumably detectable only when the program
 executes.
 ``` cpp
-runtime_error(const string& what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
-runtime_error(const char* what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg) == 0`.
 ### Class `range_error` <a id="range.error">[[range.error]]</a>
 ``` cpp
 namespace std {
   class range_error : public runtime_error {
   public:
-    explicit range_error(const string& what_arg);
-    explicit range_error(const char* what_arg);
   };
 }
 ```
 The class `range_error` defines the type of objects thrown as exceptions
 to report range errors in internal computations.
 ``` cpp
-range_error(const string& what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
-range_error(const char* what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg) == 0`.
 ### Class `overflow_error` <a id="overflow.error">[[overflow.error]]</a>
 ``` cpp
 namespace std {
   class overflow_error : public runtime_error {
   public:
-    explicit overflow_error(const string& what_arg);
-    explicit overflow_error(const char* what_arg);
   };
 }
 ```
 The class `overflow_error` defines the type of objects thrown as
 exceptions to report an arithmetic overflow error.
 ``` cpp
-overflow_error(const string& what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
-overflow_error(const char* what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg) == 0`.
 ### Class `underflow_error` <a id="underflow.error">[[underflow.error]]</a>
 ``` cpp
 namespace std {
   class underflow_error : public runtime_error {
   public:
-    explicit underflow_error(const string& what_arg);
-    explicit underflow_error(const char* what_arg);
   };
 }
 ```
 The class `underflow_error` defines the type of objects thrown as
 exceptions to report an arithmetic underflow error.
 ``` cpp
-underflow_error(const string& what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
-underflow_error(const char* what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg) == 0`.
 ## Assertions <a id="assertions">[[assertions]]</a>
 ### General <a id="assertions.general">[[assertions.general]]</a>
 The header `<cassert>` provides a macro for documenting C++ program
-assertions and a mechanism for disabling the assertion checks.
 ### Header `<cassert>` synopsis <a id="cassert.syn">[[cassert.syn]]</a>
 ``` cpp
-#define assert(E) see below
 ```
-The contents are the same as the C standard library header `<assert.h>`,
-except that a macro named `static_assert` is not defined.
-See also: ISO C 7.2
 ### The `assert` macro <a id="assertions.assert">[[assertions.assert]]</a>
 An expression `assert(E)` is a constant subexpression
 [[defns.const.subexpr]], if
 - `NDEBUG` is defined at the point where `assert` is last defined or
   redefined, or
@@ -345,84 +367,84 @@ A separate `errno` value is provided for each thread.
 ### Header `<cerrno>` synopsis <a id="cerrno.syn">[[cerrno.syn]]</a>
 ``` cpp
 #define errno see below
-#define E2BIG see below
-#define EACCES see below
-#define EADDRINUSE see below
-#define EADDRNOTAVAIL see below
-#define EAFNOSUPPORT see below
-#define EAGAIN see below
-#define EALREADY see below
-#define EBADF see below
-#define EBADMSG see below
-#define EBUSY see below
-#define ECANCELED see below
-#define ECHILD see below
-#define ECONNABORTED see below
-#define ECONNREFUSED see below
-#define ECONNRESET see below
-#define EDEADLK see below
-#define EDESTADDRREQ see below
-#define EDOM see below
-#define EEXIST see below
-#define EFAULT see below
-#define EFBIG see below
-#define EHOSTUNREACH see below
-#define EIDRM see below
-#define EILSEQ see below
-#define EINPROGRESS see below
-#define EINTR see below
-#define EINVAL see below
-#define EIO see below
-#define EISCONN see below
-#define EISDIR see below
-#define ELOOP see below
-#define EMFILE see below
-#define EMLINK see below
-#define EMSGSIZE see below
-#define ENAMETOOLONG see below
-#define ENETDOWN see below
-#define ENETRESET see below
-#define ENETUNREACH see below
-#define ENFILE see below
-#define ENOBUFS see below
-#define ENODEV see below
-#define ENOENT see below
-#define ENOEXEC see below
-#define ENOLCK see below
-#define ENOLINK see below
-#define ENOMEM see below
-#define ENOMSG see below
-#define ENOPROTOOPT see below
-#define ENOSPC see below
-#define ENOSYS see below
-#define ENOTCONN see below
-#define ENOTDIR see below
-#define ENOTEMPTY see below
-#define ENOTRECOVERABLE see below
-#define ENOTSOCK see below
-#define ENOTSUP see below
-#define ENOTTY see below
-#define ENXIO see below
-#define EOPNOTSUPP see below
-#define EOVERFLOW see below
-#define EOWNERDEAD see below
-#define EPERM see below
-#define EPIPE see below
-#define EPROTO see below
-#define EPROTONOSUPPORT see below
-#define EPROTOTYPE see below
-#define ERANGE see below
-#define EROFS see below
-#define ESPIPE see below
-#define ESRCH see below
-#define ETIMEDOUT see below
-#define ETXTBSY see below
-#define EWOULDBLOCK see below
-#define EXDEV see below
 ```
 The meaning of the macros in this header is defined by the POSIX
 standard.
@@ -460,11 +482,11 @@ namespace std {
     struct is_error_code_enum : public false_type {};
   template<class T>
     struct is_error_condition_enum : public false_type {};
-  enum class errc {
     address_family_not_supported,       // EAFNOSUPPORT
     address_in_use,                     // EADDRINUSE
     address_not_available,              // EADDRNOTAVAIL
     already_connected,                  // EISCONN
     argument_list_too_long,             // E2BIG
@@ -789,18 +811,18 @@ namespace std {
 ``` cpp
 error_code() noexcept;
 ```
-*Effects:* Initializes `val_` with `0` and `cat_` with
 `&system_category()`.
 ``` cpp
 error_code(int val, const error_category& cat) noexcept;
 ```
-*Effects:* Initializes `val_` with `val` and `cat_` with `&cat`.
 ``` cpp
 template<class ErrorCodeEnum>
   error_code(ErrorCodeEnum e) noexcept;
 ```
@@ -818,11 +840,11 @@ assign(ec.value(), ec.category());
 ``` cpp
 void assign(int val, const error_category& cat) noexcept;
 ```
-*Ensures:* `val_ == val` and `cat_ == &cat`.
 ``` cpp
 template<class ErrorCodeEnum>
   error_code& operator=(ErrorCodeEnum e) noexcept;
 ```
@@ -848,17 +870,17 @@ void clear() noexcept;
 ``` cpp
 int value() const noexcept;
 ```
-*Returns:* `val_`.
 ``` cpp
 const error_category& category() const noexcept;
 ```
-*Returns:* `*cat_`.
 ``` cpp
 error_condition default_error_condition() const noexcept;
 ```
@@ -936,18 +958,18 @@ namespace std {
 ``` cpp
 error_condition() noexcept;
 ```
-*Effects:* Initializes `val_` with `0` and `cat_` with
 `&generic_category()`.
 ``` cpp
 error_condition(int val, const error_category& cat) noexcept;
 ```
-*Effects:* Initializes `val_` with `val` and `cat_` with `&cat`.
 ``` cpp
 template<class ErrorConditionEnum>
   error_condition(ErrorConditionEnum e) noexcept;
 ```
@@ -966,11 +988,11 @@ assign(ec.value(), ec.category());
 ``` cpp
 void assign(int val, const error_category& cat) noexcept;
 ```
-*Ensures:* `val_ == val` and `cat_ == &cat`.
 ``` cpp
 template<class ErrorConditionEnum>
   error_condition& operator=(ErrorConditionEnum e) noexcept;
 ```
@@ -997,17 +1019,17 @@ void clear() noexcept;
 ``` cpp
 int value() const noexcept;
 ```
-*Returns:* `val_`.
 ``` cpp
 const error_category& category() const noexcept;
 ```
-*Returns:* `*cat_`.
 ``` cpp
 string message() const;
 ```
@@ -1411,11 +1433,11 @@ namespace std {
     const_iterator cbegin() const noexcept;
     const_iterator cend() const noexcept;
     const_reverse_iterator crbegin() const noexcept;
     const_reverse_iterator crend() const noexcept;
- [[nodiscard]] bool empty() const noexcept;
     size_type size() const noexcept;
     size_type max_size() const noexcept;
     const_reference operator[](size_type) const;
     const_reference at(size_type) const;
@@ -1453,48 +1475,49 @@ container [[container.alloc.reqmts]], and of a sequence container
 ``` cpp
 static basic_stacktrace current(const allocator_type& alloc = allocator_type()) noexcept;
 ```
-*Returns:* A `basic_stacktrace` object with `frames_` storing the
 stacktrace of the current evaluation in the current thread of execution,
-or an empty `basic_stacktrace` object if the initialization of `frames_`
-failed. `alloc` is passed to the constructor of the `frames_` object.
 [*Note 1*: If the stacktrace was successfully obtained, then
-`frames_.front()` is the `stacktrace_entry` representing approximately
-the current evaluation, and `frames_.back()` is the `stacktrace_entry`
-representing approximately the initial function of the current thread of
-execution. — *end note*]
 ``` cpp
 static basic_stacktrace current(size_type skip,
                                 const allocator_type& alloc = allocator_type()) noexcept;
 ```
 Let `t` be a stacktrace as-if obtained via
 `basic_stacktrace::current(alloc)`. Let `n` be `t.size()`.
-*Returns:* A `basic_stacktrace` object where `frames_` is
 direct-non-list-initialized from arguments `t.begin() + min(n, skip)`,
 `t.end()`, and `alloc`, or an empty `basic_stacktrace` object if the
-initialization of `frames_` failed.
 ``` cpp
 static basic_stacktrace current(size_type skip, size_type max_depth,
                                 const allocator_type& alloc = allocator_type()) noexcept;
 ```
 Let `t` be a stacktrace as-if obtained via
 `basic_stacktrace::current(alloc)`. Let `n` be `t.size()`.
-*Preconditions:* `skip <= skip + max_depth` is `true`.
-*Returns:* A `basic_stacktrace` object where `frames_` is
 direct-non-list-initialized from arguments `t.begin() + min(n, skip)`,
 `t.begin() + min(n, skip + max_depth)`, and `alloc`, or an empty
-`basic_stacktrace` object if the initialization of `frames_` failed.
 ``` cpp
 basic_stacktrace() noexcept(is_nothrow_default_constructible_v<allocator_type>);
 ```
@@ -1502,11 +1525,11 @@ basic_stacktrace() noexcept(is_nothrow_default_constructible_v<allocator_type>);
 ``` cpp
 explicit basic_stacktrace(const allocator_type& alloc) noexcept;
 ```
-*Effects:* `alloc` is passed to the `frames_` constructor.
 *Ensures:* `empty()` is `true`.
 ``` cpp
 basic_stacktrace(const basic_stacktrace& other);
@@ -1534,18 +1557,18 @@ The type models `random_access_iterator`
 ``` cpp
 allocator_type get_allocator() const noexcept;
 ```
-*Returns:* `frames_.get_allocator()`.
 ``` cpp
 const_iterator begin() const noexcept;
 const_iterator cbegin() const noexcept;
 ```
-*Returns:* An iterator referring to the first element in `frames_`. If
 `empty()` is `true`, then it returns the same value as `end()`.
 ``` cpp
 const_iterator end() const noexcept;
 const_iterator cend() const noexcept;
@@ -1566,42 +1589,42 @@ const_reverse_iterator crend() const noexcept;
 ```
 *Returns:* `reverse_iterator(cbegin())`.
 ``` cpp
-[[nodiscard]] bool empty() const noexcept;
 ```
-*Returns:* `frames_.empty()`.
 ``` cpp
 size_type size() const noexcept;
 ```
-*Returns:* `frames_.size()`.
 ``` cpp
 size_type max_size() const noexcept;
 ```
-*Returns:* `frames_.max_size()`.
 ``` cpp
 const_reference operator[](size_type frame_no) const;
 ```
-*Preconditions:* `frame_no < size()` is `true`.
-*Returns:* `frames_[frame_no]`.
 *Throws:* Nothing.
 ``` cpp
 const_reference at(size_type frame_no) const;
 ```
-*Returns:* `frames_[frame_no]`.
 *Throws:* `out_of_range` if `frame_no >= size()`.
 #### Comparisons <a id="stacktrace.basic.cmp">[[stacktrace.basic.cmp]]</a>
@@ -1673,11 +1696,11 @@ template<class Allocator>
   ostream& operator<<(ostream& os, const basic_stacktrace<Allocator>& st);
 ```
 *Effects:* Equivalent to: `return os << to_string(st);`
-#### Formatting support <a id="stacktrace.format">[[stacktrace.format]]</a>
 ``` cpp
 template<> struct formatter<stacktrace_entry>;
 ```
@@ -1705,19 +1728,88 @@ template<class Allocator> struct formatter<basic_stacktrace<Allocator>>;
 For `formatter<basic_stacktrace<Allocator>>`, *format-spec* is empty.
 A `basic_stacktrace<Allocator>` object `s` is formatted as if by copying
 `to_string(s)` through the output iterator of the context.
-#### Hash support <a id="stacktrace.basic.hash">[[stacktrace.basic.hash]]</a>
 ``` cpp
 template<> struct hash<stacktrace_entry>;
 template<class Allocator> struct hash<basic_stacktrace<Allocator>>;
 ```
 The specializations are enabled [[unord.hash]].
 <!-- Link reference definitions -->
 [assertions]: #assertions
 [assertions.assert]: #assertions.assert
 [assertions.general]: #assertions.general
 [bad.alloc]: support.md#bad.alloc
@@ -1728,18 +1820,22 @@ The specializations are enabled [[unord.hash]].
 [concepts.object]: concepts.md#concepts.object
 [container.alloc.reqmts]: containers.md#container.alloc.reqmts
 [container.rev.reqmts]: containers.md#container.rev.reqmts
 [conv]: expr.md#conv
 [cpp.predefined]: cpp.md#cpp.predefined
 [defns.const.subexpr]: intro.md#defns.const.subexpr
 [diagnostics]: #diagnostics
 [diagnostics.general]: #diagnostics.general
 [diagnostics.summary]: #diagnostics.summary
 [domain.error]: #domain.error
 [errno]: #errno
 [errno.general]: #errno.general
-[format.string.std]: utilities.md#format.string.std
 [intro.execution]: basic.md#intro.execution
 [invalid.argument]: #invalid.argument
 [iterator.concept.random.access]: iterators.md#iterator.concept.random.access
 [length.error]: #length.error
 [logic.error]: #logic.error
@@ -1795,7 +1891,8 @@ The specializations are enabled [[unord.hash]].
 [syserr.hash]: #syserr.hash
 [syserr.syserr]: #syserr.syserr
 [syserr.syserr.members]: #syserr.syserr.members
 [syserr.syserr.overview]: #syserr.syserr.overview
 [system.error.syn]: #system.error.syn
 [underflow.error]: #underflow.error
 [unord.hash]: utilities.md#unord.hash

 | [[std.exceptions]] | Exception classes    | `<stdexcept>`    |
 | [[assertions]]     | Assertions           | `<cassert>`      |
 | [[errno]]          | Error numbers        | `<cerrno>`       |
 | [[syserr]]         | System error support | `<system_error>` |
 | [[stacktrace]]     | Stacktrace           | `<stacktrace>`   |
+| [[debugging]]      | Debugging            | `<debugging>`    |
 ## Exception classes <a id="std.exceptions">[[std.exceptions]]</a>
 ### General <a id="std.exceptions.general">[[std.exceptions.general]]</a>
 ``` cpp
 namespace std {
   class logic_error : public exception {
   public:
+ constexpr explicit logic_error(const string& what_arg);
+ constexpr explicit logic_error(const char* what_arg);
   };
 }
 ```
 The class `logic_error` defines the type of objects thrown as exceptions
 to report errors presumably detectable before the program executes, such
 as violations of logical preconditions or class invariants.
 ``` cpp
+constexpr logic_error(const string& what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
+constexpr logic_error(const char* what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg) == 0`.
 ### Class `domain_error` <a id="domain.error">[[domain.error]]</a>
 ``` cpp
 namespace std {
   class domain_error : public logic_error {
   public:
+ constexpr explicit domain_error(const string& what_arg);
+ constexpr explicit domain_error(const char* what_arg);
   };
 }
 ```
 The class `domain_error` defines the type of objects thrown as
 exceptions by the implementation to report domain errors.
 ``` cpp
+constexpr domain_error(const string& what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
+constexpr domain_error(const char* what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg) == 0`.
 ### Class `invalid_argument` <a id="invalid.argument">[[invalid.argument]]</a>
 ``` cpp
 namespace std {
   class invalid_argument : public logic_error {
   public:
+ constexpr explicit invalid_argument(const string& what_arg);
+ constexpr explicit invalid_argument(const char* what_arg);
   };
 }
 ```
 The class `invalid_argument` defines the type of objects thrown as
 exceptions to report an invalid argument.
 ``` cpp
+constexpr invalid_argument(const string& what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
+constexpr invalid_argument(const char* what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg) == 0`.
 ### Class `length_error` <a id="length.error">[[length.error]]</a>
 ``` cpp
 namespace std {
   class length_error : public logic_error {
   public:
+ constexpr explicit length_error(const string& what_arg);
+ constexpr explicit length_error(const char* what_arg);
   };
 }
 ```
 The class `length_error` defines the type of objects thrown as
 exceptions to report an attempt to produce an object whose length
 exceeds its maximum allowable size.
 ``` cpp
+constexpr length_error(const string& what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
+constexpr length_error(const char* what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg) == 0`.
 ### Class `out_of_range` <a id="out.of.range">[[out.of.range]]</a>
 ``` cpp
 namespace std {
   class out_of_range : public logic_error {
   public:
+ constexpr explicit out_of_range(const string& what_arg);
+ constexpr explicit out_of_range(const char* what_arg);
   };
 }
 ```
 The class `out_of_range` defines the type of objects thrown as
 exceptions to report an argument value not in its expected range.
 ``` cpp
+constexpr out_of_range(const string& what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
+constexpr out_of_range(const char* what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg) == 0`.
 ### Class `runtime_error` <a id="runtime.error">[[runtime.error]]</a>
 ``` cpp
 namespace std {
   class runtime_error : public exception {
   public:
+ constexpr explicit runtime_error(const string& what_arg);
+ constexpr explicit runtime_error(const char* what_arg);
   };
 }
 ```
 The class `runtime_error` defines the type of objects thrown as
 exceptions to report errors presumably detectable only when the program
 executes.
 ``` cpp
+constexpr runtime_error(const string& what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
+constexpr runtime_error(const char* what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg) == 0`.
 ### Class `range_error` <a id="range.error">[[range.error]]</a>
 ``` cpp
 namespace std {
   class range_error : public runtime_error {
   public:
+ constexpr explicit range_error(const string& what_arg);
+ constexpr explicit range_error(const char* what_arg);
   };
 }
 ```
 The class `range_error` defines the type of objects thrown as exceptions
 to report range errors in internal computations.
 ``` cpp
+constexpr range_error(const string& what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
+constexpr range_error(const char* what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg) == 0`.
 ### Class `overflow_error` <a id="overflow.error">[[overflow.error]]</a>
 ``` cpp
 namespace std {
   class overflow_error : public runtime_error {
   public:
+ constexpr explicit overflow_error(const string& what_arg);
+ constexpr explicit overflow_error(const char* what_arg);
   };
 }
 ```
 The class `overflow_error` defines the type of objects thrown as
 exceptions to report an arithmetic overflow error.
 ``` cpp
+constexpr overflow_error(const string& what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
+constexpr overflow_error(const char* what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg) == 0`.
 ### Class `underflow_error` <a id="underflow.error">[[underflow.error]]</a>
 ``` cpp
 namespace std {
   class underflow_error : public runtime_error {
   public:
+ constexpr explicit underflow_error(const string& what_arg);
+ constexpr explicit underflow_error(const char* what_arg);
   };
 }
 ```
 The class `underflow_error` defines the type of objects thrown as
 exceptions to report an arithmetic underflow error.
 ``` cpp
+constexpr underflow_error(const string& what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg.c_str()) == 0`.
 ``` cpp
+constexpr underflow_error(const char* what_arg);
 ```
 *Ensures:* `strcmp(what(), what_arg) == 0`.
 ## Assertions <a id="assertions">[[assertions]]</a>
 ### General <a id="assertions.general">[[assertions.general]]</a>
 The header `<cassert>` provides a macro for documenting C++ program
+assertions and a mechanism for disabling the assertion checks through
+defining the macro `NDEBUG`.
 ### Header `<cassert>` synopsis <a id="cassert.syn">[[cassert.syn]]</a>
 ``` cpp
+#define assert(...) see below
 ```
 ### The `assert` macro <a id="assertions.assert">[[assertions.assert]]</a>
+If `NDEBUG` is defined as a macro name at the point in the source file
+where `<cassert>` is included, the `assert` macro is defined as
+``` cpp
+#define assert(...) ((void)0)
+```
+Otherwise, the `assert` macro puts a diagnostic test into programs; it
+expands to an expression of type `void` which has the following effects:
+- `__VA_ARGS__` is evaluated and contextually converted to `bool`.
+- If the evaluation yields `true` there are no further effects.
+- Otherwise, the `assert` macro’s expression creates a diagnostic on the
+  standard error stream (ISO/IEC 9899:2018 (C), 7.23.3) in an
+  *implementation-defined* format and calls `abort()`. The diagnostic
+  contains `#``__VA_ARGS__` and information on the name of the source
+  file, the source line number, and the name of the enclosing function
+  (such as provided by `source_location::current()`).
+If `__VA_ARGS__` does not expand to an *assignment-expression*, the
+program is ill-formed.
+The macro `assert` is redefined according to the current state of
+`NDEBUG` each time that `<cassert>` is included.
 An expression `assert(E)` is a constant subexpression
 [[defns.const.subexpr]], if
 - `NDEBUG` is defined at the point where `assert` is last defined or
   redefined, or
 ### Header `<cerrno>` synopsis <a id="cerrno.syn">[[cerrno.syn]]</a>
 ``` cpp
 #define errno see below
+#define E2BIG see below                                                // freestanding
+#define EACCES see below                                               // freestanding
+#define EADDRINUSE see below                                           // freestanding
+#define EADDRNOTAVAIL see below                                        // freestanding
+#define EAFNOSUPPORT see below                                         // freestanding
+#define EAGAIN see below                                               // freestanding
+#define EALREADY see below                                             // freestanding
+#define EBADF see below                                                // freestanding
+#define EBADMSG see below                                              // freestanding
+#define EBUSY see below                                                // freestanding
+#define ECANCELED see below                                            // freestanding
+#define ECHILD see below                                               // freestanding
+#define ECONNABORTED see below                                         // freestanding
+#define ECONNREFUSED see below                                         // freestanding
+#define ECONNRESET see below                                           // freestanding
+#define EDEADLK see below                                              // freestanding
+#define EDESTADDRREQ see below                                         // freestanding
+#define EDOM see below                                                 // freestanding
+#define EEXIST see below                                               // freestanding
+#define EFAULT see below                                               // freestanding
+#define EFBIG see below                                                // freestanding
+#define EHOSTUNREACH see below                                         // freestanding
+#define EIDRM see below                                                // freestanding
+#define EILSEQ see below                                               // freestanding
+#define EINPROGRESS see below                                          // freestanding
+#define EINTR see below                                                // freestanding
+#define EINVAL see below                                               // freestanding
+#define EIO see below                                                  // freestanding
+#define EISCONN see below                                              // freestanding
+#define EISDIR see below                                               // freestanding
+#define ELOOP see below                                                // freestanding
+#define EMFILE see below                                               // freestanding
+#define EMLINK see below                                               // freestanding
+#define EMSGSIZE see below                                             // freestanding
+#define ENAMETOOLONG see below                                         // freestanding
+#define ENETDOWN see below                                             // freestanding
+#define ENETRESET see below                                            // freestanding
+#define ENETUNREACH see below                                          // freestanding
+#define ENFILE see below                                               // freestanding
+#define ENOBUFS see below                                              // freestanding
+#define ENODEV see below                                               // freestanding
+#define ENOENT see below                                               // freestanding
+#define ENOEXEC see below                                              // freestanding
+#define ENOLCK see below                                               // freestanding
+#define ENOLINK see below                                              // freestanding
+#define ENOMEM see below                                               // freestanding
+#define ENOMSG see below                                               // freestanding
+#define ENOPROTOOPT see below                                          // freestanding
+#define ENOSPC see below                                               // freestanding
+#define ENOSYS see below                                               // freestanding
+#define ENOTCONN see below                                             // freestanding
+#define ENOTDIR see below                                              // freestanding
+#define ENOTEMPTY see below                                            // freestanding
+#define ENOTRECOVERABLE see below                                      // freestanding
+#define ENOTSOCK see below                                             // freestanding
+#define ENOTSUP see below                                              // freestanding
+#define ENOTTY see below                                               // freestanding
+#define ENXIO see below                                                // freestanding
+#define EOPNOTSUPP see below                                           // freestanding
+#define EOVERFLOW see below                                            // freestanding
+#define EOWNERDEAD see below                                           // freestanding
+#define EPERM see below                                                // freestanding
+#define EPIPE see below                                                // freestanding
+#define EPROTO see below                                               // freestanding
+#define EPROTONOSUPPORT see below                                      // freestanding
+#define EPROTOTYPE see below                                           // freestanding
+#define ERANGE see below                                               // freestanding
+#define EROFS see below                                                // freestanding
+#define ESPIPE see below                                               // freestanding
+#define ESRCH see below                                                // freestanding
+#define ETIMEDOUT see below                                            // freestanding
+#define ETXTBSY see below                                              // freestanding
+#define EWOULDBLOCK see below                                          // freestanding
+#define EXDEV see below                                                // freestanding
 ```
 The meaning of the macros in this header is defined by the POSIX
 standard.
     struct is_error_code_enum : public false_type {};
   template<class T>
     struct is_error_condition_enum : public false_type {};
+  enum class errc {                                                     // freestanding
     address_family_not_supported,       // EAFNOSUPPORT
     address_in_use,                     // EADDRINUSE
     address_not_available,              // EADDRNOTAVAIL
     already_connected,                  // EISCONN
     argument_list_too_long,             // E2BIG
 ``` cpp
 error_code() noexcept;
 ```
+*Effects:* Initializes *val\_* with `0` and *cat\_* with
 `&system_category()`.
 ``` cpp
 error_code(int val, const error_category& cat) noexcept;
 ```
+*Effects:* Initializes *val\_* with `val` and *cat\_* with `&cat`.
 ``` cpp
 template<class ErrorCodeEnum>
   error_code(ErrorCodeEnum e) noexcept;
 ```
 ``` cpp
 void assign(int val, const error_category& cat) noexcept;
 ```
+*Ensures:* *`val_`*` == val` and *`cat_`*` == &cat`.
 ``` cpp
 template<class ErrorCodeEnum>
   error_code& operator=(ErrorCodeEnum e) noexcept;
 ```
 ``` cpp
 int value() const noexcept;
 ```
+*Returns:* *val\_*.
 ``` cpp
 const error_category& category() const noexcept;
 ```
+*Returns:* `*`*`cat_`*.
 ``` cpp
 error_condition default_error_condition() const noexcept;
 ```
 ``` cpp
 error_condition() noexcept;
 ```
+*Effects:* Initializes *val\_* with `0` and *cat\_* with
 `&generic_category()`.
 ``` cpp
 error_condition(int val, const error_category& cat) noexcept;
 ```
+*Effects:* Initializes *val\_* with `val` and *cat\_* with `&cat`.
 ``` cpp
 template<class ErrorConditionEnum>
   error_condition(ErrorConditionEnum e) noexcept;
 ```
 ``` cpp
 void assign(int val, const error_category& cat) noexcept;
 ```
+*Ensures:* *`val_`*` == val` and *`cat_`*` == &cat`.
 ``` cpp
 template<class ErrorConditionEnum>
   error_condition& operator=(ErrorConditionEnum e) noexcept;
 ```
 ``` cpp
 int value() const noexcept;
 ```
+*Returns:* *val\_*.
 ``` cpp
 const error_category& category() const noexcept;
 ```
+*Returns:* `*`*`cat_`*.
 ``` cpp
 string message() const;
 ```
     const_iterator cbegin() const noexcept;
     const_iterator cend() const noexcept;
     const_reverse_iterator crbegin() const noexcept;
     const_reverse_iterator crend() const noexcept;
+    bool empty() const noexcept;
     size_type size() const noexcept;
     size_type max_size() const noexcept;
     const_reference operator[](size_type) const;
     const_reference at(size_type) const;
 ``` cpp
 static basic_stacktrace current(const allocator_type& alloc = allocator_type()) noexcept;
 ```
+*Returns:* A `basic_stacktrace` object with *frames\_* storing the
 stacktrace of the current evaluation in the current thread of execution,
+or an empty `basic_stacktrace` object if the initialization of
+*frames\_* failed. `alloc` is passed to the constructor of the
+*frames\_* object.
 [*Note 1*: If the stacktrace was successfully obtained, then
+*`frames_`*`.front()` is the `stacktrace_entry` representing
+approximately the current evaluation, and *`frames_`*`.back()` is the
+`stacktrace_entry` representing approximately the initial function of
+the current thread of execution. — *end note*]
 ``` cpp
 static basic_stacktrace current(size_type skip,
                                 const allocator_type& alloc = allocator_type()) noexcept;
 ```
 Let `t` be a stacktrace as-if obtained via
 `basic_stacktrace::current(alloc)`. Let `n` be `t.size()`.
+*Returns:* A `basic_stacktrace` object where *frames\_* is
 direct-non-list-initialized from arguments `t.begin() + min(n, skip)`,
 `t.end()`, and `alloc`, or an empty `basic_stacktrace` object if the
+initialization of *frames\_* failed.
 ``` cpp
 static basic_stacktrace current(size_type skip, size_type max_depth,
                                 const allocator_type& alloc = allocator_type()) noexcept;
 ```
 Let `t` be a stacktrace as-if obtained via
 `basic_stacktrace::current(alloc)`. Let `n` be `t.size()`.
+`skip <= skip + max_depth` is `true`.
+*Returns:* A `basic_stacktrace` object where *frames\_* is
 direct-non-list-initialized from arguments `t.begin() + min(n, skip)`,
 `t.begin() + min(n, skip + max_depth)`, and `alloc`, or an empty
+`basic_stacktrace` object if the initialization of *frames\_* failed.
 ``` cpp
 basic_stacktrace() noexcept(is_nothrow_default_constructible_v<allocator_type>);
 ```
 ``` cpp
 explicit basic_stacktrace(const allocator_type& alloc) noexcept;
 ```
+*Effects:* `alloc` is passed to the *frames\_* constructor.
 *Ensures:* `empty()` is `true`.
 ``` cpp
 basic_stacktrace(const basic_stacktrace& other);
 ``` cpp
 allocator_type get_allocator() const noexcept;
 ```
+*Returns:* *`frames_`*`.get_allocator()`.
 ``` cpp
 const_iterator begin() const noexcept;
 const_iterator cbegin() const noexcept;
 ```
+*Returns:* An iterator referring to the first element in *frames\_*. If
 `empty()` is `true`, then it returns the same value as `end()`.
 ``` cpp
 const_iterator end() const noexcept;
 const_iterator cend() const noexcept;
 ```
 *Returns:* `reverse_iterator(cbegin())`.
 ``` cpp
+bool empty() const noexcept;
 ```
+*Returns:* *`frames_`*`.empty()`.
 ``` cpp
 size_type size() const noexcept;
 ```
+*Returns:* *`frames_`*`.size()`.
 ``` cpp
 size_type max_size() const noexcept;
 ```
+*Returns:* *`frames_`*`.max_size()`.
 ``` cpp
 const_reference operator[](size_type frame_no) const;
 ```
+`frame_no < size()` is `true`.
+*Returns:* *`frames_`*`[frame_no]`.
 *Throws:* Nothing.
 ``` cpp
 const_reference at(size_type frame_no) const;
 ```
+*Returns:* *`frames_`*`[frame_no]`.
 *Throws:* `out_of_range` if `frame_no >= size()`.
 #### Comparisons <a id="stacktrace.basic.cmp">[[stacktrace.basic.cmp]]</a>
   ostream& operator<<(ostream& os, const basic_stacktrace<Allocator>& st);
 ```
 *Effects:* Equivalent to: `return os << to_string(st);`
+### Formatting support <a id="stacktrace.format">[[stacktrace.format]]</a>
 ``` cpp
 template<> struct formatter<stacktrace_entry>;
 ```
 For `formatter<basic_stacktrace<Allocator>>`, *format-spec* is empty.
 A `basic_stacktrace<Allocator>` object `s` is formatted as if by copying
 `to_string(s)` through the output iterator of the context.
+### Hash support <a id="stacktrace.basic.hash">[[stacktrace.basic.hash]]</a>
 ``` cpp
 template<> struct hash<stacktrace_entry>;
 template<class Allocator> struct hash<basic_stacktrace<Allocator>>;
 ```
 The specializations are enabled [[unord.hash]].
+## Debugging <a id="debugging">[[debugging]]</a>
+### General <a id="debugging.general">[[debugging.general]]</a>
+Subclause [[debugging]] describes functionality to introspect and
+interact with the execution of the program.
+[*Note 1*: The facilities provided by the debugging functionality
+interact with a program that could be tracing the execution of a C++
+program, such as a debugger. — *end note*]
+### Header `<debugging>` synopsis <a id="debugging.syn">[[debugging.syn]]</a>
+``` cpp
+// all freestanding
+namespace std {
+  // [debugging.utility], utility
+  void breakpoint() noexcept;
+  void breakpoint_if_debugging() noexcept;
+  bool is_debugger_present() noexcept;
+}
+```
+### Utility <a id="debugging.utility">[[debugging.utility]]</a>
+``` cpp
+void breakpoint() noexcept;
+```
+The semantics of this function are *implementation-defined*.
+[*Note 1*: It is intended that, when invoked with a debugger present,
+the execution of the program temporarily halts and execution is handed
+to the debugger until the program is either terminated by the debugger
+or the debugger resumes execution of the program as if the function was
+not invoked. In particular, there is no intent for a call to this
+function to accomodate resumption of the program in a different manner.
+If there is no debugger present, execution of the program can end
+abnormally. — *end note*]
+``` cpp
+void breakpoint_if_debugging() noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+if (is_debugger_present()) breakpoint();
+```
+``` cpp
+bool is_debugger_present() noexcept;
+```
+*Required behavior:* This function has no preconditions.
+*Default behavior:* *implementation-defined*.
+[*Note 2*: It is intended that, using an immediate (uncached) query to
+determine if the program is being traced by a debugger, an
+implementation returns `true` only when tracing the execution of the
+program with a debugger. On Windows or equivalent systems, this can be
+achieved by calling the `::IsDebuggerPresent()` Win32 function. For
+systems compatible with ISO/IEC 23360:2021, this can be achieved by
+checking for a tracing process, with a best-effort determination that
+such a tracing process is a debugger. — *end note*]
+*Remarks:* This function is replaceable [[term.replaceable.function]].
 <!-- Link reference definitions -->
 [assertions]: #assertions
 [assertions.assert]: #assertions.assert
 [assertions.general]: #assertions.general
 [bad.alloc]: support.md#bad.alloc
 [concepts.object]: concepts.md#concepts.object
 [container.alloc.reqmts]: containers.md#container.alloc.reqmts
 [container.rev.reqmts]: containers.md#container.rev.reqmts
 [conv]: expr.md#conv
 [cpp.predefined]: cpp.md#cpp.predefined
+[debugging]: #debugging
+[debugging.general]: #debugging.general
+[debugging.syn]: #debugging.syn
+[debugging.utility]: #debugging.utility
 [defns.const.subexpr]: intro.md#defns.const.subexpr
 [diagnostics]: #diagnostics
 [diagnostics.general]: #diagnostics.general
 [diagnostics.summary]: #diagnostics.summary
 [domain.error]: #domain.error
 [errno]: #errno
 [errno.general]: #errno.general
+[format.string.std]: text.md#format.string.std
 [intro.execution]: basic.md#intro.execution
 [invalid.argument]: #invalid.argument
 [iterator.concept.random.access]: iterators.md#iterator.concept.random.access
 [length.error]: #length.error
 [logic.error]: #logic.error
 [syserr.hash]: #syserr.hash
 [syserr.syserr]: #syserr.syserr
 [syserr.syserr.members]: #syserr.syserr.members
 [syserr.syserr.overview]: #syserr.syserr.overview
 [system.error.syn]: #system.error.syn
+[term.replaceable.function]: dcl.md#term.replaceable.function
 [underflow.error]: #underflow.error
 [unord.hash]: utilities.md#unord.hash

Diff to HTML by rtfpessoa