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_ok(__os.good()), _M_os(__os)
00045 {
00046
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
00064
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
00086
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
00108
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 && __sbin)
00123 {
00124
try
00125 {
00126
if (!__copy_streambufs(*
this, __sbin, this->rdbuf()))
00127 this->setstate(ios_base::failbit);
00128 }
00129
catch(exception& __fail)
00130 {
00131
00132
00133 this->setstate(ios_base::badbit);
00134
if ((this->exceptions() & ios_base::badbit) != 0)
00135 __throw_exception_again;
00136 }
00137 }
00138
else if (!__sbin)
00139 this->setstate(ios_base::badbit);
00140
return *
this;
00141 }
00142
00143
template<
typename _CharT,
typename _Traits>
00144 basic_ostream<_CharT, _Traits>&
00145 basic_ostream<_CharT, _Traits>::operator<<(
bool __n)
00146 {
00147 sentry __cerb(*
this);
00148
if (__cerb)
00149 {
00150
try
00151 {
00152
if (_M_check_facet(_M_fnumput))
00153
if (_M_fnumput->put(*
this, *
this, this->fill(), __n).failed())
00154 this->setstate(ios_base::badbit);
00155 }
00156
catch(exception& __fail)
00157 {
00158
00159
00160 this->setstate(ios_base::badbit);
00161
if ((this->exceptions() & ios_base::badbit) != 0)
00162 __throw_exception_again;
00163 }
00164 }
00165
return *
this;
00166 }
00167
00168
template<
typename _CharT,
typename _Traits>
00169 basic_ostream<_CharT, _Traits>&
00170 basic_ostream<_CharT, _Traits>::operator<<(
long __n)
00171 {
00172 sentry __cerb(*
this);
00173
if (__cerb)
00174 {
00175
try
00176 {
00177 char_type __c = this->
fill();
00178 ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
00179
if (_M_check_facet(_M_fnumput))
00180 {
00181
bool __b =
false;
00182
if ((__fmt & ios_base::oct) || (__fmt & ios_base::hex))
00183 {
00184
unsigned long __l = static_cast<unsigned long>(__n);
00185 __b = _M_fnumput->put(*
this, *
this, __c, __l).failed();
00186 }
00187
else
00188 __b = _M_fnumput->put(*
this, *
this, __c, __n).failed();
00189
if (__b)
00190 this->setstate(ios_base::badbit);
00191 }
00192 }
00193
catch(exception& __fail)
00194 {
00195
00196
00197 this->setstate(ios_base::badbit);
00198
if ((this->exceptions() & ios_base::badbit) != 0)
00199 __throw_exception_again;
00200 }
00201 }
00202
return *
this;
00203 }
00204
00205
template<
typename _CharT,
typename _Traits>
00206 basic_ostream<_CharT, _Traits>&
00207 basic_ostream<_CharT, _Traits>::operator<<(
unsigned long __n)
00208 {
00209 sentry __cerb(*
this);
00210
if (__cerb)
00211 {
00212
try
00213 {
00214
if (_M_check_facet(_M_fnumput))
00215
if (_M_fnumput->put(*
this, *
this, this->fill(), __n).failed())
00216 this->setstate(ios_base::badbit);
00217 }
00218
catch(exception& __fail)
00219 {
00220
00221
00222 this->setstate(ios_base::badbit);
00223
if ((this->exceptions() & ios_base::badbit) != 0)
00224 __throw_exception_again;
00225 }
00226 }
00227
return *
this;
00228 }
00229
00230
#ifdef _GLIBCPP_USE_LONG_LONG
00231
template<
typename _CharT,
typename _Traits>
00232 basic_ostream<_CharT, _Traits>&
00233 basic_ostream<_CharT, _Traits>::operator<<(
long long __n)
00234 {
00235 sentry __cerb(*
this);
00236
if (__cerb)
00237 {
00238
try
00239 {
00240 char_type __c = this->
fill();
00241 ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
00242
if (_M_check_facet(_M_fnumput))
00243 {
00244
bool __b =
false;
00245
if ((__fmt & ios_base::oct) || (__fmt & ios_base::hex))
00246 {
00247
unsigned long long __l;
00248 __l = static_cast<unsigned long long>(__n);
00249 __b = _M_fnumput->put(*
this, *
this, __c, __l).failed();
00250 }
00251
else
00252 __b = _M_fnumput->put(*
this, *
this, __c, __n).failed();
00253
if (__b)
00254 this->setstate(ios_base::badbit);
00255 }
00256 }
00257
catch(exception& __fail)
00258 {
00259
00260
00261 this->setstate(ios_base::badbit);
00262
if ((this->exceptions() & ios_base::badbit) != 0)
00263 __throw_exception_again;
00264 }
00265 }
00266
return *
this;
00267 }
00268
00269
template<
typename _CharT,
typename _Traits>
00270 basic_ostream<_CharT, _Traits>&
00271 basic_ostream<_CharT, _Traits>::operator<<(
unsigned long long __n)
00272 {
00273 sentry __cerb(*
this);
00274
if (__cerb)
00275 {
00276
try
00277 {
00278
if (_M_check_facet(_M_fnumput))
00279
if (_M_fnumput->put(*
this, *
this, this->fill(), __n).failed())
00280 this->setstate(ios_base::badbit);
00281 }
00282
catch(exception& __fail)
00283 {
00284
00285
00286 this->setstate(ios_base::badbit);
00287
if ((this->exceptions() & ios_base::badbit) != 0)
00288 __throw_exception_again;
00289 }
00290 }
00291
return *
this;
00292 }
00293
#endif
00294
00295
template<
typename _CharT,
typename _Traits>
00296 basic_ostream<_CharT, _Traits>&
00297 basic_ostream<_CharT, _Traits>::operator<<(
double __n)
00298 {
00299 sentry __cerb(*
this);
00300
if (__cerb)
00301 {
00302
try
00303 {
00304
if (_M_check_facet(_M_fnumput))
00305
if (_M_fnumput->put(*
this, *
this, this->fill(), __n).failed())
00306 this->setstate(ios_base::badbit);
00307 }
00308
catch(exception& __fail)
00309 {
00310
00311
00312 this->setstate(ios_base::badbit);
00313
if ((this->exceptions() & ios_base::badbit) != 0)
00314 __throw_exception_again;
00315 }
00316 }
00317
return *
this;
00318 }
00319
00320
template<
typename _CharT,
typename _Traits>
00321 basic_ostream<_CharT, _Traits>&
00322 basic_ostream<_CharT, _Traits>::operator<<(
long double __n)
00323 {
00324 sentry __cerb(*
this);
00325
if (__cerb)
00326 {
00327
try
00328 {
00329
if (_M_check_facet(_M_fnumput))
00330
if (_M_fnumput->put(*
this, *
this, this->fill(), __n).failed())
00331 this->setstate(ios_base::badbit);
00332 }
00333
catch(exception& __fail)
00334 {
00335
00336
00337 this->setstate(ios_base::badbit);
00338
if ((this->exceptions() & ios_base::badbit) != 0)
00339 __throw_exception_again;
00340 }
00341 }
00342
return *
this;
00343 }
00344
00345
template<
typename _CharT,
typename _Traits>
00346 basic_ostream<_CharT, _Traits>&
00347 basic_ostream<_CharT, _Traits>::operator<<(
const void* __n)
00348 {
00349 sentry __cerb(*
this);
00350
if (__cerb)
00351 {
00352
try
00353 {
00354
if (_M_check_facet(_M_fnumput))
00355
if (_M_fnumput->put(*
this, *
this, this->fill(), __n).failed())
00356 this->setstate(ios_base::badbit);
00357 }
00358
catch(exception& __fail)
00359 {
00360
00361
00362 this->setstate(ios_base::badbit);
00363
if ((this->exceptions() & ios_base::badbit) != 0)
00364 __throw_exception_again;
00365 }
00366 }
00367
return *
this;
00368 }
00369
00370
template<
typename _CharT,
typename _Traits>
00371 basic_ostream<_CharT, _Traits>&
00372 basic_ostream<_CharT, _Traits>::put(char_type __c)
00373 {
00374 sentry __cerb(*
this);
00375
if (__cerb)
00376 {
00377 int_type __put = rdbuf()->sputc(__c);
00378
if (traits_type::eq_int_type(__put, traits_type::eof()))
00379 this->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>::write(
const _CharT* __s, streamsize __n)
00387 {
00388 sentry __cerb(*
this);
00389
if (__cerb)
00390 {
00391 streamsize __put = this->rdbuf()->sputn(__s, __n);
00392
if ( __put != __n)
00393 this->setstate(ios_base::badbit);
00394 }
00395
return *
this;
00396 }
00397
00398
template<
typename _CharT,
typename _Traits>
00399 basic_ostream<_CharT, _Traits>&
00400 basic_ostream<_CharT, _Traits>::flush()
00401 {
00402 sentry __cerb(*
this);
00403
if (__cerb)
00404 {
00405
if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
00406 this->setstate(ios_base::badbit);
00407 }
00408
return *
this;
00409 }
00410
00411
template<
typename _CharT,
typename _Traits>
00412
typename basic_ostream<_CharT, _Traits>::pos_type
00413 basic_ostream<_CharT, _Traits>::tellp()
00414 {
00415 pos_type __ret = pos_type(-1);
00416
if (!this->fail())
00417 __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
00418
return __ret;
00419 }
00420
00421
00422
template<
typename _CharT,
typename _Traits>
00423 basic_ostream<_CharT, _Traits>&
00424 basic_ostream<_CharT, _Traits>::seekp(pos_type __pos)
00425 {
00426
if (!this->fail())
00427 {
00428
#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
00429
00430 pos_type __err = this->rdbuf()->pubseekpos(__pos, ios_base::out);
00431
00432
00433
if (__err == pos_type(off_type(-1)))
00434 this->setstate(ios_base::failbit);
00435
#endif
00436
}
00437
return *
this;
00438 }
00439
00440
template<
typename _CharT,
typename _Traits>
00441 basic_ostream<_CharT, _Traits>&
00442 basic_ostream<_CharT, _Traits>::
00443 seekp(off_type __off, ios_base::seekdir __d)
00444 {
00445
if (!this->fail())
00446 {
00447
#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
00448
00449 pos_type __err = this->rdbuf()->pubseekoff(__off, __d,
00450 ios_base::out);
00451
00452
00453
if (__err == pos_type(off_type(-1)))
00454 this->setstate(ios_base::failbit);
00455
#endif
00456
}
00457
return *
this;
00458 }
00459
00460
00461
template<
typename _CharT,
typename _Traits>
00462 basic_ostream<_CharT, _Traits>&
00463 operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
00464 {
00465
typedef basic_ostream<_CharT, _Traits> __ostream_type;
00466
typename __ostream_type::sentry __cerb(__out);
00467
if (__cerb)
00468 {
00469
try
00470 {
00471 streamsize __w = __out.width();
00472 _CharT* __pads = static_cast<_CharT*>(__builtin_alloca(
sizeof(_CharT) * (__w + 1)));
00473 __pads[0] = __c;
00474 streamsize __len = 1;
00475
if (__w > __len)
00476 {
00477 __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __pads,
00478 &__c, __w, __len,
false);
00479 __len = __w;
00480 }
00481 __out.write(__pads, __len);
00482 __out.width(0);
00483 }
00484
catch(exception& __fail)
00485 {
00486
00487
00488 __out.setstate(ios_base::badbit);
00489
if ((__out.exceptions() & ios_base::badbit) != 0)
00490 __throw_exception_again;
00491 }
00492 }
00493
return __out;
00494 }
00495
00496
00497
template <
class _Traits>
00498 basic_ostream<char, _Traits>&
00499 operator<<(basic_ostream<char, _Traits>& __out,
char __c)
00500 {
00501
typedef basic_ostream<char, _Traits> __ostream_type;
00502
typename __ostream_type::sentry __cerb(__out);
00503
if (__cerb)
00504 {
00505
try
00506 {
00507 streamsize __w = __out.width();
00508
char* __pads = static_cast<char*>(__builtin_alloca(__w + 1));
00509 __pads[0] = __c;
00510 streamsize __len = 1;
00511
if (__w > __len)
00512 {
00513 __pad<char, _Traits>::_S_pad(__out, __out.fill(), __pads,
00514 &__c, __w, __len,
false);
00515 __len = __w;
00516 }
00517 __out.write(__pads, __len);
00518 __out.width(0);
00519 }
00520
catch(exception& __fail)
00521 {
00522
00523
00524 __out.setstate(ios_base::badbit);
00525
if ((__out.exceptions() & ios_base::badbit) != 0)
00526 __throw_exception_again;
00527 }
00528 }
00529
return __out;
00530 }
00531
00532
template<
typename _CharT,
typename _Traits>
00533 basic_ostream<_CharT, _Traits>&
00534 operator<<(basic_ostream<_CharT, _Traits>& __out,
const _CharT* __s)
00535 {
00536
typedef basic_ostream<_CharT, _Traits> __ostream_type;
00537
typename __ostream_type::sentry __cerb(__out);
00538
if (__cerb && __s)
00539 {
00540
try
00541 {
00542 streamsize __w = __out.width();
00543 _CharT* __pads = static_cast<_CharT*>(__builtin_alloca(
sizeof(_CharT) * __w));
00544 streamsize __len = static_cast<streamsize>(_Traits::length(__s));
00545
if (__w > __len)
00546 {
00547 __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __pads,
00548 __s, __w, __len,
false);
00549 __s = __pads;
00550 __len = __w;
00551 }
00552 __out.write(__s, __len);
00553 __out.width(0);
00554 }
00555
catch(exception& __fail)
00556 {
00557
00558
00559 __out.setstate(ios_base::badbit);
00560
if ((__out.exceptions() & ios_base::badbit) != 0)
00561 __throw_exception_again;
00562 }
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 streamsize __w = __out.width();
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(exception& __fail)
00605 {
00606
00607
00608 __out.setstate(ios_base::badbit);
00609
if ((__out.exceptions() & ios_base::badbit) != 0)
00610 __throw_exception_again;
00611 }
00612 }
00613
else if (!__s)
00614 __out.setstate(ios_base::badbit);
00615
return __out;
00616 }
00617
00618
00619
template<
class _Traits>
00620 basic_ostream<char, _Traits>&
00621 operator<<(basic_ostream<char, _Traits>& __out,
const char* __s)
00622 {
00623
typedef basic_ostream<char, _Traits> __ostream_type;
00624
typename __ostream_type::sentry __cerb(__out);
00625
if (__cerb && __s)
00626 {
00627
try
00628 {
00629 streamsize __w = __out.width();
00630
char* __pads = static_cast<char*>(__builtin_alloca(__w));
00631 streamsize __len = static_cast<streamsize>(_Traits::length(__s));
00632
00633
if (__w > __len)
00634 {
00635 __pad<char, _Traits>::_S_pad(__out, __out.fill(), __pads,
00636 __s, __w, __len,
false);
00637 __s = __pads;
00638 __len = __w;
00639 }
00640 __out.write(__s, __len);
00641 __out.width(0);
00642 }
00643
catch(exception& __fail)
00644 {
00645
00646
00647 __out.setstate(ios_base::badbit);
00648
if ((__out.exceptions() & ios_base::badbit) != 0)
00649 __throw_exception_again;
00650 }
00651 }
00652
else if (!__s)
00653 __out.setstate(ios_base::badbit);
00654
return __out;
00655 }
00656
00657
00658
template<
typename _CharT,
typename _Traits,
typename _Alloc>
00659 basic_ostream<_CharT, _Traits>&
00660 operator<<(basic_ostream<_CharT, _Traits>& __out,
00661
const basic_string<_CharT, _Traits, _Alloc>& __str)
00662 {
00663
typedef basic_ostream<_CharT, _Traits> __ostream_type;
00664
typename __ostream_type::sentry __cerb(__out);
00665
if (__cerb)
00666 {
00667
const _CharT* __s = __str.data();
00668 streamsize __w = __out.width();
00669 _CharT* __pads = static_cast<_CharT*>(__builtin_alloca(
sizeof(_CharT) * __w));
00670 streamsize __len = static_cast<streamsize>(__str.size());
00671
#ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
00672
00673
#endif
00674
if (__w > __len)
00675 {
00676 __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __pads, __s,
00677 __w, __len,
false);
00678 __s = __pads;
00679 __len = __w;
00680 }
00681 streamsize __res = __out.rdbuf()->sputn(__s, __len);
00682 __out.width(0);
00683
if (__res != __len)
00684 __out.setstate(ios_base::failbit);
00685 }
00686
return __out;
00687 }
00688
00689
00690
00691
00692
extern template class basic_ostream<char>;
00693
extern template ostream& endl(ostream&);
00694
extern template ostream& ends(ostream&);
00695
extern template ostream& flush(ostream&);
00696
extern template ostream& operator<<(ostream&,
char);
00697
extern template ostream& operator<<(ostream&,
unsigned char);
00698
extern template ostream& operator<<(ostream&,
signed char);
00699
extern template ostream& operator<<(ostream&,
const char*);
00700
extern template ostream& operator<<(ostream&,
const unsigned char*);
00701
extern template ostream& operator<<(ostream&,
const signed char*);
00702
00703
#ifdef _GLIBCPP_USE_WCHAR_T
00704
extern template class basic_ostream<wchar_t>;
00705
extern template wostream& endl(wostream&);
00706
extern template wostream& ends(wostream&);
00707
extern template wostream& flush(wostream&);
00708
extern template wostream& operator<<(wostream&,
wchar_t);
00709
extern template wostream& operator<<(wostream&,
char);
00710
extern template wostream& operator<<(wostream&,
const wchar_t*);
00711
extern template wostream& operator<<(wostream&,
const char*);
00712
#endif
00713
}