[input.output] - C++11 → C++14

Files changed (1) hide show

tmp/tmpm4ldjf09/{from.md → to.md} +250 -119

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

@@ -55,15 +55,15 @@ The classes of Clause  [[input.output]] with template arguments `charT`
 and `traits` behave as described if `traits::pos_type` and
 `traits::off_type` are `streampos` and `streamoff` respectively. Except
 as noted explicitly below, their behavior when `traits::pos_type` and
 `traits::off_type` are other types is *implementation-defined*.
-In the classes of Clause  [[input.output]], a template formal parameter
-with name `charT` represents a member of the set of types containing
-`char`, `wchar_t`, and any other implementation-defined character types
-that satisfy the requirements for a character on which any of the
-iostream components can be instantiated.
 ### Thread safety <a id="iostreams.threadsafety">[[iostreams.threadsafety]]</a>
 Concurrent access to a stream object ([[string.streams]],
 [[file.streams]]), stream buffer object ([[stream.buffers]]), or C
@@ -400,13 +400,13 @@ namespace std {
   enum class io_errc {
     stream = 1
   };
   template <> struct is_error_code_enum<io_errc> : public true_type { };
-  error_code make_error_code(io_errc e);
-  error_condition make_error_condition(io_errc e);
-  const error_category& iostream_category();
 }
 ```
 ### Types <a id="stream.types">[[stream.types]]</a>
@@ -471,13 +471,13 @@ namespace std {
     static constexpr openmode out = unspecified;
     static constexpr openmode trunc = unspecified;
     // [ios::seekdir] seekdir
     typedef T4 seekdir;
-    static constexpr fmtflags beg = unspecified;
-    static constexpr fmtflags cur = unspecified;
-    static constexpr fmtflags end = unspecified;
     class Init;
     // [fmtflags.state] fmtflags state:
     fmtflags flags() const;
@@ -515,13 +515,13 @@ namespace std {
   protected:
     ios_base();
   private:
-    static int index;  // exposition onlyr
-    long* iarray;      // exposition onlyr
-    void** parray;     // exposition onlyr
   };
 }
 ```
 `ios_base`
@@ -577,11 +577,11 @@ 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);
 ```
 *Effects:* Constructs an object of class `failure` by constructing the
 base class with `msg` and `ec`.
@@ -704,11 +704,11 @@ namespace std {
   class ios_base::Init {
   public:
     Init();
    ~Init();
   private:
-    static int init_cnt; // exposition onlyr
   };
 }
 ```
 The class `Init` describes an object whose construction ensures the
@@ -869,11 +869,11 @@ c = fgetc(f);
 ```
 is the same as the effect of
 ``` cpp
-c = str.rdbuf()->sbumpc(c);
 ```
 for any sequences of characters; and the effect of pushing back a
 character `c` by
@@ -895,10 +895,13 @@ for any sequence of characters.[^6]
 static int xalloc();
 ```
 *Returns:* `index` `++`.
 ``` cpp
 long& iword(int idx);
 ```
 *Effects:* If `iarray` is a null pointer, allocates an array of `long`
@@ -968,11 +971,11 @@ ios_base();
 construction. The object’s members shall be initialized by calling
 `basic_ios::init` before the object’s first use or before it is
 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`
@@ -986,11 +989,11 @@ namespace std {
   public:
     // [fpos.members] Members
     stateT state() const;
     void state(stateT);
   private;
-    stateT st; // exposition onlyr
   };
 }
 ```
 #### `fpos` members <a id="fpos.members">[[fpos.members]]</a>
@@ -1586,23 +1589,23 @@ ios_base& defaultfloat(ios_base& str);
 *Returns:* `str`.
 #### Error reporting <a id="error.reporting">[[error.reporting]]</a>
 ``` cpp
-error_code make_error_code(io_errc e);
 ```
 *Returns:* `error_code(static_cast<int>(e), iostream_category())`.
 ``` cpp
-error_condition make_error_condition(io_errc e);
 ```
 *Returns:* `error_condition(static_cast<int>(e), iostream_category())`.
 ``` cpp
-const error_category& iostream_category();
 ```
 *Returns:* A reference to an object of a type derived from class
 `error_category`.
@@ -2047,11 +2050,11 @@ void setp(char_type* pbeg, char_type* pend);
 #### `basic_streambuf` virtual functions <a id="streambuf.virtuals">[[streambuf.virtuals]]</a>
 ##### Locales <a id="streambuf.virt.locales">[[streambuf.virt.locales]]</a>
 ``` cpp
-void imbue(const locale&)
 ```
 *Effects:* Change any translations based on locale.
 *Remarks:* Allows the derived class to be informed of changes in locale
@@ -2203,11 +2206,11 @@ The *pending sequence* is defined as for `underflow()`, with the
 modifications that
 - If `traits::eq_int_type(c,traits::eof())` returns `true`, then the
   input sequence is backed up one character before the pending sequence
   is determined.
-- If `traits::eq_int_type(c,traits::eof())` return false, then `c` is
   prepended. Whether the input sequence is backed up or modified in any
   other way is unspecified.
 On return, the constraints of `gptr()`, `eback()`, and `pptr()` are the
 same as for `underflow()`.
@@ -2225,14 +2228,42 @@ Returns some value other than `traits::eof()` to indicate success.
 ``` cpp
 streamsize xsputn(const char_type* s, streamsize n);
 ```
 ``` cpp
 int_type overflow(int_type c = traits::eof());
 ```
 ## Formatting and manipulators <a id="iostream.format">[[iostream.format]]</a>
 ### Overview <a id="iostream.format.overview">[[iostream.format.overview]]</a>
 \synopsis{Header \texttt{\<istream\>} synopsis}
