[iostream.format] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpwo0e7b8y/{from.md → to.md} +173 -97

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

@@ -2,40 +2,46 @@
 ### Header `<istream>` synopsis <a id="istream.syn">[[istream.syn]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
     class basic_istream;
   using istream  = basic_istream<char>;
   using wistream = basic_istream<wchar_t>;
   template<class charT, class traits = char_traits<charT>>
     class basic_iostream;
   using iostream  = basic_iostream<char>;
   using wiostream = basic_iostream<wchar_t>;
   template<class charT, class traits>
     basic_istream<charT, traits>& ws(basic_istream<charT, traits>& is);
   template<class Istream, class T>
     Istream&& operator>>(Istream&& is, T&& x);
 }
 ```
 ### Header `<ostream>` synopsis <a id="ostream.syn">[[ostream.syn]]</a>
 ``` cpp
 namespace std {
   template<class charT, class traits = char_traits<charT>>
     class basic_ostream;
   using ostream  = basic_ostream<char>;
   using wostream = basic_ostream<wchar_t>;
   template<class charT, class traits>
     basic_ostream<charT, traits>& endl(basic_ostream<charT, traits>& os);
   template<class charT, class traits>
     basic_ostream<charT, traits>& ends(basic_ostream<charT, traits>& os);
   template<class charT, class traits>
@@ -46,39 +52,45 @@ namespace std {
   template<class charT, class traits>
     basic_ostream<charT, traits>& noemit_on_flush(basic_ostream<charT, traits>& os);
   template<class charT, class traits>
     basic_ostream<charT, traits>& flush_emit(basic_ostream<charT, traits>& os);
   template<class Ostream, class T>
     Ostream&& operator<<(Ostream&& os, const T& x);
   // [ostream.formatted.print], print functions
   template<class... Args>
     void print(ostream& os, format_string<Args...> fmt, Args&&... args);
   template<class... Args>
     void println(ostream& os, format_string<Args...> fmt, Args&&... args);
   void vprint_unicode(ostream& os, string_view fmt, format_args args);
   void vprint_nonunicode(ostream& os, string_view fmt, format_args args);
 }
 ```
 ### Header `<iomanip>` synopsis <a id="iomanip.syn">[[iomanip.syn]]</a>
 ``` cpp
 namespace std {
   unspecified resetiosflags(ios_base::fmtflags mask);
   unspecified setiosflags  (ios_base::fmtflags mask);
   unspecified setbase(int base);
   template<class charT> unspecified setfill(charT c);
   unspecified setprecision(int n);
   unspecified setw(int n);
   template<class moneyT> unspecified get_money(moneyT& mon, bool intl = false);
   template<class moneyT> unspecified put_money(const moneyT& mon, bool intl = false);
   template<class charT> unspecified get_time(tm* tmb, const charT* fmt);
   template<class charT> unspecified put_time(const tm* tmb, const charT* fmt);
   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,
@@ -104,18 +116,22 @@ namespace std {
   template<class... Args>
     void print(FILE* stream, format_string<Args...> fmt, Args&&... args);
   template<class... Args>
     void println(format_string<Args...> fmt, Args&&... args);
   template<class... Args>
     void println(FILE* stream, format_string<Args...> fmt, Args&&... args);
   void vprint_unicode(string_view fmt, format_args args);
   void vprint_unicode(FILE* stream, string_view fmt, format_args args);
   void vprint_nonunicode(string_view fmt, format_args args);
   void vprint_nonunicode(FILE* stream, string_view fmt, format_args args);
 }
 ```
 ### Input streams <a id="input.streams">[[input.streams]]</a>
@@ -139,13 +155,13 @@ namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_istream : virtual public basic_ios<charT, traits> {
   public:
     // types (inherited from basic_ios[ios])
     using char_type   = charT;
-    using int_type    = typename traits::int_type;
-    using pos_type    = typename traits::pos_type;
-    using off_type    = typename traits::off_type;
     using traits_type = traits;
     // [istream.cons], constructor/destructor
     explicit basic_istream(basic_streambuf<charT, traits>* sb);
     virtual ~basic_istream();
@@ -186,10 +202,11 @@ namespace std {
     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);
@@ -267,11 +284,11 @@ virtual ~basic_istream();
 ``` cpp
 basic_istream& operator=(basic_istream&& rhs);
 ```
-*Effects:* Equivalent to: `swap(rhs)`.
 *Returns:* `*this`.
 ``` cpp
 void swap(basic_istream& rhs);
@@ -339,12 +356,12 @@ const ctype<charT>& ctype = use_facet<ctype<charT>>(is.getloc());
 if (ctype.is(ctype.space, c) != 0)
   // c is a whitespace character.
 ```
 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]]).[^19]
 ``` cpp
 ~sentry();
 ```
@@ -353,11 +370,11 @@ constructor may call `setstate(failbit)` (which may throw
 ``` cpp
 explicit operator bool() const;
 ```
-*Returns:* `ok_`.
 #### Formatted input functions <a id="istream.formatted">[[istream.formatted]]</a>
 ##### Common requirements <a id="istream.formatted.reqmts">[[istream.formatted.reqmts]]</a>
@@ -791,11 +808,11 @@ int main() {
 ``` 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());
 ```
@@ -803,11 +820,11 @@ basic_istream& ignore(streamsize n = 1, int_type delim = traits::eof());
 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
 - 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).
@@ -815,10 +832,19 @@ occurs:
 [*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
@@ -1006,13 +1032,13 @@ namespace std {
   class basic_iostream
     : public basic_istream<charT, traits>,
       public basic_ostream<charT, traits> {
   public:
     using char_type   = charT;
-    using int_type    = typename traits::int_type;
-    using pos_type    = typename traits::pos_type;
-    using off_type    = typename traits::off_type;
     using traits_type = traits;
     // [iostream.cons], constructor
     explicit basic_iostream(basic_streambuf<charT, traits>* sb);
@@ -1067,11 +1093,11 @@ virtual ~basic_iostream();
 ``` cpp
 basic_iostream& operator=(basic_iostream&& rhs);
 ```
-*Effects:* Equivalent to: `swap(rhs)`.
 ``` cpp
 void swap(basic_iostream& rhs);
 ```
@@ -1098,13 +1124,13 @@ namespace std {
   template<class charT, class traits = char_traits<charT>>
   class basic_ostream : virtual public basic_ios<charT, traits> {
   public:
     // types (inherited from basic_ios[ios])
     using char_type   = charT;
-    using int_type    = typename traits::int_type;
-    using pos_type    = typename traits::pos_type;
-    using off_type    = typename traits::off_type;
     using traits_type = traits;
     // [ostream.cons], constructor/destructor
     explicit basic_ostream(basic_streambuf<char_type, traits>* sb);
     virtual ~basic_ostream();
@@ -1276,11 +1302,11 @@ virtual ~basic_ostream();
 ``` cpp
 basic_ostream& operator=(basic_ostream&& rhs);
 ```
-*Effects:* Equivalent to: `swap(rhs)`.
 *Returns:* `*this`.
 ``` cpp
 void swap(basic_ostream& rhs);
@@ -1316,28 +1342,29 @@ explicit sentry(basic_ostream& 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();
 ```
 If
 `(os.flags() & ios_base::unitbuf) && !uncaught_exceptions() && os.good()`
-is `true`, calls `os.rdbuf()->pubsync()`. If that function returns -1,
-sets `badbit` in `os.rdstate()` without propagating an exception.
 ``` cpp
 explicit operator bool() const;
 ```
-*Effects:* Returns `ok_`.
 ##### Seek members <a id="ostream.seeks">[[ostream.seeks]]</a>
 Each seek member function begins execution by constructing an object of
 class `sentry`. It returns by destroying the `sentry` object.
@@ -1392,16 +1419,16 @@ 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
 basic_ostream& operator<<(bool val);
@@ -1426,59 +1453,52 @@ When `val` is of type `bool`, `long`, `unsigned long`, `long long`,
 `unsigned long long`, `double`, `long double`, or `const void*`, the
 formatting conversion occurs as if it performed the following code
 fragment:
 ``` cpp
-bool failed = use_facet<
- num_put<charT, ostreambuf_iterator<charT, traits>>
-    >(getloc()).put(*this, *this, fill(), val).failed();
 ```
 When `val` is of type `short` the formatting conversion occurs as if it
 performed the following code fragment:
 ``` cpp
 ios_base::fmtflags baseflags = ios_base::flags() & ios_base::basefield;
-bool failed = use_facet<
- num_put<charT, ostreambuf_iterator<charT, traits>>
-    >(getloc()).put(*this, *this, fill(),
     baseflags == ios_base::oct || baseflags == ios_base::hex
       ? static_cast<long>(static_cast<unsigned short>(val))
       : static_cast<long>(val)).failed();
 ```
 When `val` is of type `int` the formatting conversion occurs as if it
 performed the following code fragment:
 ``` cpp
 ios_base::fmtflags baseflags = ios_base::flags() & ios_base::basefield;
-bool failed = use_facet<
- num_put<charT, ostreambuf_iterator<charT, traits>>
-    >(getloc()).put(*this, *this, fill(),
     baseflags == ios_base::oct || baseflags == ios_base::hex
       ? static_cast<long>(static_cast<unsigned int>(val))
       : static_cast<long>(val)).failed();
 ```
 When `val` is of type `unsigned short` or `unsigned int` the formatting
 conversion occurs as if it performed the following code fragment:
 ``` cpp
-bool failed = use_facet<
- num_put<charT, ostreambuf_iterator<charT, traits>>
-    >(getloc()).put(*this, *this, fill(),
-      static_cast<unsigned long>(val)).failed();
 ```
 When `val` is of type `float` the formatting conversion occurs as if it
 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>(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
@@ -1506,26 +1526,22 @@ basic_ostream& operator<<(extended-floating-point-type val);
 *`extended-floating-point-type`* is less than or equal to that of
 `double`, the formatting conversion occurs as if it 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>(val)).failed();
 ```
 Otherwise, if the floating-point conversion rank of
 *`extended-floating-point-type`* is less than or equal to that of
 `long double`, the formatting conversion occurs as if it performed the
 following code fragment:
 ``` cpp
-bool failed = use_facet<
- num_put<charT, ostreambuf_iterator<charT, traits>>
-    >(getloc()).put(*this, *this, fill(),
-      static_cast<long double>(val)).failed();
 ```
 Otherwise, an invocation of the operator function is conditionally
 supported with *implementation-defined* semantics.
@@ -1619,15 +1635,15 @@ 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>
@@ -1677,28 +1693,38 @@ template<class... Args>
 *Effects:* If the ordinary literal encoding [[lex.charset]] is UTF-8,
 equivalent to:
 ``` cpp
-vprint_unicode(os, fmt.str, make_format_args(std::forward<Args>(args)...));
 ```
 Otherwise, equivalent to:
 ``` cpp
-vprint_nonunicode(os, fmt.str, make_format_args(std::forward<Args>(args)...));
 ```
 ``` cpp
 template<class... Args>
   void println(ostream& os, format_string<Args...> fmt, Args&&... args);
 ```
 *Effects:* Equivalent to:
 ``` cpp
-print(os, "{}\n", format(fmt, std::forward<Args>(args)...));
 ```
 ``` cpp
 void vprint_unicode(ostream& os, string_view fmt, format_args args);
 void vprint_nonunicode(ostream& os, string_view fmt, format_args args);
@@ -1710,28 +1736,29 @@ function [[ostream.formatted.reqmts]] of `os`, except that:
 - failure to generate output is reported as specified below, and
 - any exception thrown by the call to `vformat` is propagated without
   regard to the value of `os.exceptions()` and without turning on
   `ios_base::badbit` in the error state of `os`.
-After constructing a `sentry` object, the function initializes an
-automatic variable via
 ``` cpp
 string out = vformat(os.getloc(), fmt, args);
 ```
-If the function is `vprint_unicode` and `os` is a stream that refers to
-a terminal capable of displaying Unicode which is determined in an
-implementation-defined manner, writes `out` to the terminal using the
-native Unicode API; if `out` contains invalid code units, the behavior
-is undefined and implementations are encouraged to diagnose it. If the
-native Unicode API is used, the function flushes `os` before writing
-`out`. Otherwise (if `os` is not such a stream or the function is
-`vprint_nonunicode`), inserts the character sequence \[`out.begin()`,
-`out.end()`) into `os`. If writing to the terminal or inserting into
-`os` fails, calls `os.setstate(ios_base::badbit)` (which may throw
-`ios_base::failure`).
 *Recommended practice:* For `vprint_unicode`, if invoking the native
 Unicode API requires transcoding, implementations should substitute
 invalid code units with U+fffd (replacement character) per the Unicode
 Standard, Chapter 3.9 ‘U+fffd‘ Substitution in Conversion.
@@ -1792,11 +1819,11 @@ object. If that object returns `true` when converted to a value of type
 [[iostate.flags]]). Otherwise, if the `sentry` object returns `false`,
 does nothing.
 *Returns:* `*this`.
-#### Standard manipulators <a id="ostream.manip">[[ostream.manip]]</a>
 Each instantiation of any of the function templates specified in this
 subclause is a designated addressable function [[namespace.std]].
 ``` cpp
@@ -1838,11 +1865,11 @@ of exposition, calls `buf->set_emit_on_sync(true)`. Otherwise this
 manipulator has no effect.
 [*Note 1*: To work around the issue that the `Allocator` template
 argument cannot be deduced, implementations can introduce an
 intermediate base class to `basic_syncbuf` that manages its
-`emit_on_sync` flag. — *end note*]
 *Returns:* `os`.
 ``` cpp
 template<class charT, class traits>
@@ -2255,21 +2282,27 @@ print(stdout, fmt, std::forward<Args>(args)...);
 ``` cpp
 template<class... Args>
   void print(FILE* stream, format_string<Args...> fmt, Args&&... args);
 ```
-*Effects:* If the ordinary literal encoding [[lex.charset]] is UTF-8,
-equivalent to:
 ``` cpp
-vprint_unicode(stream, fmt.str, make_format_args(std::forward<Args>(args)...));
 ```
 Otherwise, equivalent to:
 ``` cpp
-vprint_nonunicode(stream, fmt.str, make_format_args(std::forward<Args>(args)...));
 ```
 ``` cpp
 template<class... Args>
   void println(format_string<Args...> fmt, Args&&... args);
@@ -2279,19 +2312,39 @@ template<class... Args>
 ``` cpp
 println(stdout, fmt, std::forward<Args>(args)...);
 ```
 ``` cpp
 template<class... Args>
   void println(FILE* stream, format_string<Args...> fmt, Args&&... args);
 ```
 *Effects:* Equivalent to:
 ``` cpp
-print(stream, "{}\n", format(fmt, std::forward<Args>(args)...));
 ```
 ``` cpp
 void vprint_unicode(string_view fmt, format_args args);
 ```
@@ -2300,37 +2353,47 @@ void vprint_unicode(string_view fmt, format_args args);
 ``` cpp
 vprint_unicode(stdout, fmt, args);
 ```
 ``` cpp
 void vprint_unicode(FILE* stream, string_view fmt, format_args args);
 ```
 *Preconditions:* `stream` is a valid pointer to an output C stream.
-*Effects:* The function initializes an automatic variable via
-``` cpp
-string out = vformat(fmt, args);
-```
-If `stream` refers to a terminal capable of displaying Unicode, writes
-`out` to the terminal using the native Unicode API; if `out` contains
-invalid code units, the behavior is undefined and implementations are
-encouraged to diagnose it. Otherwise writes `out` to `stream` unchanged.
-If the native Unicode API is used, the function flushes `stream` before
-writing `out`.
-[*Note 1*: On POSIX and Windows, `stream` referring to a terminal means
-that, respectively, `isatty(fileno(stream))` and
-`GetConsoleMode(_get_osfhandle(_fileno(stream)), ...)` return
 nonzero. — *end note*]
-[*Note 2*: On Windows, the native Unicode API is
-`WriteConsoleW`. — *end note*]
 *Throws:* Any exception thrown by the call to `vformat`
 [[format.err.report]]. `system_error` if writing to the terminal or
 `stream` fails. May throw `bad_alloc`.
 *Recommended practice:* If invoking the native Unicode API requires
@@ -2346,17 +2409,30 @@ void vprint_nonunicode(string_view fmt, format_args args);
 ``` cpp
 vprint_nonunicode(stdout, fmt, args);
 ```
 ``` cpp
 void vprint_nonunicode(FILE* stream, string_view fmt, format_args args);
 ```
 *Preconditions:* `stream` is a valid pointer to an output C stream.
-*Effects:* Writes the result of `vformat(fmt, args)` to `stream`.
 *Throws:* Any exception thrown by the call to `vformat`
 [[format.err.report]]. `system_error` if writing to `stream` fails. May
 throw `bad_alloc`.

 ### Header `<istream>` synopsis <a id="istream.syn">[[istream.syn]]</a>
 ``` cpp
 namespace std {
+  // [istream], class template basic_istream
   template<class charT, class traits = char_traits<charT>>
     class basic_istream;
   using istream  = basic_istream<char>;
   using wistream = basic_istream<wchar_t>;
+  // [iostreamclass], class template basic_iostream
   template<class charT, class traits = char_traits<charT>>
     class basic_iostream;
   using iostream  = basic_iostream<char>;
   using wiostream = basic_iostream<wchar_t>;
+  // [istream.manip], standard basic_istream manipulators
   template<class charT, class traits>
     basic_istream<charT, traits>& ws(basic_istream<charT, traits>& is);
+  // [istream.rvalue], rvalue stream extraction
   template<class Istream, class T>
     Istream&& operator>>(Istream&& is, T&& x);
 }
 ```
 ### Header `<ostream>` synopsis <a id="ostream.syn">[[ostream.syn]]</a>
 ``` cpp
 namespace std {
+  // [ostream], class template basic_ostream
   template<class charT, class traits = char_traits<charT>>
     class basic_ostream;
   using ostream  = basic_ostream<char>;
   using wostream = basic_ostream<wchar_t>;
+  // [ostream.manip], standard basic_ostream manipulators
   template<class charT, class traits>
     basic_ostream<charT, traits>& endl(basic_ostream<charT, traits>& os);
   template<class charT, class traits>
     basic_ostream<charT, traits>& ends(basic_ostream<charT, traits>& os);
   template<class charT, class traits>
   template<class charT, class traits>
     basic_ostream<charT, traits>& noemit_on_flush(basic_ostream<charT, traits>& os);
   template<class charT, class traits>
     basic_ostream<charT, traits>& flush_emit(basic_ostream<charT, traits>& os);
+  // [ostream.rvalue], rvalue stream insertion
   template<class Ostream, class T>
     Ostream&& operator<<(Ostream&& os, const T& x);
   // [ostream.formatted.print], print functions
   template<class... Args>
     void print(ostream& os, format_string<Args...> fmt, Args&&... args);
   template<class... Args>
     void println(ostream& os, format_string<Args...> fmt, Args&&... args);
+  void println(ostream& os);
   void vprint_unicode(ostream& os, string_view fmt, format_args args);
   void vprint_nonunicode(ostream& os, string_view fmt, format_args args);
 }
 ```
 ### Header `<iomanip>` synopsis <a id="iomanip.syn">[[iomanip.syn]]</a>
 ``` cpp
 namespace std {
+  // [std.manip], standard manipulators
   unspecified resetiosflags(ios_base::fmtflags mask);
   unspecified setiosflags  (ios_base::fmtflags mask);
   unspecified setbase(int base);
   template<class charT> unspecified setfill(charT c);
   unspecified setprecision(int n);
   unspecified setw(int n);
+  // [ext.manip], extended manipulators
   template<class moneyT> unspecified get_money(moneyT& mon, bool intl = false);
   template<class moneyT> unspecified put_money(const moneyT& mon, bool intl = false);
   template<class charT> unspecified get_time(tm* tmb, const charT* fmt);
   template<class charT> unspecified put_time(const tm* tmb, const charT* fmt);
+  // [quoted.manip], quoted manipulators
   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,
   template<class... Args>
     void print(FILE* stream, format_string<Args...> fmt, Args&&... args);
   template<class... Args>
     void println(format_string<Args...> fmt, Args&&... args);
+  void println();
   template<class... Args>
     void println(FILE* stream, format_string<Args...> fmt, Args&&... args);
+  void println(FILE* stream);
   void vprint_unicode(string_view fmt, format_args args);
   void vprint_unicode(FILE* stream, string_view fmt, format_args args);
+  void vprint_unicode_buffered(FILE* stream, string_view fmt, format_args args);
   void vprint_nonunicode(string_view fmt, format_args args);
   void vprint_nonunicode(FILE* stream, string_view fmt, format_args args);
+  void vprint_nonunicode_buffered(FILE* stream, string_view fmt, format_args args);
 }
 ```
 ### Input streams <a id="input.streams">[[input.streams]]</a>
   template<class charT, class traits = char_traits<charT>>
   class basic_istream : virtual public basic_ios<charT, traits> {
   public:
     // types (inherited from basic_ios[ios])
     using char_type   = charT;
+    using int_type    = traits::int_type;
+    using pos_type    = traits::pos_type;
+    using off_type    = traits::off_type;
     using traits_type = traits;
     // [istream.cons], constructor/destructor
     explicit basic_istream(basic_streambuf<charT, traits>* sb);
     virtual ~basic_istream();
     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());
+    basic_istream& ignore(streamsize n, char_type delim);
     int_type       peek();
     basic_istream& read    (char_type* s, streamsize n);
     streamsize     readsome(char_type* s, streamsize n);
     basic_istream& putback(char_type c);
 ``` cpp
 basic_istream& operator=(basic_istream&& rhs);
 ```
+*Effects:* Equivalent to `swap(rhs)`.
 *Returns:* `*this`.
 ``` cpp
 void swap(basic_istream& rhs);
 if (ctype.is(ctype.space, c) != 0)
   // c is a whitespace character.
 ```
 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]]).[^19]
 ``` cpp
 ~sentry();
 ```
 ``` cpp
 explicit operator bool() const;
 ```
