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

Files changed (1) hide show

tmp/tmpy865wxwx/{from.md → to.md} +86 -71

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

@@ -1,22 +1,22 @@
 ## Iostreams base classes <a id="iostreams.base">[[iostreams.base]]</a>
-### Overview <a id="iostreams.base.overview">[[iostreams.base.overview]]</a>
 ``` cpp
-#include <iosfwd>
 namespace std {
- typedef implementation-defined streamoff;
- typedef implementation-defined streamsize;
   template <class stateT> class fpos;
   class ios_base;
   template <class charT, class traits = char_traits<charT>>
     class basic_ios;
-  // [std.ios.manip], manipulators:
   ios_base& boolalpha  (ios_base& str);
   ios_base& noboolalpha(ios_base& str);
   ios_base& showbase   (ios_base& str);
   ios_base& noshowbase (ios_base& str);
@@ -34,27 +34,27 @@ namespace std {
   ios_base& nouppercase(ios_base& str);
   ios_base& unitbuf    (ios_base& str);
   ios_base& nounitbuf  (ios_base& str);
-  // [adjustfield.manip] adjustfield:
   ios_base& internal   (ios_base& str);
   ios_base& left       (ios_base& str);
   ios_base& right      (ios_base& str);
-  // [basefield.manip] basefield:
   ios_base& dec        (ios_base& str);
   ios_base& hex        (ios_base& str);
   ios_base& oct        (ios_base& str);
-  // [floatfield.manip] floatfield:
   ios_base& fixed      (ios_base& str);
   ios_base& scientific (ios_base& str);
   ios_base& hexfloat   (ios_base& str);
   ios_base& defaultfloat(ios_base& str);
-  // [error.reporting] error reporting:
   enum class io_errc {
     stream = 1
   };
   template <> struct is_error_code_enum<io_errc> : public true_type { };
@@ -65,19 +65,19 @@ namespace std {
 ```
 ### Types <a id="stream.types">[[stream.types]]</a>
 ``` cpp
-typedef implementation-defined streamoff;
 ```
 The type `streamoff` is a synonym for one of the signed basic integral
 types of sufficient size to represent the maximum possible file size for
 the operating system.[^4]
 ``` cpp
-typedef implementation-defined streamsize;
 ```
 The type `streamsize` is a synonym for one of the signed basic integral
 types. It is used to represent the number of characters transferred in
 an I/O operation, or the size of I/O buffers.[^5]
@@ -86,14 +86,14 @@ an I/O operation, or the size of I/O buffers.[^5]
 ``` cpp
 namespace std {
   class ios_base {
   public:
-    class failure;
-    // [ios::fmtflags] fmtflags
- typedef T1 fmtflags;
     static constexpr fmtflags boolalpha = unspecified;
     static constexpr fmtflags dec = unspecified;
     static constexpr fmtflags fixed = unspecified;
     static constexpr fmtflags hex = unspecified;
     static constexpr fmtflags internal = unspecified;
@@ -109,35 +109,35 @@ 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
- typedef T2 iostate;
     static constexpr iostate badbit = unspecified;
     static constexpr iostate eofbit = unspecified;
     static constexpr iostate failbit = unspecified;
     static constexpr iostate goodbit = see below;
-    // [ios::openmode] openmode
- typedef T3 openmode;
     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
- typedef T4 seekdir;
     static constexpr seekdir beg = unspecified;
     static constexpr seekdir cur = unspecified;
     static constexpr seekdir end = unspecified;
     class Init;
-    // [fmtflags.state] fmtflags state:
     fmtflags flags() const;
     fmtflags flags(fmtflags fmtfl);
     fmtflags setf(fmtflags fmtfl);
     fmtflags setf(fmtflags fmtfl, fmtflags mask);
     void unsetf(fmtflags mask);
@@ -145,25 +145,25 @@ namespace std {
     streamsize precision() const;
     streamsize precision(streamsize prec);
     streamsize width() const;
     streamsize width(streamsize wide);
-    // [ios.base.locales] locales:
     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 };
- typedef void (*event_callback)(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;
@@ -182,11 +182,12 @@ namespace std {
 `ios_base`
 defines several member types:
-- a class `failure` derived from `system_error`;
 - a class `Init`;
 - three bitmask types, `fmtflags`, `iostate`, and `openmode`;
 - an enumerated type, `seekdir`.
 It maintains several kinds of data:
@@ -195,20 +196,24 @@ It maintains several kinds of data:
 - control information that influences how to interpret (format) input
   sequences and how to generate (format) output sequences;
 - additional information that is stored by the program for its private
   use.
 For the sake of exposition, the maintained data is presented here as:
 - `static int index`, specifies the next available unique index for the
   integer or pointer arrays maintained for the private use of the
   program, initialized to an unspecified value;
 - `long* iarray`, points to the first element of an arbitrary-length
   `long` array maintained for the private use of the program;
 - `void** parray`, points to the first element of an arbitrary-length
   pointer array maintained for the private use of the program.
 #### Types <a id="ios.types">[[ios.types]]</a>
 ##### Class `ios_base::failure` <a id="ios::failure">[[ios::failure]]</a>
 ``` cpp
