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