contrib/libc++/include/istream

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