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