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