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