@@ -219,22 +224,32 @@ namespace std {
     explicit failure(const char* msg, const error_code& ec = io_errc::stream);
   };
 }
 ```
 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.
 When throwing `ios_base::failure` exceptions, implementations should
 provide values of `ec` that identify the specific reason for the
-failure. Errors arising from the operating system would typically be
 reported as `system_category()` errors with an error value of the error
 number reported by the operating system. Errors arising from within the
 stream library would typically be reported as
 `error_code(io_errc::stream,
-iostream_category())`.
 ``` cpp
 explicit failure(const string& msg, const error_code& ec = io_errc::stream);
 ```
@@ -249,11 +264,11 @@ explicit failure(const char* msg, const error_code& ec = io_errc::stream);
 base class with `msg` and `ec`.
 ##### Type `ios_base::fmtflags` <a id="ios::fmtflags">[[ios::fmtflags]]</a>
 ``` cpp
-typedef T1 fmtflags;
 ```
 The type `fmtflags` is a bitmask type ([[bitmask.types]]). Setting its
 elements has the effects indicated in
 Table  [[tab:iostreams.fmtflags.effects]].
@@ -292,11 +307,11 @@ Table  [[tab:iostreams.fmtflags.constants]].
 ##### Type `ios_base::iostate` <a id="ios::iostate">[[ios::iostate]]</a>
 ``` cpp
-typedef T2 iostate;
 ```
 The type `iostate` is a bitmask type ([[bitmask.types]]) that contains
 the elements indicated in Table  [[tab:iostreams.iostate.effects]].
@@ -314,11 +329,11 @@ Type `iostate` also defines the constant:
 - `goodbit`, the value zero.
 ##### Type `ios_base::openmode` <a id="ios::openmode">[[ios::openmode]]</a>
 ``` cpp
-typedef T3 openmode;
 ```
 The type `openmode` is a bitmask type ([[bitmask.types]]). It contains
 the elements indicated in Table  [[tab:iostreams.openmode.effects]].
@@ -335,11 +350,11 @@ the elements indicated in Table  [[tab:iostreams.openmode.effects]].
 ##### Type `ios_base::seekdir` <a id="ios::seekdir">[[ios::seekdir]]</a>
 ``` cpp
-typedef T4 seekdir;
 ```
 The type `seekdir` is an enumerated type ([[enumerated.types]]) that
 contains the elements indicated in
 Table  [[tab:iostreams.seekdir.effects]].
@@ -369,11 +384,11 @@ namespace std {
 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>` ([[c.files]]).
 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.
@@ -406,11 +421,11 @@ fmtflags flags() const;
 ``` cpp
 fmtflags flags(fmtflags fmtfl);
 ```
