Home | History | Annotate | Download | only in include
      1 // -*- C++ -*-
      2 //===-------------------------- ostream -----------------------------------===//
      3 //
      4 //                     The LLVM Compiler Infrastructure
      5 //
      6 // This file is dual licensed under the MIT and the University of Illinois Open
      7 // Source Licenses. See LICENSE.TXT for details.
      8 //
      9 //===----------------------------------------------------------------------===//
     10 
     11 #ifndef _LIBCPP_OSTREAM
     12 #define _LIBCPP_OSTREAM
     13 
     14 /*
     15     ostream synopsis
     16 
     17 template <class charT, class traits = char_traits<charT> >
     18 class basic_ostream
     19     : virtual public basic_ios<charT,traits>
     20 {
     21 public:
     22     // types (inherited from basic_ios (27.5.4)):
     23     typedef charT                          char_type;
     24     typedef traits                         traits_type;
     25     typedef typename traits_type::int_type int_type;
     26     typedef typename traits_type::pos_type pos_type;
     27     typedef typename traits_type::off_type off_type;
     28 
     29     // 27.7.2.2 Constructor/destructor:
     30     explicit basic_ostream(basic_streambuf<char_type,traits>* sb);
     31     basic_ostream(basic_ostream&& rhs);
     32     virtual ~basic_ostream();
     33 
     34     // 27.7.2.3 Assign/swap
     35     basic_ostream& operator=(basic_ostream&& rhs);
     36     void swap(basic_ostream& rhs);
     37 
     38     // 27.7.2.4 Prefix/suffix:
     39     class sentry;
     40 
     41     // 27.7.2.6 Formatted output:
     42     basic_ostream& operator<<(basic_ostream& (*pf)(basic_ostream&));
     43     basic_ostream& operator<<(basic_ios<charT, traits>& (*pf)(basic_ios<charT,traits>&));
     44     basic_ostream& operator<<(ios_base& (*pf)(ios_base&));
     45     basic_ostream& operator<<(bool n);
     46     basic_ostream& operator<<(short n);
     47     basic_ostream& operator<<(unsigned short n);
     48     basic_ostream& operator<<(int n);
     49     basic_ostream& operator<<(unsigned int n);
     50     basic_ostream& operator<<(long n);
     51     basic_ostream& operator<<(unsigned long n);
     52     basic_ostream& operator<<(long long n);
     53     basic_ostream& operator<<(unsigned long long n);
     54     basic_ostream& operator<<(float f);
     55     basic_ostream& operator<<(double f);
     56     basic_ostream& operator<<(long double f);
     57     basic_ostream& operator<<(const void* p);
     58     basic_ostream& operator<<(basic_streambuf<char_type,traits>* sb);
     59 
     60     // 27.7.2.7 Unformatted output:
     61     basic_ostream& put(char_type c);
     62     basic_ostream& write(const char_type* s, streamsize n);
     63     basic_ostream& flush();
     64 
     65     // 27.7.2.5 seeks:
     66     pos_type tellp();
     67     basic_ostream& seekp(pos_type);
     68     basic_ostream& seekp(off_type, ios_base::seekdir);
     69 };
     70 
     71 // 27.7.2.6.4 character inserters
     72 
     73 template<class charT, class traits>
     74   basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, charT);
     75 
     76 template<class charT, class traits>
     77   basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, char);
     78 
     79 template<class traits>
     80   basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, char);
     81 
     82 // signed and unsigned
     83 
     84 template<class traits>
     85   basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, signed char);
     86 
     87 template<class traits>
     88   basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, unsigned char);
     89 
     90 // NTBS
     91 template<class charT, class traits>
     92   basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, const charT*);
     93 
     94 template<class charT, class traits>
     95   basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, const char*);
     96 
     97 template<class traits>
     98   basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, const char*);
     99 
    100 // signed and unsigned
    101 template<class traits>
    102 basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, const signed char*);
    103 
    104 template<class traits>
    105   basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, const unsigned char*);
    106 
    107 // swap:
    108 template <class charT, class traits>
    109   void swap(basic_ostream<charT, traits>& x, basic_ostream<charT, traits>& y);
    110 
    111 template <class charT, class traits>
    112   basic_ostream<charT,traits>& endl(basic_ostream<charT,traits>& os);
    113 
    114 template <class charT, class traits>
    115   basic_ostream<charT,traits>& ends(basic_ostream<charT,traits>& os);
    116 
    117 template <class charT, class traits>
    118   basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os);
    119 
    120 // rvalue stream insertion
    121 template <class charT, class traits, class T>
    122   basic_ostream<charT, traits>&
    123   operator<<(basic_ostream<charT, traits>&& os, const T& x);
    124 
    125 }  // std
    126 
    127 */
    128 
    129 #include <__config>
    130 #include <ios>
    131 #include <streambuf>
    132 #include <locale>
    133 #include <iterator>
    134 #include <bitset>
    135 
    136 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
    137 #pragma GCC system_header
    138 #endif
    139 
    140 _LIBCPP_BEGIN_NAMESPACE_STD
    141 
    142 template <class _CharT, class _Traits>
    143 class _LIBCPP_VISIBLE basic_ostream
    144     : virtual public basic_ios<_CharT, _Traits>
    145 {
    146 public:
    147     // types (inherited from basic_ios (27.5.4)):
    148     typedef _CharT                         char_type;
    149     typedef _Traits                        traits_type;
    150     typedef typename traits_type::int_type int_type;
    151     typedef typename traits_type::pos_type pos_type;
    152     typedef typename traits_type::off_type off_type;
    153 
    154     // 27.7.2.2 Constructor/destructor:
    155     explicit basic_ostream(basic_streambuf<char_type, traits_type>* __sb);
    156     virtual ~basic_ostream();
    157 protected:
    158 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    159     _LIBCPP_INLINE_VISIBILITY
    160     basic_ostream(basic_ostream&& __rhs);
    161 #endif
    162 
    163     // 27.7.2.3 Assign/swap
    164 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    165     _LIBCPP_INLINE_VISIBILITY
    166     basic_ostream& operator=(basic_ostream&& __rhs);
    167 #endif
    168     void swap(basic_ostream& __rhs);
    169 public:
    170 
    171     // 27.7.2.4 Prefix/suffix:
    172     class _LIBCPP_VISIBLE sentry;
    173 
    174     // 27.7.2.6 Formatted output:
    175     basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&));
    176     basic_ostream& operator<<(basic_ios<char_type, traits_type>&
    177                               (*__pf)(basic_ios<char_type,traits_type>&));
    178     basic_ostream& operator<<(ios_base& (*__pf)(ios_base&));
    179     basic_ostream& operator<<(bool __n);
    180     basic_ostream& operator<<(short __n);
    181     basic_ostream& operator<<(unsigned short __n);
    182     basic_ostream& operator<<(int __n);
    183     basic_ostream& operator<<(unsigned int __n);
    184     basic_ostream& operator<<(long __n);
    185     basic_ostream& operator<<(unsigned long __n);
    186     basic_ostream& operator<<(long long __n);
    187     basic_ostream& operator<<(unsigned long long __n);
    188     basic_ostream& operator<<(float __f);
    189     basic_ostream& operator<<(double __f);
    190     basic_ostream& operator<<(long double __f);
    191     basic_ostream& operator<<(const void* __p);
    192     basic_ostream& operator<<(basic_streambuf<char_type, traits_type>* __sb);
    193 
    194     // 27.7.2.7 Unformatted output:
    195     basic_ostream& put(char_type __c);
    196     basic_ostream& write(const char_type* __s, streamsize __n);
    197     basic_ostream& flush();
    198 
    199     // 27.7.2.5 seeks:
    200     pos_type tellp();
    201     basic_ostream& seekp(pos_type __pos);
    202     basic_ostream& seekp(off_type __off, ios_base::seekdir __dir);
    203 
    204 protected:
    205     _LIBCPP_ALWAYS_INLINE
    206     basic_ostream() {}  // extension, intentially does not initialize
    207 };
    208 
    209 template <class _CharT, class _Traits>
    210 class _LIBCPP_VISIBLE basic_ostream<_CharT, _Traits>::sentry
    211 {
    212     bool __ok_;
    213     basic_ostream<_CharT, _Traits>& __os_;
    214 
    215     sentry(const sentry&); // = delete;
    216     sentry& operator=(const sentry&); // = delete;
    217 
    218 public:
    219     explicit sentry(basic_ostream<_CharT, _Traits>& __os);
    220     ~sentry();
    221 
    222     _LIBCPP_ALWAYS_INLINE
    223         _LIBCPP_EXPLICIT
    224         operator bool() const {return __ok_;}
    225 };
    226 
    227 template <class _CharT, class _Traits>
    228 basic_ostream<_CharT, _Traits>::sentry::sentry(basic_ostream<_CharT, _Traits>& __os)
    229     : __ok_(false),
    230       __os_(__os)
    231 {
    232     if (__os.good())
    233     {
    234         if (__os.tie())
    235             __os.tie()->flush();
    236         __ok_ = true;
    237     }
    238 }
    239 
    240 template <class _CharT, class _Traits>
    241 basic_ostream<_CharT, _Traits>::sentry::~sentry()
    242 {
    243     if (__os_.rdbuf() && __os_.good() && (__os_.flags() & ios_base::unitbuf)
    244                       && !uncaught_exception())
    245     {
    246 #ifndef _LIBCPP_NO_EXCEPTIONS
    247         try
    248         {
    249 #endif  // _LIBCPP_NO_EXCEPTIONS
    250             if (__os_.rdbuf()->pubsync() == -1)
    251                 __os_.setstate(ios_base::badbit);
    252 #ifndef _LIBCPP_NO_EXCEPTIONS
    253         }
    254         catch (...)
    255         {
    256         }
    257 #endif  // _LIBCPP_NO_EXCEPTIONS
    258     }
    259 }
    260 
    261 template <class _CharT, class _Traits>
    262 inline _LIBCPP_INLINE_VISIBILITY
    263 basic_ostream<_CharT, _Traits>::basic_ostream(basic_streambuf<char_type, traits_type>* __sb)
    264 {
    265     this->init(__sb);
    266 }
    267 
    268 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    269 
    270 template <class _CharT, class _Traits>
    271 inline _LIBCPP_INLINE_VISIBILITY
    272 basic_ostream<_CharT, _Traits>::basic_ostream(basic_ostream&& __rhs)
    273 {
    274     this->move(__rhs);
    275 }
    276 
    277 template <class _CharT, class _Traits>
    278 inline _LIBCPP_INLINE_VISIBILITY
    279 basic_ostream<_CharT, _Traits>&
    280 basic_ostream<_CharT, _Traits>::operator=(basic_ostream&& __rhs)
    281 {
    282     swap(__rhs);
    283     return *this;
    284 }
    285 
    286 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    287 
    288 template <class _CharT, class _Traits>
    289 basic_ostream<_CharT, _Traits>::~basic_ostream()
    290 {
    291 }
    292 
    293 template <class _CharT, class _Traits>
    294 inline _LIBCPP_INLINE_VISIBILITY
    295 void
    296 basic_ostream<_CharT, _Traits>::swap(basic_ostream& __rhs)
    297 {
    298     basic_ios<char_type, traits_type>::swap(__rhs);
    299 }
    300 
    301 template <class _CharT, class _Traits>
    302 inline _LIBCPP_INLINE_VISIBILITY
    303 basic_ostream<_CharT, _Traits>&
    304 basic_ostream<_CharT, _Traits>::operator<<(basic_ostream& (*__pf)(basic_ostream&))
    305 {
    306     return __pf(*this);
    307 }
    308 
    309 template <class _CharT, class _Traits>
    310 inline _LIBCPP_INLINE_VISIBILITY
    311 basic_ostream<_CharT, _Traits>&
    312 basic_ostream<_CharT, _Traits>::operator<<(basic_ios<char_type, traits_type>&
    313                                            (*__pf)(basic_ios<char_type,traits_type>&))
    314 {
    315     __pf(*this);
    316     return *this;
    317 }
    318 
    319 template <class _CharT, class _Traits>
    320 inline _LIBCPP_INLINE_VISIBILITY
    321 basic_ostream<_CharT, _Traits>&
    322 basic_ostream<_CharT, _Traits>::operator<<(ios_base& (*__pf)(ios_base&))
    323 {
    324     __pf(*this);
    325     return *this;
    326 }
    327 
    328 template <class _CharT, class _Traits>
    329 basic_ostream<_CharT, _Traits>&
    330 basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_type>* __sb)
    331 {
    332 #ifndef _LIBCPP_NO_EXCEPTIONS
    333     try
    334     {
    335 #endif  // _LIBCPP_NO_EXCEPTIONS
    336         sentry __s(*this);
    337         if (__s)
    338         {
    339             if (__sb)
    340             {
    341 #ifndef _LIBCPP_NO_EXCEPTIONS
    342                 try
    343                 {
    344 #endif  // _LIBCPP_NO_EXCEPTIONS
    345                     typedef istreambuf_iterator<_CharT, _Traits> _Ip;
    346                     typedef ostreambuf_iterator<_CharT, _Traits> _Op;
    347                     _Ip __i(__sb);
    348                     _Ip __eof;
    349                     _Op __o(*this);
    350                     size_t __c = 0;
    351                     for (; __i != __eof; ++__i, ++__o, ++__c)
    352                     {
    353                         *__o = *__i;
    354                         if (__o.failed())
    355                             break;
    356                     }
    357                     if (__c == 0)
    358                         this->setstate(ios_base::failbit);
    359 #ifndef _LIBCPP_NO_EXCEPTIONS
    360                 }
    361                 catch (...)
    362                 {
    363                     this->__set_failbit_and_consider_rethrow();
    364                 }
    365 #endif  // _LIBCPP_NO_EXCEPTIONS
    366             }
    367             else
    368                 this->setstate(ios_base::badbit);
    369         }
    370 #ifndef _LIBCPP_NO_EXCEPTIONS
    371     }
    372     catch (...)
    373     {
    374         this->__set_badbit_and_consider_rethrow();
    375     }
    376 #endif  // _LIBCPP_NO_EXCEPTIONS
    377     return *this;
    378 }
    379 
    380 template <class _CharT, class _Traits>
    381 basic_ostream<_CharT, _Traits>&
    382 basic_ostream<_CharT, _Traits>::operator<<(bool __n)
    383 {
    384 #ifndef _LIBCPP_NO_EXCEPTIONS
    385     try
    386     {
    387 #endif  // _LIBCPP_NO_EXCEPTIONS
    388         sentry __s(*this);
    389         if (__s)
    390         {
    391             typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
    392             const _Fp& __f = use_facet<_Fp>(this->getloc());
    393             if (__f.put(*this, *this, this->fill(), __n).failed())
    394                 this->setstate(ios_base::badbit | ios_base::failbit);
    395         }
    396 #ifndef _LIBCPP_NO_EXCEPTIONS
    397     }
    398     catch (...)
    399     {
    400         this->__set_badbit_and_consider_rethrow();
    401     }
    402 #endif  // _LIBCPP_NO_EXCEPTIONS
    403     return *this;
    404 }
    405 
    406 template <class _CharT, class _Traits>
    407 basic_ostream<_CharT, _Traits>&
    408 basic_ostream<_CharT, _Traits>::operator<<(short __n)
    409 {
    410 #ifndef _LIBCPP_NO_EXCEPTIONS
    411     try
    412     {
    413 #endif  // _LIBCPP_NO_EXCEPTIONS
    414         sentry __s(*this);
    415         if (__s)
    416         {
    417             ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
    418             typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
    419             const _Fp& __f = use_facet<_Fp>(this->getloc());
    420             if (__f.put(*this, *this, this->fill(),
    421                         __flags == ios_base::oct || __flags == ios_base::hex ?
    422                         static_cast<long>(static_cast<unsigned short>(__n))  :
    423                         static_cast<long>(__n)).failed())
    424                 this->setstate(ios_base::badbit | ios_base::failbit);
    425         }
    426 #ifndef _LIBCPP_NO_EXCEPTIONS
    427     }
    428     catch (...)
    429     {
    430         this->__set_badbit_and_consider_rethrow();
    431     }
    432 #endif  // _LIBCPP_NO_EXCEPTIONS
    433     return *this;
    434 }
    435 
    436 template <class _CharT, class _Traits>
    437 basic_ostream<_CharT, _Traits>&
    438 basic_ostream<_CharT, _Traits>::operator<<(unsigned short __n)
    439 {
    440 #ifndef _LIBCPP_NO_EXCEPTIONS
    441     try
    442     {
    443 #endif  // _LIBCPP_NO_EXCEPTIONS
    444         sentry __s(*this);
    445         if (__s)
    446         {
    447             typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
    448             const _Fp& __f = use_facet<_Fp>(this->getloc());
    449             if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed())
    450                 this->setstate(ios_base::badbit | ios_base::failbit);
    451         }
    452 #ifndef _LIBCPP_NO_EXCEPTIONS
    453     }
    454     catch (...)
    455     {
    456         this->__set_badbit_and_consider_rethrow();
    457     }
    458 #endif  // _LIBCPP_NO_EXCEPTIONS
    459     return *this;
    460 }
    461 
    462 template <class _CharT, class _Traits>
    463 basic_ostream<_CharT, _Traits>&
    464 basic_ostream<_CharT, _Traits>::operator<<(int __n)
    465 {
    466 #ifndef _LIBCPP_NO_EXCEPTIONS
    467     try
    468     {
    469 #endif  // _LIBCPP_NO_EXCEPTIONS
    470         sentry __s(*this);
    471         if (__s)
    472         {
    473             ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
    474             typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
    475             const _Fp& __f = use_facet<_Fp>(this->getloc());
    476             if (__f.put(*this, *this, this->fill(),
    477                         __flags == ios_base::oct || __flags == ios_base::hex ?
    478                         static_cast<long>(static_cast<unsigned int>(__n))  :
    479                         static_cast<long>(__n)).failed())
    480                 this->setstate(ios_base::badbit | ios_base::failbit);
    481         }
    482 #ifndef _LIBCPP_NO_EXCEPTIONS
    483     }
    484     catch (...)
    485     {
    486         this->__set_badbit_and_consider_rethrow();
    487     }
    488 #endif  // _LIBCPP_NO_EXCEPTIONS
    489     return *this;
    490 }
    491 
    492 template <class _CharT, class _Traits>
    493 basic_ostream<_CharT, _Traits>&
    494 basic_ostream<_CharT, _Traits>::operator<<(unsigned int __n)
    495 {
    496 #ifndef _LIBCPP_NO_EXCEPTIONS
    497     try
    498     {
    499 #endif  // _LIBCPP_NO_EXCEPTIONS
    500         sentry __s(*this);
    501         if (__s)
    502         {
    503             typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
    504             const _Fp& __f = use_facet<_Fp>(this->getloc());
    505             if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed())
    506                 this->setstate(ios_base::badbit | ios_base::failbit);
    507         }
    508 #ifndef _LIBCPP_NO_EXCEPTIONS
    509     }
    510     catch (...)
    511     {
    512         this->__set_badbit_and_consider_rethrow();
    513     }
    514 #endif  // _LIBCPP_NO_EXCEPTIONS
    515     return *this;
    516 }
    517 
    518 template <class _CharT, class _Traits>
    519 basic_ostream<_CharT, _Traits>&
    520 basic_ostream<_CharT, _Traits>::operator<<(long __n)
    521 {
    522 #ifndef _LIBCPP_NO_EXCEPTIONS
    523     try
    524     {
    525 #endif  // _LIBCPP_NO_EXCEPTIONS
    526         sentry __s(*this);
    527         if (__s)
    528         {
    529             typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
    530             const _Fp& __f = use_facet<_Fp>(this->getloc());
    531             if (__f.put(*this, *this, this->fill(), __n).failed())
    532                 this->setstate(ios_base::badbit | ios_base::failbit);
    533         }
    534 #ifndef _LIBCPP_NO_EXCEPTIONS
    535     }
    536     catch (...)
    537     {
    538         this->__set_badbit_and_consider_rethrow();
    539     }
    540 #endif  // _LIBCPP_NO_EXCEPTIONS
    541     return *this;
    542 }
    543 
    544 template <class _CharT, class _Traits>
    545 basic_ostream<_CharT, _Traits>&
    546 basic_ostream<_CharT, _Traits>::operator<<(unsigned long __n)
    547 {
    548 #ifndef _LIBCPP_NO_EXCEPTIONS
    549     try
    550     {
    551 #endif  // _LIBCPP_NO_EXCEPTIONS
    552         sentry __s(*this);
    553         if (__s)
    554         {
    555             typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
    556             const _Fp& __f = use_facet<_Fp>(this->getloc());
    557             if (__f.put(*this, *this, this->fill(), __n).failed())
    558                 this->setstate(ios_base::badbit | ios_base::failbit);
    559         }
    560 #ifndef _LIBCPP_NO_EXCEPTIONS
    561     }
    562     catch (...)
    563     {
    564         this->__set_badbit_and_consider_rethrow();
    565     }
    566 #endif  // _LIBCPP_NO_EXCEPTIONS
    567     return *this;
    568 }
    569 
    570 template <class _CharT, class _Traits>
    571 basic_ostream<_CharT, _Traits>&
    572 basic_ostream<_CharT, _Traits>::operator<<(long long __n)
    573 {
    574 #ifndef _LIBCPP_NO_EXCEPTIONS
    575     try
    576     {
    577 #endif  // _LIBCPP_NO_EXCEPTIONS
    578         sentry __s(*this);
    579         if (__s)
    580         {
    581             typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
    582             const _Fp& __f = use_facet<_Fp>(this->getloc());
    583             if (__f.put(*this, *this, this->fill(), __n).failed())
    584                 this->setstate(ios_base::badbit | ios_base::failbit);
    585         }
    586 #ifndef _LIBCPP_NO_EXCEPTIONS
    587     }
    588     catch (...)
    589     {
    590         this->__set_badbit_and_consider_rethrow();
    591     }
    592 #endif  // _LIBCPP_NO_EXCEPTIONS
    593     return *this;
    594 }
    595 
    596 template <class _CharT, class _Traits>
    597 basic_ostream<_CharT, _Traits>&
    598 basic_ostream<_CharT, _Traits>::operator<<(unsigned long long __n)
    599 {
    600 #ifndef _LIBCPP_NO_EXCEPTIONS
    601     try
    602     {
    603 #endif  // _LIBCPP_NO_EXCEPTIONS
    604         sentry __s(*this);
    605         if (__s)
    606         {
    607             typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
    608             const _Fp& __f = use_facet<_Fp>(this->getloc());
    609             if (__f.put(*this, *this, this->fill(), __n).failed())
    610                 this->setstate(ios_base::badbit | ios_base::failbit);
    611         }
    612 #ifndef _LIBCPP_NO_EXCEPTIONS
    613     }
    614     catch (...)
    615     {
    616         this->__set_badbit_and_consider_rethrow();
    617     }
    618 #endif  // _LIBCPP_NO_EXCEPTIONS
    619     return *this;
    620 }
    621 
    622 template <class _CharT, class _Traits>
    623 basic_ostream<_CharT, _Traits>&
    624 basic_ostream<_CharT, _Traits>::operator<<(float __n)
    625 {
    626 #ifndef _LIBCPP_NO_EXCEPTIONS
    627     try
    628     {
    629 #endif  // _LIBCPP_NO_EXCEPTIONS
    630         sentry __s(*this);
    631         if (__s)
    632         {
    633             typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
    634             const _Fp& __f = use_facet<_Fp>(this->getloc());
    635             if (__f.put(*this, *this, this->fill(), static_cast<double>(__n)).failed())
    636                 this->setstate(ios_base::badbit | ios_base::failbit);
    637         }
    638 #ifndef _LIBCPP_NO_EXCEPTIONS
    639     }
    640     catch (...)
    641     {
    642         this->__set_badbit_and_consider_rethrow();
    643     }
    644 #endif  // _LIBCPP_NO_EXCEPTIONS
    645     return *this;
    646 }
    647 
    648 template <class _CharT, class _Traits>
    649 basic_ostream<_CharT, _Traits>&
    650 basic_ostream<_CharT, _Traits>::operator<<(double __n)
    651 {
    652 #ifndef _LIBCPP_NO_EXCEPTIONS
    653     try
    654     {
    655 #endif  // _LIBCPP_NO_EXCEPTIONS
    656         sentry __s(*this);
    657         if (__s)
    658         {
    659             typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
    660             const _Fp& __f = use_facet<_Fp>(this->getloc());
    661             if (__f.put(*this, *this, this->fill(), __n).failed())
    662                 this->setstate(ios_base::badbit | ios_base::failbit);
    663         }
    664 #ifndef _LIBCPP_NO_EXCEPTIONS
    665     }
    666     catch (...)
    667     {
    668         this->__set_badbit_and_consider_rethrow();
    669     }
    670 #endif  // _LIBCPP_NO_EXCEPTIONS
    671     return *this;
    672 }
    673 
    674 template <class _CharT, class _Traits>
    675 basic_ostream<_CharT, _Traits>&
    676 basic_ostream<_CharT, _Traits>::operator<<(long double __n)
    677 {
    678 #ifndef _LIBCPP_NO_EXCEPTIONS
    679     try
    680     {
    681 #endif  // _LIBCPP_NO_EXCEPTIONS
    682         sentry __s(*this);
    683         if (__s)
    684         {
    685             typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
    686             const _Fp& __f = use_facet<_Fp>(this->getloc());
    687             if (__f.put(*this, *this, this->fill(), __n).failed())
    688                 this->setstate(ios_base::badbit | ios_base::failbit);
    689         }
    690 #ifndef _LIBCPP_NO_EXCEPTIONS
    691     }
    692     catch (...)
    693     {
    694         this->__set_badbit_and_consider_rethrow();
    695     }
    696 #endif  // _LIBCPP_NO_EXCEPTIONS
    697     return *this;
    698 }
    699 
    700 template <class _CharT, class _Traits>
    701 basic_ostream<_CharT, _Traits>&
    702 basic_ostream<_CharT, _Traits>::operator<<(const void* __n)
    703 {
    704 #ifndef _LIBCPP_NO_EXCEPTIONS
    705     try
    706     {
    707 #endif  // _LIBCPP_NO_EXCEPTIONS
    708         sentry __s(*this);
    709         if (__s)
    710         {
    711             typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
    712             const _Fp& __f = use_facet<_Fp>(this->getloc());
    713             if (__f.put(*this, *this, this->fill(), __n).failed())
    714                 this->setstate(ios_base::badbit | ios_base::failbit);
    715         }
    716 #ifndef _LIBCPP_NO_EXCEPTIONS
    717     }
    718     catch (...)
    719     {
    720         this->__set_badbit_and_consider_rethrow();
    721     }
    722 #endif  // _LIBCPP_NO_EXCEPTIONS
    723     return *this;
    724 }
    725 
    726 template<class _CharT, class _Traits>
    727 basic_ostream<_CharT, _Traits>&
    728 operator<<(basic_ostream<_CharT, _Traits>& __os, _CharT __c)
    729 {
    730 #ifndef _LIBCPP_NO_EXCEPTIONS
    731     try
    732     {
    733 #endif  // _LIBCPP_NO_EXCEPTIONS
    734         typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
    735         if (__s)
    736         {
    737             typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
    738             if (__pad_and_output(_Ip(__os),
    739                                  &__c,
    740                                  (__os.flags() & ios_base::adjustfield) == ios_base::left ?
    741                                      &__c + 1 :
    742                                      &__c,
    743                                  &__c + 1,
    744                                  __os,
    745                                  __os.fill()).failed())
    746                 __os.setstate(ios_base::badbit | ios_base::failbit);
    747         }
    748 #ifndef _LIBCPP_NO_EXCEPTIONS
    749     }
    750     catch (...)
    751     {
    752         __os.__set_badbit_and_consider_rethrow();
    753     }
    754 #endif  // _LIBCPP_NO_EXCEPTIONS
    755     return __os;
    756 }
    757 
    758 template<class _CharT, class _Traits>
    759 basic_ostream<_CharT, _Traits>&
    760 operator<<(basic_ostream<_CharT, _Traits>& __os, char __cn)
    761 {
    762 #ifndef _LIBCPP_NO_EXCEPTIONS
    763     try
    764     {
    765 #endif  // _LIBCPP_NO_EXCEPTIONS
    766         typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
    767         if (__s)
    768         {
    769             _CharT __c = __os.widen(__cn);
    770             typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
    771             if (__pad_and_output(_Ip(__os),
    772                                  &__c,
    773                                  (__os.flags() & ios_base::adjustfield) == ios_base::left ?
    774                                      &__c + 1 :
    775                                      &__c,
    776                                  &__c + 1,
    777                                  __os,
    778                                  __os.fill()).failed())
    779                 __os.setstate(ios_base::badbit | ios_base::failbit);
    780         }
    781 #ifndef _LIBCPP_NO_EXCEPTIONS
    782     }
    783     catch (...)
    784     {
    785         __os.__set_badbit_and_consider_rethrow();
    786     }
    787 #endif  // _LIBCPP_NO_EXCEPTIONS
    788     return __os;
    789 }
    790 
    791 template<class _Traits>
    792 basic_ostream<char, _Traits>&
    793 operator<<(basic_ostream<char, _Traits>& __os, char __c)
    794 {
    795 #ifndef _LIBCPP_NO_EXCEPTIONS
    796     try
    797     {
    798 #endif  // _LIBCPP_NO_EXCEPTIONS
    799         typename basic_ostream<char, _Traits>::sentry __s(__os);
    800         if (__s)
    801         {
    802             typedef ostreambuf_iterator<char, _Traits> _Ip;
    803             if (__pad_and_output(_Ip(__os),
    804                                  &__c,
    805                                  (__os.flags() & ios_base::adjustfield) == ios_base::left ?
    806                                      &__c + 1 :
    807                                      &__c,
    808                                  &__c + 1,
    809                                  __os,
    810                                  __os.fill()).failed())
    811                 __os.setstate(ios_base::badbit | ios_base::failbit);
    812         }
    813 #ifndef _LIBCPP_NO_EXCEPTIONS
    814     }
    815     catch (...)
    816     {
    817         __os.__set_badbit_and_consider_rethrow();
    818     }
    819 #endif  // _LIBCPP_NO_EXCEPTIONS
    820     return __os;
    821 }
    822 
    823 template<class _Traits>
    824 basic_ostream<char, _Traits>&
    825 operator<<(basic_ostream<char, _Traits>& __os, signed char __c)
    826 {
    827 #ifndef _LIBCPP_NO_EXCEPTIONS
    828     try
    829     {
    830 #endif  // _LIBCPP_NO_EXCEPTIONS
    831         typename basic_ostream<char, _Traits>::sentry __s(__os);
    832         if (__s)
    833         {
    834             typedef ostreambuf_iterator<char, _Traits> _Ip;
    835             if (__pad_and_output(_Ip(__os),
    836                                  (char*)&__c,
    837                                  (__os.flags() & ios_base::adjustfield) == ios_base::left ?
    838                                      (char*)&__c + 1 :
    839                                      (char*)&__c,
    840                                  (char*)&__c + 1,
    841                                  __os,
    842                                  __os.fill()).failed())
    843                 __os.setstate(ios_base::badbit | ios_base::failbit);
    844         }
    845 #ifndef _LIBCPP_NO_EXCEPTIONS
    846     }
    847     catch (...)
    848     {
    849         __os.__set_badbit_and_consider_rethrow();
    850     }
    851 #endif  // _LIBCPP_NO_EXCEPTIONS
    852     return __os;
    853 }
    854 
    855 template<class _Traits>
    856 basic_ostream<char, _Traits>&
    857 operator<<(basic_ostream<char, _Traits>& __os, unsigned char __c)
    858 {
    859 #ifndef _LIBCPP_NO_EXCEPTIONS
    860     try
    861     {
    862 #endif  // _LIBCPP_NO_EXCEPTIONS
    863         typename basic_ostream<char, _Traits>::sentry __s(__os);
    864         if (__s)
    865         {
    866             typedef ostreambuf_iterator<char, _Traits> _Ip;
    867             if (__pad_and_output(_Ip(__os),
    868                                  (char*)&__c,
    869                                  (__os.flags() & ios_base::adjustfield) == ios_base::left ?
    870                                      (char*)&__c + 1 :
    871                                      (char*)&__c,
    872                                  (char*)&__c + 1,
    873                                  __os,
    874                                  __os.fill()).failed())
    875                 __os.setstate(ios_base::badbit | ios_base::failbit);
    876         }
    877 #ifndef _LIBCPP_NO_EXCEPTIONS
    878     }
    879     catch (...)
    880     {
    881         __os.__set_badbit_and_consider_rethrow();
    882     }
    883 #endif  // _LIBCPP_NO_EXCEPTIONS
    884     return __os;
    885 }
    886 
    887 template<class _CharT, class _Traits>
    888 basic_ostream<_CharT, _Traits>&
    889 operator<<(basic_ostream<_CharT, _Traits>& __os, const _CharT* __str)
    890 {
    891 #ifndef _LIBCPP_NO_EXCEPTIONS
    892     try
    893     {
    894 #endif  // _LIBCPP_NO_EXCEPTIONS
    895         typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
    896         if (__s)
    897         {
    898             typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
    899             size_t __len = _Traits::length(__str);
    900             if (__pad_and_output(_Ip(__os),
    901                                  __str,
    902                                  (__os.flags() & ios_base::adjustfield) == ios_base::left ?
    903                                      __str + __len :
    904                                      __str,
    905                                  __str + __len,
    906                                  __os,
    907                                  __os.fill()).failed())
    908                 __os.setstate(ios_base::badbit | ios_base::failbit);
    909         }
    910 #ifndef _LIBCPP_NO_EXCEPTIONS
    911     }
    912     catch (...)
    913     {
    914         __os.__set_badbit_and_consider_rethrow();
    915     }
    916 #endif  // _LIBCPP_NO_EXCEPTIONS
    917     return __os;
    918 }
    919 
    920 template<class _CharT, class _Traits>
    921 basic_ostream<_CharT, _Traits>&
    922 operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __strn)
    923 {
    924 #ifndef _LIBCPP_NO_EXCEPTIONS
    925     try
    926     {
    927 #endif  // _LIBCPP_NO_EXCEPTIONS
    928         typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
    929         if (__s)
    930         {
    931             typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
    932             size_t __len = char_traits<char>::length(__strn);
    933             const int __bs = 100;
    934             _CharT __wbb[__bs];
    935             _CharT* __wb = __wbb;
    936             unique_ptr<_CharT, void(*)(void*)> __h(0, free);
    937             if (__len > __bs)
    938             {
    939                 __wb = (_CharT*)malloc(__len*sizeof(_CharT));
    940                 if (__wb == 0)
    941                     __throw_bad_alloc();
    942                 __h.reset(__wb);
    943             }
    944             for (_CharT* __p = __wb; *__strn != '\0'; ++__strn, ++__p)
    945                 *__p = __os.widen(*__strn);
    946             if (__pad_and_output(_Ip(__os),
    947                                  __wb,
    948                                  (__os.flags() & ios_base::adjustfield) == ios_base::left ?
    949                                      __wb + __len :
    950                                      __wb,
    951                                  __wb + __len,
    952                                  __os,
    953                                  __os.fill()).failed())
    954                 __os.setstate(ios_base::badbit | ios_base::failbit);
    955         }
    956 #ifndef _LIBCPP_NO_EXCEPTIONS
    957     }
    958     catch (...)
    959     {
    960         __os.__set_badbit_and_consider_rethrow();
    961     }
    962 #endif  // _LIBCPP_NO_EXCEPTIONS
    963     return __os;
    964 }
    965 
    966 template<class _Traits>
    967 basic_ostream<char, _Traits>&
    968 operator<<(basic_ostream<char, _Traits>& __os, const char* __str)
    969 {
    970 #ifndef _LIBCPP_NO_EXCEPTIONS
    971     try
    972     {
    973 #endif  // _LIBCPP_NO_EXCEPTIONS
    974         typename basic_ostream<char, _Traits>::sentry __s(__os);
    975         if (__s)
    976         {
    977             typedef ostreambuf_iterator<char, _Traits> _Ip;
    978             size_t __len = _Traits::length(__str);
    979             if (__pad_and_output(_Ip(__os),
    980                                  __str,
    981                                  (__os.flags() & ios_base::adjustfield) == ios_base::left ?
    982                                      __str + __len :
    983                                      __str,
    984                                  __str + __len,
    985                                  __os,
    986                                  __os.fill()).failed())
    987                 __os.setstate(ios_base::badbit | ios_base::failbit);
    988         }
    989 #ifndef _LIBCPP_NO_EXCEPTIONS
    990     }
    991     catch (...)
    992     {
    993         __os.__set_badbit_and_consider_rethrow();
    994     }
    995 #endif  // _LIBCPP_NO_EXCEPTIONS
    996     return __os;
    997 }
    998 
    999 template<class _Traits>
   1000 basic_ostream<char, _Traits>&
   1001 operator<<(basic_ostream<char, _Traits>& __os, const signed char* __str)
   1002 {
   1003 #ifndef _LIBCPP_NO_EXCEPTIONS
   1004     try
   1005     {
   1006 #endif  // _LIBCPP_NO_EXCEPTIONS
   1007         typename basic_ostream<char, _Traits>::sentry __s(__os);
   1008         if (__s)
   1009         {
   1010             typedef ostreambuf_iterator<char, _Traits> _Ip;
   1011             size_t __len = _Traits::length((const char*)__str);
   1012             if (__pad_and_output(_Ip(__os),
   1013                                  (const char*)__str,
   1014                                  (__os.flags() & ios_base::adjustfield) == ios_base::left ?
   1015                                      (const char*)__str + __len :
   1016                                      (const char*)__str,
   1017                                  (const char*)__str + __len,
   1018                                  __os,
   1019                                  __os.fill()).failed())
   1020                 __os.setstate(ios_base::badbit | ios_base::failbit);
   1021         }
   1022 #ifndef _LIBCPP_NO_EXCEPTIONS
   1023     }
   1024     catch (...)
   1025     {
   1026         __os.__set_badbit_and_consider_rethrow();
   1027     }
   1028 #endif  // _LIBCPP_NO_EXCEPTIONS
   1029     return __os;
   1030 }
   1031 
   1032 template<class _Traits>
   1033 basic_ostream<char, _Traits>&
   1034 operator<<(basic_ostream<char, _Traits>& __os, const unsigned char* __str)
   1035 {
   1036 #ifndef _LIBCPP_NO_EXCEPTIONS
   1037     try
   1038     {
   1039 #endif  // _LIBCPP_NO_EXCEPTIONS
   1040         typename basic_ostream<char, _Traits>::sentry __s(__os);
   1041         if (__s)
   1042         {
   1043             typedef ostreambuf_iterator<char, _Traits> _Ip;
   1044             size_t __len = _Traits::length((const char*)__str);
   1045             if (__pad_and_output(_Ip(__os),
   1046                                  (const char*)__str,
   1047                                  (__os.flags() & ios_base::adjustfield) == ios_base::left ?
   1048                                      (const char*)__str + __len :
   1049                                      (const char*)__str,
   1050                                  (const char*)__str + __len,
   1051                                  __os,
   1052                                  __os.fill()).failed())
   1053                 __os.setstate(ios_base::badbit | ios_base::failbit);
   1054         }
   1055 #ifndef _LIBCPP_NO_EXCEPTIONS
   1056     }
   1057     catch (...)
   1058     {
   1059         __os.__set_badbit_and_consider_rethrow();
   1060     }
   1061 #endif  // _LIBCPP_NO_EXCEPTIONS
   1062     return __os;
   1063 }
   1064 
   1065 template <class _CharT, class _Traits>
   1066 basic_ostream<_CharT, _Traits>&
   1067 basic_ostream<_CharT, _Traits>::put(char_type __c)
   1068 {
   1069 #ifndef _LIBCPP_NO_EXCEPTIONS
   1070     try
   1071     {
   1072 #endif  // _LIBCPP_NO_EXCEPTIONS
   1073         sentry __s(*this);
   1074         if (__s)
   1075         {
   1076             typedef ostreambuf_iterator<_CharT, _Traits> _Op;
   1077             _Op __o(*this);
   1078             *__o = __c;
   1079             if (__o.failed())
   1080                 this->setstate(ios_base::badbit);
   1081         }
   1082 #ifndef _LIBCPP_NO_EXCEPTIONS
   1083     }
   1084     catch (...)
   1085     {
   1086         this->__set_badbit_and_consider_rethrow();
   1087     }
   1088 #endif  // _LIBCPP_NO_EXCEPTIONS
   1089     return *this;
   1090 }
   1091 
   1092 template <class _CharT, class _Traits>
   1093 basic_ostream<_CharT, _Traits>&
   1094 basic_ostream<_CharT, _Traits>::write(const char_type* __s, streamsize __n)
   1095 {
   1096 #ifndef _LIBCPP_NO_EXCEPTIONS
   1097     try
   1098     {
   1099 #endif  // _LIBCPP_NO_EXCEPTIONS
   1100         sentry __sen(*this);
   1101         if (__sen && __n)
   1102         {
   1103             if (this->rdbuf()->sputn(__s, __n) != __n)
   1104                 this->setstate(ios_base::badbit);
   1105         }
   1106 #ifndef _LIBCPP_NO_EXCEPTIONS
   1107     }
   1108     catch (...)
   1109     {
   1110         this->__set_badbit_and_consider_rethrow();
   1111     }
   1112 #endif  // _LIBCPP_NO_EXCEPTIONS
   1113     return *this;
   1114 }
   1115 
   1116 template <class _CharT, class _Traits>
   1117 basic_ostream<_CharT, _Traits>&
   1118 basic_ostream<_CharT, _Traits>::flush()
   1119 {
   1120 #ifndef _LIBCPP_NO_EXCEPTIONS
   1121     try
   1122     {
   1123 #endif  // _LIBCPP_NO_EXCEPTIONS
   1124         if (this->rdbuf())
   1125         {
   1126             sentry __s(*this);
   1127             if (__s)
   1128             {
   1129                 if (this->rdbuf()->pubsync() == -1)
   1130                     this->setstate(ios_base::badbit);
   1131             }
   1132         }
   1133 #ifndef _LIBCPP_NO_EXCEPTIONS
   1134     }
   1135     catch (...)
   1136     {
   1137         this->__set_badbit_and_consider_rethrow();
   1138     }
   1139 #endif  // _LIBCPP_NO_EXCEPTIONS
   1140     return *this;
   1141 }
   1142 
   1143 template <class _CharT, class _Traits>
   1144 inline _LIBCPP_INLINE_VISIBILITY
   1145 typename basic_ostream<_CharT, _Traits>::pos_type
   1146 basic_ostream<_CharT, _Traits>::tellp()
   1147 {
   1148     if (this->fail())
   1149         return pos_type(-1);
   1150     return this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
   1151 }
   1152 
   1153 template <class _CharT, class _Traits>
   1154 inline _LIBCPP_INLINE_VISIBILITY
   1155 basic_ostream<_CharT, _Traits>&
   1156 basic_ostream<_CharT, _Traits>::seekp(pos_type __pos)
   1157 {
   1158     if (!this->fail())
   1159     {
   1160         if (this->rdbuf()->pubseekpos(__pos, ios_base::out) == pos_type(-1))
   1161             this->setstate(ios_base::failbit);
   1162     }
   1163     return *this;
   1164 }
   1165 
   1166 template <class _CharT, class _Traits>
   1167 inline _LIBCPP_INLINE_VISIBILITY
   1168 basic_ostream<_CharT, _Traits>&
   1169 basic_ostream<_CharT, _Traits>::seekp(off_type __off, ios_base::seekdir __dir)
   1170 {
   1171     if (!this->fail())
   1172         this->rdbuf()->pubseekoff(__off, __dir, ios_base::out);
   1173     return *this;
   1174 }
   1175 
   1176 template <class _CharT, class _Traits>
   1177 inline _LIBCPP_INLINE_VISIBILITY
   1178 basic_ostream<_CharT, _Traits>&
   1179 endl(basic_ostream<_CharT, _Traits>& __os)
   1180 {
   1181     __os.put(__os.widen('\n'));
   1182     __os.flush();
   1183     return __os;
   1184 }
   1185 
   1186 template <class _CharT, class _Traits>
   1187 inline _LIBCPP_INLINE_VISIBILITY
   1188 basic_ostream<_CharT, _Traits>&
   1189 ends(basic_ostream<_CharT, _Traits>& __os)
   1190 {
   1191     __os.put(_CharT());
   1192     return __os;
   1193 }
   1194 
   1195 template <class _CharT, class _Traits>
   1196 inline _LIBCPP_INLINE_VISIBILITY
   1197 basic_ostream<_CharT, _Traits>&
   1198 flush(basic_ostream<_CharT, _Traits>& __os)
   1199 {
   1200     __os.flush();
   1201     return __os;
   1202 }
   1203 
   1204 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
   1205 
   1206 template <class _Stream, class _Tp>
   1207 inline _LIBCPP_INLINE_VISIBILITY
   1208 typename enable_if
   1209 <
   1210     !is_lvalue_reference<_Stream>::value &&
   1211     is_base_of<ios_base, _Stream>::value,
   1212     _Stream&&
   1213 >::type
   1214 operator<<(_Stream&& __os, const _Tp& __x)
   1215 {
   1216     __os << __x;
   1217     return _VSTD::move(__os);
   1218 }
   1219 
   1220 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
   1221 
   1222 template<class _CharT, class _Traits, class _Allocator>
   1223 basic_ostream<_CharT, _Traits>&
   1224 operator<<(basic_ostream<_CharT, _Traits>& __os,
   1225            const basic_string<_CharT, _Traits, _Allocator>& __str)
   1226 {
   1227 #ifndef _LIBCPP_NO_EXCEPTIONS
   1228     try
   1229     {
   1230 #endif  // _LIBCPP_NO_EXCEPTIONS
   1231         typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
   1232         if (__s)
   1233         {
   1234             typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
   1235             size_t __len = __str.size();
   1236             if (__pad_and_output(_Ip(__os),
   1237                                  __str.data(),
   1238                                  (__os.flags() & ios_base::adjustfield) == ios_base::left ?
   1239                                      __str.data() + __len :
   1240                                      __str.data(),
   1241                                  __str.data() + __len,
   1242                                  __os,
   1243                                  __os.fill()).failed())
   1244                 __os.setstate(ios_base::badbit | ios_base::failbit);
   1245         }
   1246 #ifndef _LIBCPP_NO_EXCEPTIONS
   1247     }
   1248     catch (...)
   1249     {
   1250         __os.__set_badbit_and_consider_rethrow();
   1251     }
   1252 #endif  // _LIBCPP_NO_EXCEPTIONS
   1253     return __os;
   1254 }
   1255 
   1256 template <class _CharT, class _Traits>
   1257 inline _LIBCPP_INLINE_VISIBILITY
   1258 basic_ostream<_CharT, _Traits>&
   1259 operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __ec)
   1260 {
   1261     return __os << __ec.category().name() << ':' << __ec.value();
   1262 }
   1263 
   1264 template<class _CharT, class _Traits, class _Yp>
   1265 inline _LIBCPP_INLINE_VISIBILITY
   1266 basic_ostream<_CharT, _Traits>&
   1267 operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p)
   1268 {
   1269     return __os << __p.get();
   1270 }
   1271 
   1272 template <class _CharT, class _Traits, size_t _Size>
   1273 basic_ostream<_CharT, _Traits>&
   1274 operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x)
   1275 {
   1276     return __os << __x.template to_string<_CharT, _Traits>
   1277                         (use_facet<ctype<_CharT> >(__os.getloc()).widen('0'),
   1278                          use_facet<ctype<_CharT> >(__os.getloc()).widen('1'));
   1279 }
   1280 
   1281 _LIBCPP_EXTERN_TEMPLATE(class basic_ostream<char>)
   1282 _LIBCPP_EXTERN_TEMPLATE(class basic_ostream<wchar_t>)
   1283 
   1284 _LIBCPP_END_NAMESPACE_STD
   1285 
   1286 #endif  // _LIBCPP_OSTREAM
   1287