contrib/libc++/include/istream

   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