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 #include <bits/std_locale.h>
00033
00034 namespace std
00035 {
00036 template<typename _CharT, typename _Traits>
00037 basic_ostream<_CharT, _Traits>::sentry::
00038 sentry(basic_ostream<_CharT,_Traits>& __os)
00039 : _M_ok(__os.good()), _M_os(__os)
00040 {
00041
00042 if (_M_ok && __os.tie())
00043 __os.tie()->flush();
00044 }
00045
00046 template<typename _CharT, typename _Traits>
00047 basic_ostream<_CharT, _Traits>&
00048 basic_ostream<_CharT, _Traits>::
00049 operator<<(__ostream_type& (*__pf)(__ostream_type&))
00050 {
00051 sentry __cerb(*this);
00052 if (__cerb)
00053 {
00054 try
00055 { __pf(*this); }
00056 catch(exception& __fail)
00057 {
00058
00059
00060 this->setstate(ios_base::badbit);
00061 if ((this->exceptions() & ios_base::badbit) != 0)
00062 __throw_exception_again;
00063 }
00064 }
00065 return *this;
00066 }
00067
00068 template<typename _CharT, typename _Traits>
00069 basic_ostream<_CharT, _Traits>&
00070 basic_ostream<_CharT, _Traits>::
00071 operator<<(__ios_type& (*__pf)(__ios_type&))
00072 {
00073 sentry __cerb(*this);
00074 if (__cerb)
00075 {
00076 try
00077 { __pf(*this); }
00078 catch(exception& __fail)
00079 {
00080
00081
00082 this->setstate(ios_base::badbit);
00083 if ((this->exceptions() & ios_base::badbit) != 0)
00084 __throw_exception_again;
00085 }
00086 }
00087 return *this;
00088 }
00089
00090 template<typename _CharT, typename _Traits>
00091 basic_ostream<_CharT, _Traits>&
00092 basic_ostream<_CharT, _Traits>::
00093 operator<<(ios_base& (*__pf)(ios_base&))
00094 {
00095 sentry __cerb(*this);
00096 if (__cerb)
00097 {
00098 try
00099 { __pf(*this); }
00100 catch(exception& __fail)
00101 {
00102
00103
00104 this->setstate(ios_base::badbit);
00105 if ((this->exceptions() & ios_base::badbit) != 0)
00106 __throw_exception_again;
00107 }
00108 }
00109 return *this;
00110 }
00111
00112 template<typename _CharT, typename _Traits>
00113 basic_ostream<_CharT, _Traits>&
00114 basic_ostream<_CharT, _Traits>::operator<<(bool __n)
00115 {
00116 sentry __cerb(*this);
00117 if (__cerb)
00118 {
00119 try
00120 {
00121 if (_M_check_facet(_M_fnumput))
00122 if (_M_fnumput->put(*this, *this, this->fill(), __n).failed())
00123 this->setstate(ios_base::badbit);
00124 }
00125 catch(exception& __fail)
00126 {
00127
00128
00129 this->setstate(ios_base::badbit);
00130 if ((this->exceptions() & ios_base::badbit) != 0)
00131 __throw_exception_again;
00132 }
00133 }
00134 return *this;
00135 }
00136
00137 template<typename _CharT, typename _Traits>
00138 basic_ostream<_CharT, _Traits>&
00139 basic_ostream<_CharT, _Traits>::operator<<(long __n)
00140 {
00141 sentry __cerb(*this);
00142 if (__cerb)
00143 {
00144 try
00145 {
00146 char_type __c = this->fill();
00147 ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
00148 if (_M_check_facet(_M_fnumput))
00149 {
00150 bool __b = false;
00151 if (__fmt & ios_base::oct || __fmt & ios_base::hex)
00152 {
00153 unsigned long __l = static_cast<unsigned long>(__n);
00154 __b = _M_fnumput->put(*this, *this, __c, __l).failed();
00155 }
00156 else
00157 __b = _M_fnumput->put(*this, *this, __c, __n).failed();
00158 if (__b)
00159 this->setstate(ios_base::badbit);
00160 }
00161 }
00162 catch(exception& __fail)
00163 {
00164
00165
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<<(unsigned long __n)
00177 {
00178 sentry __cerb(*this);
00179 if (__cerb)
00180 {
00181 try
00182 {
00183 if (_M_check_facet(_M_fnumput))
00184 if (_M_fnumput->put(*this, *this, this->fill(), __n).failed())
00185 this->setstate(ios_base::badbit);
00186 }
00187 catch(exception& __fail)
00188 {
00189
00190
00191 this->setstate(ios_base::badbit);
00192 if ((this->exceptions() & ios_base::badbit) != 0)
00193 __throw_exception_again;
00194 }
00195 }
00196 return *this;
00197 }
00198
00199 #ifdef _GLIBCPP_USE_LONG_LONG
00200 template<typename _CharT, typename _Traits>
00201 basic_ostream<_CharT, _Traits>&
00202 basic_ostream<_CharT, _Traits>::operator<<(long long __n)
00203 {
00204 sentry __cerb(*this);
00205 if (__cerb)
00206 {
00207 try
00208 {
00209 char_type __c = this->fill();
00210 ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
00211 if (_M_check_facet(_M_fnumput))
00212 {
00213 bool __b = false;
00214 if (__fmt & ios_base::oct || __fmt & ios_base::hex)
00215 {
00216 unsigned long long __l;
00217 __l = static_cast<unsigned long long>(__n);
00218 __b = _M_fnumput->put(*this, *this, __c, __l).failed();
00219 }
00220 else
00221 __b = _M_fnumput->put(*this, *this, __c, __n).failed();
00222 if (__b)
00223 this->setstate(ios_base::badbit);
00224 }
00225 }
00226 catch(exception& __fail)
00227 {
00228
00229
00230 this->setstate(ios_base::badbit);
00231 if ((this->exceptions() & ios_base::badbit) != 0)
00232 __throw_exception_again;
00233 }
00234 }
00235 return *this;
00236 }
00237
00238 template<typename _CharT, typename _Traits>
00239 basic_ostream<_CharT, _Traits>&
00240 basic_ostream<_CharT, _Traits>::operator<<(unsigned long long __n)
00241 {
00242 sentry __cerb(*this);
00243 if (__cerb)
00244 {
00245 try
00246 {
00247 if (_M_check_facet(_M_fnumput))
00248 if (_M_fnumput->put(*this, *this, this->fill(), __n).failed())
00249 this->setstate(ios_base::badbit);
00250 }
00251 catch(exception& __fail)
00252 {
00253
00254
00255 this->setstate(ios_base::badbit);
00256 if ((this->exceptions() & ios_base::badbit) != 0)
00257 __throw_exception_again;
00258 }
00259 }
00260 return *this;
00261 }
00262 #endif
00263
00264 template<typename _CharT, typename _Traits>
00265 basic_ostream<_CharT, _Traits>&
00266 basic_ostream<_CharT, _Traits>::operator<<(double __n)
00267 {
00268 sentry __cerb(*this);
00269 if (__cerb)
00270 {
00271 try
00272 {
00273 if (_M_check_facet(_M_fnumput))
00274 if (_M_fnumput->put(*this, *this, this->fill(), __n).failed())
00275 this->setstate(ios_base::badbit);
00276 }
00277 catch(exception& __fail)
00278 {
00279
00280
00281 this->setstate(ios_base::badbit);
00282 if ((this->exceptions() & ios_base::badbit) != 0)
00283 __throw_exception_again;
00284 }
00285 }
00286 return *this;
00287 }
00288
00289 template<typename _CharT, typename _Traits>
00290 basic_ostream<_CharT, _Traits>&
00291 basic_ostream<_CharT, _Traits>::operator<<(long double __n)
00292 {
00293 sentry __cerb(*this);
00294 if (__cerb)
00295 {
00296 try
00297 {
00298 if (_M_check_facet(_M_fnumput))
00299 if (_M_fnumput->put(*this, *this, this->fill(), __n).failed())
00300 this->setstate(ios_base::badbit);
00301 }
00302 catch(exception& __fail)
00303 {
00304
00305
00306 this->setstate(ios_base::badbit);
00307 if ((this->exceptions() & ios_base::badbit) != 0)
00308 __throw_exception_again;
00309 }
00310 }
00311 return *this;
00312 }
00313
00314 template<typename _CharT, typename _Traits>
00315 basic_ostream<_CharT, _Traits>&
00316 basic_ostream<_CharT, _Traits>::operator<<(const void* __n)
00317 {
00318 sentry __cerb(*this);
00319 if (__cerb)
00320 {
00321 try
00322 {
00323 if (_M_check_facet(_M_fnumput))
00324 if (_M_fnumput->put(*this, *this, this->fill(), __n).failed())
00325 this->setstate(ios_base::badbit);
00326 }
00327 catch(exception& __fail)
00328 {
00329
00330
00331 this->setstate(ios_base::badbit);
00332 if ((this->exceptions() & ios_base::badbit) != 0)
00333 __throw_exception_again;
00334 }
00335 }
00336 return *this;
00337 }
00338
00339 template<typename _CharT, typename _Traits>
00340 basic_ostream<_CharT, _Traits>&
00341 basic_ostream<_CharT, _Traits>::operator<<(__streambuf_type* __sbin)
00342 {
00343 streamsize __xtrct = 0;
00344 __streambuf_type* __sbout = this->rdbuf();
00345 sentry __cerb(*this);
00346 if (__sbin && __cerb)
00347 __xtrct = __copy_streambufs(*this, __sbin, __sbout);
00348 if (!__sbin || !__xtrct)
00349 this->setstate(ios_base::failbit);
00350 return *this;
00351 }
00352
00353 template<typename _CharT, typename _Traits>
00354 basic_ostream<_CharT, _Traits>&
00355 basic_ostream<_CharT, _Traits>::put(char_type __c)
00356 {
00357 sentry __cerb(*this);
00358 if (__cerb)
00359 {
00360 int_type __put = rdbuf()->sputc(__c);
00361 if (__put != traits_type::to_int_type(__c))
00362 this->setstate(ios_base::badbit);
00363 }
00364 return *this;
00365 }
00366
00367 template<typename _CharT, typename _Traits>
00368 basic_ostream<_CharT, _Traits>&
00369 basic_ostream<_CharT, _Traits>::write(const _CharT* __s, streamsize __n)
00370 {
00371 sentry __cerb(*this);
00372 if (__cerb)
00373 {
00374 streamsize __put = this->rdbuf()->sputn(__s, __n);
00375 if ( __put != __n)
00376 this->setstate(ios_base::badbit);
00377 }
00378 return *this;
00379 }
00380
00381 template<typename _CharT, typename _Traits>
00382 basic_ostream<_CharT, _Traits>&
00383 basic_ostream<_CharT, _Traits>::flush()
00384 {
00385 sentry __cerb(*this);
00386 if (__cerb)
00387 {
00388 if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
00389 this->setstate(ios_base::badbit);
00390 }
00391 return *this;
00392 }
00393
00394 template<typename _CharT, typename _Traits>
00395 typename basic_ostream<_CharT, _Traits>::pos_type
00396 basic_ostream<_CharT, _Traits>::tellp()
00397 {
00398 pos_type __ret = pos_type(-1);
00399 bool __testok = this->fail() != true;
00400
00401 if (__testok)
00402 __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
00403 return __ret;
00404 }
00405
00406
00407 template<typename _CharT, typename _Traits>
00408 basic_ostream<_CharT, _Traits>&
00409 basic_ostream<_CharT, _Traits>::seekp(pos_type __pos)
00410 {
00411 bool __testok = this->fail() != true;
00412
00413 if (__testok)
00414 {
00415 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
00416
00417 pos_type __err = this->rdbuf()->pubseekpos(__pos, ios_base::out);
00418
00419
00420 if (__err == pos_type(off_type(-1)))
00421 this->setstate(failbit);
00422 #endif
00423 }
00424 return *this;
00425 }
00426
00427 template<typename _CharT, typename _Traits>
00428 basic_ostream<_CharT, _Traits>&
00429 basic_ostream<_CharT, _Traits>::
00430 seekp(off_type __off, ios_base::seekdir __d)
00431 {
00432 bool __testok = this->fail() != true;
00433
00434 if (__testok)
00435 {
00436 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
00437
00438 pos_type __err = this->rdbuf()->pubseekoff(__off, __d,
00439 ios_base::out);
00440
00441
00442 if (__err == pos_type(off_type(-1)))
00443 this->setstate(failbit);
00444 }
00445 #endif
00446 return *this;
00447 }
00448
00449
00450
00451
00452
00453
00454
00455
00456
00457 template<typename _CharT, typename _Traits>
00458 void
00459 __pad_char(basic_ios<_CharT, _Traits>& __ios,
00460 _CharT* __news, const _CharT* __olds,
00461 const streamsize __newlen, const streamsize __oldlen)
00462 {
00463 typedef _CharT char_type;
00464 typedef _Traits traits_type;
00465 typedef typename traits_type::int_type int_type;
00466
00467 int_type __plen = static_cast<size_t>(__newlen - __oldlen);
00468 char_type* __pads = static_cast<char_type*>(__builtin_alloca(sizeof(char_type) * __plen));
00469 traits_type::assign(__pads, __plen, __ios.fill());
00470
00471 char_type* __beg;
00472 char_type* __end;
00473 size_t __mod = 0;
00474 size_t __beglen;
00475 ios_base::fmtflags __fmt = __ios.flags() & ios_base::adjustfield;
00476
00477 if (__fmt == ios_base::left)
00478 {
00479
00480 __beg = const_cast<char_type*>(__olds);
00481 __beglen = __oldlen;
00482 __end = __pads;
00483 }
00484 else if (__fmt == ios_base::internal)
00485 {
00486
00487
00488
00489 typedef _Format_cache<_CharT> __cache_type;
00490 __cache_type const* __lfmt = __cache_type::_S_get(__ios);
00491 const char_type* __minus = traits_type::find(__olds, __oldlen,
00492 __lfmt->_S_minus);
00493 const char_type* __plus = traits_type::find(__olds, __oldlen,
00494 __lfmt->_S_plus);
00495 bool __testsign = __minus || __plus;
00496 bool __testhex = __olds[0] == '0'
00497 && (__olds[1] == 'x' || __olds[1] == 'X');
00498
00499 if (__testhex)
00500 {
00501 __news[0] = __olds[0];
00502 __news[1] = __olds[1];
00503 __mod += 2;
00504 __beg = const_cast<char_type*>(__olds + __mod);
00505 __beglen = __oldlen - __mod;
00506 __end = __pads;
00507 }
00508 else if (__testsign)
00509 {
00510 __mod += __plen;
00511 const char_type* __sign = __minus ? __minus + 1: __plus + 1;
00512 __beg = const_cast<char_type*>(__olds);
00513 __beglen = __sign - __olds;
00514 __end = const_cast<char_type*>(__sign + __plen);
00515 traits_type::copy(__news + __beglen, __pads, __plen);
00516 }
00517 else
00518 {
00519
00520 __beg = __pads;
00521 __beglen = __plen;
00522 __end = const_cast<char_type*>(__olds);
00523 }
00524 }
00525 else
00526 {
00527
00528 __beg = __pads;
00529 __beglen = __plen;
00530 __end = const_cast<char_type*>(__olds);
00531 }
00532
00533 traits_type::copy(__news, __beg, __beglen);
00534 traits_type::copy(__news + __beglen, __end, __newlen - __beglen - __mod);
00535 }
00536
00537 template<typename _CharT, typename _Traits>
00538 basic_ostream<_CharT, _Traits>&
00539 operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
00540 {
00541 typedef basic_ostream<_CharT, _Traits> __ostream_type;
00542 typename __ostream_type::sentry __cerb(__out);
00543 if (__cerb)
00544 {
00545 try
00546 {
00547 streamsize __w = __out.width();
00548 _CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w));
00549 __pads[0] = __c;
00550 streamsize __len = 1;
00551 if (__w > __len)
00552 {
00553 __pad_char(__out, __pads, &__c, __w, __len);
00554 __len = __w;
00555 }
00556 __out.write(__pads, __len);
00557 __out.width(0);
00558 }
00559 catch(exception& __fail)
00560 {
00561
00562
00563 __out.setstate(ios_base::badbit);
00564 if ((__out.exceptions() & ios_base::badbit) != 0)
00565 __throw_exception_again;
00566 }
00567 }
00568 return __out;
00569 }
00570
00571
00572 template <class _Traits>
00573 basic_ostream<char, _Traits>&
00574 operator<<(basic_ostream<char, _Traits>& __out, char __c)
00575 {
00576 typedef basic_ostream<char, _Traits> __ostream_type;
00577 typename __ostream_type::sentry __cerb(__out);
00578 if (__cerb)
00579 {
00580 try
00581 {
00582 streamsize __w = __out.width();
00583 char* __pads = static_cast<char*>(__builtin_alloca(__w + 1));
00584 __pads[0] = __c;
00585 streamsize __len = 1;
00586 if (__w > __len)
00587 {
00588 __pad_char(__out, __pads, &__c, __w, __len);
00589 __len = __w;
00590 }
00591 __out.write(__pads, __len);
00592 __out.width(0);
00593 }
00594 catch(exception& __fail)
00595 {
00596
00597
00598 __out.setstate(ios_base::badbit);
00599 if ((__out.exceptions() & ios_base::badbit) != 0)
00600 __throw_exception_again;
00601 }
00602 }
00603 return __out;
00604 }
00605
00606 template<typename _CharT, typename _Traits>
00607 basic_ostream<_CharT, _Traits>&
00608 operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
00609 {
00610 typedef basic_ostream<_CharT, _Traits> __ostream_type;
00611 typename __ostream_type::sentry __cerb(__out);
00612 if (__cerb)
00613 {
00614 try
00615 {
00616 streamsize __w = __out.width();
00617 _CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w));
00618 streamsize __len = static_cast<streamsize>(_Traits::length(__s));
00619 if (__w > __len)
00620 {
00621 __pad_char(__out, __pads, __s, __w, __len);
00622 __s = __pads;
00623 __len = __w;
00624 }
00625 __out.write(__s, __len);
00626 __out.width(0);
00627 }
00628 catch(exception& __fail)
00629 {
00630
00631
00632 __out.setstate(ios_base::badbit);
00633 if ((__out.exceptions() & ios_base::badbit) != 0)
00634 __throw_exception_again;
00635 }
00636 }
00637 return __out;
00638 }
00639
00640 template<typename _CharT, typename _Traits>
00641 basic_ostream<_CharT, _Traits>&
00642 operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
00643 {
00644 typedef basic_ostream<_CharT, _Traits> __ostream_type;
00645 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
00646
00647 typedef char_traits<char> __ctraits_type;
00648 #endif
00649 typename __ostream_type::sentry __cerb(__out);
00650 if (__cerb)
00651 {
00652 size_t __clen = __ctraits_type::length(__s);
00653 _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * (__clen + 1)));
00654 for (size_t __i = 0; __i <= __clen; ++__i)
00655 __ws[__i] = __out.widen(__s[__i]);
00656 _CharT* __str = __ws;
00657
00658 try
00659 {
00660 streamsize __len = static_cast<streamsize>(__clen);
00661 streamsize __w = __out.width();
00662 _CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w));
00663
00664 if (__w > __len)
00665 {
00666 __pad_char(__out, __pads, __ws, __w, __len);
00667 __str = __pads;
00668 __len = __w;
00669 }
00670 __out.write(__str, __len);
00671 __out.width(0);
00672 }
00673 catch(exception& __fail)
00674 {
00675
00676
00677 __out.setstate(ios_base::badbit);
00678 if ((__out.exceptions() & ios_base::badbit) != 0)
00679 __throw_exception_again;
00680 }
00681 }
00682 return __out;
00683 }
00684
00685
00686 template<class _Traits>
00687 basic_ostream<char, _Traits>&
00688 operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
00689 {
00690 typedef basic_ostream<char, _Traits> __ostream_type;
00691 typename __ostream_type::sentry __cerb(__out);
00692 if (__cerb)
00693 {
00694 try
00695 {
00696 streamsize __w = __out.width();
00697 char* __pads = static_cast<char*>(__builtin_alloca(__w));
00698 streamsize __len = static_cast<streamsize>(_Traits::length(__s));
00699 if (__w > __len)
00700 {
00701 __pad_char(__out, __pads, __s, __w, __len);
00702 __s = __pads;
00703 __len = __w;
00704 }
00705 __out.write(__s, __len);
00706 __out.width(0);
00707 }
00708 catch(exception& __fail)
00709 {
00710
00711
00712 __out.setstate(ios_base::badbit);
00713 if ((__out.exceptions() & ios_base::badbit) != 0)
00714 __throw_exception_again;
00715 }
00716 }
00717 return __out;
00718 }
00719
00720
00721 template<typename _CharT, typename _Traits, typename _Alloc>
00722 basic_ostream<_CharT, _Traits>&
00723 operator<<(basic_ostream<_CharT, _Traits>& __out,
00724 const basic_string<_CharT, _Traits, _Alloc>& __str)
00725 {
00726 typedef basic_ostream<_CharT, _Traits> __ostream_type;
00727 typename __ostream_type::sentry __cerb(__out);
00728 if (__cerb)
00729 {
00730 const _CharT* __s = __str.data();
00731 streamsize __w = __out.width();
00732 _CharT* __pads = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __w));
00733 streamsize __len = static_cast<streamsize>(__str.size());
00734 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
00735
00736 #endif
00737 if (__w > __len)
00738 {
00739 __pad_char(__out, __pads, __s, __w, __len);
00740 __s = __pads;
00741 __len = __w;
00742 }
00743 streamsize __res = __out.rdbuf()->sputn(__s, __len);
00744 __out.width(0);
00745 if (__res != __len)
00746 __out.setstate(ios_base::failbit);
00747 }
00748 return __out;
00749 }
00750 }
00751
00752
00753
00754
00755