Home | History | Annotate | Download | only in v1
      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 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
    166 #pragma GCC system_header
    167 #endif
    168 
    169 _LIBCPP_PUSH_MACROS
    170 #include <__undef_macros>
    171 
    172 
    173 _LIBCPP_BEGIN_NAMESPACE_STD
    174 
    175 template <class _CharT, class _Traits>
    176 class _LIBCPP_TEMPLATE_VIS basic_istream
    177     : virtual public basic_ios<_CharT, _Traits>
    178 {
    179     streamsize __gc_;
    180 public:
    181     // types (inherited from basic_ios (27.5.4)):
    182     typedef _CharT                         char_type;
    183     typedef _Traits                        traits_type;
    184     typedef typename traits_type::int_type int_type;
    185     typedef typename traits_type::pos_type pos_type;
    186     typedef typename traits_type::off_type off_type;
    187 
    188     // 27.7.1.1.1 Constructor/destructor:
    189     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    190     explicit basic_istream(basic_streambuf<char_type, traits_type>* __sb) : __gc_(0)
    191     { this->init(__sb); }
    192     virtual ~basic_istream();
    193 protected:
    194 #ifndef _LIBCPP_CXX03_LANG
    195     inline _LIBCPP_INLINE_VISIBILITY
    196     basic_istream(basic_istream&& __rhs);
    197 
    198     // 27.7.1.1.2 Assign/swap:
    199     inline _LIBCPP_INLINE_VISIBILITY
    200     basic_istream& operator=(basic_istream&& __rhs);
    201 #endif
    202 
    203     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    204     void swap(basic_istream& __rhs) {
    205       _VSTD::swap(__gc_, __rhs.__gc_);
    206       basic_ios<char_type, traits_type>::swap(__rhs);
    207     }
    208 
    209 #ifndef _LIBCPP_CXX03_LANG
    210     basic_istream           (const basic_istream& __rhs) = delete;
    211     basic_istream& operator=(const basic_istream& __rhs) = delete;
    212 #endif
    213 public:
    214 
    215     // 27.7.1.1.3 Prefix/suffix:
    216     class _LIBCPP_TEMPLATE_VIS sentry;
    217 
    218     // 27.7.1.2 Formatted input:
    219     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    220     basic_istream& operator>>(basic_istream& (*__pf)(basic_istream&))
    221     { return __pf(*this); }
    222 
    223     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    224     basic_istream& operator>>(basic_ios<char_type, traits_type>&
    225                               (*__pf)(basic_ios<char_type, traits_type>&))
    226     { __pf(*this); return *this; }
    227 
    228     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    229     basic_istream& operator>>(ios_base& (*__pf)(ios_base&))
    230     { __pf(*this); return *this; }
    231 
    232     basic_istream& operator>>(basic_streambuf<char_type, traits_type>* __sb);
    233     basic_istream& operator>>(bool& __n);
    234     basic_istream& operator>>(short& __n);
    235     basic_istream& operator>>(unsigned short& __n);
    236     basic_istream& operator>>(int& __n);
    237     basic_istream& operator>>(unsigned int& __n);
    238     basic_istream& operator>>(long& __n);
    239     basic_istream& operator>>(unsigned long& __n);
    240     basic_istream& operator>>(long long& __n);
    241     basic_istream& operator>>(unsigned long long& __n);
    242     basic_istream& operator>>(float& __f);
    243     basic_istream& operator>>(double& __f);
    244     basic_istream& operator>>(long double& __f);
    245     basic_istream& operator>>(void*& __p);
    246 
    247     // 27.7.1.3 Unformatted input:
    248     _LIBCPP_INLINE_VISIBILITY
    249     streamsize gcount() const {return __gc_;}
    250     int_type get();
    251 
    252     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    253     basic_istream& get(char_type& __c) {
    254       int_type __ch = get();
    255       if (__ch != traits_type::eof())
    256         __c = traits_type::to_char_type(__ch);
    257       return *this;
    258     }
    259 
    260     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    261     basic_istream& get(char_type* __s, streamsize __n)
    262     { return get(__s, __n, this->widen('\n')); }
    263 
    264     basic_istream& get(char_type* __s, streamsize __n, char_type __dlm);
    265 
    266     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    267     basic_istream& get(basic_streambuf<char_type, traits_type>& __sb)
    268     { return get(__sb, this->widen('\n')); }
    269 
    270     basic_istream& get(basic_streambuf<char_type, traits_type>& __sb, char_type __dlm);
    271 
    272     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
    273     basic_istream& getline(char_type* __s, streamsize __n)
    274     { return getline(__s, __n, this->widen('\n')); }
    275 
    276     basic_istream& getline(char_type* __s, streamsize __n, char_type __dlm);
    277 
    278     basic_istream& ignore(streamsize __n = 1, int_type __dlm = traits_type::eof());
    279     int_type peek();
    280     basic_istream& read (char_type* __s, streamsize __n);
    281     streamsize readsome(char_type* __s, streamsize __n);
    282 
    283     basic_istream& putback(char_type __c);
    284     basic_istream& unget();
    285     int sync();
    286 
    287     pos_type tellg();
    288     basic_istream& seekg(pos_type __pos);
    289     basic_istream& seekg(off_type __off, ios_base::seekdir __dir);
    290 };
    291 
    292 template <class _CharT, class _Traits>
    293 class _LIBCPP_TEMPLATE_VIS basic_istream<_CharT, _Traits>::sentry
    294 {
    295     bool __ok_;
    296 
    297     sentry(const sentry&); // = delete;
    298     sentry& operator=(const sentry&); // = delete;
    299 
    300 public:
    301     explicit sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
    302 //    ~sentry() = default;
    303 
    304     _LIBCPP_INLINE_VISIBILITY
    305         _LIBCPP_EXPLICIT
    306         operator bool() const {return __ok_;}
    307 };
    308 
    309 template <class _CharT, class _Traits>
    310 basic_istream<_CharT, _Traits>::sentry::sentry(basic_istream<_CharT, _Traits>& __is,
    311                                                bool __noskipws)
    312     : __ok_(false)
    313 {
    314     if (__is.good())
    315     {
    316         if (__is.tie())
    317             __is.tie()->flush();
    318         if (!__noskipws && (__is.flags() & ios_base::skipws))
    319         {
    320             typedef istreambuf_iterator<_CharT, _Traits> _Ip;
    321             const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
    322             _Ip __i(__is);
    323             _Ip __eof;
    324             for (; __i != __eof; ++__i)
    325                 if (!__ct.is(__ct.space, *__i))
    326                     break;
    327             if (__i == __eof)
    328                 __is.setstate(ios_base::failbit | ios_base::eofbit);
    329         }
    330         __ok_ = __is.good();
    331     }
    332     else
    333         __is.setstate(ios_base::failbit);
    334 }
    335 
    336 #ifndef _LIBCPP_CXX03_LANG
    337 
    338 template <class _CharT, class _Traits>
    339 basic_istream<_CharT, _Traits>::basic_istream(basic_istream&& __rhs)
    340     : __gc_(__rhs.__gc_)
    341 {
    342     __rhs.__gc_ = 0;
    343     this->move(__rhs);
    344 }
    345 
    346 template <class _CharT, class _Traits>
    347 basic_istream<_CharT, _Traits>&
    348 basic_istream<_CharT, _Traits>::operator=(basic_istream&& __rhs)
    349 {
    350     swap(__rhs);
    351     return *this;
    352 }
    353 
    354 #endif  // _LIBCPP_CXX03_LANG
    355 
    356 template <class _CharT, class _Traits>
    357 basic_istream<_CharT, _Traits>::~basic_istream()
    358 {
    359 }
    360 
    361 template <class _CharT, class _Traits>
    362 basic_istream<_CharT, _Traits>&
    363 basic_istream<_CharT, _Traits>::operator>>(unsigned short& __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>>(unsigned int& __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>>(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>>(unsigned 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>>(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>>(unsigned long long& __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>>(float& __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>>(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>>(long double& __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>>(bool& __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>>(void*& __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             use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __n);
    646             this->setstate(__err);
    647         }
    648 #ifndef _LIBCPP_NO_EXCEPTIONS
    649     }
    650     catch (...)
    651     {
    652         this->__set_badbit_and_consider_rethrow();
    653     }
    654 #endif  // _LIBCPP_NO_EXCEPTIONS
    655     return *this;
    656 }
    657 
    658 template <class _CharT, class _Traits>
    659 basic_istream<_CharT, _Traits>&
    660 basic_istream<_CharT, _Traits>::operator>>(short& __n)
    661 {
    662 #ifndef _LIBCPP_NO_EXCEPTIONS
    663     try
    664     {
    665 #endif  // _LIBCPP_NO_EXCEPTIONS
    666         sentry __s(*this);
    667         if (__s)
    668         {
    669             typedef istreambuf_iterator<char_type, traits_type> _Ip;
    670             typedef num_get<char_type, _Ip> _Fp;
    671             ios_base::iostate __err = ios_base::goodbit;
    672             long __temp;
    673             use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __temp);
    674             if (__temp < numeric_limits<short>::min())
    675             {
    676                 __err |= ios_base::failbit;
    677                 __n = numeric_limits<short>::min();
    678             }
    679             else if (__temp > numeric_limits<short>::max())
    680             {
    681                 __err |= ios_base::failbit;
    682                 __n = numeric_limits<short>::max();
    683             }
    684             else
    685                 __n = static_cast<short>(__temp);
    686             this->setstate(__err);
    687         }
    688 #ifndef _LIBCPP_NO_EXCEPTIONS
    689     }
    690     catch (...)
    691     {
    692         this->__set_badbit_and_consider_rethrow();
    693     }
    694 #endif  // _LIBCPP_NO_EXCEPTIONS
    695     return *this;
    696 }
    697 
    698 template <class _CharT, class _Traits>
    699 basic_istream<_CharT, _Traits>&
    700 basic_istream<_CharT, _Traits>::operator>>(int& __n)
    701 {
    702 #ifndef _LIBCPP_NO_EXCEPTIONS
    703     try
    704     {
    705 #endif  // _LIBCPP_NO_EXCEPTIONS
    706         sentry __s(*this);
    707         if (__s)
    708         {
    709             typedef istreambuf_iterator<char_type, traits_type> _Ip;
    710             typedef num_get<char_type, _Ip> _Fp;
    711             ios_base::iostate __err = ios_base::goodbit;
    712             long __temp;
    713             use_facet<_Fp>(this->getloc()).get(_Ip(*this), _Ip(), *this, __err, __temp);
    714             if (__temp < numeric_limits<int>::min())
    715             {
    716                 __err |= ios_base::failbit;
    717                 __n = numeric_limits<int>::min();
    718             }
    719             else if (__temp > numeric_limits<int>::max())
    720             {
    721                 __err |= ios_base::failbit;
    722                 __n = numeric_limits<int>::max();
    723             }
    724             else
    725                 __n = static_cast<int>(__temp);
    726             this->setstate(__err);
    727         }
    728 #ifndef _LIBCPP_NO_EXCEPTIONS
    729     }
    730     catch (...)
    731     {
    732         this->__set_badbit_and_consider_rethrow();
    733     }
    734 #endif  // _LIBCPP_NO_EXCEPTIONS
    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 basic_istream<_CharT, _Traits>&
    935 basic_istream<_CharT, _Traits>::get(char_type* __s, streamsize __n, char_type __dlm)
    936 {
    937     __gc_ = 0;
    938 #ifndef _LIBCPP_NO_EXCEPTIONS
    939     try
    940     {
    941 #endif  // _LIBCPP_NO_EXCEPTIONS
    942         sentry __sen(*this, true);
    943         if (__sen)
    944         {
    945             if (__n > 0)
    946             {
    947                 ios_base::iostate __err = ios_base::goodbit;
    948                 while (__gc_ < __n-1)
    949                 {
    950                     int_type __i = this->rdbuf()->sgetc();
    951                     if (traits_type::eq_int_type(__i, traits_type::eof()))
    952                     {
    953                        __err |= ios_base::eofbit;
    954                        break;
    955                     }
    956                     char_type __ch = traits_type::to_char_type(__i);
    957                     if (traits_type::eq(__ch, __dlm))
    958                         break;
    959                     *__s++ = __ch;
    960                     ++__gc_;
    961                      this->rdbuf()->sbumpc();
    962                 }
    963                 *__s = char_type();
    964                 if (__gc_ == 0)
    965                    __err |= ios_base::failbit;
    966                 this->setstate(__err);
    967             }
    968             else
    969                 this->setstate(ios_base::failbit);
    970         }
    971 #ifndef _LIBCPP_NO_EXCEPTIONS
    972     }
    973     catch (...)
    974     {
    975         this->__set_badbit_and_consider_rethrow();
    976     }
    977 #endif  // _LIBCPP_NO_EXCEPTIONS
    978     return *this;
    979 }
    980 
    981 template<class _CharT, class _Traits>
    982 basic_istream<_CharT, _Traits>&
    983 basic_istream<_CharT, _Traits>::get(basic_streambuf<char_type, traits_type>& __sb,
    984                                     char_type __dlm)
    985 {
    986     __gc_ = 0;
    987 #ifndef _LIBCPP_NO_EXCEPTIONS
    988     try
    989     {
    990 #endif  // _LIBCPP_NO_EXCEPTIONS
    991         sentry __sen(*this, true);
    992         if (__sen)
    993         {
    994             ios_base::iostate __err = ios_base::goodbit;
    995 #ifndef _LIBCPP_NO_EXCEPTIONS
    996             try
    997             {
    998 #endif  // _LIBCPP_NO_EXCEPTIONS
    999                 while (true)
   1000                 {
   1001                     typename traits_type::int_type __i = this->rdbuf()->sgetc();
   1002                     if (traits_type::eq_int_type(__i, traits_type::eof()))
   1003                     {
   1004                        __err |= ios_base::eofbit;
   1005                        break;
   1006                     }
   1007                     char_type __ch = traits_type::to_char_type(__i);
   1008                     if (traits_type::eq(__ch, __dlm))
   1009                         break;
   1010                     if (traits_type::eq_int_type(__sb.sputc(__ch), traits_type::eof()))
   1011                         break;
   1012                     ++__gc_;
   1013                     this->rdbuf()->sbumpc();
   1014                 }
   1015 #ifndef _LIBCPP_NO_EXCEPTIONS
   1016             }
   1017             catch (...)
   1018             {
   1019             }
   1020 #endif  // _LIBCPP_NO_EXCEPTIONS
   1021             if (__gc_ == 0)
   1022                __err |= ios_base::failbit;
   1023             this->setstate(__err);
   1024         }
   1025 #ifndef _LIBCPP_NO_EXCEPTIONS
   1026     }
   1027     catch (...)
   1028     {
   1029         this->__set_badbit_and_consider_rethrow();
   1030     }
   1031 #endif  // _LIBCPP_NO_EXCEPTIONS
   1032     return *this;
   1033 }
   1034 
   1035 template<class _CharT, class _Traits>
   1036 basic_istream<_CharT, _Traits>&
   1037 basic_istream<_CharT, _Traits>::getline(char_type* __s, streamsize __n, char_type __dlm)
   1038 {
   1039     __gc_ = 0;
   1040 #ifndef _LIBCPP_NO_EXCEPTIONS
   1041     try
   1042     {
   1043 #endif  // _LIBCPP_NO_EXCEPTIONS
   1044         sentry __sen(*this, true);
   1045         if (__sen)
   1046         {
   1047             ios_base::iostate __err = ios_base::goodbit;
   1048             while (true)
   1049             {
   1050                 typename traits_type::int_type __i = this->rdbuf()->sgetc();
   1051                 if (traits_type::eq_int_type(__i, traits_type::eof()))
   1052                 {
   1053                    __err |= ios_base::eofbit;
   1054                    break;
   1055                 }
   1056                 char_type __ch = traits_type::to_char_type(__i);
   1057                 if (traits_type::eq(__ch, __dlm))
   1058                 {
   1059                     this->rdbuf()->sbumpc();
   1060                     ++__gc_;
   1061                     break;
   1062                 }
   1063                 if (__gc_ >= __n-1)
   1064                 {
   1065                     __err |= ios_base::failbit;
   1066                     break;
   1067                 }
   1068                 *__s++ = __ch;
   1069                 this->rdbuf()->sbumpc();
   1070                 ++__gc_;
   1071             }
   1072             if (__n > 0)
   1073                 *__s = char_type();
   1074             if (__gc_ == 0)
   1075                __err |= ios_base::failbit;
   1076             this->setstate(__err);
   1077         }
   1078 #ifndef _LIBCPP_NO_EXCEPTIONS
   1079     }
   1080     catch (...)
   1081     {
   1082         this->__set_badbit_and_consider_rethrow();
   1083     }
   1084 #endif  // _LIBCPP_NO_EXCEPTIONS
   1085     return *this;
   1086 }
   1087 
   1088 template<class _CharT, class _Traits>
   1089 basic_istream<_CharT, _Traits>&
   1090 basic_istream<_CharT, _Traits>::ignore(streamsize __n, int_type __dlm)
   1091 {
   1092     __gc_ = 0;
   1093 #ifndef _LIBCPP_NO_EXCEPTIONS
   1094     try
   1095     {
   1096 #endif  // _LIBCPP_NO_EXCEPTIONS
   1097         sentry __sen(*this, true);
   1098         if (__sen)
   1099         {
   1100             ios_base::iostate __err = ios_base::goodbit;
   1101             if (__n == numeric_limits<streamsize>::max())
   1102             {
   1103                 while (true)
   1104                 {
   1105                     typename traits_type::int_type __i = this->rdbuf()->sbumpc();
   1106                     if (traits_type::eq_int_type(__i, traits_type::eof()))
   1107                     {
   1108                        __err |= ios_base::eofbit;
   1109                        break;
   1110                     }
   1111                     ++__gc_;
   1112                     if (traits_type::eq_int_type(__i, __dlm))
   1113                         break;
   1114                 }
   1115             }
   1116             else
   1117             {
   1118                 while (__gc_ < __n)
   1119                 {
   1120                     typename traits_type::int_type __i = this->rdbuf()->sbumpc();
   1121                     if (traits_type::eq_int_type(__i, traits_type::eof()))
   1122                     {
   1123                        __err |= ios_base::eofbit;
   1124                        break;
   1125                     }
   1126                     ++__gc_;
   1127                     if (traits_type::eq_int_type(__i, __dlm))
   1128                         break;
   1129                 }
   1130             }
   1131             this->setstate(__err);
   1132         }
   1133 #ifndef _LIBCPP_NO_EXCEPTIONS
   1134     }
   1135     catch (...)
   1136     {
   1137         this->__set_badbit_and_consider_rethrow();
   1138     }
   1139 #endif  // _LIBCPP_NO_EXCEPTIONS
   1140     return *this;
   1141 }
   1142 
   1143 template<class _CharT, class _Traits>
   1144 typename basic_istream<_CharT, _Traits>::int_type
   1145 basic_istream<_CharT, _Traits>::peek()
   1146 {
   1147     __gc_ = 0;
   1148     int_type __r = traits_type::eof();
   1149 #ifndef _LIBCPP_NO_EXCEPTIONS
   1150     try
   1151     {
   1152 #endif  // _LIBCPP_NO_EXCEPTIONS
   1153         sentry __sen(*this, true);
   1154         if (__sen)
   1155         {
   1156             __r = this->rdbuf()->sgetc();
   1157             if (traits_type::eq_int_type(__r, traits_type::eof()))
   1158                 this->setstate(ios_base::eofbit);
   1159         }
   1160 #ifndef _LIBCPP_NO_EXCEPTIONS
   1161     }
   1162     catch (...)
   1163     {
   1164         this->__set_badbit_and_consider_rethrow();
   1165     }
   1166 #endif  // _LIBCPP_NO_EXCEPTIONS
   1167     return __r;
   1168 }
   1169 
   1170 template<class _CharT, class _Traits>
   1171 basic_istream<_CharT, _Traits>&
   1172 basic_istream<_CharT, _Traits>::read(char_type* __s, streamsize __n)
   1173 {
   1174     __gc_ = 0;
   1175 #ifndef _LIBCPP_NO_EXCEPTIONS
   1176     try
   1177     {
   1178 #endif  // _LIBCPP_NO_EXCEPTIONS
   1179         sentry __sen(*this, true);
   1180         if (__sen)
   1181         {
   1182             __gc_ = this->rdbuf()->sgetn(__s, __n);
   1183             if (__gc_ != __n)
   1184                 this->setstate(ios_base::failbit | ios_base::eofbit);
   1185         }
   1186         else
   1187             this->setstate(ios_base::failbit);
   1188 #ifndef _LIBCPP_NO_EXCEPTIONS
   1189     }
   1190     catch (...)
   1191     {
   1192         this->__set_badbit_and_consider_rethrow();
   1193     }
   1194 #endif  // _LIBCPP_NO_EXCEPTIONS
   1195     return *this;
   1196 }
   1197 
   1198 template<class _CharT, class _Traits>
   1199 streamsize
   1200 basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __n)
   1201 {
   1202     __gc_ = 0;
   1203 #ifndef _LIBCPP_NO_EXCEPTIONS
   1204     try
   1205     {
   1206 #endif  // _LIBCPP_NO_EXCEPTIONS
   1207         sentry __sen(*this, true);
   1208         if (__sen)
   1209         {
   1210             streamsize __c = this->rdbuf()->in_avail();
   1211             switch (__c)
   1212             {
   1213             case -1:
   1214                 this->setstate(ios_base::eofbit);
   1215                 break;
   1216             case 0:
   1217                 break;
   1218             default:
   1219                 read(__s, _VSTD::min(__c, __n));
   1220                 break;
   1221             }
   1222         }
   1223         else
   1224             this->setstate(ios_base::failbit);
   1225 #ifndef _LIBCPP_NO_EXCEPTIONS
   1226     }
   1227     catch (...)
   1228     {
   1229         this->__set_badbit_and_consider_rethrow();
   1230     }
   1231 #endif  // _LIBCPP_NO_EXCEPTIONS
   1232     return __gc_;
   1233 }
   1234 
   1235 template<class _CharT, class _Traits>
   1236 basic_istream<_CharT, _Traits>&
   1237 basic_istream<_CharT, _Traits>::putback(char_type __c)
   1238 {
   1239     __gc_ = 0;
   1240 #ifndef _LIBCPP_NO_EXCEPTIONS
   1241     try
   1242     {
   1243 #endif  // _LIBCPP_NO_EXCEPTIONS
   1244         this->clear(this->rdstate() & ~ios_base::eofbit);
   1245         sentry __sen(*this, true);
   1246         if (__sen)
   1247         {
   1248             if (this->rdbuf() == 0 || this->rdbuf()->sputbackc(__c) == traits_type::eof())
   1249                 this->setstate(ios_base::badbit);
   1250         }
   1251         else
   1252             this->setstate(ios_base::failbit);
   1253 #ifndef _LIBCPP_NO_EXCEPTIONS
   1254     }
   1255     catch (...)
   1256     {
   1257         this->__set_badbit_and_consider_rethrow();
   1258     }
   1259 #endif  // _LIBCPP_NO_EXCEPTIONS
   1260     return *this;
   1261 }
   1262 
   1263 template<class _CharT, class _Traits>
   1264 basic_istream<_CharT, _Traits>&
   1265 basic_istream<_CharT, _Traits>::unget()
   1266 {
   1267     __gc_ = 0;
   1268 #ifndef _LIBCPP_NO_EXCEPTIONS
   1269     try
   1270     {
   1271 #endif  // _LIBCPP_NO_EXCEPTIONS
   1272         this->clear(this->rdstate() & ~ios_base::eofbit);
   1273         sentry __sen(*this, true);
   1274         if (__sen)
   1275         {
   1276             if (this->rdbuf() == 0 || this->rdbuf()->sungetc() == traits_type::eof())
   1277                 this->setstate(ios_base::badbit);
   1278         }
   1279         else
   1280             this->setstate(ios_base::failbit);
   1281 #ifndef _LIBCPP_NO_EXCEPTIONS
   1282     }
   1283     catch (...)
   1284     {
   1285         this->__set_badbit_and_consider_rethrow();
   1286     }
   1287 #endif  // _LIBCPP_NO_EXCEPTIONS
   1288     return *this;
   1289 }
   1290 
   1291 template<class _CharT, class _Traits>
   1292 int
   1293 basic_istream<_CharT, _Traits>::sync()
   1294 {
   1295     int __r = 0;
   1296 #ifndef _LIBCPP_NO_EXCEPTIONS
   1297     try
   1298     {
   1299 #endif  // _LIBCPP_NO_EXCEPTIONS
   1300         sentry __sen(*this, true);
   1301         if (__sen)
   1302         {
   1303             if (this->rdbuf() == 0)
   1304                 return -1;
   1305             if (this->rdbuf()->pubsync() == -1)
   1306             {
   1307                 this->setstate(ios_base::badbit);
   1308                 return -1;
   1309             }
   1310         }
   1311 #ifndef _LIBCPP_NO_EXCEPTIONS
   1312     }
   1313     catch (...)
   1314     {
   1315         this->__set_badbit_and_consider_rethrow();
   1316     }
   1317 #endif  // _LIBCPP_NO_EXCEPTIONS
   1318     return __r;
   1319 }
   1320 
   1321 template<class _CharT, class _Traits>
   1322 typename basic_istream<_CharT, _Traits>::pos_type
   1323 basic_istream<_CharT, _Traits>::tellg()
   1324 {
   1325     pos_type __r(-1);
   1326 #ifndef _LIBCPP_NO_EXCEPTIONS
   1327     try
   1328     {
   1329 #endif  // _LIBCPP_NO_EXCEPTIONS
   1330         sentry __sen(*this, true);
   1331         if (__sen)
   1332             __r = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
   1333 #ifndef _LIBCPP_NO_EXCEPTIONS
   1334     }
   1335     catch (...)
   1336     {
   1337         this->__set_badbit_and_consider_rethrow();
   1338     }
   1339 #endif  // _LIBCPP_NO_EXCEPTIONS
   1340     return __r;
   1341 }
   1342 
   1343 template<class _CharT, class _Traits>
   1344 basic_istream<_CharT, _Traits>&
   1345 basic_istream<_CharT, _Traits>::seekg(pos_type __pos)
   1346 {
   1347 #ifndef _LIBCPP_NO_EXCEPTIONS
   1348     try
   1349     {
   1350 #endif  // _LIBCPP_NO_EXCEPTIONS
   1351         this->clear(this->rdstate() & ~ios_base::eofbit);
   1352         sentry __sen(*this, true);
   1353         if (__sen)
   1354         {
   1355             if (this->rdbuf()->pubseekpos(__pos, ios_base::in) == pos_type(-1))
   1356                 this->setstate(ios_base::failbit);
   1357         }
   1358 #ifndef _LIBCPP_NO_EXCEPTIONS
   1359     }
   1360     catch (...)
   1361     {
   1362         this->__set_badbit_and_consider_rethrow();
   1363     }
   1364 #endif  // _LIBCPP_NO_EXCEPTIONS
   1365     return *this;
   1366 }
   1367 
   1368 template<class _CharT, class _Traits>
   1369 basic_istream<_CharT, _Traits>&
   1370 basic_istream<_CharT, _Traits>::seekg(off_type __off, ios_base::seekdir __dir)
   1371 {
   1372 #ifndef _LIBCPP_NO_EXCEPTIONS
   1373     try
   1374     {
   1375 #endif  // _LIBCPP_NO_EXCEPTIONS
   1376         this->clear(this->rdstate() & ~ios_base::eofbit);
   1377         sentry __sen(*this, true);
   1378         if (__sen)
   1379         {
   1380             if (this->rdbuf()->pubseekoff(__off, __dir, ios_base::in) == pos_type(-1))
   1381                 this->setstate(ios_base::failbit);
   1382         }
   1383 #ifndef _LIBCPP_NO_EXCEPTIONS
   1384     }
   1385     catch (...)
   1386     {
   1387         this->__set_badbit_and_consider_rethrow();
   1388     }
   1389 #endif  // _LIBCPP_NO_EXCEPTIONS
   1390     return *this;
   1391 }
   1392 
   1393 template <class _CharT, class _Traits>
   1394 basic_istream<_CharT, _Traits>&
   1395 ws(basic_istream<_CharT, _Traits>& __is)
   1396 {
   1397 #ifndef _LIBCPP_NO_EXCEPTIONS
   1398     try
   1399     {
   1400 #endif  // _LIBCPP_NO_EXCEPTIONS
   1401         typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true);
   1402         if (__sen)
   1403         {
   1404             const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
   1405             while (true)
   1406             {
   1407                 typename _Traits::int_type __i = __is.rdbuf()->sgetc();
   1408                 if (_Traits::eq_int_type(__i, _Traits::eof()))
   1409                 {
   1410                    __is.setstate(ios_base::eofbit);
   1411                    break;
   1412                 }
   1413                 if (!__ct.is(__ct.space, _Traits::to_char_type(__i)))
   1414                     break;
   1415                 __is.rdbuf()->sbumpc();
   1416             }
   1417         }
   1418 #ifndef _LIBCPP_NO_EXCEPTIONS
   1419     }
   1420     catch (...)
   1421     {
   1422         __is.__set_badbit_and_consider_rethrow();
   1423     }
   1424 #endif  // _LIBCPP_NO_EXCEPTIONS
   1425     return __is;
   1426 }
   1427 
   1428 #ifndef _LIBCPP_CXX03_LANG
   1429 
   1430 template <class _CharT, class _Traits, class _Tp>
   1431 inline _LIBCPP_INLINE_VISIBILITY
   1432 basic_istream<_CharT, _Traits>&
   1433 operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp&& __x)
   1434 {
   1435     __is >> _VSTD::forward<_Tp>(__x);
   1436     return __is;
   1437 }
   1438 
   1439 #endif  // _LIBCPP_CXX03_LANG
   1440 
   1441 template <class _CharT, class _Traits>
   1442 class _LIBCPP_TEMPLATE_VIS basic_iostream
   1443     : public basic_istream<_CharT, _Traits>,
   1444       public basic_ostream<_CharT, _Traits>
   1445 {
   1446 public:
   1447     // types:
   1448     typedef _CharT                         char_type;
   1449     typedef _Traits                        traits_type;
   1450     typedef typename traits_type::int_type int_type;
   1451     typedef typename traits_type::pos_type pos_type;
   1452     typedef typename traits_type::off_type off_type;
   1453 
   1454     // constructor/destructor
   1455     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
   1456     explicit basic_iostream(basic_streambuf<char_type, traits_type>* __sb)
   1457       : basic_istream<_CharT, _Traits>(__sb)
   1458     {}
   1459 
   1460     virtual ~basic_iostream();
   1461 protected:
   1462 #ifndef _LIBCPP_CXX03_LANG
   1463     inline _LIBCPP_INLINE_VISIBILITY
   1464     basic_iostream(basic_iostream&& __rhs);
   1465 
   1466     // assign/swap
   1467     inline _LIBCPP_INLINE_VISIBILITY
   1468     basic_iostream& operator=(basic_iostream&& __rhs);
   1469 #endif
   1470     inline _LIBCPP_EXTERN_TEMPLATE_INLINE_VISIBILITY
   1471     void swap(basic_iostream& __rhs)
   1472     { basic_istream<char_type, traits_type>::swap(__rhs); }
   1473 public:
   1474 };
   1475 
   1476 #ifndef _LIBCPP_CXX03_LANG
   1477 
   1478 template <class _CharT, class _Traits>
   1479 basic_iostream<_CharT, _Traits>::basic_iostream(basic_iostream&& __rhs)
   1480     : basic_istream<_CharT, _Traits>(_VSTD::move(__rhs))
   1481 {
   1482 }
   1483 
   1484 template <class _CharT, class _Traits>
   1485 basic_iostream<_CharT, _Traits>&
   1486 basic_iostream<_CharT, _Traits>::operator=(basic_iostream&& __rhs)
   1487 {
   1488     swap(__rhs);
   1489     return *this;
   1490 }
   1491 
   1492 #endif  // _LIBCPP_CXX03_LANG
   1493 
   1494 template <class _CharT, class _Traits>
   1495 basic_iostream<_CharT, _Traits>::~basic_iostream()
   1496 {
   1497 }
   1498 
   1499 template<class _CharT, class _Traits, class _Allocator>
   1500 basic_istream<_CharT, _Traits>&
   1501 operator>>(basic_istream<_CharT, _Traits>& __is,
   1502            basic_string<_CharT, _Traits, _Allocator>& __str)
   1503 {
   1504 #ifndef _LIBCPP_NO_EXCEPTIONS
   1505     try
   1506     {
   1507 #endif  // _LIBCPP_NO_EXCEPTIONS
   1508         typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
   1509         if (__sen)
   1510         {
   1511             __str.clear();
   1512             streamsize __n = __is.width();
   1513             if (__n <= 0)
   1514                 __n = __str.max_size();
   1515             if (__n <= 0)
   1516                 __n = numeric_limits<streamsize>::max();
   1517             streamsize __c = 0;
   1518             const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
   1519             ios_base::iostate __err = ios_base::goodbit;
   1520             while (__c < __n)
   1521             {
   1522                 typename _Traits::int_type __i = __is.rdbuf()->sgetc();
   1523                 if (_Traits::eq_int_type(__i, _Traits::eof()))
   1524                 {
   1525                    __err |= ios_base::eofbit;
   1526                    break;
   1527                 }
   1528                 _CharT __ch = _Traits::to_char_type(__i);
   1529                 if (__ct.is(__ct.space, __ch))
   1530                     break;
   1531                 __str.push_back(__ch);
   1532                 ++__c;
   1533                  __is.rdbuf()->sbumpc();
   1534             }
   1535             __is.width(0);
   1536             if (__c == 0)
   1537                __err |= ios_base::failbit;
   1538             __is.setstate(__err);
   1539         }
   1540         else
   1541             __is.setstate(ios_base::failbit);
   1542 #ifndef _LIBCPP_NO_EXCEPTIONS
   1543     }
   1544     catch (...)
   1545     {
   1546         __is.__set_badbit_and_consider_rethrow();
   1547     }
   1548 #endif  // _LIBCPP_NO_EXCEPTIONS
   1549     return __is;
   1550 }
   1551 
   1552 template<class _CharT, class _Traits, class _Allocator>
   1553 basic_istream<_CharT, _Traits>&
   1554 getline(basic_istream<_CharT, _Traits>& __is,
   1555         basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm)
   1556 {
   1557 #ifndef _LIBCPP_NO_EXCEPTIONS
   1558     try
   1559     {
   1560 #endif  // _LIBCPP_NO_EXCEPTIONS
   1561         typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true);
   1562         if (__sen)
   1563         {
   1564             __str.clear();
   1565             ios_base::iostate __err = ios_base::goodbit;
   1566             streamsize __extr = 0;
   1567             while (true)
   1568             {
   1569                 typename _Traits::int_type __i = __is.rdbuf()->sbumpc();
   1570                 if (_Traits::eq_int_type(__i, _Traits::eof()))
   1571                 {
   1572                    __err |= ios_base::eofbit;
   1573                    break;
   1574                 }
   1575                 ++__extr;
   1576                 _CharT __ch = _Traits::to_char_type(__i);
   1577                 if (_Traits::eq(__ch, __dlm))
   1578                     break;
   1579                 __str.push_back(__ch);
   1580                 if (__str.size() == __str.max_size())
   1581                 {
   1582                     __err |= ios_base::failbit;
   1583                     break;
   1584                 }
   1585             }
   1586             if (__extr == 0)
   1587                __err |= ios_base::failbit;
   1588             __is.setstate(__err);
   1589         }
   1590 #ifndef _LIBCPP_NO_EXCEPTIONS
   1591     }
   1592     catch (...)
   1593     {
   1594         __is.__set_badbit_and_consider_rethrow();
   1595     }
   1596 #endif  // _LIBCPP_NO_EXCEPTIONS
   1597     return __is;
   1598 }
   1599 
   1600 template<class _CharT, class _Traits, class _Allocator>
   1601 inline _LIBCPP_INLINE_VISIBILITY
   1602 basic_istream<_CharT, _Traits>&
   1603 getline(basic_istream<_CharT, _Traits>& __is,
   1604         basic_string<_CharT, _Traits, _Allocator>& __str)
   1605 {
   1606     return getline(__is, __str, __is.widen('\n'));
   1607 }
   1608 
   1609 #ifndef _LIBCPP_CXX03_LANG
   1610 
   1611 template<class _CharT, class _Traits, class _Allocator>
   1612 inline _LIBCPP_INLINE_VISIBILITY
   1613 basic_istream<_CharT, _Traits>&
   1614 getline(basic_istream<_CharT, _Traits>&& __is,
   1615         basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm)
   1616 {
   1617     return getline(__is, __str, __dlm);
   1618 }
   1619 
   1620 template<class _CharT, class _Traits, class _Allocator>
   1621 inline _LIBCPP_INLINE_VISIBILITY
   1622 basic_istream<_CharT, _Traits>&
   1623 getline(basic_istream<_CharT, _Traits>&& __is,
   1624         basic_string<_CharT, _Traits, _Allocator>& __str)
   1625 {
   1626     return getline(__is, __str, __is.widen('\n'));
   1627 }
   1628 
   1629 #endif  // _LIBCPP_CXX03_LANG
   1630 
   1631 template <class _CharT, class _Traits, size_t _Size>
   1632 basic_istream<_CharT, _Traits>&
   1633 operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x)
   1634 {
   1635 #ifndef _LIBCPP_NO_EXCEPTIONS
   1636     try
   1637     {
   1638 #endif  // _LIBCPP_NO_EXCEPTIONS
   1639         typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
   1640         if (__sen)
   1641         {
   1642             basic_string<_CharT, _Traits> __str;
   1643             const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
   1644             size_t __c = 0;
   1645             ios_base::iostate __err = ios_base::goodbit;
   1646             _CharT __zero = __ct.widen('0');
   1647             _CharT __one = __ct.widen('1');
   1648             while (__c < _Size)
   1649             {
   1650                 typename _Traits::int_type __i = __is.rdbuf()->sgetc();
   1651                 if (_Traits::eq_int_type(__i, _Traits::eof()))
   1652                 {
   1653                    __err |= ios_base::eofbit;
   1654                    break;
   1655                 }
   1656                 _CharT __ch = _Traits::to_char_type(__i);
   1657                 if (!_Traits::eq(__ch, __zero) && !_Traits::eq(__ch, __one))
   1658                     break;
   1659                 __str.push_back(__ch);
   1660                 ++__c;
   1661                  __is.rdbuf()->sbumpc();
   1662             }
   1663             __x = bitset<_Size>(__str);
   1664             if (__c == 0)
   1665                __err |= ios_base::failbit;
   1666             __is.setstate(__err);
   1667         }
   1668         else
   1669             __is.setstate(ios_base::failbit);
   1670 #ifndef _LIBCPP_NO_EXCEPTIONS
   1671     }
   1672     catch (...)
   1673     {
   1674         __is.__set_badbit_and_consider_rethrow();
   1675     }
   1676 #endif  // _LIBCPP_NO_EXCEPTIONS
   1677     return __is;
   1678 }
   1679 
   1680 #ifndef _LIBCPP_AVAILABILITY_NO_STREAMS_EXTERN_TEMPLATE
   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 #endif
   1685 
   1686 _LIBCPP_END_NAMESPACE_STD
   1687 
   1688 _LIBCPP_POP_MACROS
   1689 
   1690 #endif  // _LIBCPP_ISTREAM
   1691