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

source code of flutter_engine/third_party/libcxx/include/istream