[input.streams] - C++20 → C++23

Files changed (1) hide show

tmp/tmpoc27z615/{from.md → to.md} +264 -209

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

@@ -1,13 +1,22 @@
 ### Input streams <a id="input.streams">[[input.streams]]</a>
-The header `<istream>` defines two types and a function signature that
-control input from a stream buffer along with a function template that
-extracts from stream rvalues.
 #### Class template `basic_istream` <a id="istream">[[istream]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_istream : virtual public basic_ios<charT, traits> {
   public:
@@ -24,64 +33,62 @@ namespace std {
     // [istream.sentry], prefix/suffix
     class sentry;
     // [istream.formatted], formatted input
-    basic_istream<charT, traits>&
- operator>>(basic_istream<charT, traits>& (*pf)(basic_istream<charT, traits>&));
-    basic_istream<charT, traits>&
-      operator>>(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
-    basic_istream<charT, traits>&
-      operator>>(ios_base& (*pf)(ios_base&));
-    basic_istream<charT, traits>& operator>>(bool& n);
-    basic_istream<charT, traits>& operator>>(short& n);
-    basic_istream<charT, traits>& operator>>(unsigned short& n);
-    basic_istream<charT, traits>& operator>>(int& n);
-    basic_istream<charT, traits>& operator>>(unsigned int& n);
-    basic_istream<charT, traits>& operator>>(long& n);
-    basic_istream<charT, traits>& operator>>(unsigned long& n);
-    basic_istream<charT, traits>& operator>>(long long& n);
-    basic_istream<charT, traits>& operator>>(unsigned long long& n);
-    basic_istream<charT, traits>& operator>>(float& f);
-    basic_istream<charT, traits>& operator>>(double& f);
-    basic_istream<charT, traits>& operator>>(long double& f);
-    basic_istream<charT, traits>& operator>>(void*& p);
-    basic_istream<charT, traits>& operator>>(basic_streambuf<char_type, traits>* sb);
     // [istream.unformatted], unformatted input
     streamsize gcount() const;
     int_type get();
-    basic_istream<charT, traits>& get(char_type& c);
-    basic_istream<charT, traits>& get(char_type* s, streamsize n);
-    basic_istream<charT, traits>& get(char_type* s, streamsize n, char_type delim);
-    basic_istream<charT, traits>& get(basic_streambuf<char_type, traits>& sb);
-    basic_istream<charT, traits>& get(basic_streambuf<char_type, traits>& sb, char_type delim);
-    basic_istream<charT, traits>& getline(char_type* s, streamsize n);
-    basic_istream<charT, traits>& getline(char_type* s, streamsize n, char_type delim);
-    basic_istream<charT, traits>& ignore(streamsize n = 1, int_type delim = traits::eof());
     int_type       peek();
-    basic_istream<charT, traits>& read    (char_type* s, streamsize n);
     streamsize     readsome(char_type* s, streamsize n);
-    basic_istream<charT, traits>& putback(char_type c);
-    basic_istream<charT, traits>& unget();
     int sync();
     pos_type tellg();
-    basic_istream<charT, traits>& seekg(pos_type);
-    basic_istream<charT, traits>& seekg(off_type, ios_base::seekdir);
   protected:
     // [istream.cons], copy/move constructor
     basic_istream(const basic_istream&) = delete;
     basic_istream(basic_istream&& rhs);
-    // [istream.assign], assign and swap
     basic_istream& operator=(const basic_istream&) = delete;
     basic_istream& operator=(basic_istream&& rhs);
     void swap(basic_istream& rhs);
   };
@@ -110,22 +117,10 @@ Two groups of member function signatures share common properties: the
 *formatted input functions* (or *extractors*) and the *unformatted input
 functions.* Both groups of input functions are described as if they
 obtain (or *extract*) input *characters* by calling `rdbuf()->sbumpc()`
 or `rdbuf()->sgetc()`. They may use other public members of `istream`.
-If `rdbuf()->sbumpc()` or `rdbuf()->sgetc()` returns `traits::eof()`,
-then the input function, except as explicitly noted otherwise, completes
-its actions and does `setstate(eofbit)`, which may throw
-`ios_base::failure` [[iostate.flags]], before returning.
-If one of these called functions throws an exception, then unless
-explicitly noted otherwise, the input function sets `badbit` in the
-error state. If `badbit` is set in `exceptions()`, the input function
-rethrows the exception without completing its actions, otherwise it does
-not throw anything and proceeds as if the called function had returned a
-failure indication.
 ##### Constructors <a id="istream.cons">[[istream.cons]]</a>
 ``` cpp
 explicit basic_istream(basic_streambuf<charT, traits>* sb);
 ```
@@ -168,15 +163,16 @@ values returned by `gcount()` and `rhs.gcount()`.
 ##### Class `basic_istream::sentry` <a id="istream.sentry">[[istream.sentry]]</a>
 ``` cpp
 namespace std {
-  template<class charT, class traits = char_traits<charT>>
   class basic_istream<charT, traits>::sentry {
     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;
     sentry& operator=(const sentry&) = delete;
   };
@@ -185,32 +181,34 @@ namespace std {
 The class `sentry` defines a class that is responsible for doing
 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.[^18] 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`).
 *Remarks:* The constructor
 ``` cpp
-explicit sentry(basic_istream<charT, traits>& is, bool noskipws = false)
 ```
 uses the currently imbued locale in `is`, to determine whether the next
 input character is whitespace or not.
