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