@@ -2289,10 +2320,21 @@ namespace std {
   T6 setw(int n);
   template <class moneyT> T7 get_money(moneyT& mon, bool intl = false);
   template <class moneyT> T8 put_money(const moneyT& mon, bool intl = false);
   template <class charT> T9 get_time(struct tm* tmb, const charT* fmt);
   template <class charT> T10 put_time(const struct tm* tmb, const charT* fmt);
 }
 ```
 ### Input streams <a id="input.streams">[[input.streams]]</a>
@@ -2481,11 +2523,11 @@ values returned by `gcount()` and `rhs.gcount()`.
 ``` cpp
 namespace std {
   template <class charT,class traits = char_traits<charT> >
   class basic_istream<charT,traits>::sentry {
     typedef traits traits_type;
-    bool ok_; // exposition onlyr
   public:
     explicit sentry(basic_istream<charT,traits>& is, bool noskipws = false);
     ~sentry();
     explicit operator bool() const { return ok_; }
     sentry(const sentry&) = delete;
@@ -2499,19 +2541,19 @@ exception safe prefix and suffix operations.
 ``` cpp
 explicit sentry(basic_istream<charT,traits>& is, bool noskipws = false);
 ```
-*Effects:* If `is.good()` is `false`, calls is.setstate(failbit).
 Otherwise, prepares for formatted or unformatted input. First, if
 `is.tie()` is not a null pointer, the function calls `is.tie()->flush()`
 to synchronize the output sequence with any associated external C
 stream. Except that this call can be suppressed if the put area of
 `is.tie()` is empty. Further an implementation is allowed to defer the
 call to `flush` until a call of `is.rdbuf()->underflow()` occurs. If no
 such call occurs before the `sentry` object is destroyed, the call to
-`flush` may be eliminated entirely.[^16] If `noskipws` is zero and
 `is.flags() & ios_base::skipws` is nonzero, the function extracts and
 discards each character as long as the next available input character
 `c` is a whitespace character. If `is.rdbuf()->sbumpc()` or
 `is.rdbuf()->sgetc()` returns `traits::eof()`, the function calls
 `setstate(failbit | eofbit)` (which may throw `ios_base::failure`).
@@ -2531,11 +2573,11 @@ if (ctype.is(ctype.space,c)!=0)
 ```
 If, after any preparation is completed, `is.good()` is `true`,
 `ok_ != false` otherwise, `ok_ == false`. During preparation, the
 constructor may call `setstate(failbit)` (which may throw
-`ios_base::failure` ([[iostate.flags]]))[^17]
 ``` cpp
 ~sentry();
 ```
@@ -2553,11 +2595,11 @@ explicit operator bool() const;
 Each formatted input function begins execution by constructing an object
 of class `sentry` with the `noskipws` (second) argument `false`. If the
 `sentry` object returns `true`, when converted to a value of type
 `bool`, the function endeavors to obtain the requested input. If an
-exception is thrown during input then `ios::badbit` is turned on[^18] in
 `*this`’s error state. If `(exceptions()&badbit) != 0` then the
 exception is rethrown. In any case, the formatted input function
 destroys the `sentry` object. If no exception has been thrown, it
 returns `*this`.
@@ -2646,17 +2688,17 @@ setstate(err);
 ##### `basic_istream::operator>>` <a id="istream::extractors">[[istream::extractors]]</a>
 ``` cpp
 basic_istream<charT,traits>& operator>>
-    (basic_istream<charT,traits>& (*pf)(basic_istream<charT,traits>&))
 ```
 *Effects:* None. This extractor does not behave as a formatted input
 function (as described in  [[istream.formatted.reqmts]].)
-*Returns:* `pf(*this)`.[^19]
 ``` cpp
 basic_istream<charT,traits>& operator>>
     (basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&));
 ```
@@ -2670,11 +2712,11 @@ in  [[istream.formatted.reqmts]]).
 ``` cpp
 basic_istream<charT,traits>& operator>>
     (ios_base& (*pf)(ios_base&));
 ```
-*Effects:* Calls `pf(*this)`.[^20] This extractor does not behave as a
 formatted input function (as described
 in  [[istream.formatted.reqmts]]).
 *Returns:* `*this`.
@@ -2772,11 +2814,11 @@ an exception or if the sentry object returns false, when converted to a
 value of type `bool`, the function returns without attempting to obtain
 any input. In either case the number of extracted characters is set to
 0; unformatted input functions taking a character array of non-zero size
 as an argument shall also store a null character (using `charT()`) in
 the first location of the array. If an exception is thrown during input
-then `ios::badbit` is turned on[^21] in `*this`’s error state.
 (Exceptions thrown from `basic_ios<>::clear()` are not caught or
 rethrown.) If `(exceptions()&badbit) != 0` then the exception is
 rethrown. It also counts the number of characters extracted. If no
 exception has been thrown it ends by storing the count in a member
 object and returning the value specified. In any event the `sentry`
@@ -2809,11 +2851,11 @@ basic_istream<charT,traits>& get(char_type& c);
 ```
 *Effects:* Behaves as an unformatted input function (as described
 in  [[istream.unformatted]], paragraph 1). After constructing a sentry
 object, extracts a character, if one is available, and assigns it to
-`c`.[^22] Otherwise, the function calls `setstate(failbit)` (which may
 throw `ios_base::failure` ([[iostate.flags]])).
 *Returns:* `*this`.
 ``` cpp
@@ -2822,11 +2864,11 @@ basic_istream<charT,traits>& get(char_type* s, streamsize n,
 ```
 *Effects:* Behaves as an unformatted input function (as described
 in  [[istream.unformatted]], paragraph 1). After constructing a sentry
 object, extracts characters and stores them into successive locations of
-an array whose first element is designated by `s`.[^23] Characters are
 extracted and stored until any of the following occurs:
 - `n` is less than one or `n - 1` characters are stored;
 - end-of-file occurs on the input sequence (in which case the function
   calls `setstate(eofbit)`);
@@ -2839,11 +2881,11 @@ if `n` is greater than zero it then stores a null character into the
 next successive location of the array.
 *Returns:* `*this`.
 ``` cpp
-basic_istream<charT,traits>& get(char_type* s, streamsize n)
 ```
 *Effects:* Calls `get(s,n,widen(’\n’))`
 *Returns:* Value returned by the call.
@@ -2886,25 +2928,25 @@ basic_istream<charT,traits>& getline(char_type* s, streamsize n,
 ```
 *Effects:* Behaves as an unformatted input function (as described
 in  [[istream.unformatted]], paragraph 1). After constructing a sentry
 object, extracts characters and stores them into successive locations of
-an array whose first element is designated by `s`.[^24] Characters are
 extracted and stored until one of the following occurs:
 1.  end-of-file occurs on the input sequence (in which case the function
     calls `setstate(eofbit)`);
 2.  `traits::eq(c, delim)` for the next available input character `c`
     (in which case the input character is extracted but not
-    stored);[^25]
 3.  `n` is less than one or `n - 1` characters are stored (in which case
     the function calls `setstate(failbit)`).
-These conditions are tested in the order shown.[^26]
 If the function extracts no characters, it calls `setstate(failbit)`
-(which may throw `ios_base::failure` ([[iostate.flags]])).[^27]
 In any case, if `n` is greater than zero, it then stores a null
 character (using `charT()`) into the next successive location of the
 array.
@@ -2949,12 +2991,12 @@ basic_istream<charT,traits>&
 *Effects:* Behaves as an unformatted input function (as described
 in  [[istream.unformatted]], paragraph 1). After constructing a sentry
 object, extracts characters and discards them. Characters are extracted
 until any of the following occurs:
-- if `n != numeric_limits<streamsize>::max()` ([[limits]]), `n`
-  characters are extracted
 - end-of-file occurs on the input sequence (in which case the function
   calls `setstate(eofbit)`, which may throw
   `ios_base::failure` ([[iostate.flags]]));
 - `traits::eq_int_type(traits::to_int_type(c), delim)` for the next
   available input character `c` (in which case `c` is extracted).
@@ -2982,11 +3024,11 @@ basic_istream<charT,traits>& read(char_type* s, streamsize n);
 *Effects:* Behaves as an unformatted input function (as described
 in  [[istream.unformatted]], paragraph 1). After constructing a sentry
 object, if `!good()` calls `setstate(failbit)` which may throw an
 exception, and return. Otherwise extracts characters and stores them
 into successive locations of an array whose first element is designated
-by `s`.[^28] Characters are extracted and stored until either of the
 following occurs:
 - `n` characters are stored;
 - end-of-file occurs on the input sequence (in which case the function
   calls `setstate(failbit | eofbit)`, which may throw
@@ -3280,12 +3322,12 @@ namespace std {
   protected:
     basic_ostream(const basic_ostream& rhs) = delete;
     basic_ostream(basic_ostream&& rhs);
     // [ostream.assign] Assign/swap
-    basic_ostream& operator=(basic_ostream& rhs) = delete;
-    basic_ostream& operator=(const basic_ostream&& rhs);
     void swap(basic_ostream& rhs);
   };
   // [ostream.inserters.character] character inserters
   template<class charT, class traits>
@@ -3382,11 +3424,11 @@ void swap(basic_ostream& rhs);
 ``` cpp
 namespace std {
   template <class charT,class traits = char_traits<charT> >
   class basic_ostream<charT,traits>::sentry {
-    bool ok_; // exposition onlyr
   public:
     explicit sentry(basic_ostream<charT,traits>& os);
     ~sentry();
     explicit operator bool() const { return ok_; }
@@ -3402,16 +3444,16 @@ exception safe prefix and suffix operations.
 ``` cpp
 explicit sentry(basic_ostream<charT,traits>& os);
 ```
 If `os.good()` is nonzero, prepares for formatted or unformatted output.
-If `os.tie()` is not a null pointer, calls `os.tie()->flush()`.[^29]
 If, after any preparation is completed, `os.good()` is `true`,
 `ok_ == true` otherwise, `ok_ == false`. During preparation, the
 constructor may call `setstate(failbit)` (which may throw
-`ios_base::failure` ([[iostate.flags]]))[^30]
 ``` cpp
 ~sentry();
 ```
@@ -3442,11 +3484,13 @@ basic_ostream<charT,traits>& seekp(pos_type pos);
 ``` cpp
 basic_ostream<charT,traits>& seekp(off_type off, ios_base::seekdir dir);
 ```
 *Effects:* If `fail() != true`, executes
-`rdbuf()->pubseekoff(off, dir, ios_base::out)`.
 *Returns:* `*this`.
 #### Formatted output functions <a id="ostream.formatted">[[ostream.formatted]]</a>
@@ -3456,19 +3500,28 @@ Each formatted output function begins execution by constructing an
 object of class `sentry`. If this object returns `true` when converted
 to a value of type `bool`, the function endeavors to generate the
 requested output. If the generation fails, then the formatted output
 function does `setstate(ios_base::failbit)`, which might throw an
 exception. If an exception is thrown during output, then `ios::badbit`
-is turned on[^31] in `*this`’s error state. If
 `(exceptions()&badbit) != 0` then the exception is rethrown. Whether or
 not an exception is thrown, the `sentry` object is destroyed before
 leaving the formatted output function. If no exception is thrown, the
 result of the formatted output function is `*this`.
-The descriptions of the individual formatted output operations describe
 how they perform output and do not mention the `sentry` object.
 ##### Arithmetic inserters <a id="ostream.inserters.arithmetic">[[ostream.inserters.arithmetic]]</a>
 ``` cpp
 operator<<(bool val);
 operator<<(short val);
@@ -3540,11 +3593,11 @@ performed the following code fragment:
 ``` cpp
 bool failed = use_facet<
   num_put<charT,ostreambuf_iterator<charT,traits> >
     >(getloc()).put(*this, *this, fill(),
-      static_cast<double>(va})).failed();
 ```
 The first argument provides an object of the `ostreambuf_iterator<>`
 class which is an iterator for class `basic_ostream<>`. It bypasses
 `ostream`s and uses `streambuf`s directly. Class `locale` relies on
@@ -3559,32 +3612,32 @@ from which to obtain other facets. If `failed` is `true` then does
 ##### `basic_ostream::operator<<` <a id="ostream.inserters">[[ostream.inserters]]</a>
 ``` cpp
 basic_ostream<charT,traits>& operator<<
-    (basic_ostream<charT,traits>& (*pf)(basic_ostream<charT,traits>&))
 ```
 *Effects:* None. Does not behave as a formatted output function (as
 described in  [[ostream.formatted.reqmts]]).
-*Returns:* `pf(*this)`.[^32]
 ``` cpp
 basic_ostream<charT,traits>& operator<<
-    (basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&))
 ```
 *Effects:* Calls `pf(*this)`. This inserter does not behave as a
 formatted output function (as described
 in  [[ostream.formatted.reqmts]]).
-*Returns:* `*this`.[^33]
 ``` cpp
 basic_ostream<charT,traits>& operator<<
-    (ios_base& (*pf)(ios_base&))
 ```
 *Effects:* Calls `pf(*this)`. This inserter does not behave as a
 formatted output function (as described
 in  [[ostream.formatted.reqmts]]).
@@ -3620,11 +3673,11 @@ caught exception is rethrown.
 ##### Character inserter function templates <a id="ostream.inserters.character">[[ostream.inserters.character]]</a>
 ``` cpp
 template<class charT, class traits>
   basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& out,
-                                          charT c};
 template<class charT, class traits>
   basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& out,
                                           char c);
   // specialization
 template<class traits>
