[iostreams.base] - C++17 → C++20

Files changed (1) hide show

tmp/tmpmwdaqd99/{from.md → to.md} +175 -158

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

@@ -88,11 +88,11 @@ an I/O operation, or the size of I/O buffers.[^5]
 namespace std {
   class ios_base {
   public:
     class failure;              // see below
-    // [ios::fmtflags], fmtflags
     using fmtflags = T1;
     static constexpr fmtflags boolalpha = unspecified;
     static constexpr fmtflags dec = unspecified;
     static constexpr fmtflags fixed = unspecified;
     static constexpr fmtflags hex = unspecified;
@@ -109,27 +109,27 @@ namespace std {
     static constexpr fmtflags uppercase = unspecified;
     static constexpr fmtflags adjustfield = see below;
     static constexpr fmtflags basefield = see below;
     static constexpr fmtflags floatfield = see below;
-    // [ios::iostate], iostate
     using iostate = T2;
     static constexpr iostate badbit = unspecified;
     static constexpr iostate eofbit = unspecified;
     static constexpr iostate failbit = unspecified;
     static constexpr iostate goodbit = see below;
-    // [ios::openmode], openmode
     using openmode = T3;
     static constexpr openmode app = unspecified;
     static constexpr openmode ate = unspecified;
     static constexpr openmode binary = unspecified;
     static constexpr openmode in = unspecified;
     static constexpr openmode out = unspecified;
     static constexpr openmode trunc = unspecified;
-    // [ios::seekdir], seekdir
     using seekdir = T4;
     static constexpr seekdir beg = unspecified;
     static constexpr seekdir cur = unspecified;
     static constexpr seekdir end = unspecified;
@@ -151,20 +151,20 @@ namespace std {
     locale imbue(const locale& loc);
     locale getloc() const;
     // [ios.base.storage], storage
     static int xalloc();
-    long&  iword(int index);
-    void*& pword(int index);
-    // destructor:
     virtual ~ios_base();
-    // [ios.base.callback], callbacks;
     enum event { erase_event, imbue_event, copyfmt_event };
-    using event_callback = void (*)(event, ios_base&, int index);
-    void register_callback(event_callback fn, int index);
     ios_base(const ios_base&) = delete;
     ios_base& operator=(const ios_base&) = delete;
     static bool sync_with_stdio(bool sync = true);
@@ -212,11 +212,11 @@ For the sake of exposition, the maintained data is presented here as:
 — *end note*]
 #### Types <a id="ios.types">[[ios.types]]</a>
-##### Class `ios_base::failure` <a id="ios::failure">[[ios::failure]]</a>
 ``` cpp
 namespace std {
   class ios_base::failure : public system_error {
   public:
@@ -228,13 +228,13 @@ namespace std {
 An implementation is permitted to define `ios_base::failure` as a
 synonym for a class with equivalent functionality to class
 `ios_base::failure` shown in this subclause.
-[*Note 1*: When `ios_base::failure` is a synonym for another type it
-shall provide a nested type `failure`, to emulate the injected class
-name. — *end note*]
 The class `failure` defines the base class for the types of all objects
 thrown as exceptions, by functions in the iostreams library, to report
 errors detected during stream buffer operations.
@@ -251,31 +251,28 @@ iostream_category())`. — *end note*]
 ``` cpp
 explicit failure(const string& msg, const error_code& ec = io_errc::stream);
 ```
-*Effects:* Constructs an object of class `failure` by constructing the
-base class with `msg` and `ec`.
 ``` cpp
 explicit failure(const char* msg, const error_code& ec = io_errc::stream);
 ```
-*Effects:* Constructs an object of class `failure` by constructing the
-base class with `msg` and `ec`.
-##### Type `ios_base::fmtflags` <a id="ios::fmtflags">[[ios::fmtflags]]</a>
 ``` cpp
 using fmtflags = T1;
 ```
-The type `fmtflags` is a bitmask type ([[bitmask.types]]). Setting its
-elements has the effects indicated in
-Table  [[tab:iostreams.fmtflags.effects]].
-**Table: `fmtflags` effects** <a id="tab:iostreams.fmtflags.effects">[tab:iostreams.fmtflags.effects]</a>
 | Element      | Effect(s) if set                                                                                                                        |
 | ------------ | --------------------------------------------------------------------------------------------------------------------------------------- |
 | `boolalpha`  | insert and extract `bool` type in alphabetic format                                                                                     |
 | `dec`        | converts integer input or generates integer output in decimal base                                                                      |
@@ -293,31 +290,31 @@ Table  [[tab:iostreams.fmtflags.effects]].
 | `unitbuf`    | flushes output after each output operation                                                                                              |
 | `uppercase`  | replaces certain lowercase letters with their uppercase equivalents in generated output                                                 |
 Type `fmtflags` also defines the constants indicated in
-Table  [[tab:iostreams.fmtflags.constants]].
-**Table: `fmtflags` constants** <a id="tab:iostreams.fmtflags.constants">[tab:iostreams.fmtflags.constants]</a>
 | Constant      | Allowable values          |
 | ------------- | ------------------------- |
 | `adjustfield` | `left | right | internal` |
 | `basefield`   | `dec | oct | hex`         |
 | `floatfield`  | `scientific | fixed`      |
-##### Type `ios_base::iostate` <a id="ios::iostate">[[ios::iostate]]</a>
 ``` cpp
 using iostate = T2;
 ```
-The type `iostate` is a bitmask type ([[bitmask.types]]) that contains
-the elements indicated in Table  [[tab:iostreams.iostate.effects]].
-**Table: `iostate` effects** <a id="tab:iostreams.iostate.effects">[tab:iostreams.iostate.effects]</a>
 | Element   | Effect(s) if set                                                                                                                                 |
 | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
 | `badbit`  | indicates a loss of integrity in an input or output sequence (such as an irrecoverable read error from a file);                                  |
 | `eofbit`  | indicates that an input operation reached the end of an input sequence;                                                                          |
@@ -326,20 +323,20 @@ the elements indicated in Table  [[tab:iostreams.iostate.effects]].
 Type `iostate` also defines the constant:
 - `goodbit`, the value zero.
-##### Type `ios_base::openmode` <a id="ios::openmode">[[ios::openmode]]</a>
 ``` cpp
 using openmode = T3;
 ```
-The type `openmode` is a bitmask type ([[bitmask.types]]). It contains
-the elements indicated in Table  [[tab:iostreams.openmode.effects]].
-**Table: `openmode` effects** <a id="tab:iostreams.openmode.effects">[tab:iostreams.openmode.effects]</a>
 | Element  | Effect(s) if set                                                  |
 | -------- | ----------------------------------------------------------------- |
 | `app`    | seek to end before each write                                     |
 | `ate`    | open and seek to end immediately after opening                    |
@@ -347,73 +344,71 @@ the elements indicated in Table  [[tab:iostreams.openmode.effects]].
 | `in`     | open for input                                                    |
 | `out`    | open for output                                                   |
 | `trunc`  | truncate an existing stream when opening                          |
-##### Type `ios_base::seekdir` <a id="ios::seekdir">[[ios::seekdir]]</a>
 ``` cpp
 using seekdir = T4;
 ```
-The type `seekdir` is an enumerated type ([[enumerated.types]]) that
-contains the elements indicated in
-Table  [[tab:iostreams.seekdir.effects]].
-**Table: `seekdir` effects** <a id="tab:iostreams.seekdir.effects">[tab:iostreams.seekdir.effects]</a>
 | Element | Meaning                                                                                 |
 | ------- | --------------------------------------------------------------------------------------- |
 | `beg`   | request a seek (for subsequent input or output) relative to the beginning of the stream |
 | `cur`   | request a seek relative to the current position within the sequence                     |
 | `end`   | request a seek relative to the current end of the sequence                              |
-##### Class `ios_base::Init` <a id="ios::Init">[[ios::Init]]</a>
 ``` cpp
 namespace std {
   class ios_base::Init {
   public:
     Init();
     ~Init();
   private:
     static int init_cnt;        // exposition only
   };
 }
 ```
 The class `Init` describes an object whose construction ensures the
-construction of the eight objects declared in `<iostream>` (
-[[iostream.objects]]) that associate file stream buffers with the
-standard C streams provided for by the functions declared in
-`<cstdio>` ([[cstdio.syn]]).
 For the sake of exposition, the maintained data is presented here as:
 - `static int init_cnt`, counts the number of constructor and destructor
   calls for class `Init`, initialized to zero.
 ``` cpp
 Init();
 ```
-*Effects:* Constructs an object of class `Init`. Constructs and
-initializes the objects `cin`, `cout`, `cerr`, `clog`, `wcin`, `wcout`,
-`wcerr`, and `wclog` if they have not already been constructed and
-initialized.
 ``` cpp
 ~Init();
 ```
-*Effects:* Destroys an object of class `Init`. If there are no other
-instances of the class still in existence, calls `cout.flush()`,
-`cerr.flush()`, `clog.flush()`, `wcout.flush()`, `wcerr.flush()`,
-`wclog.flush()`.
-#### `ios_base` state functions <a id="fmtflags.state">[[fmtflags.state]]</a>
 ``` cpp
 fmtflags flags() const;
 ```
@@ -421,11 +416,11 @@ fmtflags flags() const;
 ``` cpp
 fmtflags flags(fmtflags fmtfl);
 ```
-*Postconditions:* `fmtfl == flags()`.
 *Returns:* The previous value of `flags()`.
 ``` cpp
 fmtflags setf(fmtflags fmtfl);
@@ -457,11 +452,11 @@ streamsize precision() const;
 ``` cpp
 streamsize precision(streamsize prec);
 ```
-*Postconditions:* `prec == precision()`.
 *Returns:* The previous value of `precision()`.
 ``` cpp
 streamsize width() const;
@@ -472,47 +467,46 @@ certain output conversions.
 ``` cpp
 streamsize width(streamsize wide);
 ```
-*Postconditions:* `wide == width()`.
 *Returns:* The previous value of `width()`.
-#### `ios_base` functions <a id="ios.base.locales">[[ios.base.locales]]</a>
 ``` cpp
 locale imbue(const locale& loc);
 ```
-*Effects:* Calls each registered callback pair
-`(fn, index)` ([[ios.base.callback]]) as
-`(*fn)(imbue_event, *this, index)` at such a time that a call to
-`ios_base::getloc()` from within `fn` returns the new locale value
-`loc`.
 *Returns:* The previous value of `getloc()`.
-*Postconditions:* `loc == getloc()`.
 ``` cpp
 locale getloc() const;
 ```
-*Returns:* If no locale has been imbued, a copy of the global C++locale,
-`locale()`, in effect at the time of construction. Otherwise, returns
-the imbued locale, to be used to perform locale-dependent input and
-output operations.
-#### `ios_base` static members <a id="ios.members.static">[[ios.members.static]]</a>
 ``` cpp
-bool sync_with_stdio(bool sync = true);
 ```
 *Returns:* `true` if the previous state of the standard iostream
-objects ([[iostream.objects]]) was synchronized and otherwise returns
 `false`. The first time it is called, the function returns `true`.
 *Effects:* If any input or output operation has occurred using the
 standard streams prior to the call, the effect is
 *implementation-defined*. Otherwise, called with a `false` argument, it
@@ -558,25 +552,27 @@ is the same as the effect of
 str.rdbuf()->sputbackc(c);
 ```
 for any sequence of characters.[^6]
-#### `ios_base` storage functions <a id="ios.base.storage">[[ios.base.storage]]</a>
 ``` cpp
 static int xalloc();
 ```
 *Returns:* `index` `++`.
-*Remarks:* Concurrent access to this function by multiple threads shall
-not result in a data race ([[intro.multithread]]).
 ``` cpp
 long& iword(int idx);
 ```
 *Effects:* If `iarray` is a null pointer, allocates an array of `long`
 of unspecified size and stores a pointer to its first element in
 `iarray`. The function then extends the array pointed at by `iarray` as
 necessary to include the element `iarray[idx]`. Each newly allocated
 element of the array is initialized to zero. The reference returned is
@@ -593,10 +589,12 @@ initialized to 0.
 ``` cpp
 void*& pword(int idx);
 ```
 *Effects:* If `parray` is a null pointer, allocates an array of pointers
 to `void` of unspecified size and stores a pointer to its first element
 in `parray`. The function then extends the array pointed at by `parray`
 as necessary to include the element `parray[idx]`. Each newly allocated
 element of the array is initialized to a null pointer. The reference
@@ -612,29 +610,29 @@ object (which may throw `failure`).
 initialized to 0.
 *Remarks:* After a subsequent call to `pword(int)` for the same object,
 the earlier return value may no longer be valid.
-#### `ios_base` callbacks <a id="ios.base.callback">[[ios.base.callback]]</a>
 ``` cpp
-void register_callback(event_callback fn, int index);
 ```
-*Effects:* Registers the pair `(fn, index)` such that during calls to
-`imbue()` ([[ios.base.locales]]), `copyfmt()`, or
-`~ios_base()` ([[ios.base.cons]]), the function `fn` is called with
-argument `index`. Functions registered are called when an event occurs,
-in opposite order of registration. Functions registered while a callback
-function is active are not called until the next event.
-*Requires:* The function `fn` shall not throw exceptions.
 *Remarks:* Identical pairs are not merged. A function registered twice
 will be called twice.
-#### `ios_base` constructors/destructor <a id="ios.base.cons">[[ios.base.cons]]</a>
 ``` cpp
 ios_base();
 ```
@@ -645,14 +643,14 @@ destroyed, whichever comes first; otherwise the behavior is undefined.
 ``` cpp
 ~ios_base();
 ```
-*Effects:* Destroys an object of class `ios_base`. Calls each registered
-callback pair `(fn, index)` ([[ios.base.callback]]) as
-`(*fn)(erase_event, *this, index)` at such time that any `ios_base`
-member function called from within `fn` has well defined results.
 ### Class template `fpos` <a id="fpos">[[fpos]]</a>
 ``` cpp
 namespace std {
@@ -665,11 +663,11 @@ namespace std {
     stateT st;                  // exposition only
   };
 }
 ```
-#### `fpos` members <a id="fpos.members">[[fpos.members]]</a>
 ``` cpp
 void state(stateT s);
 ```
@@ -679,27 +677,36 @@ void state(stateT s);
 stateT state() const;
 ```
 *Returns:* Current value of `st`.
-#### `fpos` requirements <a id="fpos.operations">[[fpos.operations]]</a>
-Operations specified in Table  [[tab:iostreams.position.requirements]]
-are permitted. In that table,
 - `P` refers to an instance of `fpos`,
-- `p` and `q` refer to values of type `P`,
-- `O` refers to type `streamoff`,
-- `o` refers to a value of type `streamoff`,
-- `sz` refers to a value of type `streamsize` and
-- `i` refers to a value of type `int`.
-[*Note 1*: Every implementation is required to supply overloaded
-operators on `fpos` objects to satisfy the requirements of
-[[fpos.operations]]. It is unspecified whether these operators are
-members of `fpos`, global operators, or provided in some other
-way. — *end note*]
 Stream operations that return a value of type `traits::pos_type` return
 `P(O(-1))` as an invalid value to signal an error. If this value is used
 as an argument to any `istream`, `ostream`, or `streambuf` member that
 accepts a value of type `traits::pos_type` then the behavior of that
@@ -768,28 +775,27 @@ namespace std {
   };
 }
 ```
-#### `basic_ios` constructors <a id="basic.ios.cons">[[basic.ios.cons]]</a>
 ``` cpp
 explicit basic_ios(basic_streambuf<charT, traits>* sb);
 ```
-*Effects:* Constructs an object of class `basic_ios`, assigning initial
-values to its member objects by calling `init(sb)`.
 ``` cpp
 basic_ios();
 ```
-*Effects:* Constructs an object of class
-`basic_ios` ([[ios.base.cons]]) leaving its member objects
-uninitialized. The object shall be initialized by calling
-`basic_ios::init` before its first use or before it is destroyed,
-whichever comes first; otherwise the behavior is undefined.
 ``` cpp
 ~basic_ios();
 ```
@@ -797,14 +803,14 @@ whichever comes first; otherwise the behavior is undefined.
 ``` cpp
 void init(basic_streambuf<charT, traits>* sb);
 ```
-*Postconditions:* The postconditions of this function are indicated in
-Table  [[tab:iostreams.basicios.init.effects]].
-**Table: `basic_ios::init()` effects** <a id="tab:iostreams.basicios.init.effects">[tab:iostreams.basicios.init.effects]</a>
 | Element        | Value                                                        |
 | -------------- | ------------------------------------------------------------ |
 | `rdbuf()`      | `sb`                                                         |
 | `tie()`        | `0`                                                          |
@@ -830,15 +836,15 @@ sequence controlled by the stream buffer.
 ``` cpp
 basic_ostream<charT, traits>* tie(basic_ostream<charT, traits>* tiestr);
 ```
-*Requires:* If `tiestr` is not null, `tiestr` must not be reachable by
 traversing the linked list of tied stream objects starting from
 `tiestr->tie()`.
-*Postconditions:* `tiestr == tie()`.
 *Returns:* The previous value of `tie()`.
 ``` cpp
 basic_streambuf<charT, traits>* rdbuf() const;
@@ -848,22 +854,22 @@ basic_streambuf<charT, traits>* rdbuf() const;
 ``` cpp
 basic_streambuf<charT, traits>* rdbuf(basic_streambuf<charT, traits>* sb);
 ```
-*Postconditions:* `sb == rdbuf()`.
 *Effects:* Calls `clear()`.
 *Returns:* The previous value of `rdbuf()`.
 ``` cpp
 locale imbue(const locale& loc);
 ```
-*Effects:* Calls `ios_base::imbue(loc)` ([[ios.base.locales]]) and if
-`rdbuf() != 0` then `rdbuf()->pubimbue(loc)` ([[streambuf.locales]]).
 *Returns:* The prior value of `ios_base::imbue()`.
 ``` cpp
 char narrow(char_type c, char dfault) const;
@@ -886,45 +892,45 @@ specified field width.
 ``` cpp
 char_type fill(char_type fillch);
 ```
-*Postconditions:* `traits::eq(fillch, fill())`.
 *Returns:* The previous value of `fill()`.
 ``` cpp
 basic_ios& copyfmt(const basic_ios& rhs);
 ```
-*Effects:* If `(this == &rhs)` does nothing. Otherwise assigns to the
-member objects of `*this` the corresponding member objects of `rhs` as
-follows:
-1.  calls each registered callback pair `(fn, index)` as
- `(*fn)(erase_event, *this, index)`;
-2.  assigns to the member objects of `*this` the corresponding member
- objects of `rhs`, except that
   - `rdstate()`, `rdbuf()`, and `exceptions()` are left unchanged;
- - the contents of arrays pointed at by `pword` and `iword` are
-      copied, not the pointers themselves;[^10] and
   - if any newly stored pointer values in `*this` point at objects
- stored outside the object `rhs` and those objects are destroyed
-      when `rhs` is destroyed, the newly stored pointer values are
-      altered to point at newly constructed copies of the objects;
-3.  calls each callback pair that was copied from `rhs` as
- `(*fn)(copyfmt_event, *this, index)`;
-4.  calls `exceptions(rhs.exceptions())`.
 [*Note 1*: The second pass through the callback pairs permits a copied
 `pword` value to be zeroed, or to have its referent deep copied or
 reference counted, or to have other special action taken. — *end note*]
-*Postconditions:* The postconditions of this function are indicated in
-Table  [[tab:iostreams.copyfmt.effects]].
-**Table: `basic_ios::copyfmt()` effects** <a id="tab:iostreams.copyfmt.effects">[tab:iostreams.copyfmt.effects]</a>
 | Element        | Value              |
 | -------------- | ------------------ |
 | `rdbuf()`      | unchanged          |
 | `tie()`        | `rhs.tie()`        |
@@ -942,39 +948,38 @@ Table  [[tab:iostreams.copyfmt.effects]].
 ``` cpp
 void move(basic_ios& rhs);
 void move(basic_ios&& rhs);
 ```
-*Postconditions:* `*this` shall have the state that `rhs` had before the
-function call, except that `rdbuf()` shall return 0. `rhs` shall be in a
-valid but unspecified state, except that `rhs.rdbuf()` shall return the
-same value as it returned before the function call, and `rhs.tie()`
-shall return 0.
 ``` cpp
 void swap(basic_ios& rhs) noexcept;
 ```
-*Effects:* The states of `*this` and `rhs` shall be exchanged, except
-that `rdbuf()` shall return the same value as it returned before the
-function call, and `rhs.rdbuf()` shall return the same value as it
-returned before the function call.
 ``` cpp
 void set_rdbuf(basic_streambuf<charT, traits>* sb);
 ```
-*Requires:* `sb != nullptr`.
 *Effects:* Associates the `basic_streambuf` object pointed to by `sb`
 with this stream without calling `clear()`.
-*Postconditions:* `rdbuf() == sb`.
 *Throws:* Nothing.
-#### `basic_ios` flags functions <a id="iostate.flags">[[iostate.flags]]</a>
 ``` cpp
 explicit operator bool() const;
 ```
@@ -994,25 +999,25 @@ iostate rdstate() const;
 ``` cpp
 void clear(iostate state = goodbit);
 ```
-*Postconditions:* If `rdbuf() != 0` then `state == rdstate()`; otherwise
 `rdstate() == (state | ios_base::badbit)`.
 *Effects:* If
 `((state | (rdbuf() ? goodbit : badbit)) & exceptions()) == 0`, returns.
-Otherwise, the function throws an object of class
-`basic_ios::failure` ([[ios::failure]]), constructed with
-*implementation-defined* argument values.
 ``` cpp
 void setstate(iostate state);
 ```
 *Effects:* Calls `clear(rdstate() | state)` (which may throw
-`basic_ios::failure` ([[ios::failure]])).
 ``` cpp
 bool good() const;
 ```
@@ -1045,18 +1050,21 @@ exceptions to be thrown.
 ``` cpp
 void exceptions(iostate except);
 ```
-*Postconditions:* `except == exceptions()`.
 *Effects:* Calls `clear(rdstate())`.
 ### `ios_base` manipulators <a id="std.ios.manip">[[std.ios.manip]]</a>
 #### `fmtflags` manipulators <a id="fmtflags.manip">[[fmtflags.manip]]</a>
 ``` cpp
 ios_base& boolalpha(ios_base& str);
 ```
 *Effects:* Calls `str.setf(ios_base::boolalpha)`.
@@ -1167,10 +1175,13 @@ ios_base& nounitbuf(ios_base& str);
 *Returns:* `str`.
 #### `adjustfield` manipulators <a id="adjustfield.manip">[[adjustfield.manip]]</a>
 ``` cpp
 ios_base& internal(ios_base& str);
 ```
 *Effects:* Calls `str.setf(ios_base::internal, ios_base::adjustfield)`.
@@ -1193,10 +1204,13 @@ ios_base& right(ios_base& str);
 *Returns:* `str`.
 #### `basefield` manipulators <a id="basefield.manip">[[basefield.manip]]</a>
 ``` cpp
 ios_base& dec(ios_base& str);
 ```
 *Effects:* Calls `str.setf(ios_base::dec, ios_base::basefield)`.
@@ -1219,10 +1233,13 @@ ios_base& oct(ios_base& str);
 *Returns:* `str`.
 #### `floatfield` manipulators <a id="floatfield.manip">[[floatfield.manip]]</a>
 ``` cpp
 ios_base& fixed(ios_base& str);
 ```
 *Effects:* Calls `str.setf(ios_base::fixed, ios_base::floatfield)`.
@@ -1246,22 +1263,22 @@ ios_base& hexfloat(ios_base& str);
 *Returns:* `str`.
 [*Note 1*: The more obvious use of `ios_base::hex` to specify
 hexadecimal floating-point format would change the meaning of existing
-well defined programs. C++03 gives no meaning to the combination of
 `fixed` and `scientific`. — *end note*]
 ``` cpp
 ios_base& defaultfloat(ios_base& str);
 ```
 *Effects:* Calls `str.unsetf(ios_base::floatfield)`.
 *Returns:* `str`.
-#### Error reporting <a id="error.reporting">[[error.reporting]]</a>
 ``` cpp
 error_code make_error_code(io_errc e) noexcept;
 ```

 namespace std {
   class ios_base {
   public:
     class failure;              // see below
+    // [ios.fmtflags], fmtflags
     using fmtflags = T1;
     static constexpr fmtflags boolalpha = unspecified;
     static constexpr fmtflags dec = unspecified;
     static constexpr fmtflags fixed = unspecified;
     static constexpr fmtflags hex = unspecified;
     static constexpr fmtflags uppercase = unspecified;
     static constexpr fmtflags adjustfield = see below;
     static constexpr fmtflags basefield = see below;
     static constexpr fmtflags floatfield = see below;
+    // [ios.iostate], iostate
     using iostate = T2;
     static constexpr iostate badbit = unspecified;
     static constexpr iostate eofbit = unspecified;
     static constexpr iostate failbit = unspecified;
     static constexpr iostate goodbit = see below;
+    // [ios.openmode], openmode
     using openmode = T3;
     static constexpr openmode app = unspecified;
     static constexpr openmode ate = unspecified;
     static constexpr openmode binary = unspecified;
     static constexpr openmode in = unspecified;
     static constexpr openmode out = unspecified;
     static constexpr openmode trunc = unspecified;
+    // [ios.seekdir], seekdir
     using seekdir = T4;
     static constexpr seekdir beg = unspecified;
     static constexpr seekdir cur = unspecified;
     static constexpr seekdir end = unspecified;
     locale imbue(const locale& loc);
     locale getloc() const;
     // [ios.base.storage], storage
     static int xalloc();
+    long&  iword(int idx);
+    void*& pword(int idx);
+    // destructor
     virtual ~ios_base();
+    // [ios.base.callback], callbacks
     enum event { erase_event, imbue_event, copyfmt_event };
+    using event_callback = void (*)(event, ios_base&, int idx);
+    void register_callback(event_callback fn, int idx);
     ios_base(const ios_base&) = delete;
     ios_base& operator=(const ios_base&) = delete;
     static bool sync_with_stdio(bool sync = true);
 — *end note*]
 #### Types <a id="ios.types">[[ios.types]]</a>
+##### Class `ios_base::failure` <a id="ios.failure">[[ios.failure]]</a>
 ``` cpp
 namespace std {
   class ios_base::failure : public system_error {
   public:
 An implementation is permitted to define `ios_base::failure` as a
 synonym for a class with equivalent functionality to class
 `ios_base::failure` shown in this subclause.
+[*Note 1*: When `ios_base::failure` is a synonym for another type, that
+type is required to provide a nested type `failure` to emulate the
+injected-class-name. — *end note*]
 The class `failure` defines the base class for the types of all objects
 thrown as exceptions, by functions in the iostreams library, to report
 errors detected during stream buffer operations.
 ``` cpp
 explicit failure(const string& msg, const error_code& ec = io_errc::stream);
 ```
+*Effects:* Constructs the base class with `msg` and `ec`.
 ``` cpp
 explicit failure(const char* msg, const error_code& ec = io_errc::stream);
 ```
+*Effects:* Constructs the base class with `msg` and `ec`.
+##### Type `ios_base::fmtflags` <a id="ios.fmtflags">[[ios.fmtflags]]</a>
 ``` cpp
 using fmtflags = T1;
 ```
+The type `fmtflags` is a bitmask type [[bitmask.types]]. Setting its
+elements has the effects indicated in [[ios.fmtflags]].
+**Table: `fmtflags` effects** <a id="ios.fmtflags">[ios.fmtflags]</a>
 | Element      | Effect(s) if set                                                                                                                        |
 | ------------ | --------------------------------------------------------------------------------------------------------------------------------------- |
 | `boolalpha`  | insert and extract `bool` type in alphabetic format                                                                                     |
 | `dec`        | converts integer input or generates integer output in decimal base                                                                      |
 | `unitbuf`    | flushes output after each output operation                                                                                              |
 | `uppercase`  | replaces certain lowercase letters with their uppercase equivalents in generated output                                                 |
 Type `fmtflags` also defines the constants indicated in
+[[ios.fmtflags.const]].
+**Table: `fmtflags` constants** <a id="ios.fmtflags.const">[ios.fmtflags.const]</a>
 | Constant      | Allowable values          |
 | ------------- | ------------------------- |
 | `adjustfield` | `left | right | internal` |
 | `basefield`   | `dec | oct | hex`         |
 | `floatfield`  | `scientific | fixed`      |
+##### Type `ios_base::iostate` <a id="ios.iostate">[[ios.iostate]]</a>
 ``` cpp
 using iostate = T2;
 ```
+The type `iostate` is a bitmask type [[bitmask.types]] that contains the
+elements indicated in [[ios.iostate]].
+**Table: `iostate` effects** <a id="ios.iostate">[ios.iostate]</a>
 | Element   | Effect(s) if set                                                                                                                                 |
 | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
 | `badbit`  | indicates a loss of integrity in an input or output sequence (such as an irrecoverable read error from a file);                                  |
 | `eofbit`  | indicates that an input operation reached the end of an input sequence;                                                                          |
 Type `iostate` also defines the constant:
 - `goodbit`, the value zero.
+##### Type `ios_base::openmode` <a id="ios.openmode">[[ios.openmode]]</a>
 ``` cpp
 using openmode = T3;
 ```
+The type `openmode` is a bitmask type [[bitmask.types]]. It contains the
+elements indicated in [[ios.openmode]].
+**Table: `openmode` effects** <a id="ios.openmode">[ios.openmode]</a>
 | Element  | Effect(s) if set                                                  |
 | -------- | ----------------------------------------------------------------- |
 | `app`    | seek to end before each write                                     |
 | `ate`    | open and seek to end immediately after opening                    |
 | `in`     | open for input                                                    |
 | `out`    | open for output                                                   |
 | `trunc`  | truncate an existing stream when opening                          |
+##### Type `ios_base::seekdir` <a id="ios.seekdir">[[ios.seekdir]]</a>
 ``` cpp
 using seekdir = T4;
 ```
+The type `seekdir` is an enumerated type [[enumerated.types]] that
+contains the elements indicated in [[ios.seekdir]].
+**Table: `seekdir` effects** <a id="ios.seekdir">[ios.seekdir]</a>
 | Element | Meaning                                                                                 |
 | ------- | --------------------------------------------------------------------------------------- |
 | `beg`   | request a seek (for subsequent input or output) relative to the beginning of the stream |
 | `cur`   | request a seek relative to the current position within the sequence                     |
 | `end`   | request a seek relative to the current end of the sequence                              |
+##### Class `ios_base::Init` <a id="ios.init">[[ios.init]]</a>
 ``` cpp
 namespace std {
   class ios_base::Init {
   public:
     Init();
+    Init(const Init&) = default;
     ~Init();
+    Init& operator=(const Init&) = default;
   private:
     static int init_cnt;        // exposition only
   };
 }
 ```
 The class `Init` describes an object whose construction ensures the
+construction of the eight objects declared in `<iostream>`
+[[iostream.objects]] that associate file stream buffers with the
+standard C streams provided for by the functions declared in `<cstdio>`.
 For the sake of exposition, the maintained data is presented here as:
 - `static int init_cnt`, counts the number of constructor and destructor
   calls for class `Init`, initialized to zero.
 ``` cpp
 Init();
 ```
+*Effects:* Constructs and initializes the objects `cin`, `cout`, `cerr`,
+`clog`, `wcin`, `wcout`, `wcerr`, and `wclog` if they have not already
+been constructed and initialized.
 ``` cpp
 ~Init();
 ```
+*Effects:* If there are no other instances of the class still in
+existence, calls `cout.flush()`, `cerr.flush()`, `clog.flush()`,
+`wcout.flush()`, `wcerr.flush()`, `wclog.flush()`.
+#### State functions <a id="fmtflags.state">[[fmtflags.state]]</a>
 ``` cpp
 fmtflags flags() const;
 ```
 ``` cpp
 fmtflags flags(fmtflags fmtfl);
 ```
+*Ensures:* `fmtfl == flags()`.
 *Returns:* The previous value of `flags()`.
 ``` cpp
 fmtflags setf(fmtflags fmtfl);
 ``` cpp
 streamsize precision(streamsize prec);
 ```
+*Ensures:* `prec == precision()`.
 *Returns:* The previous value of `precision()`.
 ``` cpp
 streamsize width() const;
 ``` cpp
 streamsize width(streamsize wide);
 ```
+*Ensures:* `wide == width()`.
 *Returns:* The previous value of `width()`.
+#### Functions <a id="ios.base.locales">[[ios.base.locales]]</a>
 ``` cpp
 locale imbue(const locale& loc);
 ```
+*Effects:* Calls each registered callback pair `(fn, idx)`
+[[ios.base.callback]] as `(*fn)(imbue_event, *this, idx)` at such a time
+that a call to `ios_base::getloc()` from within `fn` returns the new
+locale value `loc`.
+*Ensures:* `loc == getloc()`.
 *Returns:* The previous value of `getloc()`.
 ``` cpp
 locale getloc() const;
 ```
+*Returns:* If no locale has been imbued, a copy of the global C++
+locale, `locale()`, in effect at the time of construction. Otherwise,
+returns the imbued locale, to be used to perform locale-dependent input
+and output operations.
+#### Static members <a id="ios.members.static">[[ios.members.static]]</a>
 ``` cpp
+static bool sync_with_stdio(bool sync = true);
 ```
 *Returns:* `true` if the previous state of the standard iostream
+objects [[iostream.objects]] was synchronized and otherwise returns
 `false`. The first time it is called, the function returns `true`.
 *Effects:* If any input or output operation has occurred using the
 standard streams prior to the call, the effect is
 *implementation-defined*. Otherwise, called with a `false` argument, it
 str.rdbuf()->sputbackc(c);
 ```
 for any sequence of characters.[^6]
+#### Storage functions <a id="ios.base.storage">[[ios.base.storage]]</a>
 ``` cpp
 static int xalloc();
 ```
 *Returns:* `index` `++`.
+*Remarks:* Concurrent access to this function by multiple threads does
+not result in a data race [[intro.multithread]].
 ``` cpp
 long& iword(int idx);
 ```
+*Preconditions:* `idx` is a value obtained by a call to `xalloc`.
 *Effects:* If `iarray` is a null pointer, allocates an array of `long`
 of unspecified size and stores a pointer to its first element in
 `iarray`. The function then extends the array pointed at by `iarray` as
 necessary to include the element `iarray[idx]`. Each newly allocated
 element of the array is initialized to zero. The reference returned is
 ``` cpp
 void*& pword(int idx);
 ```
+*Preconditions:* `idx` is a value obtained by a call to `xalloc`.
 *Effects:* If `parray` is a null pointer, allocates an array of pointers
 to `void` of unspecified size and stores a pointer to its first element
 in `parray`. The function then extends the array pointed at by `parray`
 as necessary to include the element `parray[idx]`. Each newly allocated
 element of the array is initialized to a null pointer. The reference
 initialized to 0.
 *Remarks:* After a subsequent call to `pword(int)` for the same object,
 the earlier return value may no longer be valid.
+#### Callbacks <a id="ios.base.callback">[[ios.base.callback]]</a>
 ``` cpp
+void register_callback(event_callback fn, int idx);
 ```
+*Preconditions:* The function `fn` does not throw exceptions.
+*Effects:* Registers the pair `(fn, idx)` such that during calls to
+`imbue()` [[ios.base.locales]], `copyfmt()`, or `~ios_base()`
+[[ios.base.cons]], the function `fn` is called with argument `idx`.
+Functions registered are called when an event occurs, in opposite order
+of registration. Functions registered while a callback function is
+active are not called until the next event.
 *Remarks:* Identical pairs are not merged. A function registered twice
 will be called twice.
+#### Constructors and destructor <a id="ios.base.cons">[[ios.base.cons]]</a>
 ``` cpp
 ios_base();
 ```
 ``` cpp
 ~ios_base();
 ```
+*Effects:* Calls each registered callback pair `(fn, idx)`
+[[ios.base.callback]] as `(*fn)(erase_event, *this, idx)` at such time
+that any `ios_base` member function called from within `fn` has
+well-defined results.
 ### Class template `fpos` <a id="fpos">[[fpos]]</a>
 ``` cpp
 namespace std {
     stateT st;                  // exposition only
   };
 }
 ```
+#### Members <a id="fpos.members">[[fpos.members]]</a>
 ``` cpp
 void state(stateT s);
 ```
 stateT state() const;
 ```
 *Returns:* Current value of `st`.
+#### Requirements <a id="fpos.operations">[[fpos.operations]]</a>
+An `fpos` type specifies file position information. It holds a state
+object whose type is equal to the template parameter `stateT`. Type
+`stateT` shall meet the *Cpp17DefaultConstructible* (
+[[cpp17.defaultconstructible]]), *Cpp17CopyConstructible* (
+[[cpp17.copyconstructible]]), *Cpp17CopyAssignable* (
+[[cpp17.copyassignable]]), and *Cpp17Destructible* (
+[[cpp17.destructible]]) requirements. If
+`is_trivially_copy_constructible_v<stateT>` is `true`, then
+`fpos<stateT>` has a trivial copy constructor. If
+`is_trivially_copy_assignable<stateT>` is `true`, then `fpos<stateT>`
+has a trivial copy assignment operator. If
+`is_trivially_destructible_v<stateT>` is `true`, then `fpos<stateT>` has
+a trivial destructor. All specializations of `fpos` meet the
+*Cpp17DefaultConstructible*, *Cpp17CopyConstructible*,
+*Cpp17CopyAssignable*, *Cpp17Destructible*, and
+*Cpp17EqualityComparable* ([[cpp17.equalitycomparable]]) requirements.
+In addition, the expressions shown in [[fpos.operations]] are valid and
+have the indicated semantics. In that table,
 - `P` refers to an instance of `fpos`,
+- `p` and `q` refer to values of type `P` or `const P`,
+- `pl` and `ql` refer to modifiable lvalues of type `P`,
+- `O` refers to type `streamoff`, and
+- `o` refers to a value of type `streamoff` or `const streamoff`.
 Stream operations that return a value of type `traits::pos_type` return
 `P(O(-1))` as an invalid value to signal an error. If this value is used
 as an argument to any `istream`, `ostream`, or `streambuf` member that
 accepts a value of type `traits::pos_type` then the behavior of that
   };
 }
 ```
+#### Constructors <a id="basic.ios.cons">[[basic.ios.cons]]</a>
 ``` cpp
 explicit basic_ios(basic_streambuf<charT, traits>* sb);
 ```
+*Effects:* Assigns initial values to its member objects by calling
+`init(sb)`.
 ``` cpp
 basic_ios();
 ```
+*Effects:* Leaves its member objects uninitialized. The object shall be
+initialized by calling `basic_ios::init` before its first use or before
+it is destroyed, whichever comes first; otherwise the behavior is
+undefined.
 ``` cpp
 ~basic_ios();
 ```
 ``` cpp
 void init(basic_streambuf<charT, traits>* sb);
 ```
+*Ensures:* The postconditions of this function are indicated in
+[[basic.ios.cons]].
+**Table: `basic_ios::init()` effects** <a id="basic.ios.cons">[basic.ios.cons]</a>
 | Element        | Value                                                        |
 | -------------- | ------------------------------------------------------------ |
 | `rdbuf()`      | `sb`                                                         |
 | `tie()`        | `0`                                                          |
 ``` cpp
 basic_ostream<charT, traits>* tie(basic_ostream<charT, traits>* tiestr);
 ```
+*Preconditions:* If `tiestr` is not null, `tiestr` is not reachable by
 traversing the linked list of tied stream objects starting from
 `tiestr->tie()`.
+*Ensures:* `tiestr == tie()`.
 *Returns:* The previous value of `tie()`.
 ``` cpp
 basic_streambuf<charT, traits>* rdbuf() const;
 ``` cpp
 basic_streambuf<charT, traits>* rdbuf(basic_streambuf<charT, traits>* sb);
 ```
 *Effects:* Calls `clear()`.
