ostream.tcc

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

Generated on Wed May 1 19:19:33 2002 for libstdc++-v3 Source by doxygen1.2.15