@@ -3637,18 +3690,17 @@ template<class traits>
 template<class traits>
   basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>& out,
                                          unsigned char c);
 ```
-*Effects:* Behaves like a formatted inserter (as described
-in  [[ostream.formatted.reqmts]]) of `out`. After a `sentry` object is
-constructed it inserts characters. In case `c` has type `char` and the
-character type of the stream is not `char`, then the character to be
-inserted is `out.widen(c)`; otherwise the character is `c`. Padding is
-determined as described in  [[facet.num.put.virtuals]]. `width(0)` is
-called. The insertion character and any required padding are inserted
-into `out`.
 *Returns:* `out`.
 ``` cpp
 template<class charT, class traits>
@@ -3669,13 +3721,14 @@ template<class traits>
 ```
 *Requires:* `s` shall not be a null pointer.
 *Effects:* Behaves like a formatted inserter (as described
-in  [[ostream.formatted.reqmts]]) of `out`. After a `sentry` object is
-constructed it inserts `n` characters starting at `s`, where `n` is the
-number that would be computed as if by:
 - `traits::length(s)` for the overload where the first argument is of
   type `basic_ostream<charT, traits>&` and the second is of type
   `const charT*`, and also for the overload where the first argument is
   of type `basic_ostream<char, traits>&` and the second is of type
@@ -3684,24 +3737,23 @@ number that would be computed as if by:
   argument is of type `basic_ostream<charT, traits>&` and the second is
   of type `const char*`,
 - `traits::length(reinterpret_cast<const char*>(s))` for the other two
   overloads.
-Padding is determined as described in  [[facet.num.put.virtuals]]. The
-`n` characters starting at `s` are widened using
-`out.widen` ([[basic.ios.members]]). The widened characters and any
-required padding are inserted into `out`. Calls `width(0)`.
 *Returns:* `out`.
 #### Unformatted output functions <a id="ostream.unformatted">[[ostream.unformatted]]</a>
 Each unformatted output function begins execution by constructing an
 object of class `sentry`. If this object returns `true`, while
 converting to a value of type `bool`, the function endeavors to generate
 the requested output. If an exception is thrown during output, then
-`ios::badbit` is turned on[^34] in `*this`’s error state. If
 `(exceptions() & badbit) != 0` then the exception is rethrown. In any
 case, the unformatted output function ends by destroying the sentry
 object, then, if no exception was thrown, returning the value specified
 for the unformatted output function.
@@ -3709,11 +3761,11 @@ for the unformatted output function.
 basic_ostream<charT,traits>& put(char_type c);
 ```
 *Effects:* Behaves as an unformatted output function (as described
 in  [[ostream.unformatted]], paragraph 1). After constructing a sentry
-object, inserts the character `c`, if possible.[^35]
 Otherwise, calls `setstate(badbit)` (which may throw
 `ios_base::failure` ([[iostate.flags]])).
 *Returns:* `*this`.
