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