-`fmtfl == flags()`.
 *Returns:* The previous value of `flags()`.
 ``` cpp
 fmtflags setf(fmtflags fmtfl);
@@ -442,11 +457,11 @@ streamsize precision() const;
 ``` cpp
 streamsize precision(streamsize prec);
 ```
-`prec == precision()`.
 *Returns:* The previous value of `precision()`.
 ``` cpp
 streamsize width() const;
@@ -457,11 +472,11 @@ certain output conversions.
 ``` cpp
 streamsize width(streamsize wide);
 ```
-`wide == width()`.
 *Returns:* The previous value of `width()`.
 #### `ios_base` functions <a id="ios.base.locales">[[ios.base.locales]]</a>
@@ -475,11 +490,11 @@ locale imbue(const locale& loc);
 `ios_base::getloc()` from within `fn` returns the new locale value
 `loc`.
 *Returns:* The previous value of `getloc()`.
-`loc == getloc()`.
 ``` cpp
 locale getloc() const;
 ```
@@ -498,11 +513,11 @@ bool sync_with_stdio(bool sync = true);
 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
 allows the standard streams to operate independently of the standard C
 streams.
 When a standard iostream object `str` is *synchronized* with a standard
 stdio stream `f`, the effect of inserting a character `c` by
@@ -566,11 +581,11 @@ of unspecified size and stores a pointer to its first element in
 necessary to include the element `iarray[idx]`. Each newly allocated
 element of the array is initialized to zero. The reference returned is
 invalid after any other operations on the object.[^7] However, the value
 of the storage referred to is retained, so that until the next call to
 `copyfmt`, calling `iword` with the same index yields another reference
-to the same value. If the function fails[^8] and `*this` is a base
 subobject of a `basic_ios<>` object or subobject, the effect is
 equivalent to calling `basic_ios<>::setstate(badbit)` on the derived
 object (which may throw `failure`).
 *Returns:* On success `iarray[idx]`. On failure, a valid `long&`
@@ -587,12 +602,12 @@ as necessary to include the element `parray[idx]`. Each newly allocated
 element of the array is initialized to a null pointer. The reference
 returned is invalid after any other operations on the object. However,
 the value of the storage referred to is retained, so that until the next
 call to `copyfmt`, calling `pword` with the same index yields another
 reference to the same value. If the function fails[^9] and `*this` is a
-base subobject of a `basic_ios<>` object or subobject, the effect is
-equivalent to calling `basic_ios<>::setstate(badbit)` on the derived
 object (which may throw `failure`).
 *Returns:* On success `parray[idx]`. On failure a valid `void*&`
 initialized to 0.