+*Ensures:* `sb == rdbuf()`.
 *Returns:* The previous value of `rdbuf()`.
 ``` cpp
 locale imbue(const locale& loc);
 ```
+*Effects:* Calls `ios_base::imbue(loc)` [[ios.base.locales]] and if
+`rdbuf() != 0` then `rdbuf()->pubimbue(loc)` [[streambuf.locales]].
 *Returns:* The prior value of `ios_base::imbue()`.
 ``` cpp
 char narrow(char_type c, char dfault) const;
 ``` cpp
 char_type fill(char_type fillch);
 ```
+*Ensures:* `traits::eq(fillch, fill())`.
 *Returns:* The previous value of `fill()`.
 ``` cpp
 basic_ios& copyfmt(const basic_ios& rhs);
 ```
+*Effects:* If `(this == addressof(rhs))` is `true` does nothing.
+Otherwise assigns to the member objects of `*this` the corresponding
+member objects of `rhs` as follows:
+- calls each registered callback pair `(fn, idx)` as
+ `(*fn)(erase_event, *this, idx)`;
+- then, assigns to the member objects of `*this` the corresponding
+  member objects of `rhs`, except that
   - `rdstate()`, `rdbuf()`, and `exceptions()` are left unchanged;
+ - the contents of arrays pointed at by `pword` and `iword` are copied,
+ not the pointers themselves;[^10] and
   - if any newly stored pointer values in `*this` point at objects
+ stored outside the object `rhs` and those objects are destroyed when
+ `rhs` is destroyed, the newly stored pointer values are altered to
+ point at newly constructed copies of the objects;
+- then, calls each callback pair that was copied from `rhs` as
+ `(*fn)(copyfmt_event, *this, idx)`;
+- then, calls `exceptions(rhs.exceptions())`.
 [*Note 1*: The second pass through the callback pairs permits a copied
 `pword` value to be zeroed, or to have its referent deep copied or
 reference counted, or to have other special action taken. — *end note*]
+*Ensures:* The postconditions of this function are indicated in
+[[basic.ios.copyfmt]].
+**Table: `basic_ios::copyfmt()` effects** <a id="basic.ios.copyfmt">[basic.ios.copyfmt]</a>
 | Element        | Value              |
 | -------------- | ------------------ |
 | `rdbuf()`      | unchanged          |
 | `tie()`        | `rhs.tie()`        |
 ``` cpp
 void move(basic_ios& rhs);
 void move(basic_ios&& rhs);
 ```
+*Ensures:* `*this` has the state that `rhs` had before the function
+call, except that `rdbuf()` returns `nullptr`. `rhs` is in a valid but
+unspecified state, except that `rhs.rdbuf()` returns the same value as
+it returned before the function call, and `rhs.tie()` returns `nullptr`.
 ``` cpp
 void swap(basic_ios& rhs) noexcept;
 ```
+*Effects:* The states of `*this` and `rhs` are exchanged, except that
+`rdbuf()` returns the same value as it returned before the function
+call, and `rhs.rdbuf()` returns the same value as it returned before the
+function call.
 ``` cpp
 void set_rdbuf(basic_streambuf<charT, traits>* sb);
 ```
+*Preconditions:* `sb != nullptr` is `true`.
 *Effects:* Associates the `basic_streambuf` object pointed to by `sb`
 with this stream without calling `clear()`.
+*Ensures:* `rdbuf() == sb` is `true`.
 *Throws:* Nothing.
+#### Flags functions <a id="iostate.flags">[[iostate.flags]]</a>
 ``` cpp
 explicit operator bool() const;
 ```
 ``` cpp
 void clear(iostate state = goodbit);
 ```
+*Ensures:* If `rdbuf() != 0` then `state == rdstate()`; otherwise
 `rdstate() == (state | ios_base::badbit)`.
 *Effects:* If
 `((state | (rdbuf() ? goodbit : badbit)) & exceptions()) == 0`, returns.
+Otherwise, the function throws an object of class `ios_base::failure`
+[[ios.failure]], constructed with *implementation-defined* argument
+values.
 ``` cpp
 void setstate(iostate state);
 ```
 *Effects:* Calls `clear(rdstate() | state)` (which may throw
+`ios_base::failure` [[ios.failure]]).
 ``` cpp
 bool good() const;
 ```
 ``` cpp
 void exceptions(iostate except);
 ```
+*Ensures:* `except == exceptions()`.
 *Effects:* Calls `clear(rdstate())`.
 ### `ios_base` manipulators <a id="std.ios.manip">[[std.ios.manip]]</a>
 #### `fmtflags` manipulators <a id="fmtflags.manip">[[fmtflags.manip]]</a>
+Each function specified in this subclause is a designated addressable
+function [[namespace.std]].
 ``` cpp
 ios_base& boolalpha(ios_base& str);
 ```
 *Effects:* Calls `str.setf(ios_base::boolalpha)`.
 *Returns:* `str`.
 #### `adjustfield` manipulators <a id="adjustfield.manip">[[adjustfield.manip]]</a>
+Each function specified in this subclause is a designated addressable
+function [[namespace.std]].
 ``` cpp
 ios_base& internal(ios_base& str);
 ```
 *Effects:* Calls `str.setf(ios_base::internal, ios_base::adjustfield)`.
 *Returns:* `str`.
 #### `basefield` manipulators <a id="basefield.manip">[[basefield.manip]]</a>
+Each function specified in this subclause is a designated addressable
+function [[namespace.std]].
 ``` cpp
 ios_base& dec(ios_base& str);
 ```
 *Effects:* Calls `str.setf(ios_base::dec, ios_base::basefield)`.
 *Returns:* `str`.
 #### `floatfield` manipulators <a id="floatfield.manip">[[floatfield.manip]]</a>
+Each function specified in this subclause is a designated addressable
+function [[namespace.std]].
 ``` cpp
 ios_base& fixed(ios_base& str);
 ```
 *Effects:* Calls `str.setf(ios_base::fixed, ios_base::floatfield)`.
 *Returns:* `str`.
 [*Note 1*: The more obvious use of `ios_base::hex` to specify
 hexadecimal floating-point format would change the meaning of existing
+well-defined programs. C++03 gives no meaning to the combination of
 `fixed` and `scientific`. — *end note*]
 ``` cpp
 ios_base& defaultfloat(ios_base& str);
 ```
 *Effects:* Calls `str.unsetf(ios_base::floatfield)`.
 *Returns:* `str`.
+### Error reporting <a id="error.reporting">[[error.reporting]]</a>
 ``` cpp
 error_code make_error_code(io_errc e) noexcept;
 ```

Diff to HTML by rtfpessoa