@@ -243,47 +241,56 @@ explicit operator bool() const;
 #### Formatted input functions <a id="istream.formatted">[[istream.formatted]]</a>
 ##### Common requirements <a id="istream.formatted.reqmts">[[istream.formatted.reqmts]]</a>
 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_base::badbit` is turned
-on[^20] 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`.
 ##### Arithmetic extractors <a id="istream.formatted.arithmetic">[[istream.formatted.arithmetic]]</a>
 ``` cpp
-operator>>(unsigned short& val);
-operator>>(unsigned int& val);
-operator>>(long& val);
-operator>>(unsigned long& val);
-operator>>(long long& val);
-operator>>(unsigned long long& val);
-operator>>(float& val);
-operator>>(double& val);
-operator>>(long double& val);
-operator>>(bool& val);
-operator>>(void*& val);
 ```
 As in the case of the inserters, these extractors depend on the locale’s
 `num_get<>` [[locale.num.get]] object to perform parsing the input
 stream data. These extractors behave as formatted input functions (as
-described in  [[istream.formatted.reqmts]]). After a sentry object is
 constructed, the conversion occurs as if performed by the following code
-fragment:
 ``` cpp
 using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
-iostate err = iostate::goodbit;
-use_facet<numget>(loc).get(*this, 0, *this, err, val);
-setstate(err);
 ```
 In the above fragment, `loc` stands for the private member of the
 `basic_ios` class.
@@ -294,85 +301,123 @@ directly. — *end note*]
 Class `locale` relies on this type as its interface to `istream`, so
 that it does not need to depend directly on `istream`.
 ``` cpp
-operator>>(short& val);
 ```
 The conversion occurs as if performed by the following code fragment
 (using the same notation as for the preceding code fragment):
 ``` cpp
 using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
-iostate err = ios_base::goodbit;
 long lval;
-use_facet<numget>(loc).get(*this, 0, *this, err, lval);
 if (lval < numeric_limits<short>::min()) {
- err |= ios_base::failbit;
   val = numeric_limits<short>::min();
 } else if (numeric_limits<short>::max() < lval) {
- err |= ios_base::failbit;
   val = numeric_limits<short>::max();
 }  else
   val = static_cast<short>(lval);
-setstate(err);
 ```
 ``` cpp
-operator>>(int& val);
 ```
 The conversion occurs as if performed by the following code fragment
 (using the same notation as for the preceding code fragment):
 ``` cpp
 using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
-iostate err = ios_base::goodbit;
 long lval;
-use_facet<numget>(loc).get(*this, 0, *this, err, lval);
 if (lval < numeric_limits<int>::min()) {
- err |= ios_base::failbit;
   val = numeric_limits<int>::min();
 } else if (numeric_limits<int>::max() < lval) {
- err |= ios_base::failbit;
   val = numeric_limits<int>::max();
 }  else
   val = static_cast<int>(lval);
-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)`.[^21]
 ``` cpp
-basic_istream<charT, traits>&
-  operator>>(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
 ```
 *Effects:* Calls `pf(*this)`. This extractor does not behave as a
 formatted input function (as described
 in  [[istream.formatted.reqmts]]).
 *Returns:* `*this`.
 ``` cpp
-basic_istream<charT, traits>& operator>>(ios_base& (*pf)(ios_base&));
 ```
-*Effects:* Calls `pf(*this)`.[^22] This extractor does not behave as a
-formatted input function (as described
-in  [[istream.formatted.reqmts]]).
 *Returns:* `*this`.
 ``` cpp
 template<class charT, class traits, size_t N>
@@ -398,12 +443,12 @@ Characters are extracted and stored until any of the following occurs:
 `operator>>` then stores a null byte (`charT()`) in the next position,
 which may be the first position if no characters were extracted.
 `operator>>` then calls `width(0)`.
-If the function extracted no characters, it calls `setstate(failbit)`,
-which may throw `ios_base::failure` [[iostate.flags]].
 *Returns:* `in`.
 ``` cpp
 template<class charT, class traits>
@@ -413,132 +458,138 @@ template<class traits>
 template<class traits>
   basic_istream<char, traits>& operator>>(basic_istream<char, traits>& in, signed char& c);
 ```
 *Effects:* Behaves like a formatted input member (as described
-in  [[istream.formatted.reqmts]]) of `in`. After a `sentry` object is
-constructed a character is extracted from `in`, if one is available, and
-stored in `c`. Otherwise, the function calls `in.setstate(failbit)`.
 *Returns:* `in`.
 ``` cpp
