1// -*- C++ -*- 2//===--------------------------- istream ----------------------------------===// 3// 4// The LLVM Compiler Infrastructure 5// 6// This file is dual licensed under the MIT and the University of Illinois Open 7// Source Licenses. See LICENSE.TXT for details. 8// 9//===----------------------------------------------------------------------===// 10 11#ifndef _LIBCPP_ISTREAM 12#define _LIBCPP_ISTREAM 13 14/* 15 istream synopsis 16 17template <class charT, class traits = char_traits<charT> > 18class basic_istream 19 : virtual public basic_ios<charT,traits> 20{ 21public: 22 // types (inherited from basic_ios (27.5.4)): 23 typedef charT char_type; 24 typedef traits traits_type; 25 typedef typename traits_type::int_type int_type; 26 typedef typename traits_type::pos_type pos_type; 27 typedef typename traits_type::off_type off_type; 28 29 // 27.7.1.1.1 Constructor/destructor: 30 explicit basic_istream(basic_streambuf<char_type, traits_type>* sb); 31 basic_istream(basic_istream&& rhs); 32 virtual ~basic_istream(); 33 34 // 27.7.1.1.2 Assign/swap: 35 basic_istream& operator=(basic_istream&& rhs); 36 void swap(basic_istream& rhs); 37 38 // 27.7.1.1.3 Prefix/suffix: 39 class sentry; 40 41 // 27.7.1.2 Formatted input: 42 basic_istream& operator>>(basic_istream& (*pf)(basic_istream&)); 43 basic_istream& operator>>(basic_ios<char_type, traits_type>& 44 (*pf)(basic_ios<char_type, traits_type>&)); 45 basic_istream& operator>>(ios_base& (*pf)(ios_base&)); 46 basic_istream& operator>>(basic_streambuf<char_type, traits_type>* sb); 47 basic_istream& operator>>(bool& n); 48 basic_istream& operator>>(short& n); 49 basic_istream& operator>>(unsigned short& n); 50 basic_istream& operator>>(int& n); 51 basic_istream& operator>>(unsigned int& n); 52 basic_istream& operator>>(long& n); 53 basic_istream& operator>>(unsigned long& n); 54 basic_istream& operator>>(long long& n); 55 basic_istream& operator>>(unsigned long long& n); 56 basic_istream& operator>>(float& f); 57 basic_istream& operator>>(double& f); 58 basic_istream& operator>>(long double& f); 59 basic_istream& operator>>(void*& p); 60 61 // 27.7.1.3 Unformatted input: 62 streamsize gcount() const; 63 int_type get(); 64 basic_istream& get(char_type& c); 65 basic_istream& get(char_type* s, streamsize n); 66 basic_istream& get(char_type* s, streamsize n, char_type delim); 67 basic_istream& get(basic_streambuf<char_type,traits_type>& sb); 68 basic_istream& get(basic_streambuf<char_type,traits_type>& sb, char_type delim); 69 70 basic_istream& getline(char_type* s, streamsize n); 71 basic_istream& getline(char_type* s, streamsize n, char_type delim); 72 73 basic_istream& ignore(streamsize n = 1, int_type delim = traits_type::eof()); 74 int_type peek(); 75 basic_istream& read (char_type* s, streamsize n); 76 streamsize readsome(char_type* s, streamsize n); 77 78 basic_istream& putback(char_type c); 79 basic_istream& unget(); 80 int sync(); 81 82 pos_type tellg(); 83 basic_istream& seekg(pos_type); 84 basic_istream& seekg(off_type, ios_base::seekdir); 85protected: 86 basic_istream(const basic_istream& rhs) = delete; 87 basic_istream(basic_istream&& rhs); 88 // 27.7.2.1.2 Assign/swap: 89 basic_istream& operator=(const basic_istream& rhs) = delete; 90 basic_istream& operator=(basic_istream&& rhs); 91 void swap(basic_istream& rhs); 92}; 93 94// 27.7.1.2.3 character extraction templates: 95template<class charT, class traits> 96 basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>&, charT&); 97 98template<class traits> 99 basic_istream<char,traits>& operator>>(basic_istream<char,traits>&, unsigned char&); 100 101template<class traits> 102 basic_istream<char,traits>& operator>>(basic_istream<char,traits>&, signed char&); 103 104template<class charT, class traits> 105 basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>&, charT*); 106 107template<class traits> 108 basic_istream<char,traits>& operator>>(basic_istream<char,traits>&, unsigned char*); 109 110template<class traits> 111 basic_istream<char,traits>& operator>>(basic_istream<char,traits>&, signed char*); 112 113template <class charT, class traits> 114 void 115 swap(basic_istream<charT, traits>& x, basic_istream<charT, traits>& y); 116 117typedef basic_istream<char> istream; 118typedef basic_istream<wchar_t> wistream; 119 120template <class charT, class traits = char_traits<charT> > 121class basic_iostream : 122 public basic_istream<charT,traits>, 123 public basic_ostream<charT,traits> 124{ 125public: 126 // types: 127 typedef charT char_type; 128 typedef traits traits_type; 129 typedef typename traits_type::int_type int_type; 130 typedef typename traits_type::pos_type pos_type; 131 typedef typename traits_type::off_type off_type; 132 133 // constructor/destructor 134 explicit basic_iostream(basic_streambuf<char_type, traits_type>* sb); 135 basic_iostream(basic_iostream&& rhs); 136 virtual ~basic_iostream(); 137 138 // assign/swap 139 basic_iostream& operator=(basic_iostream&& rhs); 140 void swap(basic_iostream& rhs); 141}; 142 143template <class charT, class traits> 144 void 145 swap(basic_iostream<charT, traits>& x, basic_iostream<charT, traits>& y); 146 147typedef basic_iostream<char> iostream; 148typedef basic_iostream<wchar_t> wiostream; 149 150template <class charT, class traits> 151 basic_istream<charT,traits>& 152 ws(basic_istream<charT,traits>& is); 153 154template <class charT, class traits, class T> 155 basic_istream<charT, traits>& 156 operator>>(basic_istream<charT, traits>&& is, T& x); 157 158} // std 159 160*/ 161 162#include <__config> 163#include <ostream> 164 165#include <__undef_min_max> 166 167#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 168#pragma GCC system_header 169#endif 170 171_LIBCPP_BEGIN_NAMESPACE_STD 172 173template <class _CharT, class _Traits> 174class _LIBCPP_TYPE_VIS_ONLY basic_istream 175 : virtual public basic_ios<_CharT, _Traits> 176{ 177 streamsize __gc_; 178public: 179 // types (inherited from basic_ios (27.5.4)): 180 typedef _CharT char_type; 181 typedef _Traits traits_type; 182 typedef typename traits_type::int_type int_type; 183 typedef typename traits_type::pos_type pos_type; 184 typedef typename traits_type::off_type off_type; 185 186 // 27.7.1.1.1 Constructor/destructor: 187 explicit basic_istream(basic_streambuf<char_type, traits_type>* __sb); 188 virtual ~basic_istream(); 189protected: 190#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 191 _LIBCPP_INLINE_VISIBILITY 192 basic_istream(basic_istream&& __rhs); 193#endif 194 // 27.7.1.1.2 Assign/swap: 195#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 196 _LIBCPP_INLINE_VISIBILITY 197 basic_istream& operator=(basic_istream&& __rhs); 198#endif 199 void swap(basic_istream& __rhs); 200 201#if _LIBCPP_STD_VER > 11 202#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS 203 basic_istream (const basic_istream& __rhs) = delete; 204 basic_istream& operator=(const basic_istream& __rhs) = delete; 205#else 206 basic_istream (const basic_istream& __rhs); // not defined 207 basic_istream& operator=(const basic_istream& __rhs); // not defined 208#endif 209#endif 210public: 211 212 // 27.7.1.1.3 Prefix/suffix: 213 class _LIBCPP_TYPE_VIS_ONLY sentry; 214 215 // 27.7.1.2 Formatted input: 216 basic_istream& operator>>(basic_istream& (*__pf)(basic_istream&)); 217 basic_istream& operator>>(basic_ios<char_type, traits_type>& 218 (*__pf)(basic_ios<char_type, traits_type>&)); 219 basic_istream& operator>>(ios_base& (*__pf)(ios_base&)); 220 basic_istream& operator>>(basic_streambuf<char_type, traits_type>* __sb); 221 basic_istream& operator>>(bool& __n); 222 basic_istream& operator>>(short& __n); 223 basic_istream& operator>>(unsigned short& __n); 224 basic_istream& operator>>(int& __n); 225 basic_istream& operator>>(unsigned int& __n); 226 basic_istream& operator>>(long& __n); 227 basic_istream& operator>>(unsigned long& __n); 228 basic_istream& operator>>(long long& __n); 229 basic_istream& operator>>(unsigned long long& __n); 230 basic_istream& operator>>(float& __f); 231 basic_istream& operator>>(double& __f); 232 basic_istream& operator>>(long double& __f); 233 basic_istream& operator>>(void*& __p); 234 235 // 27.7.1.3 Unformatted input: 236 _LIBCPP_INLINE_VISIBILITY 237 streamsize gcount() const {return __gc_;} 238 int_type get(); 239 basic_istream& get(char_type& __c); 240 basic_istream& get(char_type* __s, streamsize __n); 241 basic_istream& get(char_type* __s, streamsize __n, char_type __dlm); 242 basic_istream& get(basic_streambuf<char_type, traits_type>& __sb); 243 basic_istream& get(basic_streambuf<char_type, traits_type>& __sb, char_type __dlm); 244 245 basic_istream& getline(char_type* __s, streamsize __n); 246 basic_istream& getline(char_type* __s, streamsize __n, char_type __dlm); 247 248 basic_istream& ignore(streamsize __n = 1, int_type __dlm = traits_type::eof()); 249 int_type peek(); 250 basic_istream& read (char_type* __s, streamsize __n); 251 streamsize readsome(char_type* __s, streamsize __n); 252 253 basic_istream& putback(char_type __c); 254 basic_istream& unget(); 255 int sync(); 256 257 pos_type tellg(); 258 basic_istream& seekg(pos_type __pos); 259 basic_istream& seekg(off_type __off, ios_base::seekdir __dir); 260}; 261 262template <class _CharT, class _Traits> 263class _LIBCPP_TYPE_VIS_ONLY basic_istream<_CharT, _Traits>::sentry 264{ 265 bool __ok_; 266 267 sentry(const sentry&); // = delete; 268 sentry& operator=(const sentry&); // = delete; 269 270public: 271 explicit sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false); 272// ~sentry() = default; 273 274 _LIBCPP_INLINE_VISIBILITY 275 _LIBCPP_EXPLICIT 276 operator bool() const {return __ok_;} 277}; 278 279template <class _CharT, class _Traits> 280basic_istream<_CharT, _Traits>::sentry::sentry(basic_istream<_CharT, _Traits>& __is, 281 bool __noskipws) 282 : __ok_(false) 283{ 284 if (__is.good()) 285 { 286 if (__is.tie()) 287 __is.tie()->flush(); 288 if (!__noskipws && (__is.flags() & ios_base::skipws)) 289 { 290 typedef istreambuf_iterator<_CharT, _Traits> _Ip; 291 const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc()); 292 _Ip __i(__is); 293 _Ip __eof; 294 for (; __i != __eof; ++__i) 295 if (!__ct.is(__ct.space, *__i)) 296 break; 297 if (__i == __eof) 298 __is.setstate(ios_base::failbit | ios_base::eofbit); 299 } 300 __ok_ = __is.good(); 301 } 302 else 303 __is.setstate(ios_base::failbit); 304} 305 306template <class _CharT, class _Traits> 307inline _LIBCPP_INLINE_VISIBILITY 308basic_istream<_CharT, _Traits>::basic_istream(basic_streambuf<char_type, traits_type>* __sb) 309 : __gc_(0) 310{ 311 this->init(__sb); 312} 313 314#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 315 316template <class _CharT, class _Traits> 317inline _LIBCPP_INLINE_VISIBILITY 318basic_istream<_CharT, _Traits>::basic_istream(basic_istream&& __rhs) 319 : __gc_(__rhs.__gc_) 320{ 321 __rhs.__gc_ = 0; 322 this->move(__rhs); 323} 324 325template <class _CharT, class _Traits> 326inline _LIBCPP_INLINE_VISIBILITY 327basic_istream<_CharT, _Traits>& 328basic_istream<_CharT, _Traits>::operator=(basic_istream&& __rhs) 329{ 330 swap(__rhs); 331 return *this; 332} 333 334#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 335 336template <class _CharT, class _Traits> 337basic_istream<_CharT, _Traits>::~basic_istream() 338{ 339} 340 341template <class _CharT, class _Traits> 342inline _LIBCPP_INLINE_VISIBILITY 343void 344basic_istream<_CharT, _Traits>::swap(basic_istream& __rhs) 345{ 346 _VSTD::swap(__gc_, __rhs.__gc_); 347 basic_ios<char_type, traits_type>::swap(__rhs); 348} 349 350template <class _CharT, class _Traits> 351basic_istream<_CharT, _Traits>& 352basic_istream<_CharT, _Traits>::operator>>(unsigned short& __n) 353{ 354#ifndef _LIBCPP_NO_EXCEPTIONS 355 try 356 { 357#endif // _LIBCPP_NO_EXCEPTIONS 358 sentry __s(*this); 359 if (__s) 360 { 361 typedef istreambuf_iterator<char_type, traits_type> _Ip; 362 typedef num_get<char_type, _Ip> _Fp; 363 ios_base::iostate __err = ios_base::goodbit; 364 use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __n); 365 this->setstate(__err); 366 } 367#ifndef _LIBCPP_NO_EXCEPTIONS 368 } 369 catch (...) 370 { 371 this->__set_badbit_and_consider_rethrow(); 372 } 373#endif // _LIBCPP_NO_EXCEPTIONS 374 return *this; 375} 376 377template <class _CharT, class _Traits> 378basic_istream<_CharT, _Traits>& 379basic_istream<_CharT, _Traits>::operator>>(unsigned int& __n) 380{ 381#ifndef _LIBCPP_NO_EXCEPTIONS 382 try 383 { 384#endif // _LIBCPP_NO_EXCEPTIONS 385 sentry __s(*this); 386 if (__s) 387 { 388 typedef istreambuf_iterator<char_type, traits_type> _Ip; 389 typedef num_get<char_type, _Ip> _Fp; 390 ios_base::iostate __err = ios_base::goodbit; 391 use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __n); 392 this->setstate(__err); 393 } 394#ifndef _LIBCPP_NO_EXCEPTIONS 395 } 396 catch (...) 397 { 398 this->__set_badbit_and_consider_rethrow(); 399 } 400#endif // _LIBCPP_NO_EXCEPTIONS 401 return *this; 402} 403 404template <class _CharT, class _Traits> 405basic_istream<_CharT, _Traits>& 406basic_istream<_CharT, _Traits>::operator>>(long& __n) 407{ 408#ifndef _LIBCPP_NO_EXCEPTIONS 409 try 410 { 411#endif // _LIBCPP_NO_EXCEPTIONS 412 sentry __s(*this); 413 if (__s) 414 { 415 typedef istreambuf_iterator<char_type, traits_type> _Ip; 416 typedef num_get<char_type, _Ip> _Fp; 417 ios_base::iostate __err = ios_base::goodbit; 418 use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __n); 419 this->setstate(__err); 420 } 421#ifndef _LIBCPP_NO_EXCEPTIONS 422 } 423 catch (...) 424 { 425 this->__set_badbit_and_consider_rethrow(); 426 } 427#endif // _LIBCPP_NO_EXCEPTIONS 428 return *this; 429} 430 431template <class _CharT, class _Traits> 432basic_istream<_CharT, _Traits>& 433basic_istream<_CharT, _Traits>::operator>>(unsigned long& __n) 434{ 435#ifndef _LIBCPP_NO_EXCEPTIONS 436 try 437 { 438#endif // _LIBCPP_NO_EXCEPTIONS 439 sentry __s(*this); 440 if (__s) 441 { 442 typedef istreambuf_iterator<char_type, traits_type> _Ip; 443 typedef num_get<char_type, _Ip> _Fp; 444 ios_base::iostate __err = ios_base::goodbit; 445 use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __n); 446 this->setstate(__err); 447 } 448#ifndef _LIBCPP_NO_EXCEPTIONS 449 } 450 catch (...) 451 { 452 this->__set_badbit_and_consider_rethrow(); 453 } 454#endif // _LIBCPP_NO_EXCEPTIONS 455 return *this; 456} 457 458template <class _CharT, class _Traits> 459basic_istream<_CharT, _Traits>& 460basic_istream<_CharT, _Traits>::operator>>(long long& __n) 461{ 462#ifndef _LIBCPP_NO_EXCEPTIONS 463 try 464 { 465#endif // _LIBCPP_NO_EXCEPTIONS 466 sentry __s(*this); 467 if (__s) 468 { 469 typedef istreambuf_iterator<char_type, traits_type> _Ip; 470 typedef num_get<char_type, _Ip> _Fp; 471 ios_base::iostate __err = ios_base::goodbit; 472 use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __n); 473 this->setstate(__err); 474 } 475#ifndef _LIBCPP_NO_EXCEPTIONS 476 } 477 catch (...) 478 { 479 this->__set_badbit_and_consider_rethrow(); 480 } 481#endif // _LIBCPP_NO_EXCEPTIONS 482 return *this; 483} 484 485template <class _CharT, class _Traits> 486basic_istream<_CharT, _Traits>& 487basic_istream<_CharT, _Traits>::operator>>(unsigned long long& __n) 488{ 489#ifndef _LIBCPP_NO_EXCEPTIONS 490 try 491 { 492#endif // _LIBCPP_NO_EXCEPTIONS 493 sentry __s(*this); 494 if (__s) 495 { 496 typedef istreambuf_iterator<char_type, traits_type> _Ip; 497 typedef num_get<char_type, _Ip> _Fp; 498 ios_base::iostate __err = ios_base::goodbit; 499 use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __n); 500 this->setstate(__err); 501 } 502#ifndef _LIBCPP_NO_EXCEPTIONS 503 } 504 catch (...) 505 { 506 this->__set_badbit_and_consider_rethrow(); 507 } 508#endif // _LIBCPP_NO_EXCEPTIONS 509 return *this; 510} 511 512template <class _CharT, class _Traits> 513basic_istream<_CharT, _Traits>& 514basic_istream<_CharT, _Traits>::operator>>(float& __n) 515{ 516#ifndef _LIBCPP_NO_EXCEPTIONS 517 try 518 { 519#endif // _LIBCPP_NO_EXCEPTIONS 520 sentry __s(*this); 521 if (__s) 522 { 523 typedef istreambuf_iterator<char_type, traits_type> _Ip; 524 typedef num_get<char_type, _Ip> _Fp; 525 ios_base::iostate __err = ios_base::goodbit; 526 use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __n); 527 this->setstate(__err); 528 } 529#ifndef _LIBCPP_NO_EXCEPTIONS 530 } 531 catch (...) 532 { 533 this->__set_badbit_and_consider_rethrow(); 534 } 535#endif // _LIBCPP_NO_EXCEPTIONS 536 return *this; 537} 538 539template <class _CharT, class _Traits> 540basic_istream<_CharT, _Traits>& 541basic_istream<_CharT, _Traits>::operator>>(double& __n) 542{ 543#ifndef _LIBCPP_NO_EXCEPTIONS 544 try 545 { 546#endif // _LIBCPP_NO_EXCEPTIONS 547 sentry __s(*this); 548 if (__s) 549 { 550 typedef istreambuf_iterator<char_type, traits_type> _Ip; 551 typedef num_get<char_type, _Ip> _Fp; 552 ios_base::iostate __err = ios_base::goodbit; 553 use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __n); 554 this->setstate(__err); 555 } 556#ifndef _LIBCPP_NO_EXCEPTIONS 557 } 558 catch (...) 559 { 560 this->__set_badbit_and_consider_rethrow(); 561 } 562#endif // _LIBCPP_NO_EXCEPTIONS 563 return *this; 564} 565 566template <class _CharT, class _Traits> 567basic_istream<_CharT, _Traits>& 568basic_istream<_CharT, _Traits>::operator>>(long double& __n) 569{ 570#ifndef _LIBCPP_NO_EXCEPTIONS 571 try 572 { 573#endif // _LIBCPP_NO_EXCEPTIONS 574 sentry __s(*this); 575 if (__s) 576 { 577 typedef istreambuf_iterator<char_type, traits_type> _Ip; 578 typedef num_get<char_type, _Ip> _Fp; 579 ios_base::iostate __err = ios_base::goodbit; 580 use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __n); 581 this->setstate(__err); 582 } 583#ifndef _LIBCPP_NO_EXCEPTIONS 584 } 585 catch (...) 586 { 587 this->__set_badbit_and_consider_rethrow(); 588 } 589#endif // _LIBCPP_NO_EXCEPTIONS 590 return *this; 591} 592 593template <class _CharT, class _Traits> 594basic_istream<_CharT, _Traits>& 595basic_istream<_CharT, _Traits>::operator>>(bool& __n) 596{ 597#ifndef _LIBCPP_NO_EXCEPTIONS 598 try 599 { 600#endif // _LIBCPP_NO_EXCEPTIONS 601 sentry __s(*this); 602 if (__s) 603 { 604 typedef istreambuf_iterator<char_type, traits_type> _Ip; 605 typedef num_get<char_type, _Ip> _Fp; 606 ios_base::iostate __err = ios_base::goodbit; 607 use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __n); 608 this->setstate(__err); 609 } 610#ifndef _LIBCPP_NO_EXCEPTIONS 611 } 612 catch (...) 613 { 614 this->__set_badbit_and_consider_rethrow(); 615 } 616#endif // _LIBCPP_NO_EXCEPTIONS 617 return *this; 618} 619 620template <class _CharT, class _Traits> 621basic_istream<_CharT, _Traits>& 622basic_istream<_CharT, _Traits>::operator>>(void*& __n) 623{ 624#ifndef _LIBCPP_NO_EXCEPTIONS 625 try 626 { 627#endif // _LIBCPP_NO_EXCEPTIONS 628 sentry __s(*this); 629 if (__s) 630 { 631 typedef istreambuf_iterator<char_type, traits_type> _Ip; 632 typedef num_get<char_type, _Ip> _Fp; 633 ios_base::iostate __err = ios_base::goodbit; 634 use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __n); 635 this->setstate(__err); 636 } 637#ifndef _LIBCPP_NO_EXCEPTIONS 638 } 639 catch (...) 640 { 641 this->__set_badbit_and_consider_rethrow(); 642 } 643#endif // _LIBCPP_NO_EXCEPTIONS 644 return *this; 645} 646 647template <class _CharT, class _Traits> 648basic_istream<_CharT, _Traits>& 649basic_istream<_CharT, _Traits>::operator>>(short& __n) 650{ 651#ifndef _LIBCPP_NO_EXCEPTIONS 652 try 653 { 654#endif // _LIBCPP_NO_EXCEPTIONS 655 sentry __s(*this); 656 if (__s) 657 { 658 typedef istreambuf_iterator<char_type, traits_type> _Ip; 659 typedef num_get<char_type, _Ip> _Fp; 660 ios_base::iostate __err = ios_base::goodbit; 661 long __temp; 662 use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __temp); 663 if (__temp < numeric_limits<short>::min()) 664 { 665 __err |= ios_base::failbit; 666 __n = numeric_limits<short>::min(); 667 } 668 else if (__temp > numeric_limits<short>::max()) 669 { 670 __err |= ios_base::failbit; 671 __n = numeric_limits<short>::max(); 672 } 673 else 674 __n = static_cast<short>(__temp); 675 this->setstate(__err); 676 } 677#ifndef _LIBCPP_NO_EXCEPTIONS 678 } 679 catch (...) 680 { 681 this->__set_badbit_and_consider_rethrow(); 682 } 683#endif // _LIBCPP_NO_EXCEPTIONS 684 return *this; 685} 686 687template <class _CharT, class _Traits> 688basic_istream<_CharT, _Traits>& 689basic_istream<_CharT, _Traits>::operator>>(int& __n) 690{ 691#ifndef _LIBCPP_NO_EXCEPTIONS 692 try 693 { 694#endif // _LIBCPP_NO_EXCEPTIONS 695 sentry __s(*this); 696 if (__s) 697 { 698 typedef istreambuf_iterator<char_type, traits_type> _Ip; 699 typedef num_get<char_type, _Ip> _Fp; 700 ios_base::iostate __err = ios_base::goodbit; 701 long __temp; 702 use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __temp); 703 if (__temp < numeric_limits<int>::min()) 704 { 705 __err |= ios_base::failbit; 706 __n = numeric_limits<int>::min(); 707 } 708 else if (__temp > numeric_limits<int>::max()) 709 { 710 __err |= ios_base::failbit; 711 __n = numeric_limits<int>::max(); 712 } 713 else 714 __n = static_cast<int>(__temp); 715 this->setstate(__err); 716 } 717#ifndef _LIBCPP_NO_EXCEPTIONS 718 } 719 catch (...) 720 { 721 this->__set_badbit_and_consider_rethrow(); 722 } 723#endif // _LIBCPP_NO_EXCEPTIONS 724 return *this; 725} 726 727template <class _CharT, class _Traits> 728inline _LIBCPP_INLINE_VISIBILITY 729basic_istream<_CharT, _Traits>& 730basic_istream<_CharT, _Traits>::operator>>(basic_istream& (*__pf)(basic_istream&)) 731{ 732 return __pf(*this); 733} 734 735template <class _CharT, class _Traits> 736inline _LIBCPP_INLINE_VISIBILITY 737basic_istream<_CharT, _Traits>& 738basic_istream<_CharT, _Traits>::operator>>(basic_ios<char_type, traits_type>& 739 (*__pf)(basic_ios<char_type, traits_type>&)) 740{ 741 __pf(*this); 742 return *this; 743} 744 745template <class _CharT, class _Traits> 746inline _LIBCPP_INLINE_VISIBILITY 747basic_istream<_CharT, _Traits>& 748basic_istream<_CharT, _Traits>::operator>>(ios_base& (*__pf)(ios_base&)) 749{ 750 __pf(*this); 751 return *this; 752} 753 754template<class _CharT, class _Traits> 755basic_istream<_CharT, _Traits>& 756operator>>(basic_istream<_CharT, _Traits>& __is, _CharT* __s) 757{ 758#ifndef _LIBCPP_NO_EXCEPTIONS 759 try 760 { 761#endif // _LIBCPP_NO_EXCEPTIONS 762 typename basic_istream<_CharT, _Traits>::sentry __sen(__is); 763 if (__sen) 764 { 765 streamsize __n = __is.width(); 766 if (__n <= 0) 767 __n = numeric_limits<streamsize>::max() / sizeof(_CharT) - 1; 768 streamsize __c = 0; 769 const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc()); 770 ios_base::iostate __err = ios_base::goodbit; 771 while (__c < __n-1) 772 { 773 typename _Traits::int_type __i = __is.rdbuf()->sgetc(); 774 if (_Traits::eq_int_type(__i, _Traits::eof())) 775 { 776 __err |= ios_base::eofbit; 777 break; 778 } 779 _CharT __ch = _Traits::to_char_type(__i); 780 if (__ct.is(__ct.space, __ch)) 781 break; 782 *__s++ = __ch; 783 ++__c; 784 __is.rdbuf()->sbumpc(); 785 } 786 *__s = _CharT(); 787 __is.width(0); 788 if (__c == 0) 789 __err |= ios_base::failbit; 790 __is.setstate(__err); 791 } 792#ifndef _LIBCPP_NO_EXCEPTIONS 793 } 794 catch (...) 795 { 796 __is.__set_badbit_and_consider_rethrow(); 797 } 798#endif // _LIBCPP_NO_EXCEPTIONS 799 return __is; 800} 801 802template<class _Traits> 803inline _LIBCPP_INLINE_VISIBILITY 804basic_istream<char, _Traits>& 805operator>>(basic_istream<char, _Traits>& __is, unsigned char* __s) 806{ 807 return __is >> (char*)__s; 808} 809 810template<class _Traits> 811inline _LIBCPP_INLINE_VISIBILITY 812basic_istream<char, _Traits>& 813operator>>(basic_istream<char, _Traits>& __is, signed char* __s) 814{ 815 return __is >> (char*)__s; 816} 817 818template<class _CharT, class _Traits> 819basic_istream<_CharT, _Traits>& 820operator>>(basic_istream<_CharT, _Traits>& __is, _CharT& __c) 821{ 822#ifndef _LIBCPP_NO_EXCEPTIONS 823 try 824 { 825#endif // _LIBCPP_NO_EXCEPTIONS 826 typename basic_istream<_CharT, _Traits>::sentry __sen(__is); 827 if (__sen) 828 { 829 typename _Traits::int_type __i = __is.rdbuf()->sbumpc(); 830 if (_Traits::eq_int_type(__i, _Traits::eof())) 831 __is.setstate(ios_base::eofbit | ios_base::failbit); 832 else 833 __c = _Traits::to_char_type(__i); 834 } 835#ifndef _LIBCPP_NO_EXCEPTIONS 836 } 837 catch (...) 838 { 839 __is.__set_badbit_and_consider_rethrow(); 840 } 841#endif // _LIBCPP_NO_EXCEPTIONS 842 return __is; 843} 844 845template<class _Traits> 846inline _LIBCPP_INLINE_VISIBILITY 847basic_istream<char, _Traits>& 848operator>>(basic_istream<char, _Traits>& __is, unsigned char& __c) 849{ 850 return __is >> (char&)__c; 851} 852 853template<class _Traits> 854inline _LIBCPP_INLINE_VISIBILITY 855basic_istream<char, _Traits>& 856operator>>(basic_istream<char, _Traits>& __is, signed char& __c) 857{ 858 return __is >> (char&)__c; 859} 860 861template<class _CharT, class _Traits> 862basic_istream<_CharT, _Traits>& 863basic_istream<_CharT, _Traits>::operator>>(basic_streambuf<char_type, traits_type>* __sb) 864{ 865 __gc_ = 0; 866#ifndef _LIBCPP_NO_EXCEPTIONS 867 try 868 { 869#endif // _LIBCPP_NO_EXCEPTIONS 870 sentry __s(*this, true); 871 if (__s) 872 { 873 if (__sb) 874 { 875#ifndef _LIBCPP_NO_EXCEPTIONS 876 try 877 { 878#endif // _LIBCPP_NO_EXCEPTIONS 879 ios_base::iostate __err = ios_base::goodbit; 880 while (true) 881 { 882 typename traits_type::int_type __i = this->rdbuf()->sgetc(); 883 if (traits_type::eq_int_type(__i, _Traits::eof())) 884 { 885 __err |= ios_base::eofbit; 886 break; 887 } 888 if (traits_type::eq_int_type( 889 __sb->sputc(traits_type::to_char_type(__i)), 890 traits_type::eof())) 891 break; 892 ++__gc_; 893 this->rdbuf()->sbumpc(); 894 } 895 if (__gc_ == 0) 896 __err |= ios_base::failbit; 897 this->setstate(__err); 898#ifndef _LIBCPP_NO_EXCEPTIONS 899 } 900 catch (...) 901 { 902 if (__gc_ == 0) 903 this->__set_failbit_and_consider_rethrow(); 904 } 905#endif // _LIBCPP_NO_EXCEPTIONS 906 } 907 else 908 this->setstate(ios_base::failbit); 909 } 910#ifndef _LIBCPP_NO_EXCEPTIONS 911 } 912 catch (...) 913 { 914 this->__set_badbit_and_consider_rethrow(); 915 } 916#endif // _LIBCPP_NO_EXCEPTIONS 917 return *this; 918} 919 920template<class _CharT, class _Traits> 921typename basic_istream<_CharT, _Traits>::int_type 922basic_istream<_CharT, _Traits>::get() 923{ 924 __gc_ = 0; 925 int_type __r = traits_type::eof(); 926#ifndef _LIBCPP_NO_EXCEPTIONS 927 try 928 { 929#endif // _LIBCPP_NO_EXCEPTIONS 930 sentry __s(*this, true); 931 if (__s) 932 { 933 __r = this->rdbuf()->sbumpc(); 934 if (traits_type::eq_int_type(__r, traits_type::eof())) 935 this->setstate(ios_base::failbit | ios_base::eofbit); 936 else 937 __gc_ = 1; 938 } 939#ifndef _LIBCPP_NO_EXCEPTIONS 940 } 941 catch (...) 942 { 943 this->__set_badbit_and_consider_rethrow(); 944 } 945#endif // _LIBCPP_NO_EXCEPTIONS 946 return __r; 947} 948 949template<class _CharT, class _Traits> 950inline _LIBCPP_INLINE_VISIBILITY 951basic_istream<_CharT, _Traits>& 952basic_istream<_CharT, _Traits>::get(char_type& __c) 953{ 954 int_type __ch = get(); 955 if (__ch != traits_type::eof()) 956 __c = traits_type::to_char_type(__ch); 957 return *this; 958} 959 960template<class _CharT, class _Traits> 961basic_istream<_CharT, _Traits>& 962basic_istream<_CharT, _Traits>::get(char_type* __s, streamsize __n, char_type __dlm) 963{ 964 __gc_ = 0; 965#ifndef _LIBCPP_NO_EXCEPTIONS 966 try 967 { 968#endif // _LIBCPP_NO_EXCEPTIONS 969 sentry __sen(*this, true); 970 if (__sen) 971 { 972 if (__n > 0) 973 { 974 ios_base::iostate __err = ios_base::goodbit; 975 while (__gc_ < __n-1) 976 { 977 int_type __i = this->rdbuf()->sgetc(); 978 if (traits_type::eq_int_type(__i, traits_type::eof())) 979 { 980 __err |= ios_base::eofbit; 981 break; 982 } 983 char_type __ch = traits_type::to_char_type(__i); 984 if (traits_type::eq(__ch, __dlm)) 985 break; 986 *__s++ = __ch; 987 ++__gc_; 988 this->rdbuf()->sbumpc(); 989 } 990 *__s = char_type(); 991 if (__gc_ == 0) 992 __err |= ios_base::failbit; 993 this->setstate(__err); 994 } 995 else 996 this->setstate(ios_base::failbit); 997 } 998#ifndef _LIBCPP_NO_EXCEPTIONS 999 } 1000 catch (...) 1001 { 1002 this->__set_badbit_and_consider_rethrow(); 1003 } 1004#endif // _LIBCPP_NO_EXCEPTIONS 1005 return *this; 1006} 1007 1008template<class _CharT, class _Traits> 1009inline _LIBCPP_INLINE_VISIBILITY 1010basic_istream<_CharT, _Traits>& 1011basic_istream<_CharT, _Traits>::get(char_type* __s, streamsize __n) 1012{ 1013 return get(__s, __n, this->widen('\n')); 1014} 1015 1016template<class _CharT, class _Traits> 1017basic_istream<_CharT, _Traits>& 1018basic_istream<_CharT, _Traits>::get(basic_streambuf<char_type, traits_type>& __sb, 1019 char_type __dlm) 1020{ 1021 __gc_ = 0; 1022#ifndef _LIBCPP_NO_EXCEPTIONS 1023 try 1024 { 1025#endif // _LIBCPP_NO_EXCEPTIONS 1026 sentry __sen(*this, true); 1027 if (__sen) 1028 { 1029 ios_base::iostate __err = ios_base::goodbit; 1030#ifndef _LIBCPP_NO_EXCEPTIONS 1031 try 1032 { 1033#endif // _LIBCPP_NO_EXCEPTIONS 1034 while (true) 1035 { 1036 typename traits_type::int_type __i = this->rdbuf()->sgetc(); 1037 if (traits_type::eq_int_type(__i, traits_type::eof())) 1038 { 1039 __err |= ios_base::eofbit; 1040 break; 1041 } 1042 char_type __ch = traits_type::to_char_type(__i); 1043 if (traits_type::eq(__ch, __dlm)) 1044 break; 1045 if (traits_type::eq_int_type(__sb.sputc(__ch), traits_type::eof())) 1046 break; 1047 ++__gc_; 1048 this->rdbuf()->sbumpc(); 1049 } 1050#ifndef _LIBCPP_NO_EXCEPTIONS 1051 } 1052 catch (...) 1053 { 1054 } 1055#endif // _LIBCPP_NO_EXCEPTIONS 1056 if (__gc_ == 0) 1057 __err |= ios_base::failbit; 1058 this->setstate(__err); 1059 } 1060#ifndef _LIBCPP_NO_EXCEPTIONS 1061 } 1062 catch (...) 1063 { 1064 this->__set_badbit_and_consider_rethrow(); 1065 } 1066#endif // _LIBCPP_NO_EXCEPTIONS 1067 return *this; 1068} 1069 1070template<class _CharT, class _Traits> 1071inline _LIBCPP_INLINE_VISIBILITY 1072basic_istream<_CharT, _Traits>& 1073basic_istream<_CharT, _Traits>::get(basic_streambuf<char_type, traits_type>& __sb) 1074{ 1075 return get(__sb, this->widen('\n')); 1076} 1077 1078template<class _CharT, class _Traits> 1079basic_istream<_CharT, _Traits>& 1080basic_istream<_CharT, _Traits>::getline(char_type* __s, streamsize __n, char_type __dlm) 1081{ 1082 __gc_ = 0; 1083#ifndef _LIBCPP_NO_EXCEPTIONS 1084 try 1085 { 1086#endif // _LIBCPP_NO_EXCEPTIONS 1087 sentry __sen(*this, true); 1088 if (__sen) 1089 { 1090 ios_base::iostate __err = ios_base::goodbit; 1091 while (true) 1092 { 1093 typename traits_type::int_type __i = this->rdbuf()->sgetc(); 1094 if (traits_type::eq_int_type(__i, traits_type::eof())) 1095 { 1096 __err |= ios_base::eofbit; 1097 break; 1098 } 1099 char_type __ch = traits_type::to_char_type(__i); 1100 if (traits_type::eq(__ch, __dlm)) 1101 { 1102 this->rdbuf()->sbumpc(); 1103 ++__gc_; 1104 break; 1105 } 1106 if (__gc_ >= __n-1) 1107 { 1108 __err |= ios_base::failbit; 1109 break; 1110 } 1111 *__s++ = __ch; 1112 this->rdbuf()->sbumpc(); 1113 ++__gc_; 1114 } 1115 if (__n > 0) 1116 *__s = char_type(); 1117 if (__gc_ == 0) 1118 __err |= ios_base::failbit; 1119 this->setstate(__err); 1120 } 1121#ifndef _LIBCPP_NO_EXCEPTIONS 1122 } 1123 catch (...) 1124 { 1125 this->__set_badbit_and_consider_rethrow(); 1126 } 1127#endif // _LIBCPP_NO_EXCEPTIONS 1128 return *this; 1129} 1130 1131template<class _CharT, class _Traits> 1132inline _LIBCPP_INLINE_VISIBILITY 1133basic_istream<_CharT, _Traits>& 1134basic_istream<_CharT, _Traits>::getline(char_type* __s, streamsize __n) 1135{ 1136 return getline(__s, __n, this->widen('\n')); 1137} 1138 1139template<class _CharT, class _Traits> 1140basic_istream<_CharT, _Traits>& 1141basic_istream<_CharT, _Traits>::ignore(streamsize __n, int_type __dlm) 1142{ 1143 __gc_ = 0; 1144#ifndef _LIBCPP_NO_EXCEPTIONS 1145 try 1146 { 1147#endif // _LIBCPP_NO_EXCEPTIONS 1148 sentry __sen(*this, true); 1149 if (__sen) 1150 { 1151 ios_base::iostate __err = ios_base::goodbit; 1152 if (__n == numeric_limits<streamsize>::max()) 1153 { 1154 while (true) 1155 { 1156 typename traits_type::int_type __i = this->rdbuf()->sbumpc(); 1157 if (traits_type::eq_int_type(__i, traits_type::eof())) 1158 { 1159 __err |= ios_base::eofbit; 1160 break; 1161 } 1162 ++__gc_; 1163 if (traits_type::eq_int_type(__i, __dlm)) 1164 break; 1165 } 1166 } 1167 else 1168 { 1169 while (__gc_ < __n) 1170 { 1171 typename traits_type::int_type __i = this->rdbuf()->sbumpc(); 1172 if (traits_type::eq_int_type(__i, traits_type::eof())) 1173 { 1174 __err |= ios_base::eofbit; 1175 break; 1176 } 1177 ++__gc_; 1178 if (traits_type::eq_int_type(__i, __dlm)) 1179 break; 1180 } 1181 } 1182 this->setstate(__err); 1183 } 1184#ifndef _LIBCPP_NO_EXCEPTIONS 1185 } 1186 catch (...) 1187 { 1188 this->__set_badbit_and_consider_rethrow(); 1189 } 1190#endif // _LIBCPP_NO_EXCEPTIONS 1191 return *this; 1192} 1193 1194template<class _CharT, class _Traits> 1195typename basic_istream<_CharT, _Traits>::int_type 1196basic_istream<_CharT, _Traits>::peek() 1197{ 1198 __gc_ = 0; 1199 int_type __r = traits_type::eof(); 1200#ifndef _LIBCPP_NO_EXCEPTIONS 1201 try 1202 { 1203#endif // _LIBCPP_NO_EXCEPTIONS 1204 sentry __sen(*this, true); 1205 if (__sen) 1206 { 1207 __r = this->rdbuf()->sgetc(); 1208 if (traits_type::eq_int_type(__r, traits_type::eof())) 1209 this->setstate(ios_base::eofbit); 1210 } 1211#ifndef _LIBCPP_NO_EXCEPTIONS 1212 } 1213 catch (...) 1214 { 1215 this->__set_badbit_and_consider_rethrow(); 1216 } 1217#endif // _LIBCPP_NO_EXCEPTIONS 1218 return __r; 1219} 1220 1221template<class _CharT, class _Traits> 1222basic_istream<_CharT, _Traits>& 1223basic_istream<_CharT, _Traits>::read(char_type* __s, streamsize __n) 1224{ 1225 __gc_ = 0; 1226#ifndef _LIBCPP_NO_EXCEPTIONS 1227 try 1228 { 1229#endif // _LIBCPP_NO_EXCEPTIONS 1230 sentry __sen(*this, true); 1231 if (__sen) 1232 { 1233 __gc_ = this->rdbuf()->sgetn(__s, __n); 1234 if (__gc_ != __n) 1235 this->setstate(ios_base::failbit | ios_base::eofbit); 1236 } 1237 else 1238 this->setstate(ios_base::failbit); 1239#ifndef _LIBCPP_NO_EXCEPTIONS 1240 } 1241 catch (...) 1242 { 1243 this->__set_badbit_and_consider_rethrow(); 1244 } 1245#endif // _LIBCPP_NO_EXCEPTIONS 1246 return *this; 1247} 1248 1249template<class _CharT, class _Traits> 1250streamsize 1251basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __n) 1252{ 1253 __gc_ = 0; 1254 streamsize __c = this->rdbuf()->in_avail(); 1255 switch (__c) 1256 { 1257 case -1: 1258 this->setstate(ios_base::eofbit); 1259 break; 1260 case 0: 1261 break; 1262 default: 1263 read(__s, _VSTD::min(__c, __n)); 1264 break; 1265 } 1266 return __gc_; 1267} 1268 1269template<class _CharT, class _Traits> 1270basic_istream<_CharT, _Traits>& 1271basic_istream<_CharT, _Traits>::putback(char_type __c) 1272{ 1273 __gc_ = 0; 1274#ifndef _LIBCPP_NO_EXCEPTIONS 1275 try 1276 { 1277#endif // _LIBCPP_NO_EXCEPTIONS 1278 this->clear(this->rdstate() & ~ios_base::eofbit); 1279 sentry __sen(*this, true); 1280 if (__sen) 1281 { 1282 if (this->rdbuf() == 0 || this->rdbuf()->sputbackc(__c) == traits_type::eof()) 1283 this->setstate(ios_base::badbit); 1284 } 1285 else 1286 this->setstate(ios_base::failbit); 1287#ifndef _LIBCPP_NO_EXCEPTIONS 1288 } 1289 catch (...) 1290 { 1291 this->__set_badbit_and_consider_rethrow(); 1292 } 1293#endif // _LIBCPP_NO_EXCEPTIONS 1294 return *this; 1295} 1296 1297template<class _CharT, class _Traits> 1298basic_istream<_CharT, _Traits>& 1299basic_istream<_CharT, _Traits>::unget() 1300{ 1301 __gc_ = 0; 1302#ifndef _LIBCPP_NO_EXCEPTIONS 1303 try 1304 { 1305#endif // _LIBCPP_NO_EXCEPTIONS 1306 this->clear(this->rdstate() & ~ios_base::eofbit); 1307 sentry __sen(*this, true); 1308 if (__sen) 1309 { 1310 if (this->rdbuf() == 0 || this->rdbuf()->sungetc() == traits_type::eof()) 1311 this->setstate(ios_base::badbit); 1312 } 1313 else 1314 this->setstate(ios_base::failbit); 1315#ifndef _LIBCPP_NO_EXCEPTIONS 1316 } 1317 catch (...) 1318 { 1319 this->__set_badbit_and_consider_rethrow(); 1320 } 1321#endif // _LIBCPP_NO_EXCEPTIONS 1322 return *this; 1323} 1324 1325template<class _CharT, class _Traits> 1326int 1327basic_istream<_CharT, _Traits>::sync() 1328{ 1329 int __r = 0; 1330#ifndef _LIBCPP_NO_EXCEPTIONS 1331 try 1332 { 1333#endif // _LIBCPP_NO_EXCEPTIONS 1334 sentry __sen(*this, true); 1335 if (__sen) 1336 { 1337 if (this->rdbuf() == 0) 1338 return -1; 1339 if (this->rdbuf()->pubsync() == -1) 1340 { 1341 this->setstate(ios_base::badbit); 1342 return -1; 1343 } 1344 } 1345#ifndef _LIBCPP_NO_EXCEPTIONS 1346 } 1347 catch (...) 1348 { 1349 this->__set_badbit_and_consider_rethrow(); 1350 } 1351#endif // _LIBCPP_NO_EXCEPTIONS 1352 return __r; 1353} 1354 1355template<class _CharT, class _Traits> 1356typename basic_istream<_CharT, _Traits>::pos_type 1357basic_istream<_CharT, _Traits>::tellg() 1358{ 1359 pos_type __r(-1); 1360#ifndef _LIBCPP_NO_EXCEPTIONS 1361 try 1362 { 1363#endif // _LIBCPP_NO_EXCEPTIONS 1364 sentry __sen(*this, true); 1365 if (__sen) 1366 __r = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in); 1367#ifndef _LIBCPP_NO_EXCEPTIONS 1368 } 1369 catch (...) 1370 { 1371 this->__set_badbit_and_consider_rethrow(); 1372 } 1373#endif // _LIBCPP_NO_EXCEPTIONS 1374 return __r; 1375} 1376 1377template<class _CharT, class _Traits> 1378basic_istream<_CharT, _Traits>& 1379basic_istream<_CharT, _Traits>::seekg(pos_type __pos) 1380{ 1381#ifndef _LIBCPP_NO_EXCEPTIONS 1382 try 1383 { 1384#endif // _LIBCPP_NO_EXCEPTIONS 1385 this->clear(this->rdstate() & ~ios_base::eofbit); 1386 sentry __sen(*this, true); 1387 if (__sen) 1388 { 1389 if (this->rdbuf()->pubseekpos(__pos, ios_base::in) == pos_type(-1)) 1390 this->setstate(ios_base::failbit); 1391 } 1392#ifndef _LIBCPP_NO_EXCEPTIONS 1393 } 1394 catch (...) 1395 { 1396 this->__set_badbit_and_consider_rethrow(); 1397 } 1398#endif // _LIBCPP_NO_EXCEPTIONS 1399 return *this; 1400} 1401 1402template<class _CharT, class _Traits> 1403basic_istream<_CharT, _Traits>& 1404basic_istream<_CharT, _Traits>::seekg(off_type __off, ios_base::seekdir __dir) 1405{ 1406#ifndef _LIBCPP_NO_EXCEPTIONS 1407 try 1408 { 1409#endif // _LIBCPP_NO_EXCEPTIONS 1410 sentry __sen(*this, true); 1411 if (__sen) 1412 { 1413 if (this->rdbuf()->pubseekoff(__off, __dir, ios_base::in) == pos_type(-1)) 1414 this->setstate(ios_base::failbit); 1415 } 1416#ifndef _LIBCPP_NO_EXCEPTIONS 1417 } 1418 catch (...) 1419 { 1420 this->__set_badbit_and_consider_rethrow(); 1421 } 1422#endif // _LIBCPP_NO_EXCEPTIONS 1423 return *this; 1424} 1425 1426template <class _CharT, class _Traits> 1427basic_istream<_CharT, _Traits>& 1428ws(basic_istream<_CharT, _Traits>& __is) 1429{ 1430#ifndef _LIBCPP_NO_EXCEPTIONS 1431 try 1432 { 1433#endif // _LIBCPP_NO_EXCEPTIONS 1434 typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true); 1435 if (__sen) 1436 { 1437 const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc()); 1438 while (true) 1439 { 1440 typename _Traits::int_type __i = __is.rdbuf()->sgetc(); 1441 if (_Traits::eq_int_type(__i, _Traits::eof())) 1442 { 1443 __is.setstate(ios_base::eofbit); 1444 break; 1445 } 1446 if (!__ct.is(__ct.space, _Traits::to_char_type(__i))) 1447 break; 1448 __is.rdbuf()->sbumpc(); 1449 } 1450 } 1451#ifndef _LIBCPP_NO_EXCEPTIONS 1452 } 1453 catch (...) 1454 { 1455 __is.__set_badbit_and_consider_rethrow(); 1456 } 1457#endif // _LIBCPP_NO_EXCEPTIONS 1458 return __is; 1459} 1460 1461#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1462 1463template <class _CharT, class _Traits, class _Tp> 1464inline _LIBCPP_INLINE_VISIBILITY 1465basic_istream<_CharT, _Traits>& 1466operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x) 1467{ 1468 __is >> __x; 1469 return __is; 1470} 1471 1472#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1473 1474template <class _CharT, class _Traits> 1475class _LIBCPP_TYPE_VIS_ONLY basic_iostream 1476 : public basic_istream<_CharT, _Traits>, 1477 public basic_ostream<_CharT, _Traits> 1478{ 1479public: 1480 // types: 1481 typedef _CharT char_type; 1482 typedef _Traits traits_type; 1483 typedef typename traits_type::int_type int_type; 1484 typedef typename traits_type::pos_type pos_type; 1485 typedef typename traits_type::off_type off_type; 1486 1487 // constructor/destructor 1488 explicit basic_iostream(basic_streambuf<char_type, traits_type>* __sb); 1489 virtual ~basic_iostream(); 1490protected: 1491#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1492 _LIBCPP_INLINE_VISIBILITY 1493 basic_iostream(basic_iostream&& __rhs); 1494#endif 1495 1496 // assign/swap 1497#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1498 _LIBCPP_INLINE_VISIBILITY 1499 basic_iostream& operator=(basic_iostream&& __rhs); 1500#endif 1501 void swap(basic_iostream& __rhs); 1502public: 1503}; 1504 1505template <class _CharT, class _Traits> 1506inline _LIBCPP_INLINE_VISIBILITY 1507basic_iostream<_CharT, _Traits>::basic_iostream(basic_streambuf<char_type, traits_type>* __sb) 1508 : basic_istream<_CharT, _Traits>(__sb) 1509{ 1510} 1511 1512#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1513 1514template <class _CharT, class _Traits> 1515inline _LIBCPP_INLINE_VISIBILITY 1516basic_iostream<_CharT, _Traits>::basic_iostream(basic_iostream&& __rhs) 1517 : basic_istream<_CharT, _Traits>(_VSTD::move(__rhs)) 1518{ 1519} 1520 1521template <class _CharT, class _Traits> 1522inline _LIBCPP_INLINE_VISIBILITY 1523basic_iostream<_CharT, _Traits>& 1524basic_iostream<_CharT, _Traits>::operator=(basic_iostream&& __rhs) 1525{ 1526 swap(__rhs); 1527 return *this; 1528} 1529 1530#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1531 1532template <class _CharT, class _Traits> 1533basic_iostream<_CharT, _Traits>::~basic_iostream() 1534{ 1535} 1536 1537template <class _CharT, class _Traits> 1538inline _LIBCPP_INLINE_VISIBILITY 1539void 1540basic_iostream<_CharT, _Traits>::swap(basic_iostream& __rhs) 1541{ 1542 basic_istream<char_type, traits_type>::swap(__rhs); 1543} 1544 1545template<class _CharT, class _Traits, class _Allocator> 1546basic_istream<_CharT, _Traits>& 1547operator>>(basic_istream<_CharT, _Traits>& __is, 1548 basic_string<_CharT, _Traits, _Allocator>& __str) 1549{ 1550#ifndef _LIBCPP_NO_EXCEPTIONS 1551 try 1552 { 1553#endif // _LIBCPP_NO_EXCEPTIONS 1554 typename basic_istream<_CharT, _Traits>::sentry __sen(__is); 1555 if (__sen) 1556 { 1557 __str.clear(); 1558 streamsize __n = __is.width(); 1559 if (__n <= 0) 1560 __n = __str.max_size(); 1561 if (__n <= 0) 1562 __n = numeric_limits<streamsize>::max(); 1563 streamsize __c = 0; 1564 const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc()); 1565 ios_base::iostate __err = ios_base::goodbit; 1566 while (__c < __n) 1567 { 1568 typename _Traits::int_type __i = __is.rdbuf()->sgetc(); 1569 if (_Traits::eq_int_type(__i, _Traits::eof())) 1570 { 1571 __err |= ios_base::eofbit; 1572 break; 1573 } 1574 _CharT __ch = _Traits::to_char_type(__i); 1575 if (__ct.is(__ct.space, __ch)) 1576 break; 1577 __str.push_back(__ch); 1578 ++__c; 1579 __is.rdbuf()->sbumpc(); 1580 } 1581 __is.width(0); 1582 if (__c == 0) 1583 __err |= ios_base::failbit; 1584 __is.setstate(__err); 1585 } 1586 else 1587 __is.setstate(ios_base::failbit); 1588#ifndef _LIBCPP_NO_EXCEPTIONS 1589 } 1590 catch (...) 1591 { 1592 __is.__set_badbit_and_consider_rethrow(); 1593 } 1594#endif // _LIBCPP_NO_EXCEPTIONS 1595 return __is; 1596} 1597 1598template<class _CharT, class _Traits, class _Allocator> 1599basic_istream<_CharT, _Traits>& 1600getline(basic_istream<_CharT, _Traits>& __is, 1601 basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm) 1602{ 1603#ifndef _LIBCPP_NO_EXCEPTIONS 1604 try 1605 { 1606#endif // _LIBCPP_NO_EXCEPTIONS 1607 typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true); 1608 if (__sen) 1609 { 1610 __str.clear(); 1611 ios_base::iostate __err = ios_base::goodbit; 1612 streamsize __extr = 0; 1613 while (true) 1614 { 1615 typename _Traits::int_type __i = __is.rdbuf()->sbumpc(); 1616 if (_Traits::eq_int_type(__i, _Traits::eof())) 1617 { 1618 __err |= ios_base::eofbit; 1619 break; 1620 } 1621 ++__extr; 1622 _CharT __ch = _Traits::to_char_type(__i); 1623 if (_Traits::eq(__ch, __dlm)) 1624 break; 1625 __str.push_back(__ch); 1626 if (__str.size() == __str.max_size()) 1627 { 1628 __err |= ios_base::failbit; 1629 break; 1630 } 1631 } 1632 if (__extr == 0) 1633 __err |= ios_base::failbit; 1634 __is.setstate(__err); 1635 } 1636#ifndef _LIBCPP_NO_EXCEPTIONS 1637 } 1638 catch (...) 1639 { 1640 __is.__set_badbit_and_consider_rethrow(); 1641 } 1642#endif // _LIBCPP_NO_EXCEPTIONS 1643 return __is; 1644} 1645 1646template<class _CharT, class _Traits, class _Allocator> 1647inline _LIBCPP_INLINE_VISIBILITY 1648basic_istream<_CharT, _Traits>& 1649getline(basic_istream<_CharT, _Traits>& __is, 1650 basic_string<_CharT, _Traits, _Allocator>& __str) 1651{ 1652 return getline(__is, __str, __is.widen('\n')); 1653} 1654 1655#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1656 1657template<class _CharT, class _Traits, class _Allocator> 1658inline _LIBCPP_INLINE_VISIBILITY 1659basic_istream<_CharT, _Traits>& 1660getline(basic_istream<_CharT, _Traits>&& __is, 1661 basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm) 1662{ 1663 return getline(__is, __str, __dlm); 1664} 1665 1666template<class _CharT, class _Traits, class _Allocator> 1667inline _LIBCPP_INLINE_VISIBILITY 1668basic_istream<_CharT, _Traits>& 1669getline(basic_istream<_CharT, _Traits>&& __is, 1670 basic_string<_CharT, _Traits, _Allocator>& __str) 1671{ 1672 return getline(__is, __str, __is.widen('\n')); 1673} 1674 1675#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1676 1677template <class _CharT, class _Traits, size_t _Size> 1678basic_istream<_CharT, _Traits>& 1679operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x) 1680{ 1681#ifndef _LIBCPP_NO_EXCEPTIONS 1682 try 1683 { 1684#endif // _LIBCPP_NO_EXCEPTIONS 1685 typename basic_istream<_CharT, _Traits>::sentry __sen(__is); 1686 if (__sen) 1687 { 1688 basic_string<_CharT, _Traits> __str; 1689 const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc()); 1690 streamsize __c = 0; 1691 ios_base::iostate __err = ios_base::goodbit; 1692 _CharT __zero = __ct.widen('0'); 1693 _CharT __one = __ct.widen('1'); 1694 while (__c < _Size) 1695 { 1696 typename _Traits::int_type __i = __is.rdbuf()->sgetc(); 1697 if (_Traits::eq_int_type(__i, _Traits::eof())) 1698 { 1699 __err |= ios_base::eofbit; 1700 break; 1701 } 1702 _CharT __ch = _Traits::to_char_type(__i); 1703 if (!_Traits::eq(__ch, __zero) && !_Traits::eq(__ch, __one)) 1704 break; 1705 __str.push_back(__ch); 1706 ++__c; 1707 __is.rdbuf()->sbumpc(); 1708 } 1709 __x = bitset<_Size>(__str); 1710 if (__c == 0) 1711 __err |= ios_base::failbit; 1712 __is.setstate(__err); 1713 } 1714 else 1715 __is.setstate(ios_base::failbit); 1716#ifndef _LIBCPP_NO_EXCEPTIONS 1717 } 1718 catch (...) 1719 { 1720 __is.__set_badbit_and_consider_rethrow(); 1721 } 1722#endif // _LIBCPP_NO_EXCEPTIONS 1723 return __is; 1724} 1725 1726_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS basic_istream<char>) 1727_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS basic_istream<wchar_t>) 1728_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_TYPE_VIS basic_iostream<char>) 1729 1730_LIBCPP_END_NAMESPACE_STD 1731 1732#endif // _LIBCPP_ISTREAM 1733