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