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