-basic_istream<charT, traits>& operator>>(basic_streambuf<charT, traits>* sb);
 ```
 *Effects:* Behaves as an unformatted input
 function [[istream.unformatted]]. If `sb` is null, calls
 `setstate(failbit)`, which may throw `ios_base::failure`
-[[iostate.flags]]. After a sentry object is constructed, extracts
 characters from `*this` and inserts them in the output sequence
 controlled by `sb`. Characters are extracted and inserted until any of
 the following occurs:
 - end-of-file occurs on the input sequence;
 - inserting in the output sequence fails (in which case the character to
   be inserted is not extracted);
 - an exception occurs (in which case the exception is caught).
-If the function inserts no characters, it calls `setstate(failbit)`,
-which may throw `ios_base::failure` [[iostate.flags]]. If it inserted no
-characters because it caught an exception thrown while extracting
-characters from `*this` and `failbit` is set in `exceptions()`
-[[iostate.flags]], then the caught exception is rethrown.
 *Returns:* `*this`.
 #### Unformatted input functions <a id="istream.unformatted">[[istream.unformatted]]</a>
 Each unformatted input function begins execution by constructing an
-object of class `sentry` with the default argument `noskipws` (second)
-argument `true`. If the `sentry` object returns `true`, when converted
-to a value of type `bool`, the function endeavors to obtain the
-requested input. Otherwise, if the sentry constructor exits by throwing
-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
-nonzero 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_base::badbit` is turned on[^23] 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`
-object is destroyed before leaving the unformatted input function.
 ``` cpp
 streamsize gcount() const;
 ```
 *Effects:* None. This member function does not behave as an unformatted
 input function (as described above).
 *Returns:* The number of characters extracted by the last unformatted
-input member function called for the object.
 ``` cpp
 int_type get();
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). After constructing a sentry object, extracts a character `c`, if
-one is available. Otherwise, the function calls `setstate(failbit)`,
-which may throw `ios_base::failure` [[iostate.flags]].
 *Returns:* `c` if available, otherwise `traits::eof()`.
 ``` cpp
-basic_istream<charT, traits>& get(char_type& c);
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). After constructing a sentry object, extracts a character, if one
-is available, and assigns it to `c`.[^24] Otherwise, the function calls
-`setstate(failbit)` (which may throw `ios_base::failure`
-[[iostate.flags]]).
 *Returns:* `*this`.
 ``` cpp
-basic_istream<charT, traits>& get(char_type* s, streamsize n, char_type delim);
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). 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 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)`);
 - `traits::eq(c, delim)` for the next available input character `c` (in
   which case `c` is not extracted).
-If the function stores no characters, it calls `setstate(failbit)`
-(which may throw `ios_base::failure` [[iostate.flags]]). In any case, 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.
 ``` cpp
-basic_istream<charT, traits>& get(basic_streambuf<char_type, traits>& sb, char_type delim);
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). After constructing a sentry object, extracts characters and
 inserts them in the output sequence controlled by `sb`. Characters are
 extracted and inserted until any of the following occurs:
 - end-of-file occurs on the input sequence;
 - inserting in the output sequence fails (in which case the character to
@@ -546,45 +597,45 @@ extracted and inserted until any of the following occurs:
 - `traits::eq(c, delim)` for the next available input character `c` (in
   which case `c` is not extracted);
 - an exception occurs (in which case, the exception is caught but not
   rethrown).
-If the function inserts no characters, it calls `setstate(failbit)`,
-which may throw `ios_base::failure` [[iostate.flags]].
 *Returns:* `*this`.
 ``` cpp
-basic_istream<charT, traits>& get(basic_streambuf<char_type, traits>& sb);
 ```
 *Effects:* Calls `get(sb, widen(’\n’))`.
 *Returns:* Value returned by the call.
 ``` cpp
-basic_istream<charT, traits>& getline(char_type* s, streamsize n, char_type delim);
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). After constructing a sentry object, extracts characters and
 stores them into successive locations of an array whose first element is
-designated by `s`.[^26] 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);[^27]
 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.[^28]
-If the function extracts no characters, it calls `setstate(failbit)`
-(which may throw `ios_base::failure` [[iostate.flags]]).[^29]
 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.
@@ -618,21 +669,21 @@ int main() {
 ```
 — *end example*]
 ``` cpp
-basic_istream<charT, traits>& getline(char_type* s, streamsize n);
 ```
 *Returns:* `getline(s, n, widen(’\n’))`
 ``` cpp
-basic_istream<charT, traits>& ignore(streamsize n = 1, int_type delim = traits::eof());
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). After constructing a sentry object, extracts characters and
 discards them. Characters are extracted until any of the following
 occurs:
 - `n != numeric_limits<streamsize>::max()` [[numeric.limits]] and `n`
   characters have been extracted so far
@@ -640,36 +691,38 @@ occurs:
   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).
-*Remarks:* The last condition will never occur if
-`traits::eq_int_type(delim, traits::eof())`.
 *Returns:* `*this`.
 ``` cpp
 int_type peek();
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). After constructing a sentry object, reads but does not extract
 the current input character.
 *Returns:* `traits::eof()` if `good()` is `false`. Otherwise, returns
 `rdbuf()->sgetc()`.
 ``` cpp
-basic_istream<charT, traits>& read(char_type* s, streamsize n);
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). 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`.[^30] 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
   `ios_base::failure` [[iostate.flags]]).
@@ -679,11 +732,11 @@ extracted and stored until either of the following occurs:
 ``` cpp
 streamsize readsome(char_type* s, streamsize n);
 ```
 *Effects:* Behaves as an unformatted input function (as described
-above). 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`. If
 `rdbuf()->in_avail() == -1`, calls `setstate(eofbit)` (which may throw
 `ios_base::failure` [[iostate.flags]]), and extracts no characters;
@@ -692,51 +745,51 @@ array whose first element is designated by `s`. If
 - If `rdbuf()->in_avail() > 0`, extracts `min(rdbuf()->in_avail(), n))`.
 *Returns:* The number of characters extracted.
 ``` cpp
-basic_istream<charT, traits>& putback(char_type c);
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above), except that the function first clears `eofbit`. After
-constructing a sentry object, if `!good()` calls `setstate(failbit)`
 which may throw an exception, and return. If `rdbuf()` is not null,
 calls `rdbuf()->sputbackc(c)`. If `rdbuf()` is null, or if `sputbackc`
 returns `traits::eof()`, calls `setstate(badbit)` (which may throw
 `ios_base::failure` [[iostate.flags]]).