@@ -3723,11 +3775,11 @@ basic_ostream& write(const char_type* s, streamsize n);
 ```
 *Effects:* Behaves as an unformatted output function (as described
 in  [[ostream.unformatted]], paragraph 1). After constructing a sentry
 object, obtains characters to insert from successive locations of an
-array whose first element is designated by `s`.[^36] Characters are
 inserted until either of the following occurs:
 - `n` characters are inserted;
 - inserting in the output sequence fails (in which case the function
   calls `setstate(badbit)`, which may throw
@@ -3811,11 +3863,11 @@ unspecified resetiosflags(ios_base::fmtflags mask);
 *Returns:* An object of unspecified type such that if `out` is an object
 of type `basic_ostream<charT, traits>` then the expression
 `out << resetiosflags(mask)` behaves as if it called `f(out, mask)`, or
 if `in` is an object of type `basic_istream<charT, traits>` then the
 expression `in >> resetiosflags(mask)` behaves as if it called
-`f(in, mask)`, where the function `f` is defined as:[^37]
 ``` cpp
 void f(ios_base& str, ios_base::fmtflags mask) {
   // reset specified flags
   str.setf(ios_base::fmtflags(0), mask);
@@ -4073,11 +4125,85 @@ void f(basic_ios<charT, traits>& str, const struct tm* tmb, const charT* fmt) {
     str.setstate(ios_base::badbit);
 }
 ```
 The expression `out << put_time(tmb, fmt)` shall have type
-`basic_istream<charT, traits>&` and value `out`.
 ## String-based streams <a id="string.streams">[[string.streams]]</a>
 ### Overview <a id="string.streams.overview">[[string.streams.overview]]</a>
@@ -4162,11 +4288,11 @@ namespace std {
     virtual pos_type seekpos(pos_type sp,
                              ios_base::openmode which
                                = ios_base::in | ios_base::out);
   private:
-    ios_base::openmode mode;  // exposition onlyr
   };
   template <class charT, class traits, class Allocator>
   void swap(basic_stringbuf<charT, traits, Allocator>& x,
             basic_stringbuf<charT, traits, Allocator>& y);
@@ -4457,11 +4583,11 @@ namespace std {
     basic_stringbuf<charT,traits,Allocator>* rdbuf() const;
     basic_string<charT,traits,Allocator> str() const;
     void str(const basic_string<charT,traits,Allocator>& s);
   private:
-    basic_stringbuf<charT,traits,Allocator> sb; // exposition onlyr
   };
   template <class charT, class traits, class Allocator>
   void swap(basic_istringstream<charT, traits, Allocator>& x,
             basic_istringstream<charT, traits, Allocator>& y);
@@ -4587,11 +4713,11 @@ namespace std {
     basic_stringbuf<charT,traits,Allocator>* rdbuf() const;
     basic_string<charT,traits,Allocator> str() const;
     void    str(const basic_string<charT,traits,Allocator>& s);
    private:
-    basic_stringbuf<charT,traits,Allocator> sb; // exposition onlyr
   };
   template <class charT, class traits, class Allocator>
   void swap(basic_ostringstream<charT, traits, Allocator>& x,
             basic_ostringstream<charT, traits, Allocator>& y);
@@ -4718,11 +4844,11 @@ namespace std {
     basic_stringbuf<charT,traits,Allocator>* rdbuf() const;
     basic_string<charT,traits,Allocator> str() const;
     void str(const basic_string<charT,traits,Allocator>& str);
   private:
-    basic_stringbuf<charT, traits> sb;  // exposition onlyr
   };
   template <class charT, class traits, class Allocator>
   void swap(basic_stringstream<charT, traits, Allocator>& x,
             basic_stringstream<charT, traits, Allocator>& y);
@@ -4736,11 +4862,11 @@ and writing from objects of class
 associated sequence. For the sake of exposition, the maintained data is
 presented here as
 - `sb`, the `stringbuf` object.
-### basic_stringstream constructors <a id="stringstream.cons">[[stringstream.cons]]</a>
 ``` cpp
 explicit basic_stringstream(
     ios_base::openmode which = ios_base::out|ios_base::in);
 ```
@@ -4794,11 +4920,11 @@ void swap(basic_stringstream<charT, traits, Allocator>& x,
           basic_stringstream<charT, traits, Allocator>& y);
 ```
 *Effects:* `x.swap(y)`.
-### Member functions <a id="stringstream.members">[[stringstream.members]]</a>
 ``` cpp
 basic_stringbuf<charT,traits,Allocator>* rdbuf() const;
 ```
@@ -5033,11 +5159,11 @@ basic_filebuf<charT,traits>* open(const char* s,
 *Effects:* If `is_open() != false`, returns a null pointer. Otherwise,
 initializes the `filebuf` as required. It then opens a file, if
 possible, whose name is the NTBS`s` (as if by calling
 `std::fopen(s,modstr)`). The NTBS`modstr` is determined from
-`mode & `~`ios_base::ate` as indicated in
 Table  [[tab:iostreams.file.open.modes]]. If `mode` is not some
 combination of flags shown in the table then the open fails.
 **Table: File open modes** <a id="tab:iostreams.file.open.modes">[tab:iostreams.file.open.modes]</a>
@@ -5062,11 +5188,11 @@ combination of flags shown in the table then the open fails.
 | +        | +    |       |         | +     | `"a+b"` |
 If the open operation succeeds and `(mode & ios_base::ate) != 0`,
 positions the file to the end (as if by calling
-`std::fseek(file,0,SEEK_END)`).[^38]
 If the repositioning operation fails, calls `close()` and returns a null
 pointer to indicate failure.
 *Returns:* `this` if successful, a null pointer otherwise.
@@ -5088,11 +5214,11 @@ last virtual member function called on `*this` (between `underflow`,
 `overflow`, `seekoff`, and `seekpos`) was `overflow` then calls
 `a_codecvt.unshift` (possibly several times) to determine a termination
 sequence, inserts those characters and calls `overflow(traits::eof())`
 again. Finally, regardless of whether any of the preceding calls fails
 or throws an exception, the function closes the file (as if by calling
-`std::fclose(file)`).[^39] If any of the calls made by the function,
 including `std::fclose`, fails, `close` fails by returning a null
 pointer. If one of these calls throws an exception, the exception is
 caught and rethrown after closing the file.
 *Returns:* `this` on success, a null pointer otherwise.
@@ -5338,11 +5464,11 @@ namespace std {
     bool is_open() const;
     void open(const char* s, ios_base::openmode mode = ios_base::in);
     void open(const string& s, ios_base::openmode mode = ios_base::in);
     void close();
   private:
-    basic_filebuf<charT,traits> sb; // exposition onlyr
   };
   template <class charT, class traits>
   void swap(basic_ifstream<charT, traits>& x,
             basic_ifstream<charT, traits>& y);
@@ -5490,11 +5616,11 @@ namespace std {
     bool is_open() const;
     void open(const char* s, ios_base::openmode mode = ios_base::out);
     void open(const string& s, ios_base::openmode mode = ios_base::out);
     void close();
   private:
-    basic_filebuf<charT,traits> sb; // exposition onlyr
   };
   template <class charT, class traits>
   void swap(basic_ofstream<charT, traits>& x,
             basic_ofstream<charT, traits>& y);
@@ -5646,11 +5772,11 @@ namespace std {
     void open(const string& s,
         ios_base::openmode mode = ios_base::in|ios_base::out);
     void close();
   private:
-    basic_filebuf<charT,traits> sb; // exposition onlyr
   };
   template <class charT, class traits>
   void swap(basic_fstream<charT, traits>& x,
             basic_fstream<charT, traits>& y);
@@ -5766,11 +5892,12 @@ void close();
 returns a null pointer, calls `setstate(failbit)` ([[iostate.flags]])
 (which may throw `ios_base::failure`).
 ### C library files <a id="c.files">[[c.files]]</a>
-Table  [[tab:iostreams.hdr.cstdio]] describes header `<cstdio>`.
 Calls to the function `tmpnam` with an argument of `NULL` may introduce
 a data race ([[res.on.data.races]]) with other calls to `tmpnam` with
 an argument of `NULL`.
@@ -5807,11 +5934,10 @@ Library header `<inttypes.h>`, with the following changes:
 [bitmask.types]: library.md#bitmask.types
 [c.files]: #c.files
 [enumerated.types]: library.md#enumerated.types
 [error.reporting]: #error.reporting
 [ext.manip]: #ext.manip
-[facet.num.put.virtuals]: localization.md#facet.num.put.virtuals
 [fig:streampos]: #fig:streampos
 [file.streams]: #file.streams
 [filebuf]: #filebuf
 [filebuf.assign]: #filebuf.assign
 [filebuf.cons]: #filebuf.cons
@@ -5906,10 +6032,11 @@ Library header `<inttypes.h>`, with the following changes:
 [ostringstream]: #ostringstream
 [ostringstream.assign]: #ostringstream.assign
 [ostringstream.cons]: #ostringstream.cons
 [ostringstream.members]: #ostringstream.members
 [output.streams]: #output.streams
 [res.on.data.races]: library.md#res.on.data.races
 [res.on.exception.handling]: library.md#res.on.exception.handling
 [std.ios.manip]: #std.ios.manip
 [std.manip]: #std.manip
 [stream.buffers]: #stream.buffers
@@ -6019,81 +6146,85 @@ Library header `<inttypes.h>`, with the following changes:
 [^15]: Classes derived from `basic_streambuf` can provide more efficient
     ways to implement `xsgetn()` and `xsputn()` by overriding these
     definitions from the base class.
-[^16]: This will be possible only in functions that are part of the
     library. The semantics of the constructor used in user code is as
     specified.
-[^17]: The sentry constructor and destructor can also perform additional
     implementation-dependent operations.
-[^18]: This is done without causing an `ios::failure` to be thrown.
-[^19]: See, for example, the function signature
-    `ws(basic_istream&)` ([[istream.manip]]).
 [^20]: See, for example, the function signature
     `dec(ios_base&)` ([[basefield.manip]]).
-[^21]: This is done without causing an `ios::failure` to be thrown.
-[^22]: Note that this function is not overloaded on types `signed char`
-    and `unsigned char`.
 [^23]: Note that this function is not overloaded on types `signed char`
     and `unsigned char`.
 [^24]: Note that this function is not overloaded on types `signed char`
     and `unsigned char`.
-[^25]: Since the final input character is “extracted,” it is counted in
     the `gcount()`, even though it is not stored.
-[^26]: This allows an input line which exactly fills the buffer, without
     setting `failbit`. This is different behavior than the historical
     AT&T implementation.
-[^27]: This implies an empty input line will not cause `failbit` to be
     set.
-[^28]: Note that this function is not overloaded on types `signed char`
     and `unsigned char`.
-[^29]: The call `os.tie()->flush()` does not necessarily occur if the
     function can determine that no synchronization is necessary.
-[^30]: The `sentry` constructor and destructor can also perform
     additional implementation-dependent operations.
-[^31]: without causing an `ios::failure` to be thrown.
-[^32]: See, for example, the function signature
-    `endl(basic_ostream&)` ([[ostream.manip]]).
 [^33]: See, for example, the function signature
     `dec(ios_base&)` ([[basefield.manip]]).
-[^34]: without causing an `ios::failure` to be thrown.
-[^35]: Note that this function is not overloaded on types `signed char`
-    and `unsigned char`.
 [^36]: Note that this function is not overloaded on types `signed char`
     and `unsigned char`.
-[^37]: The expression `cin >>resetiosflags(ios_base::skipws)` clears
     `ios_base::skipws` in the format flags stored in the
     `basic_istream<charT,traits>` object `cin` (the same as
     `cin >>noskipws`), and the expression
     `cout << resetiosflags(ios_base::showbase)` clears
     `ios_base::showbase` in the format flags stored in the
     `basic_ostream<charT,traits>` object `cout` (the same as
     `cout <<noshowbase`).
-[^38]: The macro `SEEK_END` is defined, and the function signatures
     `fopen(const char*, const char*)` and `fseek(FILE*, long, int)` are
     declared, in `<cstdio>` ([[c.files]]).
-[^39]: The function signature `fclose(FILE*)` is declared in `<cstdio>`
     ([[c.files]]).

 and `traits` behave as described if `traits::pos_type` and
 `traits::off_type` are `streampos` and `streamoff` respectively. Except
 as noted explicitly below, their behavior when `traits::pos_type` and
 `traits::off_type` are other types is *implementation-defined*.
+In the classes of Clause  [[input.output]], a template parameter with
+name `charT` represents a member of the set of types containing `char`,
+`wchar_t`, and any other implementation-defined character types that
+satisfy the requirements for a character on which any of the iostream
+components can be instantiated.
 ### Thread safety <a id="iostreams.threadsafety">[[iostreams.threadsafety]]</a>
 Concurrent access to a stream object ([[string.streams]],
 [[file.streams]]), stream buffer object ([[stream.buffers]]), or C
   enum class io_errc {
     stream = 1
   };
   template <> struct is_error_code_enum<io_errc> : public true_type { };
+  error_code make_error_code(io_errc e) noexcept;
+  error_condition make_error_condition(io_errc e) noexcept;
+  const error_category& iostream_category() noexcept;
 }
 ```
 ### Types <a id="stream.types">[[stream.types]]</a>
     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;
   protected:
     ios_base();
   private:
+    static int index;  // exposition only
+    long* iarray;      // exposition only
+    void** parray;     // exposition only
   };
 }
 ```
 `ios_base`
 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);
 ```
 *Effects:* Constructs an object of class `failure` by constructing the
 base class with `msg` and `ec`.
   class ios_base::Init {
   public:
     Init();
    ~Init();
   private:
+    static int init_cnt; // exposition only
   };
 }
 ```
 The class `Init` describes an object whose construction ensures the
 ```
 is the same as the effect of
 ``` cpp