@@ -641,11 +656,11 @@ member function called from within `fn` has well defined results.
 ``` cpp
 namespace std {
   template <class stateT> class fpos {
   public:
-    // [fpos.members] Members
     stateT state() const;
     void state(stateT);
   private;
     stateT st; // exposition only
   };
@@ -656,11 +671,11 @@ namespace std {
 ``` cpp
 void state(stateT s);
 ```
-*Effects:* Assign `s` to `st`.
 ``` cpp
 stateT state() const;
 ```
@@ -676,14 +691,15 @@ are permitted. In that table,
 - `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`.
-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.
 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
@@ -696,18 +712,17 @@ function is undefined.
 ``` cpp
 namespace std {
   template <class charT, class traits = char_traits<charT>>
   class basic_ios : public ios_base {
   public:
-    // types:
-    typedef charT                     char_type;
-    typedef typename traits::int_type int_type;
-    typedef typename traits::pos_type pos_type;
-    typedef typename traits::off_type off_type;
-    typedef traits                    traits_type;
     explicit operator bool() const;
     bool operator!() const;
     iostate rdstate() const;
     void clear(iostate state = goodbit);
     void setstate(iostate state);
@@ -717,15 +732,15 @@ namespace std {
     bool bad()  const;
     iostate exceptions() const;
     void exceptions(iostate except);
-    // [basic.ios.cons] Constructor/destructor:
     explicit basic_ios(basic_streambuf<charT, traits>* sb);
     virtual ~basic_ios();
-    // [basic.ios.members] Members:
     basic_ostream<charT, traits>* tie() const;
     basic_ostream<charT, traits>* tie(basic_ostream<charT, traits>* tiestr);
     basic_streambuf<charT, traits>* rdbuf() const;
     basic_streambuf<charT, traits>* rdbuf(basic_streambuf<charT, traits>* sb);
@@ -796,11 +811,11 @@ Table  [[tab:iostreams.basicios.init.effects]].
 | `rdstate()`    | `goodbit` if `sb` is not a null pointer, otherwise `badbit`. |
 | `exceptions()` | `goodbit`                                                    |
 | `flags()`      | `skipws | dec`                                               |
 | `width()`      | `0`                                                          |
 | `precision()`  | `6`                                                          |
-| `fill()`       | `widen(' ');` |
 | `getloc()`     | a copy of the value returned by `locale()`                   |
 | `iarray`       | a null pointer                                               |
 | `parray`       | a null pointer                                               |
@@ -819,11 +834,11 @@ 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()`.
-`tiestr == tie()`.
 *Returns:* The previous value of `tie()`.
 ``` cpp
 basic_streambuf<charT, traits>* rdbuf() const;
@@ -833,11 +848,11 @@ basic_streambuf<charT,traits>* rdbuf() const;
 ``` cpp
 basic_streambuf<charT, traits>* rdbuf(basic_streambuf<charT, traits>* sb);
 ```
-`sb == rdbuf()`.
 *Effects:* Calls `clear()`.
 *Returns:* The previous value of `rdbuf()`.
@@ -871,11 +886,11 @@ specified field width.
 ``` cpp
 char_type fill(char_type fillch);
 ```
-`traits::eq(fillch, fill())`
 *Returns:* The previous value of `fill()`.
 ``` cpp
 basic_ios& copyfmt(const basic_ios& rhs);
@@ -896,15 +911,15 @@ follows:
       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.except())`.
-*Note:* 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.
 *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>
@@ -979,16 +994,16 @@ iostate rdstate() const;
 ``` cpp
 void clear(iostate state = goodbit);
 ```
-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 `fail` of class
 `basic_ios::failure` ([[ios::failure]]), constructed with
 *implementation-defined* argument values.
 ``` cpp
 void setstate(iostate state);
@@ -1030,11 +1045,11 @@ exceptions to be thrown.
 ``` cpp
 void exceptions(iostate except);
 ```
-`except == exceptions()`.
 *Effects:* Calls `clear(rdstate())`.
 ### `ios_base` manipulators <a id="std.ios.manip">[[std.ios.manip]]</a>
@@ -1229,14 +1244,14 @@ ios_base& hexfloat(ios_base& str);
 *Effects:* Calls
 `str.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield)`.
 *Returns:* `str`.
-The more obvious use of `ios_base::hex` to specify hexadecimal
-floating-point format would change the meaning of existing well defined
-programs. C++2003 gives no meaning to the combination of `fixed` and
-`scientific`.
 ``` cpp
 ios_base& defaultfloat(ios_base& str);
 ```

 ## Iostreams base classes <a id="iostreams.base">[[iostreams.base]]</a>
+### Header `<ios>` synopsis <a id="ios.syn">[[ios.syn]]</a>
 ``` cpp
+#include <iosfwd>   // see [iosfwd.syn]
 namespace std {
+ using streamoff  = implementation-defined;
+ using streamsize = implementation-defined;
   template <class stateT> class fpos;
   class ios_base;
   template <class charT, class traits = char_traits<charT>>
     class basic_ios;
+  // [std.ios.manip], manipulators
   ios_base& boolalpha  (ios_base& str);
   ios_base& noboolalpha(ios_base& str);
   ios_base& showbase   (ios_base& str);
   ios_base& noshowbase (ios_base& str);
   ios_base& nouppercase(ios_base& str);
   ios_base& unitbuf    (ios_base& str);
   ios_base& nounitbuf  (ios_base& str);
+  // [adjustfield.manip], adjustfield
   ios_base& internal   (ios_base& str);
   ios_base& left       (ios_base& str);
   ios_base& right      (ios_base& str);
+  // [basefield.manip], basefield
   ios_base& dec        (ios_base& str);
   ios_base& hex        (ios_base& str);
   ios_base& oct        (ios_base& str);
+  // [floatfield.manip], floatfield
   ios_base& fixed      (ios_base& str);
   ios_base& scientific (ios_base& str);
   ios_base& hexfloat   (ios_base& str);
   ios_base& defaultfloat(ios_base& str);
+  // [error.reporting], error reporting
   enum class io_errc {
     stream = 1
   };
   template <> struct is_error_code_enum<io_errc> : public true_type { };
 ```
 ### Types <a id="stream.types">[[stream.types]]</a>
 ``` cpp
+using streamoff = implementation-defined;
 ```
 The type `streamoff` is a synonym for one of the signed basic integral
 types of sufficient size to represent the maximum possible file size for
 the operating system.[^4]
 ``` cpp
+using streamsize = implementation-defined;
 ```
 The type `streamsize` is a synonym for one of the signed basic integral
 types. It is used to represent the number of characters transferred in
 an I/O operation, or the size of I/O buffers.[^5]
 ``` cpp
 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 internal = 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;
     class Init;
+    // [fmtflags.state], fmtflags state
     fmtflags flags() const;
     fmtflags flags(fmtflags fmtfl);
     fmtflags setf(fmtflags fmtfl);
     fmtflags setf(fmtflags fmtfl, fmtflags mask);
     void unsetf(fmtflags mask);
     streamsize precision() const;
     streamsize precision(streamsize prec);
     streamsize width() const;
     streamsize width(streamsize wide);
+    // [ios.base.locales], locales
     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;
 `ios_base`
 defines several member types:
+- a type `failure`, defined as either a class derived from
+  `system_error` or a synonym for a class derived from `system_error`;
 - a class `Init`;
 - three bitmask types, `fmtflags`, `iostate`, and `openmode`;
 - an enumerated type, `seekdir`.
 It maintains several kinds of data:
 - control information that influences how to interpret (format) input
   sequences and how to generate (format) output sequences;
 - additional information that is stored by the program for its private
   use.
+[*Note 1*:
 For the sake of exposition, the maintained data is presented here as:
 - `static int index`, specifies the next available unique index for the
   integer or pointer arrays maintained for the private use of the
   program, initialized to an unspecified value;
 - `long* iarray`, points to the first element of an arbitrary-length
   `long` array maintained for the private use of the program;
 - `void** parray`, points to the first element of an arbitrary-length
   pointer array maintained for the private use of the program.
+— *end note*]
 #### Types <a id="ios.types">[[ios.types]]</a>
 ##### Class `ios_base::failure` <a id="ios::failure">[[ios::failure]]</a>
 ``` cpp
     explicit failure(const char* msg, const error_code& ec = io_errc::stream);
   };
 }
 ```
+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.
 When throwing `ios_base::failure` exceptions, implementations should
 provide values of `ec` that identify the specific reason for the
+failure.
+[*Note 2*: Errors arising from the operating system would typically be
 reported as `system_category()` errors with an error value of the error
 number reported by the operating system. Errors arising from within the
 stream library would typically be reported as
 `error_code(io_errc::stream,
+iostream_category())`. — *end note*]
 ``` cpp
 explicit failure(const string& msg, const error_code& ec = io_errc::stream);
 ```
 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]].
 ##### 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]].
 - `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]].
 ##### 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]].
 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
 fmtflags flags(fmtflags fmtfl);
 ```
+*Postconditions:* `fmtfl == flags()`.
 *Returns:* The previous value of `flags()`.
 ``` cpp
 fmtflags setf(fmtflags fmtfl);
 ``` cpp
 streamsize precision(streamsize prec);
 ```
+*Postconditions:* `prec == precision()`.
 *Returns:* The previous value of `precision()`.
 ``` cpp
 streamsize width() const;
 ``` 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>
 `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;
 ```
 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
 allows the standard streams to operate independently of the standard C
 streams.
 When a standard iostream object `str` is *synchronized* with a standard
 stdio stream `f`, the effect of inserting a character `c` by
 necessary to include the element `iarray[idx]`. Each newly allocated
 element of the array is initialized to zero. The reference returned is
 invalid after any other operations on the object.[^7] However, the value
 of the storage referred to is retained, so that until the next call to
 `copyfmt`, calling `iword` with the same index yields another reference
+to the same value. If the function fails[^8] and `*this` is a base class
 subobject of a `basic_ios<>` object or subobject, the effect is
 equivalent to calling `basic_ios<>::setstate(badbit)` on the derived
 object (which may throw `failure`).
 *Returns:* On success `iarray[idx]`. On failure, a valid `long&`
 element of the array is initialized to a null pointer. The reference
 returned is invalid after any other operations on the object. However,
 the value of the storage referred to is retained, so that until the next
 call to `copyfmt`, calling `pword` with the same index yields another
 reference to the same value. If the function fails[^9] and `*this` is a
+base class subobject of a `basic_ios<>` object or subobject, the effect
+is equivalent to calling `basic_ios<>::setstate(badbit)` on the derived
 object (which may throw `failure`).
 *Returns:* On success `parray[idx]`. On failure a valid `void*&`
 initialized to 0.
 ``` cpp
 namespace std {
   template <class stateT> class fpos {
   public:
+    // [fpos.members], members
     stateT state() const;
     void state(stateT);
   private;
     stateT st; // exposition only
   };
 ``` cpp
 void state(stateT s);
 ```
+*Effects:* Assigns `s` to `st`.
 ``` cpp
 stateT state() const;
 ```
 - `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
 ``` cpp
 namespace std {
   template <class charT, class traits = char_traits<charT>>
   class basic_ios : public ios_base {
   public:
+    using char_type   = charT;
+    using int_type    = typename traits::int_type;
+    using pos_type    = typename traits::pos_type;
+    using off_type    = typename traits::off_type;
+    using traits_type = traits;
+    // [iostate.flags], flags functions
     explicit operator bool() const;
     bool operator!() const;
     iostate rdstate() const;
     void clear(iostate state = goodbit);
     void setstate(iostate state);
     bool bad()  const;
     iostate exceptions() const;
     void exceptions(iostate except);
+    // [basic.ios.cons], constructor/destructor
     explicit basic_ios(basic_streambuf<charT, traits>* sb);
     virtual ~basic_ios();
+    // [basic.ios.members], members
     basic_ostream<charT, traits>* tie() const;
     basic_ostream<charT, traits>* tie(basic_ostream<charT, traits>* tiestr);
     basic_streambuf<charT, traits>* rdbuf() const;
     basic_streambuf<charT, traits>* rdbuf(basic_streambuf<charT, traits>* sb);
 | `rdstate()`    | `goodbit` if `sb` is not a null pointer, otherwise `badbit`. |
 | `exceptions()` | `goodbit`                                                    |
 | `flags()`      | `skipws | dec`                                               |
 | `width()`      | `0`                                                          |
 | `precision()`  | `6`                                                          |
+| `fill()`       | `widen(' ')` |
 | `getloc()`     | a copy of the value returned by `locale()`                   |
 | `iarray`       | a null pointer                                               |
 | `parray`       | a null pointer                                               |
 *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;
 ``` cpp
 basic_streambuf<charT, traits>* rdbuf(basic_streambuf<charT, traits>* sb);
 ```
+*Postconditions:* `sb == rdbuf()`.
 *Effects:* Calls `clear()`.
 *Returns:* The previous value of `rdbuf()`.
 ``` 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);
       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>
 ``` 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);
 ``` cpp
 void exceptions(iostate except);
 ```
+*Postconditions:* `except == exceptions()`.
 *Effects:* Calls `clear(rdstate())`.
 ### `ios_base` manipulators <a id="std.ios.manip">[[std.ios.manip]]</a>
 *Effects:* Calls
 `str.setf(ios_base::fixed | ios_base::scientific, 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);
 ```

Diff to HTML by rtfpessoa