-[*Note 1*: This function extracts no characters, so the value returned
-by the next call to `gcount()` is 0. — *end note*]
-*Returns:* `*this`.
-``` cpp
-basic_istream<charT, traits>& unget();
-```
-*Effects:* Behaves as an unformatted input function (as described
-above), except that the function first clears `eofbit`. After
-constructing a sentry object, if `!good()` calls `setstate(failbit)`
-which may throw an exception, and return. If `rdbuf()` is not null,
-calls `rdbuf()->sungetc()`. If `rdbuf()` is null, or if `sungetc`
-returns `traits::eof()`, calls `setstate(badbit)` (which may throw
-`ios_base::failure` [[iostate.flags]]).
 [*Note 2*: This function extracts no characters, so the value returned
 by the next call to `gcount()` is 0. — *end note*]
 *Returns:* `*this`.
 ``` cpp
 int sync();
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above), except that it does not count the number of characters extracted
 and does not affect the value returned by subsequent calls to
-`gcount()`. After constructing a sentry object, if `rdbuf()` is a null
 pointer, returns `-1`. Otherwise, calls `rdbuf()->pubsync()` and, if
 that function returns `-1` calls `setstate(badbit)` (which may throw
 `ios_base::failure` [[iostate.flags]], and returns `-1`. Otherwise,
 returns zero.
@@ -747,38 +800,38 @@ pos_type tellg();
 *Effects:* Behaves as an unformatted input function (as described
 above), except that it does not count the number of characters extracted
 and does not affect the value returned by subsequent calls to
 `gcount()`.
-*Returns:* After constructing a sentry object, if `fail() != false`,
 returns `pos_type(-1)` to indicate failure. Otherwise, returns
 `rdbuf()->pubseekoff(0, cur, in)`.
 ``` cpp
-basic_istream<charT, traits>& seekg(pos_type pos);
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above), except that the function first clears `eofbit`, it does not
 count the number of characters extracted, and it does not affect the
 value returned by subsequent calls to `gcount()`. After constructing a
-sentry object, if `fail() != true`, executes
 `rdbuf()->pubseekpos(pos, ios_base::in)`. In case of failure, the
 function calls `setstate(failbit)` (which may throw
 `ios_base::failure`).
 *Returns:* `*this`.
 ``` cpp
-basic_istream<charT, traits>& seekg(off_type off, ios_base::seekdir dir);
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above), except that the function first clears `eofbit`, does not count
 the number of characters extracted, and does not affect the value
-returned by subsequent calls to `gcount()`. After constructing a sentry
-object, if `fail() != true`, executes
 `rdbuf()->pubseekoff(off, dir, ios_base::in)`. In case of failure, the
 function calls `setstate(failbit)` (which may throw
 `ios_base::failure`).
 *Returns:* `*this`.
@@ -794,11 +847,11 @@ template<class charT, class traits>
 ```
 *Effects:* Behaves as an unformatted input
 function [[istream.unformatted]], except that it does not count the
 number of characters extracted and does not affect the value returned by
-subsequent calls to `is.gcount()`. After constructing a sentry object
 extracts characters as long as the next available character `c` is
 whitespace or until there are no more characters in the sequence.
 Whitespace characters are distinguished with the same criterion as used
 by `sentry::sentry` [[istream.sentry]]. If `ws` stops extracting
 characters because there are no more available it sets `eofbit`, but not
@@ -812,22 +865,24 @@ characters because there are no more available it sets `eofbit`, but not
 template<class Istream, class T>
   Istream&& operator>>(Istream&& is, T&& x);
 ```
 *Constraints:* The expression `is >> std::forward<T>(x)` is well-formed
-when treated as an unevaluated operand and `Istream` is publicly and
-unambiguously derived from `ios_base`.
 *Effects:* Equivalent to:
 ``` cpp
 is >> std::forward<T>(x);
 return std::move(is);
 ```
 #### Class template `basic_iostream` <a id="iostreamclass">[[iostreamclass]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_iostream
     : public basic_istream<charT, traits>,
@@ -848,11 +903,11 @@ namespace std {
   protected:
     // [iostream.cons], constructor
     basic_iostream(const basic_iostream&) = delete;
     basic_iostream(basic_iostream&& rhs);
-    // [iostream.assign], assign and swap
     basic_iostream& operator=(const basic_iostream&) = delete;
     basic_iostream& operator=(basic_iostream&& rhs);
     void swap(basic_iostream& rhs);
   };
 }
@@ -877,11 +932,11 @@ explicit basic_iostream(basic_streambuf<charT, traits>* sb);
 ``` cpp
 basic_iostream(basic_iostream&& rhs);
 ```
 *Effects:* Move constructs from the rvalue `rhs` by constructing the
-`basic_istream` base class with `move(rhs)`.
 ##### Destructor <a id="iostream.dest">[[iostream.dest]]</a>
 ``` cpp
 virtual ~basic_iostream();

 ### Input streams <a id="input.streams">[[input.streams]]</a>
+#### General <a id="input.streams.general">[[input.streams.general]]</a>
+The header `<istream>` defines two class templates and a function
+template that control input from a stream buffer, along with a function
+template that extracts from stream rvalues.
 #### Class template `basic_istream` <a id="istream">[[istream]]</a>
