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