+*Returns:* *ok\_*.
 #### Formatted input functions <a id="istream.formatted">[[istream.formatted]]</a>
 ##### Common requirements <a id="istream.formatted.reqmts">[[istream.formatted.reqmts]]</a>
 ``` 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());
 ```
 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;
 - 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).
 [*Note 1*: The last condition will never occur if
 `traits::eq_int_type(delim, traits::eof())`. — *end note*]
 *Returns:* `*this`.
+``` cpp
+basic_istream& ignore(streamsize n, char_type delim);
+```
+*Constraints:* `is_same_v<char_type, char>` is `true`.
+*Effects:* Equivalent to:
+`return ignore(n, traits::to_int_type(delim));`
 ``` cpp
 int_type peek();
 ```
 *Effects:* Behaves as an unformatted input function (as described
   class basic_iostream
     : public basic_istream<charT, traits>,
       public basic_ostream<charT, traits> {
   public:
     using char_type   = charT;
+    using int_type    = traits::int_type;
+    using pos_type    = traits::pos_type;
+    using off_type    = traits::off_type;
     using traits_type = traits;
     // [iostream.cons], constructor
     explicit basic_iostream(basic_streambuf<charT, traits>* sb);
 ``` cpp
 basic_iostream& operator=(basic_iostream&& rhs);
 ```
+*Effects:* Equivalent to `swap(rhs)`.
 ``` cpp
 void swap(basic_iostream& rhs);
 ```
   template<class charT, class traits = char_traits<charT>>
   class basic_ostream : virtual public basic_ios<charT, traits> {
   public:
     // types (inherited from basic_ios[ios])
     using char_type   = charT;
+    using int_type    = traits::int_type;
+    using pos_type    = traits::pos_type;
+    using off_type    = traits::off_type;
     using traits_type = traits;
     // [ostream.cons], constructor/destructor
     explicit basic_ostream(basic_streambuf<char_type, traits>* sb);
     virtual ~basic_ostream();
 ``` cpp
 basic_ostream& operator=(basic_ostream&& rhs);
 ```
+*Effects:* Equivalent to `swap(rhs)`.
 *Returns:* `*this`.
 ``` cpp
 void swap(basic_ostream& rhs);
 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();
 ```
 If
 `(os.flags() & ios_base::unitbuf) && !uncaught_exceptions() && os.good()`
+is `true`, calls `os.rdbuf()->pubsync()`. If that function returns -1 or
+exits via an exception, sets `badbit` in `os.rdstate()` without
+propagating an exception.
 ``` cpp
 explicit operator bool() const;
 ```
+*Effects:* Returns *ok\_*.
 ##### Seek members <a id="ostream.seeks">[[ostream.seeks]]</a>
 Each seek member function begins execution by constructing an object of
 class `sentry`. It returns by destroying the `sentry` object.
 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 container 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
 basic_ostream& operator<<(bool val);
 `unsigned long long`, `double`, `long double`, or `const void*`, the
 formatting conversion occurs as if it performed the following code
 fragment:
 ``` cpp
+bool failed = use_facet<num_put<charT, ostreambuf_iterator<charT, traits>>>(
+ getloc()).put(*this, *this, fill(), val).failed();
 ```
 When `val` is of type `short` the formatting conversion occurs as if it
 performed the following code fragment:
 ``` cpp
 ios_base::fmtflags baseflags = ios_base::flags() & ios_base::basefield;
+bool failed = use_facet<num_put<charT, ostreambuf_iterator<charT, traits>>>(
+ getloc()).put(*this, *this, fill(),
     baseflags == ios_base::oct || baseflags == ios_base::hex
       ? static_cast<long>(static_cast<unsigned short>(val))
       : static_cast<long>(val)).failed();
 ```
 When `val` is of type `int` the formatting conversion occurs as if it
 performed the following code fragment:
 ``` cpp
 ios_base::fmtflags baseflags = ios_base::flags() & ios_base::basefield;
+bool failed = use_facet<num_put<charT, ostreambuf_iterator<charT, traits>>>(
+ getloc()).put(*this, *this, fill(),
     baseflags == ios_base::oct || baseflags == ios_base::hex
       ? static_cast<long>(static_cast<unsigned int>(val))
       : static_cast<long>(val)).failed();
 ```
 When `val` is of type `unsigned short` or `unsigned int` the formatting
 conversion occurs as if it performed the following code fragment:
 ``` cpp
+bool failed = use_facet<num_put<charT, ostreambuf_iterator<charT, traits>>>(
+ getloc()).put(*this, *this, fill(), static_cast<unsigned long>(val)).failed();
 ```
 When `val` is of type `float` the formatting conversion occurs as if it
 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>(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
 *`extended-floating-point-type`* is less than or equal to that of
 `double`, the formatting conversion occurs as if it 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>(val)).failed();
 ```
 Otherwise, if the floating-point conversion rank of
 *`extended-floating-point-type`* is less than or equal to that of
 `long double`, the formatting conversion occurs as if it performed the
 following code fragment:
 ``` cpp
+bool failed = use_facet<num_put<charT, ostreambuf_iterator<charT, traits>>>(
+ getloc()).put(*this, *this, fill(), static_cast<long double>(val)).failed();
 ```
 Otherwise, an invocation of the operator function is conditionally
 supported with *implementation-defined* semantics.
   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 container 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>
 *Effects:* If the ordinary literal encoding [[lex.charset]] is UTF-8,
 equivalent to:
 ``` cpp
+vprint_unicode(os, fmt.str, make_format_args(args...));
 ```
 Otherwise, equivalent to:
 ``` cpp
+vprint_nonunicode(os, fmt.str, make_format_args(args...));
 ```
 ``` cpp
 template<class... Args>
   void println(ostream& os, format_string<Args...> fmt, Args&&... args);
 ```
 *Effects:* Equivalent to:
 ``` cpp
+print(os, "{}\n", format(os.getloc(), fmt, std::forward<Args>(args)...));
+```
+``` cpp
+void println(ostream& os);
+```
+*Effects:* Equivalent to:
+``` cpp
+print(os, "\n");
 ```
 ``` cpp
 void vprint_unicode(ostream& os, string_view fmt, format_args args);
 void vprint_nonunicode(ostream& os, string_view fmt, format_args args);
 - failure to generate output is reported as specified below, and
 - any exception thrown by the call to `vformat` is propagated without
   regard to the value of `os.exceptions()` and without turning on
   `ios_base::badbit` in the error state of `os`.
+After constructing a `sentry` object, the function initializes a
+variable with automatic storage duration via
 ``` cpp
 string out = vformat(os.getloc(), fmt, args);
 ```
+- If the function is `vprint_unicode` and `os` is a stream that refers
+  to a terminal that is capable of displaying Unicode only via a native
+  Unicode API, which is determined in an implementation-defined manner,
+  flushes `os` and then writes `out` to the terminal using the native
+  Unicode API; if `out` contains invalid code units, the behavior is
+  undefined. Then establishes an observable
+  checkpoint [[intro.abstract]].
+- Otherwise inserts the character sequence \[`out.begin()`, `out.end()`)
+ into `os`.
+If writing to the terminal or inserting into `os` fails, calls
+`os.setstate(ios_base::badbit)` (which may throw `ios_base::failure`).
 *Recommended practice:* For `vprint_unicode`, if invoking the native
 Unicode API requires transcoding, implementations should substitute
 invalid code units with U+fffd (replacement character) per the Unicode
 Standard, Chapter 3.9 ‘U+fffd‘ Substitution in Conversion.
 [[iostate.flags]]). Otherwise, if the `sentry` object returns `false`,
 does nothing.
 *Returns:* `*this`.
+#### Standard `basic_ostream` manipulators <a id="ostream.manip">[[ostream.manip]]</a>
 Each instantiation of any of the function templates specified in this
 subclause is a designated addressable function [[namespace.std]].
 ``` cpp
 manipulator has no effect.
 [*Note 1*: To work around the issue that the `Allocator` template
 argument cannot be deduced, implementations can introduce an
 intermediate base class to `basic_syncbuf` that manages its
+*emit-on-sync* flag. — *end note*]
 *Returns:* `os`.
 ``` cpp
 template<class charT, class traits>
 ``` cpp
 template<class... Args>
   void print(FILE* stream, format_string<Args...> fmt, Args&&... args);
 ```
+*Effects:* Let `locksafe` be
+`(enable_nonlocking_formatter_optimization<remove_cvref_t<Args>> && ...)`.
+If the ordinary literal encoding [[lex.charset]] is UTF-8, equivalent
+to:
 ``` cpp
+locksafe
+  ? vprint_unicode(stream, fmt.str, make_format_args(args...))
+  : vprint_unicode_buffered(stream, fmt.str, make_format_args(args...));
 ```
 Otherwise, equivalent to:
 ``` cpp
+locksafe
+  ? vprint_nonunicode(stream, fmt.str, make_format_args(args...))
+  : vprint_nonunicode_buffered(stream, fmt.str, make_format_args(args...));
 ```
 ``` cpp
 template<class... Args>
   void println(format_string<Args...> fmt, Args&&... args);
 ``` cpp
 println(stdout, fmt, std::forward<Args>(args)...);
 ```
+``` cpp
+void println();
+```
+*Effects:* Equivalent to:
+``` cpp
+println(stdout);
+```
 ``` cpp
 template<class... Args>
   void println(FILE* stream, format_string<Args...> fmt, Args&&... args);
 ```
 *Effects:* Equivalent to:
 ``` cpp
+print(stream, runtime_format(string(fmt.get()) + '\n'), std::forward<Args>(args)...);
+```
+``` cpp
+void println(FILE* stream);
+```
+*Effects:* Equivalent to:
+``` cpp
+print(stream, "\n");
 ```
 ``` cpp
 void vprint_unicode(string_view fmt, format_args args);
 ```
 ``` cpp
 vprint_unicode(stdout, fmt, args);
 ```
+``` cpp
+void vprint_unicode_buffered(FILE* stream, string_view fmt, format_args args);
+```
+*Effects:* Equivalent to:
+``` cpp
+string out = vformat(fmt, args);
+vprint_unicode(stream, "{}", make_format_args(out));
+```
 ``` cpp
 void vprint_unicode(FILE* stream, string_view fmt, format_args args);
 ```
 *Preconditions:* `stream` is a valid pointer to an output C stream.
+*Effects:* Locks `stream`. Let `out` denote the character representation
+of formatting arguments provided by `args` formatted according to
+specifications given in `fmt`.
+- If `stream` refers to a terminal that is capable of displaying Unicode
+  only via a native Unicode API, flushes `stream` and then writes `out`
+  to the terminal using the native Unicode API; if `out` contains
+  invalid code units, the behavior is undefined. Then establishes an
+  observable checkpoint [[intro.abstract]].
+- Otherwise writes `out` to `stream` unchanged.
+Unconditionally unlocks `stream` on function exit.
+See also: ISO C 7.23.2.
+[*Note 1*: On Windows the native Unicode API is `WriteConsoleW` and
+`stream` referring to a terminal means that
+`GetConsoleMode(_get_osfhandle(_fileno(stream)), ...)` returns
 nonzero. — *end note*]
 *Throws:* Any exception thrown by the call to `vformat`
 [[format.err.report]]. `system_error` if writing to the terminal or
 `stream` fails. May throw `bad_alloc`.
 *Recommended practice:* If invoking the native Unicode API requires
 ``` cpp
 vprint_nonunicode(stdout, fmt, args);
 ```
+``` cpp
+void vprint_nonunicode_buffered(FILE* stream, string_view fmt, format_args args);
+```
+*Effects:* Equivalent to:
+``` cpp
+string out = vformat(fmt, args);
+vprint_nonunicode("{}", make_format_args(out));
+```
 ``` cpp
 void vprint_nonunicode(FILE* stream, string_view fmt, format_args args);
 ```
 *Preconditions:* `stream` is a valid pointer to an output C stream.
+*Effects:* While holding the lock on `stream`, writes the character
+representation of formatting arguments provided by `args` formatted
+according to specifications given in `fmt` to `stream`.
 *Throws:* Any exception thrown by the call to `vformat`
 [[format.err.report]]. `system_error` if writing to `stream` fails. May
 throw `bad_alloc`.

Diff to HTML by rtfpessoa