+##### General <a id="istream.general">[[istream.general]]</a>
+When a function is specified with a type placeholder of
+`extended-floating-point-type`, the implementation provides overloads
+for all cv-unqualified extended floating-point types
+[[basic.fundamental]] in lieu of `extended-floating-{point-type}`.
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_istream : virtual public basic_ios<charT, traits> {
   public:
     // [istream.sentry], prefix/suffix
     class sentry;
     // [istream.formatted], formatted input
+    basic_istream& operator>>(basic_istream& (*pf)(basic_istream&));
+    basic_istream& operator>>(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
+    basic_istream& operator>>(ios_base& (*pf)(ios_base&));
+    basic_istream& operator>>(bool& n);
+    basic_istream& operator>>(short& n);
+    basic_istream& operator>>(unsigned short& n);
+    basic_istream& operator>>(int& n);
+    basic_istream& operator>>(unsigned int& n);
+    basic_istream& operator>>(long& n);
+    basic_istream& operator>>(unsigned long& n);
+    basic_istream& operator>>(long long& n);
+    basic_istream& operator>>(unsigned long long& n);
+    basic_istream& operator>>(float& f);
+    basic_istream& operator>>(double& f);
+    basic_istream& operator>>(long double& f);
+    basic_istream& operator>>(extended-floating-point-type& f);
+    basic_istream& operator>>(void*& p);
+    basic_istream& operator>>(basic_streambuf<char_type, traits>* sb);
     // [istream.unformatted], unformatted input
     streamsize gcount() const;
     int_type get();
+    basic_istream& get(char_type& c);
+    basic_istream& get(char_type* s, streamsize n);
+    basic_istream& get(char_type* s, streamsize n, char_type delim);
+    basic_istream& get(basic_streambuf<char_type, traits>& sb);
+    basic_istream& get(basic_streambuf<char_type, traits>& sb, char_type delim);
+    basic_istream& getline(char_type* s, streamsize n);
+    basic_istream& getline(char_type* s, streamsize n, char_type delim);
+    basic_istream& ignore(streamsize n = 1, int_type delim = traits::eof());
     int_type       peek();
+    basic_istream& read    (char_type* s, streamsize n);
     streamsize     readsome(char_type* s, streamsize n);
+    basic_istream& putback(char_type c);
+    basic_istream& unget();
     int sync();
     pos_type tellg();
+    basic_istream& seekg(pos_type);
+    basic_istream& seekg(off_type, ios_base::seekdir);
   protected:
     // [istream.cons], copy/move constructor
     basic_istream(const basic_istream&) = delete;
     basic_istream(basic_istream&& rhs);
+    // [istream.assign], assignment and swap
     basic_istream& operator=(const basic_istream&) = delete;
     basic_istream& operator=(basic_istream&& rhs);
     void swap(basic_istream& rhs);
   };
 *formatted input functions* (or *extractors*) and the *unformatted input
 functions.* Both groups of input functions are described as if they
 obtain (or *extract*) input *characters* by calling `rdbuf()->sbumpc()`
 or `rdbuf()->sgetc()`. They may use other public members of `istream`.
 ##### Constructors <a id="istream.cons">[[istream.cons]]</a>
 ``` cpp
 explicit basic_istream(basic_streambuf<charT, traits>* sb);
 ```
 ##### Class `basic_istream::sentry` <a id="istream.sentry">[[istream.sentry]]</a>
 ``` cpp
 namespace std {
+  template<class charT, class traits>
   class basic_istream<charT, traits>::sentry {
     bool ok_;                   // exposition only
   public:
+    explicit sentry(basic_istream& is, bool noskipws = false);
     ~sentry();
     explicit operator bool() const { return ok_; }
     sentry(const sentry&) = delete;
     sentry& operator=(const sentry&) = delete;
   };
 The class `sentry` defines a class that is responsible for doing
 exception safe prefix and suffix operations.
 ``` cpp
+explicit sentry(basic_istream& 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.[^18]
+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`).
 *Remarks:* The constructor
 ``` cpp
+explicit sentry(basic_istream& is, bool noskipws = false)
 ```
 uses the currently imbued locale in `is`, to determine whether the next
 input character is whitespace or not.
 #### Formatted input functions <a id="istream.formatted">[[istream.formatted]]</a>
 ##### Common requirements <a id="istream.formatted.reqmts">[[istream.formatted.reqmts]]</a>
 Each formatted input function begins execution by constructing an object
+of type `ios_base::iostate`, termed the local error state, and
+initializing it to `ios_base::goodbit`. It then creates 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. Otherwise,
+if the `sentry` constructor exits by throwing an exception or if the
+`sentry` object produces `false` when converted to a value of type
+`bool`, the function returns without attempting to obtain any input. If
+`rdbuf()->sbumpc()` or `rdbuf()->sgetc()` returns `traits::eof()`, then
+`ios_base::eofbit` is set in the local error state and the input
+function stops trying to obtain the requested input. If an exception is
+thrown during input then `ios_base::badbit` is set in the local error
+state, `*this`’s error state is set to the local error state, and the
+exception is rethrown if `(exceptions() & badbit) != 0`. After
+extraction is done, the input function calls `setstate`, which sets
+`*this`’s error state to the local error state, and may throw an
+exception. In any case, the formatted input function destroys the
+`sentry` object. If no exception has been thrown, it returns `*this`.
 ##### Arithmetic extractors <a id="istream.formatted.arithmetic">[[istream.formatted.arithmetic]]</a>
 ``` cpp
+basic_istream& operator>>(unsigned short& val);
+basic_istream& operator>>(unsigned int& val);
+basic_istream& operator>>(long& val);
+basic_istream& operator>>(unsigned long& val);
+basic_istream& operator>>(long long& val);
+basic_istream& operator>>(unsigned long long& val);
+basic_istream& operator>>(float& val);
+basic_istream& operator>>(double& val);
+basic_istream& operator>>(long double& val);
+basic_istream& operator>>(bool& val);
+basic_istream& operator>>(void*& val);
 ```
 As in the case of the inserters, these extractors depend on the locale’s
 `num_get<>` [[locale.num.get]] object to perform parsing the input
 stream data. These extractors behave as formatted input functions (as
+described in  [[istream.formatted.reqmts]]). After a `sentry` object is
 constructed, the conversion occurs as if performed by the following code
+fragment, where `state` represents the input function’s local error
+state:
 ``` cpp
 using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
+use_facet<numget>(loc).get(*this, 0, *this, state, val);
 ```
 In the above fragment, `loc` stands for the private member of the
 `basic_ios` class.
 Class `locale` relies on this type as its interface to `istream`, so
 that it does not need to depend directly on `istream`.
 ``` cpp
+basic_istream& operator>>(short& val);
 ```
 The conversion occurs as if performed by the following code fragment
 (using the same notation as for the preceding code fragment):
 ``` cpp
 using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
 long lval;
+use_facet<numget>(loc).get(*this, 0, *this, state, lval);
 if (lval < numeric_limits<short>::min()) {
+ state |= ios_base::failbit;
   val = numeric_limits<short>::min();
 } else if (numeric_limits<short>::max() < lval) {
+ state |= ios_base::failbit;
   val = numeric_limits<short>::max();
 }  else
   val = static_cast<short>(lval);
 ```
 ``` cpp
+basic_istream& operator>>(int& val);
 ```
 The conversion occurs as if performed by the following code fragment
 (using the same notation as for the preceding code fragment):
 ``` cpp
 using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
 long lval;
+use_facet<numget>(loc).get(*this, 0, *this, state, lval);
 if (lval < numeric_limits<int>::min()) {
+ state |= ios_base::failbit;
   val = numeric_limits<int>::min();
 } else if (numeric_limits<int>::max() < lval) {
+ state |= ios_base::failbit;
   val = numeric_limits<int>::max();
 }  else
   val = static_cast<int>(lval);
 ```
+``` cpp
+basic_istream& operator>>(extended-floating-point-type& val);
+```
+If the floating-point conversion rank of
+*`extended-floating-point-type`* is not less than or equal to that of
+`long double`, then an invocation of the operator function is
+conditionally supported with *implementation-defined* semantics.
+Otherwise, let `FP` be a standard floating-point type:
+- if the floating-point conversion rank of
+  *`extended-floating-point-type`* is less than or equal to that of
+  `float`, then `FP` is `float`,
+- otherwise, if the floating-point conversion rank of
+  *`extended-floating-point-type`* is less than or equal to that of
+  `double`, then `FP` is `double`,
+- otherwise, `FP` is `long double`.
+The conversion occurs as if performed by the following code fragment
+(using the same notation as for the preceding code fragment):
+``` cpp
+using numget = num_get<charT, istreambuf_iterator<charT, traits>>;
+FP fval;
+use_facet<numget>(loc).get(*this, 0, *this, state, fval);
+if (fval < -numeric_limits<extended-floating-point-type>::max()) {
+  state |= ios_base::failbit;
+  val = -numeric_limits<extended-floating-point-type>::max();
+} else if (numeric_limits<extended-floating-point-type>::max() < fval) {
+  state |= ios_base::failbit;
+  val = numeric_limits<extended-floating-point-type>::max();
+} else {
+  val = static_cast<extended-floating-point-type>(fval);
+}
+```
+[*Note 2*: When the extended floating-point type has a floating-point
+conversion rank that is not equal to the rank of any standard
+floating-point type, then double rounding during the conversion can
+result in inaccurate results. `from_chars` can be used in situations
+where maximum accuracy is important. — *end note*]
 ##### `basic_istream::operator>>` <a id="istream.extractors">[[istream.extractors]]</a>
 ``` cpp
+basic_istream& operator>>(basic_istream& (*pf)(basic_istream&));
 ```
 *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& operator>>(basic_ios<charT, traits>& (*pf)(basic_ios<charT, traits>&));
 ```
 *Effects:* Calls `pf(*this)`. This extractor does not behave as a
 formatted input function (as described
 in  [[istream.formatted.reqmts]]).
 *Returns:* `*this`.
 ``` cpp
+basic_istream& 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`.
 ``` cpp
 template<class charT, class traits, size_t N>
 `operator>>` then stores a null byte (`charT()`) in the next position,
 which may be the first position if no characters were extracted.
 `operator>>` then calls `width(0)`.
+If the function extracted no characters, `ios_base::failbit` is set in
+the input function’s local error state before `setstate` is called.
 *Returns:* `in`.
 ``` cpp
 template<class charT, class traits>
 template<class traits>
   basic_istream<char, traits>& operator>>(basic_istream<char, traits>& in, signed char& c);
 ```
 *Effects:* Behaves like a formatted input member (as described
+in  [[istream.formatted.reqmts]]) of `in`. A character is extracted from
+`in`, if one is available, and stored in `c`. Otherwise,
+`ios_base::failbit` is set in the input function’s local error state
+before `setstate` is called.
 *Returns:* `in`.
 ``` cpp
+basic_istream& operator>>(basic_streambuf<charT, traits>* sb);
 ```
 *Effects:* Behaves as an unformatted input
 function [[istream.unformatted]]. If `sb` is null, calls
 `setstate(failbit)`, which may throw `ios_base::failure`
+[[iostate.flags]]. After a `sentry` object is constructed, extracts
 characters from `*this` and inserts them in the output sequence
 controlled by `sb`. Characters are extracted and inserted until any of
 the following occurs:
 - end-of-file occurs on the input sequence;
 - inserting in the output sequence fails (in which case the character to
   be inserted is not extracted);
 - an exception occurs (in which case the exception is caught).
+If the function inserts no characters, `ios_base::failbit` is set in the
+input function’s local error state before `setstate` is called.
 *Returns:* `*this`.
 #### Unformatted input functions <a id="istream.unformatted">[[istream.unformatted]]</a>
 Each unformatted input function begins execution by constructing an
+object of type `ios_base::iostate`, termed the local error state, and
+initializing it to `ios_base::goodbit`. It then creates an object of
+class `sentry` with the default argument `noskipws` (second) argument
+`true`. If the `sentry` object returns `true`, when converted to a value
+of type `bool`, the function endeavors to obtain the requested input.
+Otherwise, if the `sentry` constructor exits by throwing an exception or
+if the `sentry` object produces `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 nonzero size as
+an argument shall also store a null character (using `charT()`) in the
+first location of the array. If `rdbuf()->sbumpc()` or
+`rdbuf()->sgetc()` returns `traits::eof()`, then `ios_base::eofbit` is
+set in the local error state and the input function stops trying to
+obtain the requested input. If an exception is thrown during input then
+`ios_base::badbit` is set in the local error state, `*this`’s error
+state is set to the local error state, and the exception is rethrown if
+`(exceptions() & badbit) != 0`. If no exception has been thrown it
+stores the number of characters extracted in a member object. After
+extraction is done, the input function calls `setstate`, which sets
+`*this`’s error state to the local error state, and may throw an
+exception. In any event the `sentry` object is destroyed before leaving
+the unformatted input function.
 ``` cpp
 streamsize gcount() const;
 ```
 *Effects:* None. This member function does not behave as an unformatted
 input function (as described above).
 *Returns:* The number of characters extracted by the last unformatted
+input member function called for the object. If the number cannot be
+represented, returns `numeric_limits<streamsize>::max()`.
 ``` cpp
 int_type get();
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a `sentry` object, extracts a character `c`,
+if one is available. Otherwise, `ios_base::failbit` is set in the input
+function’s local error state before `setstate` is called.
 *Returns:* `c` if available, otherwise `traits::eof()`.
 ``` cpp
+basic_istream& get(char_type& c);
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a `sentry` object, extracts a character, if
+one is available, and assigns it to `c`.[^22]
+Otherwise, `ios_base::failbit` is set in the input function’s local
+error state before `setstate` is called.
 *Returns:* `*this`.
 ``` cpp
+basic_istream& get(char_type* s, streamsize n, char_type delim);
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). 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;
 - `traits::eq(c, delim)` for the next available input character `c` (in
   which case `c` is not extracted).
+If the function stores no characters, `ios_base::failbit` is set in the
+input function’s local error state before `setstate` is called. In any
+case, 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& get(char_type* s, streamsize n);
 ```
 *Effects:* Calls `get(s, n, widen(’\n’))`.
 *Returns:* Value returned by the call.
 ``` cpp
+basic_istream& get(basic_streambuf<char_type, traits>& sb, char_type delim);
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a `sentry` object, extracts characters and
 inserts them in the output sequence controlled by `sb`. Characters are
 extracted and inserted until any of the following occurs:
 - end-of-file occurs on the input sequence;
 - inserting in the output sequence fails (in which case the character to
 - `traits::eq(c, delim)` for the next available input character `c` (in
   which case `c` is not extracted);
 - an exception occurs (in which case, the exception is caught but not
   rethrown).
+If the function inserts no characters, `ios_base::failbit` is set in the
+input function’s local error state before `setstate` is called.
 *Returns:* `*this`.
 ``` cpp
+basic_istream& get(basic_streambuf<char_type, traits>& sb);
 ```
 *Effects:* Calls `get(sb, widen(’\n’))`.
 *Returns:* Value returned by the call.
 ``` cpp
+basic_istream& getline(char_type* s, streamsize n, char_type delim);
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). 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;
 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, `ios_base::failbit` is set in
+the input function’s local error state before `setstate` is called.[^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.
 ```
 — *end example*]
 ``` cpp
+basic_istream& getline(char_type* s, streamsize n);
 ```
 *Returns:* `getline(s, n, widen(’\n’))`
 ``` cpp
+basic_istream& ignore(streamsize n = 1, int_type delim = traits::eof());
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a `sentry` object, extracts characters and
 discards them. Characters are extracted until any of the following
 occurs:
 - `n != numeric_limits<streamsize>::max()` [[numeric.limits]] and `n`
   characters have been extracted so far
   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).
+[*Note 1*: The last condition will never occur if
+`traits::eq_int_type(delim, traits::eof())`. — *end note*]
 *Returns:* `*this`.
 ``` cpp
 int_type peek();
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). After constructing a `sentry` object, reads but does not extract
 the current input character.
 *Returns:* `traits::eof()` if `good()` is `false`. Otherwise, returns
 `rdbuf()->sgetc()`.
 ``` cpp
+basic_istream& read(char_type* s, streamsize n);
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). 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
   `ios_base::failure` [[iostate.flags]]).
 ``` cpp
 streamsize readsome(char_type* s, streamsize n);
 ```
 *Effects:* Behaves as an unformatted input function (as described
+above). 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`. If
 `rdbuf()->in_avail() == -1`, calls `setstate(eofbit)` (which may throw
 `ios_base::failure` [[iostate.flags]]), and extracts no characters;
 - If `rdbuf()->in_avail() > 0`, extracts `min(rdbuf()->in_avail(), n))`.
 *Returns:* The number of characters extracted.
 ``` cpp