+c = str.rdbuf()->sbumpc();
 ```
 for any sequences of characters; and the effect of pushing back a
 character `c` by
 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`
 construction. The object’s members shall be initialized by calling
 `basic_ios::init` before the object’s first use or before it is
 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`
   public:
     // [fpos.members] Members
     stateT state() const;
     void state(stateT);
   private;
+    stateT st; // exposition only
   };
 }
 ```
 #### `fpos` members <a id="fpos.members">[[fpos.members]]</a>
 *Returns:* `str`.
 #### Error reporting <a id="error.reporting">[[error.reporting]]</a>
 ``` cpp
+error_code make_error_code(io_errc e) noexcept;
 ```
 *Returns:* `error_code(static_cast<int>(e), iostream_category())`.
 ``` cpp
+error_condition make_error_condition(io_errc e) noexcept;
 ```
 *Returns:* `error_condition(static_cast<int>(e), iostream_category())`.
 ``` cpp
+const error_category& iostream_category() noexcept;
 ```
 *Returns:* A reference to an object of a type derived from class
 `error_category`.
 #### `basic_streambuf` virtual functions <a id="streambuf.virtuals">[[streambuf.virtuals]]</a>
 ##### Locales <a id="streambuf.virt.locales">[[streambuf.virt.locales]]</a>
 ``` cpp
+void imbue(const locale&);
 ```
 *Effects:* Change any translations based on locale.
 *Remarks:* Allows the derived class to be informed of changes in locale
 modifications that
 - If `traits::eq_int_type(c,traits::eof())` returns `true`, then the
   input sequence is backed up one character before the pending sequence
   is determined.
+- If `traits::eq_int_type(c,traits::eof())` returns `false`, then `c` is
   prepended. Whether the input sequence is backed up or modified in any
   other way is unspecified.
 On return, the constraints of `gptr()`, `eback()`, and `pptr()` are the
 same as for `underflow()`.
 ``` cpp
 streamsize xsputn(const char_type* s, streamsize n);
 ```
+*Effects:* Writes up to `n` characters to the output sequence as if by
+repeated calls to `sputc(c)`. The characters written are obtained from
+successive elements of the array whose first element is designated by
+`s`. Writing stops when either `n` characters have been written or a
+call to `sputc(c)` would return `traits::eof()`. Is is unspecified
+whether the function calls `overflow()` when `pptr() == epptr()` becomes
+true or whether it achieves the same effects by other means.
+*Returns:* The number of characters written.
 ``` cpp
 int_type overflow(int_type c = traits::eof());
 ```
+*Effects:* Consumes some initial subsequence of the characters of the
+*pending sequence*. The pending sequence is defined as the concatenation
+of
+*Remarks:* The member functions `sputc()` and `sputn()` call this
+function in case that no room can be found in the put buffer enough to
+accommodate the argument character sequence.
+*Requires:* Every overriding definition of this virtual function shall
+obey the following constraints:
+*Returns:* `traits::eof()` or throws an exception if the function fails.
+Otherwise, returns some value other than `traits::eof()` to indicate
+success.[^16]
+*Default behavior:* Returns `traits::eof()`.
 ## Formatting and manipulators <a id="iostream.format">[[iostream.format]]</a>
 ### Overview <a id="iostream.format.overview">[[iostream.format.overview]]</a>
 \synopsis{Header \texttt{\<istream\>} synopsis}
   T6 setw(int n);
   template <class moneyT> T7 get_money(moneyT& mon, bool intl = false);
   template <class moneyT> T8 put_money(const moneyT& mon, bool intl = false);
   template <class charT> T9 get_time(struct tm* tmb, const charT* fmt);
   template <class charT> T10 put_time(const struct tm* tmb, const charT* fmt);
