# ostream.tcc

Go to the documentation of this file.

    00001 // ostream classes -*- C++ -*-
    00002
    00003 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
    00004 // Free Software Foundation, Inc.
    00005 //
    00006 // This file is part of the GNU ISO C++ Library.  This library is free
    00007 // software; you can redistribute it and/or modify it under the
    00008 // terms of the GNU General Public License as published by the
    00009 // Free Software Foundation; either version 2, or (at your option)
    00010 // any later version.
    00011
    00012 // This library is distributed in the hope that it will be useful,
    00013 // but WITHOUT ANY WARRANTY; without even the implied warranty of
    00014 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    00015 // GNU General Public License for more details.
    00016
    00017 // You should have received a copy of the GNU General Public License along
    00018 // with this library; see the file COPYING.  If not, write to the Free
    00019 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
    00020 // USA.
    00021
    00022 // As a special exception, you may use this file as part of a free software
    00023 // library without restriction.  Specifically, if other files instantiate
    00024 // templates or use macros or inline functions from this file, or you compile
    00025 // this file and link it with other files to produce an executable, this
    00026 // file does not by itself cause the resulting executable to be covered by
    00027 // the GNU General Public License.  This exception does not however
    00028 // invalidate any other reasons why the executable file might be covered by
    00029 // the GNU General Public License.
    00030
    00031 /** @file ostream.tcc
    00032  *  This is an internal header file, included by other library headers.
    00033  *  You should not attempt to use it directly.
    00034  */
    00035
    00036 //
    00037 // ISO C++ 14882: 27.6.2  Output streams
    00038 //
    00039
    00040 #ifndef _OSTREAM_TCC
    00041 #define _OSTREAM_TCC 1
    00042
    00043 #pragma GCC system_header
    00044
    00045 #include <locale>
    00046
    00047 namespace std
    00048 {
    00049   template<typename _CharT, typename _Traits>
    00050     basic_ostream<_CharT, _Traits>::sentry::
    00051     sentry(basic_ostream<_CharT, _Traits>& __os)
    00052     : _M_ok(false), _M_os(__os)
    00053     {
    00054       // XXX MT
    00055       if (__os.tie() && __os.good())
    00056     __os.tie()->flush();
    00057
    00058       if (__os.good())
    00059     _M_ok = true;
    00060       else
    00061     __os.setstate(ios_base::failbit);
    00062     }
    00063
    00064   template<typename _CharT, typename _Traits>
    00065     basic_ostream<_CharT, _Traits>&
    00066     basic_ostream<_CharT, _Traits>::
    00067     operator<<(__ostream_type& (*__pf)(__ostream_type&))
    00068     {
    00069       // _GLIBCXX_RESOLVE_LIB_DEFECTS
    00070       // DR 60. What is a formatted input function?
    00071       // The inserters for manipulators are *not* formatted output functions.
    00072       return __pf(*this);
    00073     }
    00074
    00075   template<typename _CharT, typename _Traits>
    00076     basic_ostream<_CharT, _Traits>&
    00077     basic_ostream<_CharT, _Traits>::
    00078     operator<<(__ios_type& (*__pf)(__ios_type&))
    00079     {
    00080       // _GLIBCXX_RESOLVE_LIB_DEFECTS
    00081       // DR 60. What is a formatted input function?
    00082       // The inserters for manipulators are *not* formatted output functions.
    00083       __pf(*this);
    00084       return *this;
    00085     }
    00086
    00087   template<typename _CharT, typename _Traits>
    00088     basic_ostream<_CharT, _Traits>&
    00089     basic_ostream<_CharT, _Traits>::
    00090     operator<<(ios_base& (*__pf)(ios_base&))
    00091     {
    00092       // _GLIBCXX_RESOLVE_LIB_DEFECTS
    00093       // DR 60. What is a formatted input function?
    00094       // The inserters for manipulators are *not* formatted output functions.
    00095       __pf(*this);
    00096       return *this;
    00097     }
    00098
    00099   template<typename _CharT, typename _Traits>
    00100     basic_ostream<_CharT, _Traits>&
    00101     basic_ostream<_CharT, _Traits>::
    00102     operator<<(bool __n)
    00103     {
    00104       sentry __cerb(*this);
    00105       if (__cerb)
    00106     {
    00107       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
    00108       try
    00109         {
    00110           const __num_put_type& __np = __check_facet(this->_M_num_put);
    00111           if (__np.put(*this, *this, this->fill(), __n).failed())
    00112         __err |= ios_base::badbit;
    00113         }
    00114       catch(...)
    00115         { this->_M_setstate(ios_base::badbit); }
    00116       if (__err)
    00117         this->setstate(__err);
    00118     }
    00119       return *this;
    00120     }
    00121
    00122   template<typename _CharT, typename _Traits>
    00123     basic_ostream<_CharT, _Traits>&
    00124     basic_ostream<_CharT, _Traits>::
    00125     operator<<(long __n)
    00126     {
    00127       sentry __cerb(*this);
    00128       if (__cerb)
    00129     {
    00130       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
    00131       try
    00132         {
    00133           bool __b = false;
    00134           const char_type __c = this->fill();
    00135           const ios_base::fmtflags __fmt = (this->flags()
    00136                         & ios_base::basefield);
    00137           const __num_put_type& __np = __check_facet(this->_M_num_put);
    00138           if ((__fmt & ios_base::oct) || (__fmt & ios_base::hex))
    00139         {
    00140           const unsigned long __l = static_cast<unsigned long>(__n);
    00141           __b = __np.put(*this, *this, __c, __l).failed();
    00142         }
    00143           else
    00144         __b = __np.put(*this, *this, __c, __n).failed();
    00145           if (__b)
    00146         __err |= ios_base::badbit;
    00147         }
    00148       catch(...)
    00149         { this->_M_setstate(ios_base::badbit); }
    00150       if (__err)
    00151         this->setstate(__err);
    00152     }
    00153       return *this;
    00154     }
    00155
    00156   template<typename _CharT, typename _Traits>
    00157     basic_ostream<_CharT, _Traits>&
    00158     basic_ostream<_CharT, _Traits>::
    00159     operator<<(unsigned long __n)
    00160     {
    00161       sentry __cerb(*this);
    00162       if (__cerb)
    00163     {
    00164       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
    00165       try
    00166         {
    00167           const __num_put_type& __np = __check_facet(this->_M_num_put);
    00168           if (__np.put(*this, *this, this->fill(), __n).failed())
    00169         __err |= ios_base::badbit;
    00170         }
    00171       catch(...)
    00172         { this->_M_setstate(ios_base::badbit); }
    00173       if (__err)
    00174         this->setstate(__err);
    00175     }
    00176       return *this;
    00177     }
    00178
    00179 #ifdef _GLIBCXX_USE_LONG_LONG
    00180   template<typename _CharT, typename _Traits>
    00181     basic_ostream<_CharT, _Traits>&
    00182     basic_ostream<_CharT, _Traits>::
    00183     operator<<(long long __n)
    00184     {
    00185       sentry __cerb(*this);
    00186       if (__cerb)
    00187     {
    00188       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
    00189       try
    00190         {
    00191           bool __b = false;
    00192           const char_type __c = this->fill();
    00193           const ios_base::fmtflags __fmt = (this->flags()
    00194                         & ios_base::basefield);
    00195           const __num_put_type& __np = __check_facet(this->_M_num_put);
    00196           if ((__fmt & ios_base::oct) || (__fmt & ios_base::hex))
    00197         {
    00198           const unsigned long long __l = (static_cast<
    00199                           unsigned long long>(__n));
    00200           __b = __np.put(*this, *this, __c, __l).failed();
    00201         }
    00202           else
    00203         __b = __np.put(*this, *this, __c, __n).failed();
    00204           if (__b)
    00205         __err |= ios_base::badbit;
    00206         }
    00207       catch(...)
    00208         { this->_M_setstate(ios_base::badbit); }
    00209       if (__err)
    00210         this->setstate(__err);
    00211     }
    00212       return *this;
    00213     }
    00214
    00215   template<typename _CharT, typename _Traits>
    00216     basic_ostream<_CharT, _Traits>&
    00217     basic_ostream<_CharT, _Traits>::
    00218     operator<<(unsigned long long __n)
    00219     {
    00220       sentry __cerb(*this);
    00221       if (__cerb)
    00222     {
    00223       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
    00224       try
    00225         {
    00226           const __num_put_type& __np = __check_facet(this->_M_num_put);
    00227           if (__np.put(*this, *this, this->fill(), __n).failed())
    00228         __err |= ios_base::badbit;
    00229         }
    00230       catch(...)
    00231         { this->_M_setstate(ios_base::badbit); }
    00232       if (__err)
    00233         this->setstate(__err);
    00234     }
    00235       return *this;
    00236     }
    00237 #endif
    00238
    00239   template<typename _CharT, typename _Traits>
    00240     basic_ostream<_CharT, _Traits>&
    00241     basic_ostream<_CharT, _Traits>::
    00242     operator<<(double __n)
    00243     {
    00244       sentry __cerb(*this);
    00245       if (__cerb)
    00246     {
    00247       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
    00248       try
    00249         {
    00250           const __num_put_type& __np = __check_facet(this->_M_num_put);
    00251           if (__np.put(*this, *this, this->fill(), __n).failed())
    00252         __err |= ios_base::badbit;
    00253         }
    00254       catch(...)
    00255         { this->_M_setstate(ios_base::badbit); }
    00256       if (__err)
    00257         this->setstate(__err);
    00258     }
    00259       return *this;
    00260     }
    00261
    00262   template<typename _CharT, typename _Traits>
    00263     basic_ostream<_CharT, _Traits>&
    00264     basic_ostream<_CharT, _Traits>::
    00265     operator<<(long double __n)
    00266     {
    00267       sentry __cerb(*this);
    00268       if (__cerb)
    00269     {
    00270       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
    00271       try
    00272         {
    00273           const __num_put_type& __np = __check_facet(this->_M_num_put);
    00274           if (__np.put(*this, *this, this->fill(), __n).failed())
    00275         __err |= ios_base::badbit;
    00276         }
    00277       catch(...)
    00278         { this->_M_setstate(ios_base::badbit); }
    00279       if (__err)
    00280         this->setstate(__err);
    00281     }
    00282       return *this;
    00283     }
    00284
    00285   template<typename _CharT, typename _Traits>
    00286     basic_ostream<_CharT, _Traits>&
    00287     basic_ostream<_CharT, _Traits>::
    00288     operator<<(const void* __n)
    00289     {
    00290       sentry __cerb(*this);
    00291       if (__cerb)
    00292     {
    00293       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
    00294       try
    00295         {
    00296           const __num_put_type& __np = __check_facet(this->_M_num_put);
    00297           if (__np.put(*this, *this, this->fill(), __n).failed())
    00298         __err |= ios_base::badbit;
    00299         }
    00300       catch(...)
    00301         { this->_M_setstate(ios_base::badbit); }
    00302       if (__err)
    00303         this->setstate(__err);
    00304     }
    00305       return *this;
    00306     }
    00307
    00308   template<typename _CharT, typename _Traits>
    00309     basic_ostream<_CharT, _Traits>&
    00310     basic_ostream<_CharT, _Traits>::
    00311     operator<<(__streambuf_type* __sbin)
    00312     {
    00313       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
    00314       sentry __cerb(*this);
    00315       if (__cerb && __sbin)
    00316     {
    00317       try
    00318         {
    00319           if (!__copy_streambufs(__sbin, this->rdbuf()))
    00320         __err |= ios_base::failbit;
    00321         }
    00322       catch(...)
    00323         { this->_M_setstate(ios_base::failbit); }
    00324     }
    00325       else if (!__sbin)
    00326     __err |= ios_base::badbit;
    00327       if (__err)
    00328     this->setstate(__err);
    00329       return *this;
    00330     }
    00331
    00332   template<typename _CharT, typename _Traits>
    00333     basic_ostream<_CharT, _Traits>&
    00334     basic_ostream<_CharT, _Traits>::
    00335     put(char_type __c)
    00336     {
    00337       // _GLIBCXX_RESOLVE_LIB_DEFECTS
    00338       // DR 60. What is a formatted input function?
    00339       // basic_ostream::put(char_type) is an unformatted output function.
    00340       // DR 63. Exception-handling policy for unformatted output.
    00341       // Unformatted output functions should catch exceptions thrown
    00342       // from streambuf members.
    00343       sentry __cerb(*this);
    00344       if (__cerb)
    00345     {
    00346       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
    00347       try
    00348         {
    00349           const int_type __put = this->rdbuf()->sputc(__c);
    00350           if (traits_type::eq_int_type(__put, traits_type::eof()))
    00351         __err |= ios_base::badbit;
    00352         }
    00353       catch (...)
    00354         { this->_M_setstate(ios_base::badbit); }
    00355       if (__err)
    00356         this->setstate(__err);
    00357     }
    00358       return *this;
    00359     }
    00360
    00361   template<typename _CharT, typename _Traits>
    00362     basic_ostream<_CharT, _Traits>&
    00363     basic_ostream<_CharT, _Traits>::
    00364     write(const _CharT* __s, streamsize __n)
    00365     {
    00366       // _GLIBCXX_RESOLVE_LIB_DEFECTS
    00367       // DR 60. What is a formatted input function?
    00368       // basic_ostream::write(const char_type*, streamsize) is an
    00369       // unformatted output function.
    00370       // DR 63. Exception-handling policy for unformatted output.
    00371       // Unformatted output functions should catch exceptions thrown
    00372       // from streambuf members.
    00373       sentry __cerb(*this);
    00374       if (__cerb)
    00375     {
    00376       try
    00377         { _M_write(__s, __n); }
    00378       catch (...)
    00379         { this->_M_setstate(ios_base::badbit); }
    00380     }
    00381       return *this;
    00382     }
    00383
    00384   template<typename _CharT, typename _Traits>
    00385     basic_ostream<_CharT, _Traits>&
    00386     basic_ostream<_CharT, _Traits>::
    00387     flush()
    00388     {
    00389       // _GLIBCXX_RESOLVE_LIB_DEFECTS
    00390       // DR 60. What is a formatted input function?
    00391       // basic_ostream::flush() is *not* an unformatted output function.
    00392       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
    00393       try
    00394     {
    00395       if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
    00396         __err |= ios_base::badbit;
    00397     }
    00398       catch(...)
    00399     { this->_M_setstate(ios_base::badbit); }
    00400       if (__err)
    00401     this->setstate(__err);
    00402       return *this;
    00403     }
    00404
    00405   template<typename _CharT, typename _Traits>
    00406     typename basic_ostream<_CharT, _Traits>::pos_type
    00407     basic_ostream<_CharT, _Traits>::
    00408     tellp()
    00409     {
    00410       pos_type __ret = pos_type(-1);
    00411       try
    00412     {
    00413       if (!this->fail())
    00414         __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
    00415     }
    00416       catch(...)
    00417     { this->_M_setstate(ios_base::badbit); }
    00418       return __ret;
    00419     }
    00420
    00421   template<typename _CharT, typename _Traits>
    00422     basic_ostream<_CharT, _Traits>&
    00423     basic_ostream<_CharT, _Traits>::
    00424     seekp(pos_type __pos)
    00425     {
    00426       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
    00427       try
    00428     {
    00429       if (!this->fail())
    00430         {
    00431           // _GLIBCXX_RESOLVE_LIB_DEFECTS
    00432           // 136.  seekp, seekg setting wrong streams?
    00433           const pos_type __p = this->rdbuf()->pubseekpos(__pos,
    00434                                  ios_base::out);
    00435
    00436           // 129. Need error indication from seekp() and seekg()
    00437           if (__p == pos_type(off_type(-1)))
    00438         __err |= ios_base::failbit;
    00439         }
    00440     }
    00441       catch(...)
    00442     { this->_M_setstate(ios_base::badbit); }
    00443       if (__err)
    00444     this->setstate(__err);
    00445       return *this;
    00446     }
    00447
    00448   template<typename _CharT, typename _Traits>
    00449     basic_ostream<_CharT, _Traits>&
    00450     basic_ostream<_CharT, _Traits>::
    00451     seekp(off_type __off, ios_base::seekdir __dir)
    00452     {
    00453       ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
    00454       try
    00455     {
    00456       if (!this->fail())
    00457         {
    00458           // _GLIBCXX_RESOLVE_LIB_DEFECTS
    00459           // 136.  seekp, seekg setting wrong streams?
    00460           const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
    00461                                  ios_base::out);
    00462
    00463           // 129. Need error indication from seekp() and seekg()
    00464           if (__p == pos_type(off_type(-1)))
    00465         __err |= ios_base::failbit;
    00466         }
    00467     }
    00468       catch(...)
    00469     { this->_M_setstate(ios_base::badbit); }
    00470       if (__err)
    00471     this->setstate(__err);
    00472       return *this;
    00473     }
    00474
    00475   // 27.6.2.5.4 Character inserters.
    00476   template<typename _CharT, typename _Traits>
    00477     basic_ostream<_CharT, _Traits>&
    00478     operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
    00479     {
    00480       typedef basic_ostream<_CharT, _Traits> __ostream_type;
    00481       typename __ostream_type::sentry __cerb(__out);
    00482       if (__cerb)
    00483     {
    00484       try
    00485         {
    00486           const streamsize __w = __out.width();
    00487           streamsize __len = 1;
    00488           _CharT* __cs = &__c;
    00489           if (__w > __len)
    00490         {
    00491           __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
    00492                                    * __w));
    00493           __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs,
    00494                          &__c, __w, __len, false);
    00495           __len = __w;
    00496         }
    00497           __out._M_write(__cs, __len);
    00498           __out.width(0);
    00499         }
    00500       catch(...)
    00501         { __out._M_setstate(ios_base::badbit); }
    00502     }
    00503       return __out;
    00504     }
    00505
    00506   // Specializations.
    00507   template <class _Traits>
    00508     basic_ostream<char, _Traits>&
    00509     operator<<(basic_ostream<char, _Traits>& __out, char __c)
    00510     {
    00511       typedef basic_ostream<char, _Traits> __ostream_type;
    00512       typename __ostream_type::sentry __cerb(__out);
    00513       if (__cerb)
    00514     {
    00515       try
    00516         {
    00517           const streamsize __w = __out.width();
    00518           streamsize __len = 1;
    00519           char* __cs = &__c;
    00520           if (__w > __len)
    00521         {
    00522           __cs = static_cast<char*>(__builtin_alloca(__w));
    00523           __pad<char, _Traits>::_S_pad(__out, __out.fill(), __cs,
    00524                            &__c, __w, __len, false);
    00525           __len = __w;
    00526         }
    00527           __out._M_write(__cs, __len);
    00528           __out.width(0);
    00529         }
    00530       catch(...)
    00531         { __out._M_setstate(ios_base::badbit); }
    00532     }
    00533       return __out;
    00534      }
    00535
    00536   template<typename _CharT, typename _Traits>
    00537     basic_ostream<_CharT, _Traits>&
    00538     operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
    00539     {
    00540       typedef basic_ostream<_CharT, _Traits> __ostream_type;
    00541       typename __ostream_type::sentry __cerb(__out);
    00542       if (__cerb && __s)
    00543     {
    00544       try
    00545         {
    00546           const streamsize __w = __out.width();
    00547           streamsize __len = static_cast<streamsize>(_Traits::length(__s));
    00548           if (__w > __len)
    00549         {
    00550           _CharT* __cs = (static_cast<
    00551                   _CharT*>(__builtin_alloca(sizeof(_CharT)
    00552                                 * __w)));
    00553           __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs,
    00554                          __s, __w, __len, false);
    00555           __s = __cs;
    00556           __len = __w;
    00557         }
    00558           __out._M_write(__s, __len);
    00559           __out.width(0);
    00560         }
    00561       catch(...)
    00562         { __out._M_setstate(ios_base::badbit); }
    00563     }
    00564       else if (!__s)
    00565     __out.setstate(ios_base::badbit);
    00566       return __out;
    00567     }
    00568
    00569   template<typename _CharT, typename _Traits>
    00570     basic_ostream<_CharT, _Traits>&
    00571     operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
    00572     {
    00573       typedef basic_ostream<_CharT, _Traits> __ostream_type;
    00574       // _GLIBCXX_RESOLVE_LIB_DEFECTS
    00575       // 167.  Improper use of traits_type::length()
    00576       // Note that this is only in 'Review' status.
    00577       typedef char_traits<char>          __traits_type;
    00578       typename __ostream_type::sentry __cerb(__out);
    00579       if (__cerb && __s)
    00580     {
    00581       size_t __clen = __traits_type::length(__s);
    00582       _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
    00583                                    * __clen));
    00584       for (size_t  __i = 0; __i < __clen; ++__i)
    00585         __ws[__i] = __out.widen(__s[__i]);
    00586       _CharT* __str = __ws;
    00587
    00588       try
    00589         {
    00590           const streamsize __w = __out.width();
    00591           streamsize __len = static_cast<streamsize>(__clen);
    00592           if (__w > __len)
    00593         {
    00594           _CharT* __cs = (static_cast<
    00595                   _CharT*>(__builtin_alloca(sizeof(_CharT)
    00596                                 * __w)));
    00597           __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs,
    00598                          __ws, __w, __len, false);
    00599           __str = __cs;
    00600           __len = __w;
    00601         }
    00602           __out._M_write(__str, __len);
    00603           __out.width(0);
    00604         }
    00605       catch(...)
    00606         { __out._M_setstate(ios_base::badbit); }
    00607     }
    00608       else if (!__s)
    00609     __out.setstate(ios_base::badbit);
    00610       return __out;
    00611     }
    00612
    00613   // Partial specializations.
    00614   template<class _Traits>
    00615     basic_ostream<char, _Traits>&
    00616     operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
    00617     {
    00618       typedef basic_ostream<char, _Traits> __ostream_type;
    00619       typename __ostream_type::sentry __cerb(__out);
    00620       if (__cerb && __s)
    00621     {
    00622       try
    00623         {
    00624           const streamsize __w = __out.width();
    00625           streamsize __len = static_cast<streamsize>(_Traits::length(__s));
    00626           if (__w > __len)
    00627         {
    00628           char* __cs = static_cast<char*>(__builtin_alloca(__w));
    00629           __pad<char, _Traits>::_S_pad(__out, __out.fill(), __cs,
    00630                          __s, __w, __len, false);
    00631           __s = __cs;
    00632           __len = __w;
    00633         }
    00634           __out._M_write(__s, __len);
    00635           __out.width(0);
    00636         }
    00637       catch(...)
    00638         { __out._M_setstate(ios_base::badbit); }
    00639     }
    00640       else if (!__s)
    00641     __out.setstate(ios_base::badbit);
    00642       return __out;
    00643     }
    00644
    00645   // 21.3.7.9 basic_string::operator<<
    00646   template<typename _CharT, typename _Traits, typename _Alloc>
    00647     basic_ostream<_CharT, _Traits>&
    00648     operator<<(basic_ostream<_CharT, _Traits>& __out,
    00649            const basic_string<_CharT, _Traits, _Alloc>& __str)
    00650     {
    00651       typedef basic_ostream<_CharT, _Traits> __ostream_type;
    00652       typename __ostream_type::sentry __cerb(__out);
    00653       if (__cerb)
    00654     {
    00655       const streamsize __w = __out.width();
    00656       streamsize __len = static_cast<streamsize>(__str.size());
    00657       const _CharT* __s = __str.data();
    00658
    00659       // _GLIBCXX_RESOLVE_LIB_DEFECTS
    00660       // 25. String operator<< uses width() value wrong
    00661       if (__w > __len)
    00662         {
    00663           _CharT* __cs = (static_cast<
    00664                   _CharT*>(__builtin_alloca(sizeof(_CharT) * __w)));
    00665           __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs, __s,
    00666                          __w, __len, false);
    00667           __s = __cs;
    00668           __len = __w;
    00669         }
    00670       __out._M_write(__s, __len);
    00671       __out.width(0);
    00672     }
    00673       return __out;
    00674     }
    00675
    00676   // Inhibit implicit instantiations for required instantiations,
    00677   // which are defined via explicit instantiations elsewhere.
    00678   // NB:  This syntax is a GNU extension.
    00679 #if _GLIBCXX_EXTERN_TEMPLATE
    00680   extern template class basic_ostream<char>;
    00681   extern template ostream& endl(ostream&);
    00682   extern template ostream& ends(ostream&);
    00683   extern template ostream& flush(ostream&);
    00684   extern template ostream& operator<<(ostream&, char);
    00685   extern template ostream& operator<<(ostream&, unsigned char);
    00686   extern template ostream& operator<<(ostream&, signed char);
    00687   extern template ostream& operator<<(ostream&, const char*);
    00688   extern template ostream& operator<<(ostream&, const unsigned char*);
    00689   extern template ostream& operator<<(ostream&, const signed char*);
    00690
    00691 #ifdef _GLIBCXX_USE_WCHAR_T
    00692   extern template class basic_ostream<wchar_t>;
    00693   extern template wostream& endl(wostream&);
    00694   extern template wostream& ends(wostream&);
    00695   extern template wostream& flush(wostream&);
    00696   extern template wostream& operator<<(wostream&, wchar_t);
    00697   extern template wostream& operator<<(wostream&, char);
    00698   extern template wostream& operator<<(wostream&, const wchar_t*);
    00699   extern template wostream& operator<<(wostream&, const char*);
    00700 #endif
    00701 #endif
    00702 } // namespace std
    00703
    00704 #endif