+basic_istream& putback(char_type c);
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above), except that the function first clears `eofbit`. After
+constructing a `sentry` object, if `!good()` calls `setstate(failbit)`
 which may throw an exception, and return. If `rdbuf()` is not null,
 calls `rdbuf()->sputbackc(c)`. If `rdbuf()` is null, or if `sputbackc`
 returns `traits::eof()`, calls `setstate(badbit)` (which may throw
 `ios_base::failure` [[iostate.flags]]).
 [*Note 2*: This function extracts no characters, so the value returned
 by the next call to `gcount()` is 0. — *end note*]
 *Returns:* `*this`.
+``` cpp
+basic_istream& unget();
+```
+*Effects:* Behaves as an unformatted input function (as described
+above), except that the function first clears `eofbit`. After
+constructing a `sentry` object, if `!good()` calls `setstate(failbit)`
+which may throw an exception, and return. If `rdbuf()` is not null,
+calls `rdbuf()->sungetc()`. If `rdbuf()` is null, or if `sungetc`
+returns `traits::eof()`, calls `setstate(badbit)` (which may throw
+`ios_base::failure` [[iostate.flags]]).
+[*Note 3*: This function extracts no characters, so the value returned
+by the next call to `gcount()` is 0. — *end note*]
+*Returns:* `*this`.
 ``` cpp
 int sync();
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above), except that it does not count the number of characters extracted
 and does not affect the value returned by subsequent calls to
+`gcount()`. After constructing a `sentry` object, if `rdbuf()` is a null
 pointer, returns `-1`. Otherwise, calls `rdbuf()->pubsync()` and, if
 that function returns `-1` calls `setstate(badbit)` (which may throw
 `ios_base::failure` [[iostate.flags]], and returns `-1`. Otherwise,
 returns zero.
 *Effects:* Behaves as an unformatted input function (as described
 above), except that it does not count the number of characters extracted
 and does not affect the value returned by subsequent calls to
 `gcount()`.
+*Returns:* After constructing a `sentry` object, if `fail() != false`,
 returns `pos_type(-1)` to indicate failure. Otherwise, returns
 `rdbuf()->pubseekoff(0, cur, in)`.
 ``` cpp
