libcxx/include/istream

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