+  template <class charT>
+    T11 quoted(const charT* s, charT delim=charT('"'), charT escape=charT('\\'));
+  template <class charT, class traits, class Allocator>
+    T12 quoted(const basic_string<charT, traits, Allocator>& s,
+               charT delim=charT('"'), charT escape=charT('\\'));
+  template <class charT, class traits, class Allocator>
+    T13 quoted(basic_string<charT, traits, Allocator>& s,
+               charT delim=charT('"'), charT escape=charT('\\'));
 }
 ```
 ### Input streams <a id="input.streams">[[input.streams]]</a>
 ``` cpp
 namespace std {
   template <class charT,class traits = char_traits<charT> >
   class basic_istream<charT,traits>::sentry {
     typedef traits traits_type;
+    bool ok_; // exposition only
   public:
     explicit sentry(basic_istream<charT,traits>& is, bool noskipws = false);
     ~sentry();
     explicit operator bool() const { return ok_; }
     sentry(const sentry&) = delete;
 ``` cpp
 explicit sentry(basic_istream<charT,traits>& is, bool noskipws = false);
 ```
+*Effects:* If `is.good()` is `false`, calls `is.setstate(failbit)`.
 Otherwise, prepares for formatted or unformatted input. First, if
 `is.tie()` is not a null pointer, the function calls `is.tie()->flush()`
 to synchronize the output sequence with any associated external C
 stream. Except that this call can be suppressed if the put area of
 `is.tie()` is empty. Further an implementation is allowed to defer the
 call to `flush` until a call of `is.rdbuf()->underflow()` occurs. If no
 such call occurs before the `sentry` object is destroyed, the call to
+`flush` may be eliminated entirely.[^17] If `noskipws` is zero and
 `is.flags() & ios_base::skipws` is nonzero, the function extracts and
 discards each character as long as the next available input character
 `c` is a whitespace character. If `is.rdbuf()->sbumpc()` or
 `is.rdbuf()->sgetc()` returns `traits::eof()`, the function calls
 `setstate(failbit | eofbit)` (which may throw `ios_base::failure`).
 ```
 If, after any preparation is completed, `is.good()` is `true`,
 `ok_ != false` otherwise, `ok_ == false`. During preparation, the
 constructor may call `setstate(failbit)` (which may throw
+`ios_base::failure` ([[iostate.flags]]))[^18]
 ``` cpp
 ~sentry();
 ```
 Each formatted input function begins execution by constructing an object
 of class `sentry` with the `noskipws` (second) argument `false`. If the
 `sentry` object returns `true`, when converted to a value of type
 `bool`, the function endeavors to obtain the requested input. If an
+exception is thrown during input then `ios::badbit` is turned on[^19] in
 `*this`’s error state. If `(exceptions()&badbit) != 0` then the
 exception is rethrown. In any case, the formatted input function
 destroys the `sentry` object. If no exception has been thrown, it
 returns `*this`.
 ##### `basic_istream::operator>>` <a id="istream::extractors">[[istream::extractors]]</a>
 ``` cpp
 basic_istream<charT,traits>& operator>>
+    (basic_istream<charT,traits>& (*pf)(basic_istream<charT,traits>&));
 ```
 *Effects:* None. This extractor does not behave as a formatted input
 function (as described in  [[istream.formatted.reqmts]].)
+*Returns:* `pf(*this)`.[^20]
 ``` cpp
 basic_istream<charT,traits>& operator>>
     (basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&));
 ```
 ``` cpp
 basic_istream<charT,traits>& operator>>
     (ios_base& (*pf)(ios_base&));
 ```
+*Effects:* Calls `pf(*this)`.[^21] This extractor does not behave as a
 formatted input function (as described
 in  [[istream.formatted.reqmts]]).
 *Returns:* `*this`.
 value of type `bool`, the function returns without attempting to obtain
 any input. In either case the number of extracted characters is set to
 0; unformatted input functions taking a character array of non-zero size
 as an argument shall also store a null character (using `charT()`) in
 the first location of the array. If an exception is thrown during input
+then `ios::badbit` is turned on[^22] in `*this`’s error state.
 (Exceptions thrown from `basic_ios<>::clear()` are not caught or
 rethrown.) If `(exceptions()&badbit) != 0` then the exception is
 rethrown. It also counts the number of characters extracted. If no
 exception has been thrown it ends by storing the count in a member
 object and returning the value specified. In any event the `sentry`
 ```
 *Effects:* Behaves as an unformatted input function (as described
 in  [[istream.unformatted]], paragraph 1). After constructing a sentry
 object, extracts a character, if one is available, and assigns it to
+`c`.[^23] Otherwise, the function calls `setstate(failbit)` (which may
 throw `ios_base::failure` ([[iostate.flags]])).
 *Returns:* `*this`.
 ``` cpp
 ```
 *Effects:* Behaves as an unformatted input function (as described
 in  [[istream.unformatted]], paragraph 1). After constructing a sentry
 object, extracts characters and stores them into successive locations of
+an array whose first element is designated by `s`.[^24] Characters are
 extracted and stored until any of the following occurs:
 - `n` is less than one or `n - 1` characters are stored;
 - end-of-file occurs on the input sequence (in which case the function
   calls `setstate(eofbit)`);
 next successive location of the array.
 *Returns:* `*this`.
 ``` cpp
+basic_istream<charT,traits>& get(char_type* s, streamsize n);
 ```
 *Effects:* Calls `get(s,n,widen(’\n’))`
 *Returns:* Value returned by the call.
 ```
 *Effects:* Behaves as an unformatted input function (as described
 in  [[istream.unformatted]], paragraph 1). After constructing a sentry
 object, extracts characters and stores them into successive locations of
+an array whose first element is designated by `s`.[^25] Characters are
 extracted and stored until one of the following occurs:
 1.  end-of-file occurs on the input sequence (in which case the function
     calls `setstate(eofbit)`);
 2.  `traits::eq(c, delim)` for the next available input character `c`
     (in which case the input character is extracted but not
+    stored);[^26]
 3.  `n` is less than one or `n - 1` characters are stored (in which case
     the function calls `setstate(failbit)`).
+These conditions are tested in the order shown.[^27]
 If the function extracts no characters, it calls `setstate(failbit)`
+(which may throw `ios_base::failure` ([[iostate.flags]])).[^28]
 In any case, if `n` is greater than zero, it then stores a null
 character (using `charT()`) into the next successive location of the
 array.
 *Effects:* Behaves as an unformatted input function (as described
 in  [[istream.unformatted]], paragraph 1). After constructing a sentry
 object, extracts characters and discards them. Characters are extracted
 until any of the following occurs:
+- `n != numeric_limits<streamsize>::max()` ([[limits]]) and `n`
+  characters have been extracted so far
 - end-of-file occurs on the input sequence (in which case the function
   calls `setstate(eofbit)`, which may throw
   `ios_base::failure` ([[iostate.flags]]));
 - `traits::eq_int_type(traits::to_int_type(c), delim)` for the next
   available input character `c` (in which case `c` is extracted).
 *Effects:* Behaves as an unformatted input function (as described
 in  [[istream.unformatted]], paragraph 1). After constructing a sentry
 object, if `!good()` calls `setstate(failbit)` which may throw an
 exception, and return. Otherwise extracts characters and stores them
 into successive locations of an array whose first element is designated
+by `s`.[^29] Characters are extracted and stored until either of the
 following occurs:
 - `n` characters are stored;
 - end-of-file occurs on the input sequence (in which case the function
   calls `setstate(failbit | eofbit)`, which may throw
   protected:
     basic_ostream(const basic_ostream& rhs) = delete;
     basic_ostream(basic_ostream&& rhs);
     // [ostream.assign] Assign/swap
+    basic_ostream& operator=(const basic_ostream& rhs) = delete;
+    basic_ostream& operator=(basic_ostream&& rhs);
     void swap(basic_ostream& rhs);
   };
   // [ostream.inserters.character] character inserters
   template<class charT, class traits>
 ``` cpp
 namespace std {
   template <class charT,class traits = char_traits<charT> >
   class basic_ostream<charT,traits>::sentry {
+    bool ok_; // exposition only
   public:
     explicit sentry(basic_ostream<charT,traits>& os);
     ~sentry();
     explicit operator bool() const { return ok_; }
 ``` cpp
 explicit sentry(basic_ostream<charT,traits>& os);
 ```
 If `os.good()` is nonzero, prepares for formatted or unformatted output.
+If `os.tie()` is not a null pointer, calls `os.tie()->flush()`.[^30]
 If, after any preparation is completed, `os.good()` is `true`,
 `ok_ == true` otherwise, `ok_ == false`. During preparation, the
 constructor may call `setstate(failbit)` (which may throw
+`ios_base::failure` ([[iostate.flags]]))[^31]
 ``` cpp
 ~sentry();
 ```
 ``` cpp
 basic_ostream<charT,traits>& seekp(off_type off, ios_base::seekdir dir);
 ```
 *Effects:* If `fail() != true`, executes
+`rdbuf()->pubseekoff(off, dir, ios_base::out)`. In case of failure, the
+function calls `setstate(failbit)` (which may throw
+`ios_base::failure`).
 *Returns:* `*this`.
 #### Formatted output functions <a id="ostream.formatted">[[ostream.formatted]]</a>
 object of class `sentry`. If this object returns `true` when converted
 to a value of type `bool`, the function endeavors to generate the
 requested output. If the generation fails, then the formatted output
 function does `setstate(ios_base::failbit)`, which might throw an
 exception. If an exception is thrown during output, then `ios::badbit`
+is turned on[^32] in `*this`’s error state. If
 `(exceptions()&badbit) != 0` then the exception is rethrown. Whether or
 not an exception is thrown, the `sentry` object is destroyed before
 leaving the formatted output function. If no exception is thrown, the
 result of the formatted output function is `*this`.
+The descriptions of the individual formatted output functions describe
 how they perform output and do not mention the `sentry` object.
+If a formatted output function of a stream `os` determines padding, it
+does so as follows. Given a `charT` character sequence `seq` where
+`charT` is the character type of the stream, if the length of `seq` is
+less than `os.width()`, then enough copies of `os.fill()` are added to
+this sequence as necessary to pad to a width of `os.width()` characters.
+If `(os.flags() & ios_base::adjustfield) == ios_base::left` is `true`,
+the fill characters are placed after the character sequence; otherwise,
+they are placed before the character sequence.
 ##### Arithmetic inserters <a id="ostream.inserters.arithmetic">[[ostream.inserters.arithmetic]]</a>
 ``` cpp
 operator<<(bool val);
 operator<<(short val);
 ``` cpp
 bool failed = use_facet<
   num_put<charT,ostreambuf_iterator<charT,traits> >
     >(getloc()).put(*this, *this, fill(),
+      static_cast<double>(val)).failed();
 ```
 The first argument provides an object of the `ostreambuf_iterator<>`
 class which is an iterator for class `basic_ostream<>`. It bypasses
 `ostream`s and uses `streambuf`s directly. Class `locale` relies on
 ##### `basic_ostream::operator<<` <a id="ostream.inserters">[[ostream.inserters]]</a>
 ``` cpp
 basic_ostream<charT,traits>& operator<<
+    (basic_ostream<charT,traits>& (*pf)(basic_ostream<charT,traits>&));
 ```
 *Effects:* None. Does not behave as a formatted output function (as
 described in  [[ostream.formatted.reqmts]]).
+*Returns:* `pf(*this)`.[^33]
 ``` cpp
 basic_ostream<charT,traits>& operator<<
+    (basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&));
 ```
 *Effects:* Calls `pf(*this)`. This inserter does not behave as a
 formatted output function (as described
 in  [[ostream.formatted.reqmts]]).
+*Returns:* `*this`.[^34]
 ``` cpp
 basic_ostream<charT,traits>& operator<<
+    (ios_base& (*pf)(ios_base&));
 ```
 *Effects:* Calls `pf(*this)`. This inserter does not behave as a
 formatted output function (as described
 in  [[ostream.formatted.reqmts]]).
 ##### Character inserter function templates <a id="ostream.inserters.character">[[ostream.inserters.character]]</a>
 ``` cpp
 template<class charT, class traits>
   basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& out,
+                                          charT c);
 template<class charT, class traits>
   basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>& out,
                                           char c);
   // specialization
 template<class traits>
 template<class traits>
   basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>& out,
                                          unsigned char c);
 ```
+*Effects:* Behaves as a formatted output function
+(  [[ostream.formatted.reqmts]]) of `out`. Constructs a character
+sequence `seq`. If `c` has type `char` and the character type of the
+stream is not `char`, then `seq` consists of `out.widen(c)`; otherwise
+`seq` consists of `c`. Determines padding for `seq` as described
+in  [[ostream.formatted.reqmts]]. Inserts `seq` into `out`. Calls
+`os.width(0)`.
 *Returns:* `out`.
 ``` cpp
 template<class charT, class traits>
 ```
 *Requires:* `s` shall not be a null pointer.
 *Effects:* Behaves like a formatted inserter (as described
+in  [[ostream.formatted.reqmts]]) of `out`. Creates a character sequence
+`seq` of `n` characters starting at `s`, each widened using
+`out.widen()` ([[basic.ios.members]]), where `n` is the number that
+would be computed as if by:
 - `traits::length(s)` for the overload where the first argument is of
   type `basic_ostream<charT, traits>&` and the second is of type
   `const charT*`, and also for the overload where the first argument is
   of type `basic_ostream<char, traits>&` and the second is of type
   argument is of type `basic_ostream<charT, traits>&` and the second is
   of type `const char*`,
 - `traits::length(reinterpret_cast<const char*>(s))` for the other two
   overloads.
+Determines padding for `seq` as described
+in  [[ostream.formatted.reqmts]]. Inserts `seq` into `out`. Calls
+`width(0)`.
 *Returns:* `out`.
 #### Unformatted output functions <a id="ostream.unformatted">[[ostream.unformatted]]</a>
 Each unformatted output function begins execution by constructing an
 object of class `sentry`. If this object returns `true`, while
 converting to a value of type `bool`, the function endeavors to generate
 the requested output. If an exception is thrown during output, then
+`ios::badbit` is turned on[^35] in `*this`’s error state. If
 `(exceptions() & badbit) != 0` then the exception is rethrown. In any
 case, the unformatted output function ends by destroying the sentry
 object, then, if no exception was thrown, returning the value specified
 for the unformatted output function.
 basic_ostream<charT,traits>& put(char_type c);
 ```
 *Effects:* Behaves as an unformatted output function (as described
 in  [[ostream.unformatted]], paragraph 1). After constructing a sentry
