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