gnu/dist/gcc4/libstdc++-v3/include/bits/ostream.tcc

   1 // ostream classes -*- C++ -*-
   2
   3 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
   4 // Free Software Foundation, Inc.
   5 //
   6 // This file is part of the GNU ISO C++ Library.  This library is free
   7 // software; you can redistribute it and/or modify it under the
   8 // terms of the GNU General Public License as published by the
   9 // Free Software Foundation; either version 2, or (at your option)
  10 // any later version.
  11
  12 // This library is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU General Public License for more details.
  16
  17 // You should have received a copy of the GNU General Public License along
  18 // with this library; see the file COPYING.  If not, write to the Free
  19 // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  20 // USA.
  21
  22 // As a special exception, you may use this file as part of a free software
  23 // library without restriction.  Specifically, if other files instantiate
  24 // templates or use macros or inline functions from this file, or you compile
  25 // this file and link it with other files to produce an executable, this
  26 // file does not by itself cause the resulting executable to be covered by
  27 // the GNU General Public License.  This exception does not however
  28 // invalidate any other reasons why the executable file might be covered by
  29 // the GNU General Public License.
  30
  31 /** @file ostream.tcc
  32  *  This is an internal header file, included by other library headers.
  33  *  You should not attempt to use it directly.
  34  */
  35
  36 //
  37 // ISO C++ 14882: 27.6.2  Output streams
  38 //
  39
  40 #ifndef _OSTREAM_TCC
  41 #define _OSTREAM_TCC 1
  42
  43 #pragma GCC system_header
  44
  45 #include <locale>
  46
  47 namespace std
  48 {
  49   template<typename _CharT, typename _Traits>
  50     basic_ostream<_CharT, _Traits>::sentry::
  51     sentry(basic_ostream<_CharT, _Traits>& __os)
  52     : _M_ok(false), _M_os(__os)
  53     {
  54       // XXX MT
  55       if (__os.tie() && __os.good())
  56         __os.tie()->flush();
  57
  58       if (__os.good())
  59         _M_ok = true;
  60       else
  61         __os.setstate(ios_base::failbit);
  62     }
  63
  64   template<typename _CharT, typename _Traits>
  65     basic_ostream<_CharT, _Traits>&
  66     basic_ostream<_CharT, _Traits>::
  67     operator<<(__ostream_type& (*__pf)(__ostream_type&))
  68     {
  69       // _GLIBCXX_RESOLVE_LIB_DEFECTS
  70       // DR 60. What is a formatted input function?
  71       // The inserters for manipulators are *not* formatted output functions.
  72       return __pf(*this);
  73     }
  74
  75   template<typename _CharT, typename _Traits>
  76     basic_ostream<_CharT, _Traits>&
  77     basic_ostream<_CharT, _Traits>::
  78     operator<<(__ios_type& (*__pf)(__ios_type&))
  79     {
  80       // _GLIBCXX_RESOLVE_LIB_DEFECTS
  81       // DR 60. What is a formatted input function?
  82       // The inserters for manipulators are *not* formatted output functions.
  83       __pf(*this);
  84       return *this;
  85     }
  86
  87   template<typename _CharT, typename _Traits>
  88     basic_ostream<_CharT, _Traits>&
  89     basic_ostream<_CharT, _Traits>::
  90     operator<<(ios_base& (*__pf)(ios_base&))
  91     {
  92       // _GLIBCXX_RESOLVE_LIB_DEFECTS
  93       // DR 60. What is a formatted input function?
  94       // The inserters for manipulators are *not* formatted output functions.
  95       __pf(*this);
  96       return *this;
  97     }
  98
  99   template<typename _CharT, typename _Traits>
 100     basic_ostream<_CharT, _Traits>&
 101     basic_ostream<_CharT, _Traits>::
 102     operator<<(bool __n)
 103     {
 104       sentry __cerb(*this);
 105       if (__cerb)
 106         {
 107           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
 108           try
 109             {
 110               const __num_put_type& __np = __check_facet(this->_M_num_put);
 111               if (__np.put(*this, *this, this->fill(), __n).failed())
 112                 __err |= ios_base::badbit;
 113             }
 114           catch(...)
 115             { this->_M_setstate(ios_base::badbit); }
 116           if (__err)
 117             this->setstate(__err);
 118         }
 119       return *this;
 120     }
 121
 122   template<typename _CharT, typename _Traits>
 123     basic_ostream<_CharT, _Traits>&
 124     basic_ostream<_CharT, _Traits>::
 125     operator<<(short __n)
 126     {
 127       sentry __cerb(*this);
 128       if (__cerb)
 129         {
 130           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
 131           try
 132             {
 133               // _GLIBCXX_RESOLVE_LIB_DEFECTS
 134               // 117. basic_ostream uses nonexistent num_put member functions.
 135               long __l;
 136               const ios_base::fmtflags __fmt = (this->flags()
 137                                                 & ios_base::basefield);
 138               if (__fmt == ios_base::oct || __fmt == ios_base::hex)
 139                 __l = static_cast<long>(static_cast<unsigned short>(__n));
 140               else
 141                 __l = static_cast<long>(__n);
 142               const __num_put_type& __np = __check_facet(this->_M_num_put);
 143               if (__np.put(*this, *this, this->fill(), __l).failed())
 144                 __err |= ios_base::badbit;
 145             }
 146           catch(...)
 147             { this->_M_setstate(ios_base::badbit); }
 148           if (__err)
 149             this->setstate(__err);
 150         }
 151       return *this;
 152     }
 153
 154   template<typename _CharT, typename _Traits>
 155     basic_ostream<_CharT, _Traits>&
 156     basic_ostream<_CharT, _Traits>::
 157     operator<<(unsigned short __n)
 158     {
 159       sentry __cerb(*this);
 160       if (__cerb)
 161         {
 162           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
 163           try
 164             {
 165               // _GLIBCXX_RESOLVE_LIB_DEFECTS
 166               // 117. basic_ostream uses nonexistent num_put member functions.
 167               const __num_put_type& __np = __check_facet(this->_M_num_put);
 168               if (__np.put(*this, *this, this->fill(),
 169                            static_cast<unsigned long>(__n)).failed())
 170                 __err |= ios_base::badbit;
 171             }
 172           catch(...)
 173             { this->_M_setstate(ios_base::badbit); }
 174           if (__err)
 175             this->setstate(__err);
 176         }
 177       return *this;
 178     }
 179
 180   template<typename _CharT, typename _Traits>
 181     basic_ostream<_CharT, _Traits>&
 182     basic_ostream<_CharT, _Traits>::
 183     operator<<(int __n)
 184     {
 185       sentry __cerb(*this);
 186       if (__cerb)
 187         {
 188           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
 189           try
 190             {
 191               // _GLIBCXX_RESOLVE_LIB_DEFECTS
 192               // 117. basic_ostream uses nonexistent num_put member functions.
 193               long __l;
 194               const ios_base::fmtflags __fmt = (this->flags()
 195                                                 & ios_base::basefield);
 196               if (__fmt == ios_base::oct || __fmt == ios_base::hex)
 197                 __l = static_cast<long>(static_cast<unsigned int>(__n));
 198               else
 199                 __l = static_cast<long>(__n);
 200               const __num_put_type& __np = __check_facet(this->_M_num_put);
 201               if (__np.put(*this, *this, this->fill(), __l).failed())
 202                 __err |= ios_base::badbit;
 203             }
 204           catch(...)
 205             { this->_M_setstate(ios_base::badbit); }
 206           if (__err)
 207             this->setstate(__err);
 208         }
 209       return *this;
 210     }
 211
 212   template<typename _CharT, typename _Traits>
 213     basic_ostream<_CharT, _Traits>&
 214     basic_ostream<_CharT, _Traits>::
 215     operator<<(unsigned int __n)
 216     {
 217       sentry __cerb(*this);
 218       if (__cerb)
 219         {
 220           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
 221           try
 222             {
 223               // _GLIBCXX_RESOLVE_LIB_DEFECTS
 224               // 117. basic_ostream uses nonexistent num_put member functions.
 225               const __num_put_type& __np = __check_facet(this->_M_num_put);
 226               if (__np.put(*this, *this, this->fill(),
 227                            static_cast<unsigned long>(__n)).failed())
 228                 __err |= ios_base::badbit;
 229             }
 230           catch(...)
 231             { this->_M_setstate(ios_base::badbit); }
 232           if (__err)
 233             this->setstate(__err);
 234         }
 235       return *this;
 236     }
 237
 238   template<typename _CharT, typename _Traits>
 239     basic_ostream<_CharT, _Traits>&
 240     basic_ostream<_CharT, _Traits>::
 241     operator<<(long __n)
 242     {
 243       sentry __cerb(*this);
 244       if (__cerb)
 245         {
 246           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
 247           try
 248             {
 249               const __num_put_type& __np = __check_facet(this->_M_num_put);
 250               if (__np.put(*this, *this, this->fill(), __n).failed())
 251                 __err |= ios_base::badbit;
 252             }
 253           catch(...)
 254             { this->_M_setstate(ios_base::badbit); }
 255           if (__err)
 256             this->setstate(__err);
 257         }
 258       return *this;
 259     }
 260
 261   template<typename _CharT, typename _Traits>
 262     basic_ostream<_CharT, _Traits>&
 263     basic_ostream<_CharT, _Traits>::
 264     operator<<(unsigned long __n)
 265     {
 266       sentry __cerb(*this);
 267       if (__cerb)
 268         {
 269           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
 270           try
 271             {
 272               const __num_put_type& __np = __check_facet(this->_M_num_put);
 273               if (__np.put(*this, *this, this->fill(), __n).failed())
 274                 __err |= ios_base::badbit;
 275             }
 276           catch(...)
 277             { this->_M_setstate(ios_base::badbit); }
 278           if (__err)
 279             this->setstate(__err);
 280         }
 281       return *this;
 282     }
 283
 284 #ifdef _GLIBCXX_USE_LONG_LONG
 285   template<typename _CharT, typename _Traits>
 286     basic_ostream<_CharT, _Traits>&
 287     basic_ostream<_CharT, _Traits>::
 288     operator<<(long long __n)
 289     {
 290       sentry __cerb(*this);
 291       if (__cerb)
 292         {
 293           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
 294           try
 295             {
 296               const __num_put_type& __np = __check_facet(this->_M_num_put);
 297               if (__np.put(*this, *this, this->fill(), __n).failed())
 298                 __err |= ios_base::badbit;
 299             }
 300           catch(...)
 301             { this->_M_setstate(ios_base::badbit); }
 302           if (__err)
 303             this->setstate(__err);
 304         }
 305       return *this;
 306     }
 307
 308   template<typename _CharT, typename _Traits>
 309     basic_ostream<_CharT, _Traits>&
 310     basic_ostream<_CharT, _Traits>::
 311     operator<<(unsigned long long __n)
 312     {
 313       sentry __cerb(*this);
 314       if (__cerb)
 315         {
 316           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
 317           try
 318             {
 319               const __num_put_type& __np = __check_facet(this->_M_num_put);
 320               if (__np.put(*this, *this, this->fill(), __n).failed())
 321                 __err |= ios_base::badbit;
 322             }
 323           catch(...)
 324             { this->_M_setstate(ios_base::badbit); }
 325           if (__err)
 326             this->setstate(__err);
 327         }
 328       return *this;
 329     }
 330 #endif
 331
 332   template<typename _CharT, typename _Traits>
 333     basic_ostream<_CharT, _Traits>&
 334     basic_ostream<_CharT, _Traits>::
 335     operator<<(float __n)
 336     {
 337       sentry __cerb(*this);
 338       if (__cerb)
 339         {
 340           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
 341           try
 342             {
 343               // _GLIBCXX_RESOLVE_LIB_DEFECTS
 344               // 117. basic_ostream uses nonexistent num_put member functions.
 345               const __num_put_type& __np = __check_facet(this->_M_num_put);
 346               if (__np.put(*this, *this, this->fill(),
 347                            static_cast<double>(__n)).failed())
 348                 __err |= ios_base::badbit;
 349             }
 350           catch(...)
 351             { this->_M_setstate(ios_base::badbit); }
 352           if (__err)
 353             this->setstate(__err);
 354         }
 355       return *this;
 356     }
 357
 358   template<typename _CharT, typename _Traits>
 359     basic_ostream<_CharT, _Traits>&
 360     basic_ostream<_CharT, _Traits>::
 361     operator<<(double __n)
 362     {
 363       sentry __cerb(*this);
 364       if (__cerb)
 365         {
 366           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
 367           try
 368             {
 369               const __num_put_type& __np = __check_facet(this->_M_num_put);
 370               if (__np.put(*this, *this, this->fill(), __n).failed())
 371                 __err |= ios_base::badbit;
 372             }
 373           catch(...)
 374             { this->_M_setstate(ios_base::badbit); }
 375           if (__err)
 376             this->setstate(__err);
 377         }
 378       return *this;
 379     }
 380
 381   template<typename _CharT, typename _Traits>
 382     basic_ostream<_CharT, _Traits>&
 383     basic_ostream<_CharT, _Traits>::
 384     operator<<(long double __n)
 385     {
 386       sentry __cerb(*this);
 387       if (__cerb)
 388         {
 389           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
 390           try
 391             {
 392               const __num_put_type& __np = __check_facet(this->_M_num_put);
 393               if (__np.put(*this, *this, this->fill(), __n).failed())
 394                 __err |= ios_base::badbit;
 395             }
 396           catch(...)
 397             { this->_M_setstate(ios_base::badbit); }
 398           if (__err)
 399             this->setstate(__err);
 400         }
 401       return *this;
 402     }
 403
 404   template<typename _CharT, typename _Traits>
 405     basic_ostream<_CharT, _Traits>&
 406     basic_ostream<_CharT, _Traits>::
 407     operator<<(const void* __n)
 408     {
 409       sentry __cerb(*this);
 410       if (__cerb)
 411         {
 412           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
 413           try
 414             {
 415               const __num_put_type& __np = __check_facet(this->_M_num_put);
 416               if (__np.put(*this, *this, this->fill(), __n).failed())
 417                 __err |= ios_base::badbit;
 418             }
 419           catch(...)
 420             { this->_M_setstate(ios_base::badbit); }
 421           if (__err)
 422             this->setstate(__err);
 423         }
 424       return *this;
 425     }
 426
 427   template<typename _CharT, typename _Traits>
 428     basic_ostream<_CharT, _Traits>&
 429     basic_ostream<_CharT, _Traits>::
 430     operator<<(__streambuf_type* __sbin)
 431     {
 432       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
 433       sentry __cerb(*this);
 434       if (__cerb && __sbin)
 435         {
 436           try
 437             {
 438               if (!__copy_streambufs(__sbin, this->rdbuf()))
 439                 __err |= ios_base::failbit;
 440             }
 441           catch(...)
 442             { this->_M_setstate(ios_base::failbit); }
 443         }
 444       else if (!__sbin)
 445         __err |= ios_base::badbit;
 446       if (__err)
 447         this->setstate(__err);
 448       return *this;
 449     }
 450
 451   template<typename _CharT, typename _Traits>
 452     basic_ostream<_CharT, _Traits>&
 453     basic_ostream<_CharT, _Traits>::
 454     put(char_type __c)
 455     {
 456       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 457       // DR 60. What is a formatted input function?
 458       // basic_ostream::put(char_type) is an unformatted output function.
 459       // DR 63. Exception-handling policy for unformatted output.
 460       // Unformatted output functions should catch exceptions thrown
 461       // from streambuf members.
 462       sentry __cerb(*this);
 463       if (__cerb)
 464         {
 465           ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
 466           try
 467             {
 468               const int_type __put = this->rdbuf()->sputc(__c);
 469               if (traits_type::eq_int_type(__put, traits_type::eof()))
 470                 __err |= ios_base::badbit;
 471             }
 472           catch (...)
 473             { this->_M_setstate(ios_base::badbit); }
 474           if (__err)
 475             this->setstate(__err);
 476         }
 477       return *this;
 478     }
 479
 480   template<typename _CharT, typename _Traits>
 481     basic_ostream<_CharT, _Traits>&
 482     basic_ostream<_CharT, _Traits>::
 483     write(const _CharT* __s, streamsize __n)
 484     {
 485       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 486       // DR 60. What is a formatted input function?
 487       // basic_ostream::write(const char_type*, streamsize) is an
 488       // unformatted output function.
 489       // DR 63. Exception-handling policy for unformatted output.
 490       // Unformatted output functions should catch exceptions thrown
 491       // from streambuf members.
 492       sentry __cerb(*this);
 493       if (__cerb)
 494         {
 495           try
 496             { _M_write(__s, __n); }
 497           catch (...)
 498             { this->_M_setstate(ios_base::badbit); }
 499         }
 500       return *this;
 501     }
 502
 503   template<typename _CharT, typename _Traits>
 504     basic_ostream<_CharT, _Traits>&
 505     basic_ostream<_CharT, _Traits>::
 506     flush()
 507     {
 508       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 509       // DR 60. What is a formatted input function?
 510       // basic_ostream::flush() is *not* an unformatted output function.
 511       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
 512       try
 513         {
 514           if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
 515             __err |= ios_base::badbit;
 516         }
 517       catch(...)
 518         { this->_M_setstate(ios_base::badbit); }
 519       if (__err)
 520         this->setstate(__err);
 521       return *this;
 522     }
 523
 524   template<typename _CharT, typename _Traits>
 525     typename basic_ostream<_CharT, _Traits>::pos_type
 526     basic_ostream<_CharT, _Traits>::
 527     tellp()
 528     {
 529       pos_type __ret = pos_type(-1);
 530       try
 531         {
 532           if (!this->fail())
 533             __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
 534         }
 535       catch(...)
 536         { this->_M_setstate(ios_base::badbit); }
 537       return __ret;
 538     }
 539
 540   template<typename _CharT, typename _Traits>
 541     basic_ostream<_CharT, _Traits>&
 542     basic_ostream<_CharT, _Traits>::
 543     seekp(pos_type __pos)
 544     {
 545       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
 546       try
 547         {
 548           if (!this->fail())
 549             {
 550               // _GLIBCXX_RESOLVE_LIB_DEFECTS
 551               // 136.  seekp, seekg setting wrong streams?
 552               const pos_type __p = this->rdbuf()->pubseekpos(__pos,
 553                                                              ios_base::out);
 554
 555               // 129. Need error indication from seekp() and seekg()
 556               if (__p == pos_type(off_type(-1)))
 557                 __err |= ios_base::failbit;
 558             }
 559         }
 560       catch(...)
 561         { this->_M_setstate(ios_base::badbit); }
 562       if (__err)
 563         this->setstate(__err);
 564       return *this;
 565     }
 566
 567   template<typename _CharT, typename _Traits>
 568     basic_ostream<_CharT, _Traits>&
 569     basic_ostream<_CharT, _Traits>::
 570     seekp(off_type __off, ios_base::seekdir __dir)
 571     {
 572       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
 573       try
 574         {
 575           if (!this->fail())
 576             {
 577               // _GLIBCXX_RESOLVE_LIB_DEFECTS
 578               // 136.  seekp, seekg setting wrong streams?
 579               const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
 580                                                              ios_base::out);
 581
 582               // 129. Need error indication from seekp() and seekg()
 583               if (__p == pos_type(off_type(-1)))
 584                 __err |= ios_base::failbit;
 585             }
 586         }
 587       catch(...)
 588         { this->_M_setstate(ios_base::badbit); }
 589       if (__err)
 590         this->setstate(__err);
 591       return *this;
 592     }
 593
 594   // 27.6.2.5.4 Character inserters.
 595   template<typename _CharT, typename _Traits>
 596     basic_ostream<_CharT, _Traits>&
 597     operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
 598     {
 599       typedef basic_ostream<_CharT, _Traits> __ostream_type;
 600       typename __ostream_type::sentry __cerb(__out);
 601       if (__cerb)
 602         {
 603           try
 604             {
 605               const streamsize __w = __out.width();
 606               streamsize __len = 1;
 607               _CharT* __cs = &__c;
 608               if (__w > __len)
 609                 {
 610                   __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
 611                                                                * __w));
 612                   __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs,
 613                                                  &__c, __w, __len, false);
 614                   __len = __w;
 615                 }
 616               __out._M_write(__cs, __len);
 617               __out.width(0);
 618             }
 619           catch(...)
 620             { __out._M_setstate(ios_base::badbit); }
 621         }
 622       return __out;
 623     }
 624
 625   // Specializations.
 626   template <class _Traits>
 627     basic_ostream<char, _Traits>&
 628     operator<<(basic_ostream<char, _Traits>& __out, char __c)
 629     {
 630       typedef basic_ostream<char, _Traits> __ostream_type;
 631       typename __ostream_type::sentry __cerb(__out);
 632       if (__cerb)
 633         {
 634           try
 635             {
 636               const streamsize __w = __out.width();
 637               streamsize __len = 1;
 638               char* __cs = &__c;
 639               if (__w > __len)
 640                 {
 641                   __cs = static_cast<char*>(__builtin_alloca(__w));
 642                   __pad<char, _Traits>::_S_pad(__out, __out.fill(), __cs,
 643                                                &__c, __w, __len, false);
 644                   __len = __w;
 645                 }
 646               __out._M_write(__cs, __len);
 647               __out.width(0);
 648             }
 649           catch(...)
 650             { __out._M_setstate(ios_base::badbit); }
 651         }
 652       return __out;
 653      }
 654
 655   template<typename _CharT, typename _Traits>
 656     basic_ostream<_CharT, _Traits>&
 657     operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
 658     {
 659       typedef basic_ostream<_CharT, _Traits> __ostream_type;
 660       typename __ostream_type::sentry __cerb(__out);
 661       if (__cerb && __s)
 662         {
 663           try
 664             {
 665               const streamsize __w = __out.width();
 666               streamsize __len = static_cast<streamsize>(_Traits::length(__s));
 667               if (__w > __len)
 668                 {
 669                   _CharT* __cs = (static_cast<
 670                                   _CharT*>(__builtin_alloca(sizeof(_CharT)
 671                                                             * __w)));
 672                   __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs,
 673                                                  __s, __w, __len, false);
 674                   __s = __cs;
 675                   __len = __w;
 676                 }
 677               __out._M_write(__s, __len);
 678               __out.width(0);
 679             }
 680           catch(...)
 681             { __out._M_setstate(ios_base::badbit); }
 682         }
 683       else if (!__s)
 684         __out.setstate(ios_base::badbit);
 685       return __out;
 686     }
 687
 688   template<typename _CharT, typename _Traits>
 689     basic_ostream<_CharT, _Traits>&
 690     operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
 691     {
 692       typedef basic_ostream<_CharT, _Traits> __ostream_type;
 693       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 694       // 167.  Improper use of traits_type::length()
 695       // Note that this is only in 'Review' status.
 696       typedef char_traits<char>              __traits_type;
 697       typename __ostream_type::sentry __cerb(__out);
 698       if (__cerb && __s)
 699         {
 700           size_t __clen = __traits_type::length(__s);
 701           _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
 702                                                                * __clen));
 703           for (size_t  __i = 0; __i < __clen; ++__i)
 704             __ws[__i] = __out.widen(__s[__i]);
 705           _CharT* __str = __ws;
 706
 707           try
 708             {
 709               const streamsize __w = __out.width();
 710               streamsize __len = static_cast<streamsize>(__clen);
 711               if (__w > __len)
 712                 {
 713                   _CharT* __cs = (static_cast<
 714                                   _CharT*>(__builtin_alloca(sizeof(_CharT)
 715                                                             * __w)));
 716                   __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs,
 717                                                  __ws, __w, __len, false);
 718                   __str = __cs;
 719                   __len = __w;
 720                 }
 721               __out._M_write(__str, __len);
 722               __out.width(0);
 723             }
 724           catch(...)
 725             { __out._M_setstate(ios_base::badbit); }
 726         }
 727       else if (!__s)
 728         __out.setstate(ios_base::badbit);
 729       return __out;
 730     }
 731
 732   // Partial specializations.
 733   template<class _Traits>
 734     basic_ostream<char, _Traits>&
 735     operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
 736     {
 737       typedef basic_ostream<char, _Traits> __ostream_type;
 738       typename __ostream_type::sentry __cerb(__out);
 739       if (__cerb && __s)
 740         {
 741           try
 742             {
 743               const streamsize __w = __out.width();
 744               streamsize __len = static_cast<streamsize>(_Traits::length(__s));
 745               if (__w > __len)
 746                 {
 747                   char* __cs = static_cast<char*>(__builtin_alloca(__w));
 748                   __pad<char, _Traits>::_S_pad(__out, __out.fill(), __cs,
 749                                                  __s, __w, __len, false);
 750                   __s = __cs;
 751                   __len = __w;
 752                 }
 753               __out._M_write(__s, __len);
 754               __out.width(0);
 755             }
 756           catch(...)
 757             { __out._M_setstate(ios_base::badbit); }
 758         }
 759       else if (!__s)
 760         __out.setstate(ios_base::badbit);
 761       return __out;
 762     }
 763
 764   // 21.3.7.9 basic_string::operator<<
 765   template<typename _CharT, typename _Traits, typename _Alloc>
 766     basic_ostream<_CharT, _Traits>&
 767     operator<<(basic_ostream<_CharT, _Traits>& __out,
 768                const basic_string<_CharT, _Traits, _Alloc>& __str)
 769     {
 770       typedef basic_ostream<_CharT, _Traits> __ostream_type;
 771       typename __ostream_type::sentry __cerb(__out);
 772       if (__cerb)
 773         {
 774           const streamsize __w = __out.width();
 775           streamsize __len = static_cast<streamsize>(__str.size());
 776           const _CharT* __s = __str.data();
 777
 778           // _GLIBCXX_RESOLVE_LIB_DEFECTS
 779           // 25. String operator<< uses width() value wrong
 780           if (__w > __len)
 781             {
 782               _CharT* __cs = (static_cast<
 783                               _CharT*>(__builtin_alloca(sizeof(_CharT) * __w)));
 784               __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs, __s,
 785                                              __w, __len, false);
 786               __s = __cs;
 787               __len = __w;
 788             }
 789           __out._M_write(__s, __len);
 790           __out.width(0);
 791         }
 792       return __out;
 793     }
 794
 795   // Inhibit implicit instantiations for required instantiations,
 796   // which are defined via explicit instantiations elsewhere.
 797   // NB:  This syntax is a GNU extension.
 798 #if _GLIBCXX_EXTERN_TEMPLATE
 799   extern template class basic_ostream<char>;
 800   extern template ostream& endl(ostream&);
 801   extern template ostream& ends(ostream&);
 802   extern template ostream& flush(ostream&);
 803   extern template ostream& operator<<(ostream&, char);
 804   extern template ostream& operator<<(ostream&, unsigned char);
 805   extern template ostream& operator<<(ostream&, signed char);
 806   extern template ostream& operator<<(ostream&, const char*);
 807   extern template ostream& operator<<(ostream&, const unsigned char*);
 808   extern template ostream& operator<<(ostream&, const signed char*);
 809
 810 #ifdef _GLIBCXX_USE_WCHAR_T
 811   extern template class basic_ostream<wchar_t>;
 812   extern template wostream& endl(wostream&);
 813   extern template wostream& ends(wostream&);
 814   extern template wostream& flush(wostream&);
 815   extern template wostream& operator<<(wostream&, wchar_t);
 816   extern template wostream& operator<<(wostream&, char);
 817   extern template wostream& operator<<(wostream&, const wchar_t*);
 818   extern template wostream& operator<<(wostream&, const char*);
 819 #endif
 820 #endif
 821 } // namespace std
 822
 823 #endif