+object, inserts the character `c`, if possible.[^36]
 Otherwise, calls `setstate(badbit)` (which may throw
 `ios_base::failure` ([[iostate.flags]])).
 *Returns:* `*this`.
 ```
 *Effects:* Behaves as an unformatted output function (as described
 in  [[ostream.unformatted]], paragraph 1). After constructing a sentry
 object, obtains characters to insert from successive locations of an
+array whose first element is designated by `s`.[^37] Characters are
 inserted until either of the following occurs:
 - `n` characters are inserted;
 - inserting in the output sequence fails (in which case the function
   calls `setstate(badbit)`, which may throw
 *Returns:* An object of unspecified type such that if `out` is an object
 of type `basic_ostream<charT, traits>` then the expression
 `out << resetiosflags(mask)` behaves as if it called `f(out, mask)`, or
 if `in` is an object of type `basic_istream<charT, traits>` then the
 expression `in >> resetiosflags(mask)` behaves as if it called
+`f(in, mask)`, where the function `f` is defined as:[^38]
 ``` cpp
 void f(ios_base& str, ios_base::fmtflags mask) {
   // reset specified flags
   str.setf(ios_base::fmtflags(0), mask);
     str.setstate(ios_base::badbit);
 }
 ```
 The expression `out << put_time(tmb, fmt)` shall have type
+`basic_ostream<charT, traits>&` and value `out`.
+### Quoted manipulators <a id="quoted.manip">[[quoted.manip]]</a>
+Quoted manipulators provide string insertion and extraction of quoted
+strings (for example, XML and CSV formats). Quoted manipulators are
+useful in ensuring that the content of a string with embedded spaces
+remains unchanged if inserted and then extracted via stream I/O.
+``` cpp
+template <class charT>
+  unspecified quoted(const charT* s, charT delim=charT('"'), charT escape=charT('\\'));
+template <class charT, class traits, class Allocator>
+  unspecified quoted(const basic_string<charT, traits, Allocator>& s,
+                      charT delim=charT('"'), charT escape=charT('\\'));
+```
+*Returns:* An object of unspecified type such that if `out` is an
+instance of `basic_ostream` with member type `char_type` the same as
+`charT` and with member type `traits_type`, which in the second form is
+the same as `traits`, then the expression
+`out << quoted(s, delim, escape)` behaves as a formatted output
+function ([[ostream.formatted.reqmts]]) of `out`. This forms a
+character sequence `seq`, initially consisting of the following
+elements:
+- `delim`.
+- Each character in `s`. If the character to be output is equal to
+  `escape` or `delim`, as determined by `traits_type::eq`, first output
+  `escape`.
+- `delim`.
+Let `x` be the number of elements initially in `seq`. Then padding is
+determined for `seq` as described in  [[ostream.formatted.reqmts]],
+`seq` is inserted as if by calling `out.rdbuf()->sputn(seq, n)`, where
+`n` is the larger of `out.width()` and `x`, and `out.width(0)` is
+called. The expression `out << quoted(s, delim, escape)` shall have type
+`basic_ostream<charT, traits>&` and value `out`.
+``` cpp
+template <class charT, class traits, class Allocator>
+  unspecified quoted(basic_string<charT, traits, Allocator>& s,
+                      charT delim=charT('"'), charT escape=charT('\\'));
+```
+*Returns:* An object of unspecified type such that:
+- If `in` is an instance of `basic_istream` with member types
+  `char_type` and `traits_type` the same as `charT` and `traits`,
+  respectively, then the expression `in >> quoted(s, delim, escape)`
+  behaves as if it extracts the following characters from `in` using
+  `basic_istream::operator>>` ([[istream::extractors]]) which may throw
+  `ios_base::failure` ([[ios::failure]]):
+  - If the first character extracted is equal to `delim`, as determined
+    by `traits_type::eq`, then:
+    - Turn off the `skipws` flag.
+    - `s.clear()`
+    - Until an unescaped `delim` character is reached or `!in`, extract
+      characters from `in` and append them to `s`, except that if an
+      `escape` is reached, ignore it and append the next character to
+      `s`.
+    - Discard the final `delim` character.
+    - Restore the `skipws` flag to its original value.
+  - Otherwise, `in >> s`.
+- If `out` is an instance of `basic_ostream` with member types
+  `char_type` and `traits_type` the same as `charT` and `traits`,
+  respectively, then the expression `out << quoted(s, delim, escape)`
+  behaves as specified for the
+  `const basic_string<charT, traits, Allocator>&` overload of the
+  `quoted` function.
+The expression `in >> quoted(s, delim, escape)` shall have type
+`basic_istream<charT, traits>&` and value `in`. The expression
+`out << quoted(s, delim, escape)` shall have type
+`basic_ostream<charT, traits>&` and value `out`.
 ## String-based streams <a id="string.streams">[[string.streams]]</a>
 ### Overview <a id="string.streams.overview">[[string.streams.overview]]</a>
     virtual pos_type seekpos(pos_type sp,
                              ios_base::openmode which
                                = ios_base::in | ios_base::out);
   private:
+    ios_base::openmode mode;  // exposition only
   };
   template <class charT, class traits, class Allocator>
   void swap(basic_stringbuf<charT, traits, Allocator>& x,
             basic_stringbuf<charT, traits, Allocator>& y);
     basic_stringbuf<charT,traits,Allocator>* rdbuf() const;
     basic_string<charT,traits,Allocator> str() const;
     void str(const basic_string<charT,traits,Allocator>& s);
   private:
+    basic_stringbuf<charT,traits,Allocator> sb; // exposition only
   };
   template <class charT, class traits, class Allocator>
   void swap(basic_istringstream<charT, traits, Allocator>& x,
             basic_istringstream<charT, traits, Allocator>& y);
     basic_stringbuf<charT,traits,Allocator>* rdbuf() const;
     basic_string<charT,traits,Allocator> str() const;
     void    str(const basic_string<charT,traits,Allocator>& s);
    private:
+    basic_stringbuf<charT,traits,Allocator> sb; // exposition only
   };
   template <class charT, class traits, class Allocator>
   void swap(basic_ostringstream<charT, traits, Allocator>& x,
             basic_ostringstream<charT, traits, Allocator>& y);
     basic_stringbuf<charT,traits,Allocator>* rdbuf() const;
     basic_string<charT,traits,Allocator> str() const;
     void str(const basic_string<charT,traits,Allocator>& str);
   private:
+    basic_stringbuf<charT, traits> sb;  // exposition only
   };
   template <class charT, class traits, class Allocator>
   void swap(basic_stringstream<charT, traits, Allocator>& x,
             basic_stringstream<charT, traits, Allocator>& y);
 associated sequence. For the sake of exposition, the maintained data is
 presented here as
 - `sb`, the `stringbuf` object.
+#### basic_stringstream constructors <a id="stringstream.cons">[[stringstream.cons]]</a>
 ``` cpp
 explicit basic_stringstream(
     ios_base::openmode which = ios_base::out|ios_base::in);
 ```
           basic_stringstream<charT, traits, Allocator>& y);
 ```
 *Effects:* `x.swap(y)`.
