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 #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_os(__os)
00045 {
00046
00047 if (__os.tie() && __os.good())
00048 __os.tie()->flush();
00049
00050 if (__os.good())
00051 _M_ok = true;
00052 else
00053 {
00054 _M_ok = false;
00055 __os.setstate(ios_base::failbit);
00056 }
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 _M_check_facet(this->_M_fnumput);
00106 const __numput_type& __np = *this->_M_fnumput;
00107 if (__np.put(*this, *this, this->fill(), __n).failed())
00108 __err |= ios_base::badbit;
00109 }
00110 catch(...)
00111 { this->_M_setstate(ios_base::badbit); }
00112 if (__err)
00113 this->setstate(__err);
00114 }
00115 return *this;
00116 }
00117
00118 template<typename _CharT, typename _Traits>
00119 basic_ostream<_CharT, _Traits>&
00120 basic_ostream<_CharT, _Traits>::
00121 operator<<(long __n)
00122 {
00123 sentry __cerb(*this);
00124 if (__cerb)
00125 {
00126 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00127 try
00128 {
00129 bool __b = false;
00130 char_type __c = this->fill();
00131 ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
00132 _M_check_facet(this->_M_fnumput);
00133 const __numput_type& __np = *this->_M_fnumput;
00134 if ((__fmt & ios_base::oct) || (__fmt & ios_base::hex))
00135 {
00136 unsigned long __l = static_cast<unsigned long>(__n);
00137 __b = __np.put(*this, *this, __c, __l).failed();
00138 }
00139 else
00140 __b = __np.put(*this, *this, __c, __n).failed();
00141 if (__b)
00142 __err |= ios_base::badbit;
00143 }
00144 catch(...)
00145 { this->_M_setstate(ios_base::badbit); }
00146 if (__err)
00147 this->setstate(__err);
00148 }
00149 return *this;
00150 }
00151
00152 template<typename _CharT, typename _Traits>
00153 basic_ostream<_CharT, _Traits>&
00154 basic_ostream<_CharT, _Traits>::
00155 operator<<(unsigned long __n)
00156 {
00157 sentry __cerb(*this);
00158 if (__cerb)
00159 {
00160 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00161 try
00162 {
00163 _M_check_facet(this->_M_fnumput);
00164 const __numput_type& __np = *this->_M_fnumput;
00165 if (__np.put(*this, *this, this->fill(), __n).failed())
00166 __err |= ios_base::badbit;
00167 }
00168 catch(...)
00169 { this->_M_setstate(ios_base::badbit); }
00170 if (__err)
00171 this->setstate(__err);
00172 }
00173 return *this;
00174 }
00175
00176 #ifdef _GLIBCPP_USE_LONG_LONG
00177 template<typename _CharT, typename _Traits>
00178 basic_ostream<_CharT, _Traits>&
00179 basic_ostream<_CharT, _Traits>::
00180 operator<<(long long __n)
00181 {
00182 sentry __cerb(*this);
00183 if (__cerb)
00184 {
00185 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00186 try
00187 {
00188 bool __b = false;
00189 char_type __c = this->fill();
00190 ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
00191 _M_check_facet(this->_M_fnumput);
00192 const __numput_type& __np = *this->_M_fnumput;
00193 if ((__fmt & ios_base::oct) || (__fmt & ios_base::hex))
00194 {
00195 unsigned long long __l;
00196 __l = static_cast<unsigned long long>(__n);
00197 __b = __np.put(*this, *this, __c, __l).failed();
00198 }
00199 else
00200 __b = __np.put(*this, *this, __c, __n).failed();
00201 if (__b)
00202 __err |= ios_base::badbit;
00203 }
00204 catch(...)
00205 { this->_M_setstate(ios_base::badbit); }
00206 if (__err)
00207 this->setstate(__err);
00208 }
00209 return *this;
00210 }
00211
00212 template<typename _CharT, typename _Traits>
00213 basic_ostream<_CharT, _Traits>&
00214 basic_ostream<_CharT, _Traits>::
00215 operator<<(unsigned long long __n)
00216 {
00217 sentry __cerb(*this);
00218 if (__cerb)
00219 {
00220 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00221 try
00222 {
00223 _M_check_facet(this->_M_fnumput);
00224 const __numput_type& __np = *this->_M_fnumput;
00225 if (__np.put(*this, *this, this->fill(), __n).failed())
00226 __err |= ios_base::badbit;
00227 }
00228 catch(...)
00229 { this->_M_setstate(ios_base::badbit); }
00230 if (__err)
00231 this->setstate(__err);
00232 }
00233 return *this;
00234 }
00235 #endif
00236
00237 template<typename _CharT, typename _Traits>
00238 basic_ostream<_CharT, _Traits>&
00239 basic_ostream<_CharT, _Traits>::
00240 operator<<(double __n)
00241 {
00242 sentry __cerb(*this);
00243 if (__cerb)
00244 {
00245 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00246 try
00247 {
00248 _M_check_facet(this->_M_fnumput);
00249 const __numput_type& __np = *this->_M_fnumput;
00250 if (__np.put(*this, *this, this->fill(), __n).failed())
00251 __err |= ios_base::badbit;
00252 }
00253 catch(...)
00254 { this->_M_setstate(ios_base::badbit); }
00255 if (__err)
00256 this->setstate(__err);
00257 }
00258 return *this;
00259 }
00260
00261 template<typename _CharT, typename _Traits>
00262 basic_ostream<_CharT, _Traits>&
00263 basic_ostream<_CharT, _Traits>::
00264 operator<<(long double __n)
00265 {
00266 sentry __cerb(*this);
00267 if (__cerb)
00268 {
00269 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00270 try
00271 {
00272 _M_check_facet(this->_M_fnumput);
00273 const __numput_type& __np = *this->_M_fnumput;
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 _M_check_facet(this->_M_fnumput);
00297 const __numput_type& __np = *this->_M_fnumput;
00298 if (__np.put(*this, *this, this->fill(), __n).failed())
00299 __err |= ios_base::badbit;
00300 }
00301 catch(...)
00302 { this->_M_setstate(ios_base::badbit); }
00303 if (__err)
00304 this->setstate(__err);
00305 }
00306 return *this;
00307 }
00308
00309 template<typename _CharT, typename _Traits>
00310 basic_ostream<_CharT, _Traits>&
00311 basic_ostream<_CharT, _Traits>::
00312 operator<<(__streambuf_type* __sbin)
00313 {
00314 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00315 sentry __cerb(*this);
00316 if (__cerb && __sbin)
00317 {
00318 try
00319 {
00320 if (!__copy_streambufs(*this, __sbin, this->rdbuf()))
00321 __err |= ios_base::failbit;
00322 }
00323 catch(...)
00324 { this->_M_setstate(ios_base::failbit); }
00325 }
00326 else if (!__sbin)
00327 __err |= ios_base::badbit;
00328 if (__err)
00329 this->setstate(__err);
00330 return *this;
00331 }
00332
00333 template<typename _CharT, typename _Traits>
00334 basic_ostream<_CharT, _Traits>&
00335 basic_ostream<_CharT, _Traits>::put(char_type __c)
00336 {
00337
00338
00339
00340
00341
00342
00343 sentry __cerb(*this);
00344 if (__cerb)
00345 {
00346 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00347 try
00348 {
00349 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>::write(const _CharT* __s, streamsize __n)
00364 {
00365
00366
00367
00368
00369
00370
00371
00372 sentry __cerb(*this);
00373 if (__cerb)
00374 {
00375 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00376 try
00377 {
00378 streamsize __put = this->rdbuf()->sputn(__s, __n);
00379 if (__put != __n)
00380 __err |= ios_base::badbit;
00381 }
00382 catch (...)
00383 { this->_M_setstate(ios_base::badbit); }
00384 if (__err)
00385 this->setstate(__err);
00386 }
00387 return *this;
00388 }
00389
00390 template<typename _CharT, typename _Traits>
00391 basic_ostream<_CharT, _Traits>&
00392 basic_ostream<_CharT, _Traits>::flush()
00393 {
00394
00395
00396
00397 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00398 try
00399 {
00400 if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
00401 __err |= ios_base::badbit;
00402 }
00403 catch(...)
00404 { this->_M_setstate(ios_base::badbit); }
00405 if (__err)
00406 this->setstate(__err);
00407 return *this;
00408 }
00409
00410 template<typename _CharT, typename _Traits>
00411 typename basic_ostream<_CharT, _Traits>::pos_type
00412 basic_ostream<_CharT, _Traits>::tellp()
00413 {
00414 pos_type __ret = pos_type(-1);
00415 try
00416 {
00417 if (!this->fail())
00418 __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
00419 }
00420 catch(...)
00421 { this->_M_setstate(ios_base::badbit); }
00422 return __ret;
00423 }
00424
00425
00426 template<typename _CharT, typename _Traits>
00427 basic_ostream<_CharT, _Traits>&
00428 basic_ostream<_CharT, _Traits>::seekp(pos_type __pos)
00429 {
00430 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00431 try
00432 {
00433 if (!this->fail())
00434 {
00435
00436
00437 pos_type __p = this->rdbuf()->pubseekpos(__pos, ios_base::out);
00438
00439
00440 if (__p == pos_type(off_type(-1)))
00441 __err |= ios_base::failbit;
00442 }
00443 }
00444 catch(...)
00445 { this->_M_setstate(ios_base::badbit); }
00446 if (__err)
00447 this->setstate(__err);
00448 return *this;
00449 }
00450
00451 template<typename _CharT, typename _Traits>
00452 basic_ostream<_CharT, _Traits>&
00453 basic_ostream<_CharT, _Traits>::
00454 seekp(off_type __off, ios_base::seekdir __dir)
00455 {
00456 ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
00457 try
00458 {
00459 if (!this->fail())
00460 {
00461
00462
00463 pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
00464 ios_base::out);
00465
00466
00467 if (__p == pos_type(off_type(-1)))
00468 __err |= ios_base::failbit;
00469 }
00470 }
00471 catch(...)
00472 { this->_M_setstate(ios_base::badbit); }
00473 if (__err)
00474 this->setstate(__err);
00475 return *this;
00476 }
00477
00478
00479 template<typename _CharT, typename _Traits>
00480 basic_ostream<_CharT, _Traits>&
00481 operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
00482 {
00483 typedef basic_ostream<_CharT, _Traits> __ostream_type;
00484 typename __ostream_type::sentry __cerb(__out);
00485 if (__cerb)
00486 {
00487 try
00488 {
00489 const streamsize __w = __out.width() > 0 ? __out.width() : 0;
00490 _CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * (__w + 1)));
00491 __pads[0] = __c;
00492 streamsize __len = 1;
00493 if (__w > __len)
00494 {
00495 __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __pads,
00496 &__c, __w, __len, false);
00497 __len = __w;
00498 }
00499 __out.write(__pads, __len);
00500 __out.width(0);
00501 }
00502 catch(...)
00503 { __out._M_setstate(ios_base::badbit); }
00504 }
00505 return __out;
00506 }
00507
00508
00509 template <class _Traits>
00510 basic_ostream<char, _Traits>&
00511 operator<<(basic_ostream<char, _Traits>& __out, char __c)
00512 {
00513 typedef basic_ostream<char, _Traits> __ostream_type;
00514 typename __ostream_type::sentry __cerb(__out);
00515 if (__cerb)
00516 {
00517 try
00518 {
00519 const streamsize __w = __out.width() > 0 ? __out.width() : 0;
00520 char* __pads = static_cast<char*>(__builtin_alloca(__w + 1));
00521 __pads[0] = __c;
00522 streamsize __len = 1;
00523 if (__w > __len)
00524 {
00525 __pad<char, _Traits>::_S_pad(__out, __out.fill(), __pads,
00526 &__c, __w, __len, false);
00527 __len = __w;
00528 }
00529 __out.write(__pads, __len);
00530 __out.width(0);
00531 }
00532 catch(...)
00533 { __out._M_setstate(ios_base::badbit); }
00534 }
00535 return __out;
00536 }
00537
00538 template<typename _CharT, typename _Traits>
00539 basic_ostream<_CharT, _Traits>&
00540 operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
00541 {
00542 typedef basic_ostream<_CharT, _Traits> __ostream_type;
00543 typename __ostream_type::sentry __cerb(__out);
00544 if (__cerb && __s)
00545 {
00546 try
00547 {
00548 const streamsize __w = __out.width() > 0 ? __out.width() : 0;
00549 _CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w));
00550 streamsize __len = static_cast<streamsize>(_Traits::length(__s));
00551 if (__w > __len)
00552 {
00553 __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __pads,
00554 __s, __w, __len, false);
00555 __s = __pads;
00556 __len = __w;
00557 }
00558 __out.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 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
00575
00576
00577 typedef char_traits<char> __traits_type;
00578 #endif
00579 typename __ostream_type::sentry __cerb(__out);
00580 if (__cerb && __s)
00581 {
00582 size_t __clen = __traits_type::length(__s);
00583 _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * (__clen + 1)));
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 streamsize __len = static_cast<streamsize>(__clen);
00591 const streamsize __w = __out.width() > 0 ? __out.width() : 0;
00592 _CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w));
00593
00594 if (__w > __len)
00595 {
00596 __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __pads,
00597 __ws, __w, __len, false);
00598 __str = __pads;
00599 __len = __w;
00600 }
00601 __out.write(__str, __len);
00602 __out.width(0);
00603 }
00604 catch(...)
00605 { __out._M_setstate(ios_base::badbit); }
00606 }
00607 else if (!__s)
00608 __out.setstate(ios_base::badbit);
00609 return __out;
00610 }
00611
00612
00613 template<class _Traits>
00614 basic_ostream<char, _Traits>&
00615 operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
00616 {
00617 typedef basic_ostream<char, _Traits> __ostream_type;
00618 typename __ostream_type::sentry __cerb(__out);
00619 if (__cerb && __s)
00620 {
00621 try
00622 {
00623 const streamsize __w = __out.width() > 0 ? __out.width() : 0;
00624 char* __pads = static_cast<char*>(__builtin_alloca(__w));
00625 streamsize __len = static_cast<streamsize>(_Traits::length(__s));
00626
00627 if (__w > __len)
00628 {
00629 __pad<char, _Traits>::_S_pad(__out, __out.fill(), __pads,
00630 __s, __w, __len, false);
00631 __s = __pads;
00632 __len = __w;
00633 }
00634 __out.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
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 _CharT* __s = __str.data();
00656 const streamsize __w = __out.width() > 0 ? __out.width() : 0;
00657 _CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w));
00658 streamsize __len = static_cast<streamsize>(__str.size());
00659 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
00660
00661 #endif
00662 if (__w > __len)
00663 {
00664 __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __pads, __s,
00665 __w, __len, false);
00666 __s = __pads;
00667 __len = __w;
00668 }
00669 streamsize __res = __out.rdbuf()->sputn(__s, __len);
00670 __out.width(0);
00671 if (__res != __len)
00672 __out.setstate(ios_base::failbit);
00673 }
00674 return __out;
00675 }
00676
00677
00678
00679
00680 #if _GLIBCPP_EXTERN_TEMPLATE
00681 extern template class basic_ostream<char>;
00682 extern template ostream& endl(ostream&);
00683 extern template ostream& ends(ostream&);
00684 extern template ostream& flush(ostream&);
00685 extern template ostream& operator<<(ostream&, char);
00686 extern template ostream& operator<<(ostream&, unsigned char);
00687 extern template ostream& operator<<(ostream&, signed char);
00688 extern template ostream& operator<<(ostream&, const char*);
00689 extern template ostream& operator<<(ostream&, const unsigned char*);
00690 extern template ostream& operator<<(ostream&, const signed char*);
00691
00692 #ifdef _GLIBCPP_USE_WCHAR_T
00693 extern template class basic_ostream<wchar_t>;
00694 extern template wostream& endl(wostream&);
00695 extern template wostream& ends(wostream&);
00696 extern template wostream& flush(wostream&);
00697 extern template wostream& operator<<(wostream&, wchar_t);
00698 extern template wostream& operator<<(wostream&, char);
00699 extern template wostream& operator<<(wostream&, const wchar_t*);
00700 extern template wostream& operator<<(wostream&, const char*);
00701 #endif
00702 #endif
00703 }