+basic_istream& seekg(pos_type pos);
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above), except that the function first clears `eofbit`, it does not
 count the number of characters extracted, and it does not affect the
 value returned by subsequent calls to `gcount()`. After constructing a
+`sentry` object, if `fail() != true`, executes
 `rdbuf()->pubseekpos(pos, ios_base::in)`. In case of failure, the
 function calls `setstate(failbit)` (which may throw
 `ios_base::failure`).
 *Returns:* `*this`.
 ``` cpp
+basic_istream& seekg(off_type off, ios_base::seekdir dir);
 ```
 *Effects:* Behaves as an unformatted input function (as described
 above), except that the function first clears `eofbit`, does not count
 the number of characters extracted, and does not affect the value
+returned by subsequent calls to `gcount()`. After constructing a
+`sentry` object, if `fail() != true`, executes
 `rdbuf()->pubseekoff(off, dir, ios_base::in)`. In case of failure, the
 function calls `setstate(failbit)` (which may throw
 `ios_base::failure`).
 *Returns:* `*this`.
 ```
 *Effects:* Behaves as an unformatted input
 function [[istream.unformatted]], except that it does not count the
 number of characters extracted and does not affect the value returned by
+subsequent calls to `is.gcount()`. After constructing a `sentry` object
 extracts characters as long as the next available character `c` is
 whitespace or until there are no more characters in the sequence.
 Whitespace characters are distinguished with the same criterion as used
 by `sentry::sentry` [[istream.sentry]]. If `ws` stops extracting
 characters because there are no more available it sets `eofbit`, but not
 template<class Istream, class T>
   Istream&& operator>>(Istream&& is, T&& x);
 ```
 *Constraints:* The expression `is >> std::forward<T>(x)` is well-formed
+when treated as an unevaluated operand [[term.unevaluated.operand]] and
+`Istream` is publicly and unambiguously derived from `ios_base`.
 *Effects:* Equivalent to:
 ``` cpp
 is >> std::forward<T>(x);
 return std::move(is);
 ```
 #### Class template `basic_iostream` <a id="iostreamclass">[[iostreamclass]]</a>
+##### General <a id="iostreamclass.general">[[iostreamclass.general]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_iostream
     : public basic_istream<charT, traits>,
   protected:
     // [iostream.cons], constructor
     basic_iostream(const basic_iostream&) = delete;
     basic_iostream(basic_iostream&& rhs);
+    // [iostream.assign], assignment and swap
     basic_iostream& operator=(const basic_iostream&) = delete;
     basic_iostream& operator=(basic_iostream&& rhs);
     void swap(basic_iostream& rhs);
   };
 }
 ``` cpp
 basic_iostream(basic_iostream&& rhs);
 ```
 *Effects:* Move constructs from the rvalue `rhs` by constructing the
+`basic_istream` base class with `std::move(rhs)`.
 ##### Destructor <a id="iostream.dest">[[iostream.dest]]</a>
 ``` cpp
 virtual ~basic_iostream();

Diff to HTML by rtfpessoa