+#### Member functions <a id="stringstream.members">[[stringstream.members]]</a>
 ``` cpp
 basic_stringbuf<charT,traits,Allocator>* rdbuf() const;
 ```
 *Effects:* If `is_open() != false`, returns a null pointer. Otherwise,
 initializes the `filebuf` as required. It then opens a file, if
 possible, whose name is the NTBS`s` (as if by calling
 `std::fopen(s,modstr)`). The NTBS`modstr` is determined from
+`mode & ~ios_base::ate` as indicated in
 Table  [[tab:iostreams.file.open.modes]]. If `mode` is not some
 combination of flags shown in the table then the open fails.
 **Table: File open modes** <a id="tab:iostreams.file.open.modes">[tab:iostreams.file.open.modes]</a>
 | +        | +    |       |         | +     | `"a+b"` |
 If the open operation succeeds and `(mode & ios_base::ate) != 0`,
 positions the file to the end (as if by calling
+`std::fseek(file,0,SEEK_END)`).[^39]
 If the repositioning operation fails, calls `close()` and returns a null
 pointer to indicate failure.
 *Returns:* `this` if successful, a null pointer otherwise.
 `overflow`, `seekoff`, and `seekpos`) was `overflow` then calls
 `a_codecvt.unshift` (possibly several times) to determine a termination
 sequence, inserts those characters and calls `overflow(traits::eof())`
 again. Finally, regardless of whether any of the preceding calls fails
 or throws an exception, the function closes the file (as if by calling
+`std::fclose(file)`).[^40] If any of the calls made by the function,
 including `std::fclose`, fails, `close` fails by returning a null
 pointer. If one of these calls throws an exception, the exception is
 caught and rethrown after closing the file.
 *Returns:* `this` on success, a null pointer otherwise.
     bool is_open() const;
     void open(const char* s, ios_base::openmode mode = ios_base::in);
     void open(const string& s, ios_base::openmode mode = ios_base::in);
     void close();
   private:
+    basic_filebuf<charT,traits> sb; // exposition only
   };
   template <class charT, class traits>
   void swap(basic_ifstream<charT, traits>& x,
             basic_ifstream<charT, traits>& y);
     bool is_open() const;
     void open(const char* s, ios_base::openmode mode = ios_base::out);
     void open(const string& s, ios_base::openmode mode = ios_base::out);
     void close();
   private:
+    basic_filebuf<charT,traits> sb; // exposition only
   };
   template <class charT, class traits>
   void swap(basic_ofstream<charT, traits>& x,
             basic_ofstream<charT, traits>& y);
     void open(const string& s,
         ios_base::openmode mode = ios_base::in|ios_base::out);
     void close();
   private:
+    basic_filebuf<charT,traits> sb; // exposition only
   };
   template <class charT, class traits>
   void swap(basic_fstream<charT, traits>& x,
             basic_fstream<charT, traits>& y);
 returns a null pointer, calls `setstate(failbit)` ([[iostate.flags]])
 (which may throw `ios_base::failure`).
 ### C library files <a id="c.files">[[c.files]]</a>
+Table  [[tab:iostreams.hdr.cstdio]] describes header `<cstdio>`. C++does
+not define the function `gets`.
 Calls to the function `tmpnam` with an argument of `NULL` may introduce
 a data race ([[res.on.data.races]]) with other calls to `tmpnam` with
 an argument of `NULL`.
 [bitmask.types]: library.md#bitmask.types
 [c.files]: #c.files
 [enumerated.types]: library.md#enumerated.types
 [error.reporting]: #error.reporting
 [ext.manip]: #ext.manip
 [fig:streampos]: #fig:streampos
 [file.streams]: #file.streams
 [filebuf]: #filebuf
 [filebuf.assign]: #filebuf.assign
 [filebuf.cons]: #filebuf.cons
 [ostringstream]: #ostringstream
 [ostringstream.assign]: #ostringstream.assign
 [ostringstream.cons]: #ostringstream.cons
 [ostringstream.members]: #ostringstream.members
 [output.streams]: #output.streams
+[quoted.manip]: #quoted.manip
 [res.on.data.races]: library.md#res.on.data.races
 [res.on.exception.handling]: library.md#res.on.exception.handling
 [std.ios.manip]: #std.ios.manip
 [std.manip]: #std.manip
 [stream.buffers]: #stream.buffers
 [^15]: Classes derived from `basic_streambuf` can provide more efficient
     ways to implement `xsgetn()` and `xsputn()` by overriding these
     definitions from the base class.
+[^16]: Typically, `overflow` returns `c` to indicate success, except
+    when `traits::eq_int_type(c,traits::eof())` returns `true`, in which
+    case it returns `traits::not_eof(c)`.
+[^17]: This will be possible only in functions that are part of the
     library. The semantics of the constructor used in user code is as
     specified.
+[^18]: The sentry constructor and destructor can also perform additional
     implementation-dependent operations.
+[^19]: This is done without causing an `ios::failure` to be thrown.
 [^20]: See, for example, the function signature
+    `ws(basic_istream&)` ([[istream.manip]]).
+[^21]: See, for example, the function signature
     `dec(ios_base&)` ([[basefield.manip]]).
+[^22]: This is done without causing an `ios::failure` to be thrown.
 [^23]: Note that this function is not overloaded on types `signed char`
     and `unsigned char`.
 [^24]: Note that this function is not overloaded on types `signed char`
     and `unsigned char`.
+[^25]: Note that this function is not overloaded on types `signed char`
+    and `unsigned char`.
+[^26]: Since the final input character is “extracted,” it is counted in
     the `gcount()`, even though it is not stored.
+[^27]: This allows an input line which exactly fills the buffer, without
     setting `failbit`. This is different behavior than the historical
     AT&T implementation.
+[^28]: This implies an empty input line will not cause `failbit` to be
     set.
+[^29]: Note that this function is not overloaded on types `signed char`
     and `unsigned char`.
+[^30]: The call `os.tie()->flush()` does not necessarily occur if the
     function can determine that no synchronization is necessary.
+[^31]: The `sentry` constructor and destructor can also perform
     additional implementation-dependent operations.
+[^32]: without causing an `ios::failure` to be thrown.
 [^33]: See, for example, the function signature
+    `endl(basic_ostream&)` ([[ostream.manip]]).
+[^34]: See, for example, the function signature
     `dec(ios_base&)` ([[basefield.manip]]).
+[^35]: without causing an `ios::failure` to be thrown.
 [^36]: Note that this function is not overloaded on types `signed char`
     and `unsigned char`.
+[^37]: Note that this function is not overloaded on types `signed char`
+    and `unsigned char`.
+[^38]: The expression `cin >>resetiosflags(ios_base::skipws)` clears
     `ios_base::skipws` in the format flags stored in the
     `basic_istream<charT,traits>` object `cin` (the same as
     `cin >>noskipws`), and the expression
     `cout << resetiosflags(ios_base::showbase)` clears
     `ios_base::showbase` in the format flags stored in the
     `basic_ostream<charT,traits>` object `cout` (the same as
     `cout <<noshowbase`).
+[^39]: The macro `SEEK_END` is defined, and the function signatures
     `fopen(const char*, const char*)` and `fseek(FILE*, long, int)` are
     declared, in `<cstdio>` ([[c.files]]).
+[^40]: The function signature `fclose(FILE*)` is declared in `<cstdio>`
     ([[c.files]]).

Diff to HTML by rtfpessoa