diff --git a/libcxx/include/CMakeLists.txt b/libcxx/include/CMakeLists.txt --- a/libcxx/include/CMakeLists.txt +++ b/libcxx/include/CMakeLists.txt @@ -346,6 +346,9 @@ __fwd/tuple.h __hash_table __ios/fpos.h + __istream/basic_iostream.h + __istream/basic_istream.h + __istream/basic_istream_def.h __iterator/access.h __iterator/advance.h __iterator/back_insert_iterator.h diff --git a/libcxx/include/__istream/basic_iostream.h b/libcxx/include/__istream/basic_iostream.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__istream/basic_iostream.h @@ -0,0 +1,271 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___ISTREAM_BASIC_IOSTREAM_H +#define _LIBCPP___ISTREAM_BASIC_IOSTREAM_H + +#include <__config> +#include <__istream/basic_istream.h> +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +class _LIBCPP_TEMPLATE_VIS basic_iostream + : public basic_istream<_CharT, _Traits>, + public basic_ostream<_CharT, _Traits> +{ +public: + // types: + typedef _CharT char_type; + typedef _Traits traits_type; + typedef typename traits_type::int_type int_type; + typedef typename traits_type::pos_type pos_type; + typedef typename traits_type::off_type off_type; + + // constructor/destructor + inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 + explicit basic_iostream(basic_streambuf* __sb) + : basic_istream<_CharT, _Traits>(__sb) + {} + + ~basic_iostream() override; +protected: + inline _LIBCPP_INLINE_VISIBILITY + basic_iostream(basic_iostream&& __rhs); + + // assign/swap + inline _LIBCPP_INLINE_VISIBILITY + basic_iostream& operator=(basic_iostream&& __rhs); + + inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 + void swap(basic_iostream& __rhs) + { basic_istream::swap(__rhs); } +}; + +template +basic_iostream<_CharT, _Traits>::basic_iostream(basic_iostream&& __rhs) + : basic_istream<_CharT, _Traits>(_VSTD::move(__rhs)) +{ +} + +template +basic_iostream<_CharT, _Traits>& +basic_iostream<_CharT, _Traits>::operator=(basic_iostream&& __rhs) +{ + swap(__rhs); + return *this; +} + +template +basic_iostream<_CharT, _Traits>::~basic_iostream() +{ +} + +template +_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, + basic_string<_CharT, _Traits, _Allocator>& __str) +{ + ios_base::iostate __state = ios_base::goodbit; + typename basic_istream<_CharT, _Traits>::sentry __sen(__is); + if (__sen) + { +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif + __str.clear(); + streamsize __n = __is.width(); + if (__n <= 0) + __n = __str.max_size(); + if (__n <= 0) + __n = numeric_limits::max(); + streamsize __c = 0; + const ctype<_CharT>& __ct = use_facet >(__is.getloc()); + while (__c < __n) + { + typename _Traits::int_type __i = __is.rdbuf()->sgetc(); + if (_Traits::eq_int_type(__i, _Traits::eof())) + { + __state |= ios_base::eofbit; + break; + } + _CharT __ch = _Traits::to_char_type(__i); + if (__ct.is(__ct.space, __ch)) + break; + __str.push_back(__ch); + ++__c; + __is.rdbuf()->sbumpc(); + } + __is.width(0); + if (__c == 0) + __state |= ios_base::failbit; +#ifndef _LIBCPP_NO_EXCEPTIONS + } + catch (...) + { + __state |= ios_base::badbit; + __is.__setstate_nothrow(__state); + if (__is.exceptions() & ios_base::badbit) + { + throw; + } + } +#endif + __is.setstate(__state); + } + return __is; +} + +template +_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& +getline(basic_istream<_CharT, _Traits>& __is, + basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm) +{ + ios_base::iostate __state = ios_base::goodbit; + typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true); + if (__sen) + { +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif + __str.clear(); + streamsize __extr = 0; + while (true) + { + typename _Traits::int_type __i = __is.rdbuf()->sbumpc(); + if (_Traits::eq_int_type(__i, _Traits::eof())) + { + __state |= ios_base::eofbit; + break; + } + ++__extr; + _CharT __ch = _Traits::to_char_type(__i); + if (_Traits::eq(__ch, __dlm)) + break; + __str.push_back(__ch); + if (__str.size() == __str.max_size()) + { + __state |= ios_base::failbit; + break; + } + } + if (__extr == 0) + __state |= ios_base::failbit; +#ifndef _LIBCPP_NO_EXCEPTIONS + } + catch (...) + { + __state |= ios_base::badbit; + __is.__setstate_nothrow(__state); + if (__is.exceptions() & ios_base::badbit) + { + throw; + } + } +#endif + __is.setstate(__state); + } + return __is; +} + +template +inline _LIBCPP_INLINE_VISIBILITY +basic_istream<_CharT, _Traits>& +getline(basic_istream<_CharT, _Traits>& __is, + basic_string<_CharT, _Traits, _Allocator>& __str) +{ + return getline(__is, __str, __is.widen('\n')); +} + +template +inline _LIBCPP_INLINE_VISIBILITY +basic_istream<_CharT, _Traits>& +getline(basic_istream<_CharT, _Traits>&& __is, + basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm) +{ + return getline(__is, __str, __dlm); +} + +template +inline _LIBCPP_INLINE_VISIBILITY +basic_istream<_CharT, _Traits>& +getline(basic_istream<_CharT, _Traits>&& __is, + basic_string<_CharT, _Traits, _Allocator>& __str) +{ + return getline(__is, __str, __is.widen('\n')); +} + +template +_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x) +{ + ios_base::iostate __state = ios_base::goodbit; + typename basic_istream<_CharT, _Traits>::sentry __sen(__is); + if (__sen) + { +#ifndef _LIBCPP_NO_EXCEPTIONS + try + { +#endif + basic_string<_CharT, _Traits> __str; + const ctype<_CharT>& __ct = use_facet >(__is.getloc()); + size_t __c = 0; + _CharT __zero = __ct.widen('0'); + _CharT __one = __ct.widen('1'); + while (__c != _Size) + { + typename _Traits::int_type __i = __is.rdbuf()->sgetc(); + if (_Traits::eq_int_type(__i, _Traits::eof())) + { + __state |= ios_base::eofbit; + break; + } + _CharT __ch = _Traits::to_char_type(__i); + if (!_Traits::eq(__ch, __zero) && !_Traits::eq(__ch, __one)) + break; + __str.push_back(__ch); + ++__c; + __is.rdbuf()->sbumpc(); + } + __x = bitset<_Size>(__str); + if (_Size > 0 && __c == 0) + __state |= ios_base::failbit; +#ifndef _LIBCPP_NO_EXCEPTIONS + } + catch (...) + { + __state |= ios_base::badbit; + __is.__setstate_nothrow(__state); + if (__is.exceptions() & ios_base::badbit) + { + throw; + } + } +#endif + __is.setstate(__state); + } + return __is; +} + +extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_iostream; + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___ISTREAM_BASIC_IOSTREAM_H \ No newline at end of file diff --git a/libcxx/include/__istream/basic_istream.h b/libcxx/include/__istream/basic_istream.h new file mode 100644 --- /dev/null +++ b/libcxx/include/__istream/basic_istream.h @@ -0,0 +1,230 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___ISTREAM_BASIC_ISTREAM_H +#define _LIBCPP___ISTREAM_BASIC_ISTREAM_H + +#include <__config> +#include <__utility/forward.h> +#include + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_PUSH_MACROS +#include <__undef_macros> + +_LIBCPP_BEGIN_NAMESPACE_STD + +template +class _LIBCPP_TEMPLATE_VIS basic_istream + : virtual public basic_ios<_CharT, _Traits> +{ + streamsize __gc_; +public: + // types (inherited from basic_ios (27.5.4)): + typedef _CharT char_type; + typedef _Traits traits_type; + typedef typename traits_type::int_type int_type; + typedef typename traits_type::pos_type pos_type; + typedef typename traits_type::off_type off_type; + + // 27.7.1.1.1 Constructor/destructor: + inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 + explicit basic_istream(basic_streambuf* __sb) : __gc_(0) + { this->init(__sb); } + ~basic_istream() override; +protected: + inline _LIBCPP_INLINE_VISIBILITY + basic_istream(basic_istream&& __rhs); + + // 27.7.1.1.2 Assign/swap: + inline _LIBCPP_INLINE_VISIBILITY + basic_istream& operator=(basic_istream&& __rhs); + + inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 + void swap(basic_istream& __rhs) { + _VSTD::swap(__gc_, __rhs.__gc_); + basic_ios::swap(__rhs); + } + + basic_istream (const basic_istream& __rhs) = delete; + basic_istream& operator=(const basic_istream& __rhs) = delete; +public: + + // 27.7.1.1.3 Prefix/suffix: + class _LIBCPP_TEMPLATE_VIS sentry; + + // 27.7.1.2 Formatted input: + inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 + basic_istream& operator>>(basic_istream& (*__pf)(basic_istream&)) + { return __pf(*this); } + + inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 + basic_istream& operator>>(basic_ios& + (*__pf)(basic_ios&)) + { __pf(*this); return *this; } + + inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 + basic_istream& operator>>(ios_base& (*__pf)(ios_base&)) + { __pf(*this); return *this; } + + basic_istream& operator>>(basic_streambuf* __sb); + basic_istream& operator>>(bool& __n); + basic_istream& operator>>(short& __n); + basic_istream& operator>>(unsigned short& __n); + basic_istream& operator>>(int& __n); + basic_istream& operator>>(unsigned int& __n); + basic_istream& operator>>(long& __n); + basic_istream& operator>>(unsigned long& __n); + basic_istream& operator>>(long long& __n); + basic_istream& operator>>(unsigned long long& __n); + basic_istream& operator>>(float& __f); + basic_istream& operator>>(double& __f); + basic_istream& operator>>(long double& __f); + basic_istream& operator>>(void*& __p); + + // 27.7.1.3 Unformatted input: + _LIBCPP_INLINE_VISIBILITY + streamsize gcount() const {return __gc_;} + int_type get(); + + inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 + basic_istream& get(char_type& __c) { + int_type __ch = get(); + if (__ch != traits_type::eof()) + __c = traits_type::to_char_type(__ch); + return *this; + } + + inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 + basic_istream& get(char_type* __s, streamsize __n) + { return get(__s, __n, this->widen('\n')); } + + basic_istream& get(char_type* __s, streamsize __n, char_type __dlm); + + inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 + basic_istream& get(basic_streambuf& __sb) + { return get(__sb, this->widen('\n')); } + + basic_istream& get(basic_streambuf& __sb, char_type __dlm); + + inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 + basic_istream& getline(char_type* __s, streamsize __n) + { return getline(__s, __n, this->widen('\n')); } + + basic_istream& getline(char_type* __s, streamsize __n, char_type __dlm); + + basic_istream& ignore(streamsize __n = 1, int_type __dlm = traits_type::eof()); + int_type peek(); + basic_istream& read (char_type* __s, streamsize __n); + streamsize readsome(char_type* __s, streamsize __n); + + basic_istream& putback(char_type __c); + basic_istream& unget(); + int sync(); + + pos_type tellg(); + basic_istream& seekg(pos_type __pos); + basic_istream& seekg(off_type __off, ios_base::seekdir __dir); +}; + +template +class _LIBCPP_TEMPLATE_VIS basic_istream<_CharT, _Traits>::sentry +{ + bool __ok_; + +public: + explicit sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false); +// ~sentry() = default; + + _LIBCPP_INLINE_VISIBILITY + explicit operator bool() const {return __ok_;} + + sentry(const sentry&) = delete; + sentry& operator=(const sentry&) = delete; +}; + +#if _LIBCPP_STD_VER > 17 + +template +inline _LIBCPP_INLINE_VISIBILITY +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, _CharT (&__buf)[_Np]); + +template +inline _LIBCPP_INLINE_VISIBILITY +basic_istream& +operator>>(basic_istream& __is, unsigned char (&__buf)[_Np]); + +template +inline _LIBCPP_INLINE_VISIBILITY +basic_istream& +operator>>(basic_istream& __is, signed char (&__buf)[_Np]); + +#else + +template +inline _LIBCPP_INLINE_VISIBILITY +basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, _CharT* __s); + +template +inline _LIBCPP_INLINE_VISIBILITY +basic_istream& +operator>>(basic_istream& __is, unsigned char* __s); + +template +inline _LIBCPP_INLINE_VISIBILITY +basic_istream& +operator>>(basic_istream& __is, signed char* __s); +#endif // _LIBCPP_STD_VER > 17 + +template +_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& +operator>>(basic_istream<_CharT, _Traits>& __is, _CharT& __c); + +template +inline _LIBCPP_INLINE_VISIBILITY +basic_istream& +operator>>(basic_istream& __is, unsigned char& __c); + +template +inline _LIBCPP_INLINE_VISIBILITY +basic_istream& +operator>>(basic_istream& __is, signed char& __c); + +template +_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& +ws(basic_istream<_CharT, _Traits>& __is); + +template +struct __is_istreamable : false_type { }; + +template +struct __is_istreamable<_Stream, _Tp, decltype( + declval<_Stream>() >> declval<_Tp>(), void() +)> : true_type { }; + +template , + __is_istreamable<_Stream&, _Tp&&> >::value +>::type> +_LIBCPP_INLINE_VISIBILITY +_Stream&& operator>>(_Stream&& __is, _Tp&& __x) +{ + __is >> _VSTD::forward<_Tp>(__x); + return _VSTD::move(__is); +} + +_LIBCPP_END_NAMESPACE_STD + +_LIBCPP_POP_MACROS + +#endif // _LIBCPP___ISTREAM_BASIC_ISTREAM_H diff --git a/libcxx/include/istream b/libcxx/include/__istream/basic_istream_def.h copy from libcxx/include/istream copy to libcxx/include/__istream/basic_istream_def.h --- a/libcxx/include/istream +++ b/libcxx/include/__istream/basic_istream_def.h @@ -1,4 +1,3 @@ -// -*- C++ -*- //===----------------------------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. @@ -7,163 +6,13 @@ // //===----------------------------------------------------------------------===// -#ifndef _LIBCPP_ISTREAM -#define _LIBCPP_ISTREAM +#ifndef _LIBCPP___ISTREAM_BASIC_ISTREAM_DEF_H +#define _LIBCPP___ISTREAM_BASIC_ISTREAM_DEF_H -/* - istream synopsis - -template > -class basic_istream - : virtual public basic_ios -{ -public: - // types (inherited from basic_ios (27.5.4)): - typedef charT char_type; - typedef traits traits_type; - typedef typename traits_type::int_type int_type; - typedef typename traits_type::pos_type pos_type; - typedef typename traits_type::off_type off_type; - - // 27.7.1.1.1 Constructor/destructor: - explicit basic_istream(basic_streambuf* sb); - basic_istream(basic_istream&& rhs); - virtual ~basic_istream(); - - // 27.7.1.1.2 Assign/swap: - basic_istream& operator=(basic_istream&& rhs); - void swap(basic_istream& rhs); - - // 27.7.1.1.3 Prefix/suffix: - class sentry; - - // 27.7.1.2 Formatted input: - basic_istream& operator>>(basic_istream& (*pf)(basic_istream&)); - basic_istream& operator>>(basic_ios& - (*pf)(basic_ios&)); - basic_istream& operator>>(ios_base& (*pf)(ios_base&)); - basic_istream& operator>>(basic_streambuf* sb); - basic_istream& operator>>(bool& n); - basic_istream& operator>>(short& n); - basic_istream& operator>>(unsigned short& n); - basic_istream& operator>>(int& n); - basic_istream& operator>>(unsigned int& n); - basic_istream& operator>>(long& n); - basic_istream& operator>>(unsigned long& n); - basic_istream& operator>>(long long& n); - basic_istream& operator>>(unsigned long long& n); - basic_istream& operator>>(float& f); - basic_istream& operator>>(double& f); - basic_istream& operator>>(long double& f); - basic_istream& operator>>(void*& p); - - // 27.7.1.3 Unformatted input: - streamsize gcount() const; - int_type get(); - basic_istream& get(char_type& c); - basic_istream& get(char_type* s, streamsize n); - basic_istream& get(char_type* s, streamsize n, char_type delim); - basic_istream& get(basic_streambuf& sb); - basic_istream& get(basic_streambuf& sb, char_type delim); - - basic_istream& getline(char_type* s, streamsize n); - basic_istream& getline(char_type* s, streamsize n, char_type delim); - - basic_istream& ignore(streamsize n = 1, int_type delim = traits_type::eof()); - int_type peek(); - basic_istream& read (char_type* s, streamsize n); - streamsize readsome(char_type* s, streamsize n); - - basic_istream& putback(char_type c); - basic_istream& unget(); - int sync(); - - pos_type tellg(); - basic_istream& seekg(pos_type); - basic_istream& seekg(off_type, ios_base::seekdir); -protected: - basic_istream(const basic_istream& rhs) = delete; - basic_istream(basic_istream&& rhs); - // 27.7.2.1.2 Assign/swap: - basic_istream& operator=(const basic_istream& rhs) = delete; - basic_istream& operator=(basic_istream&& rhs); - void swap(basic_istream& rhs); -}; - -// 27.7.1.2.3 character extraction templates: -template - basic_istream& operator>>(basic_istream&, charT&); - -template - basic_istream& operator>>(basic_istream&, unsigned char&); - -template - basic_istream& operator>>(basic_istream&, signed char&); - -template - basic_istream& operator>>(basic_istream&, charT*); - -template - basic_istream& operator>>(basic_istream&, unsigned char*); - -template - basic_istream& operator>>(basic_istream&, signed char*); - -template - void - swap(basic_istream& x, basic_istream& y); - -typedef basic_istream istream; -typedef basic_istream wistream; - -template > -class basic_iostream : - public basic_istream, - public basic_ostream -{ -public: - // types: - typedef charT char_type; - typedef traits traits_type; - typedef typename traits_type::int_type int_type; - typedef typename traits_type::pos_type pos_type; - typedef typename traits_type::off_type off_type; - - // constructor/destructor - explicit basic_iostream(basic_streambuf* sb); - basic_iostream(basic_iostream&& rhs); - virtual ~basic_iostream(); - - // assign/swap - basic_iostream& operator=(basic_iostream&& rhs); - void swap(basic_iostream& rhs); -}; - -template - void - swap(basic_iostream& x, basic_iostream& y); - -typedef basic_iostream iostream; -typedef basic_iostream wiostream; - -template - basic_istream& - ws(basic_istream& is); - -// rvalue stream extraction -template - Stream&& operator>>(Stream&& is, T&& x); - -} // std - -*/ - -#include <__assert> // all public C++ headers provide the assertion handler #include <__config> +#include <__istream/basic_istream.h> #include <__iterator/istreambuf_iterator.h> -#include <__utility/forward.h> -#include -#include +#include #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) # pragma GCC system_header @@ -172,138 +21,8 @@ _LIBCPP_PUSH_MACROS #include <__undef_macros> - _LIBCPP_BEGIN_NAMESPACE_STD -template -class _LIBCPP_TEMPLATE_VIS basic_istream - : virtual public basic_ios<_CharT, _Traits> -{ - streamsize __gc_; -public: - // types (inherited from basic_ios (27.5.4)): - typedef _CharT char_type; - typedef _Traits traits_type; - typedef typename traits_type::int_type int_type; - typedef typename traits_type::pos_type pos_type; - typedef typename traits_type::off_type off_type; - - // 27.7.1.1.1 Constructor/destructor: - inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 - explicit basic_istream(basic_streambuf* __sb) : __gc_(0) - { this->init(__sb); } - ~basic_istream() override; -protected: - inline _LIBCPP_INLINE_VISIBILITY - basic_istream(basic_istream&& __rhs); - - // 27.7.1.1.2 Assign/swap: - inline _LIBCPP_INLINE_VISIBILITY - basic_istream& operator=(basic_istream&& __rhs); - - inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 - void swap(basic_istream& __rhs) { - _VSTD::swap(__gc_, __rhs.__gc_); - basic_ios::swap(__rhs); - } - - basic_istream (const basic_istream& __rhs) = delete; - basic_istream& operator=(const basic_istream& __rhs) = delete; -public: - - // 27.7.1.1.3 Prefix/suffix: - class _LIBCPP_TEMPLATE_VIS sentry; - - // 27.7.1.2 Formatted input: - inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 - basic_istream& operator>>(basic_istream& (*__pf)(basic_istream&)) - { return __pf(*this); } - - inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 - basic_istream& operator>>(basic_ios& - (*__pf)(basic_ios&)) - { __pf(*this); return *this; } - - inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 - basic_istream& operator>>(ios_base& (*__pf)(ios_base&)) - { __pf(*this); return *this; } - - basic_istream& operator>>(basic_streambuf* __sb); - basic_istream& operator>>(bool& __n); - basic_istream& operator>>(short& __n); - basic_istream& operator>>(unsigned short& __n); - basic_istream& operator>>(int& __n); - basic_istream& operator>>(unsigned int& __n); - basic_istream& operator>>(long& __n); - basic_istream& operator>>(unsigned long& __n); - basic_istream& operator>>(long long& __n); - basic_istream& operator>>(unsigned long long& __n); - basic_istream& operator>>(float& __f); - basic_istream& operator>>(double& __f); - basic_istream& operator>>(long double& __f); - basic_istream& operator>>(void*& __p); - - // 27.7.1.3 Unformatted input: - _LIBCPP_INLINE_VISIBILITY - streamsize gcount() const {return __gc_;} - int_type get(); - - inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 - basic_istream& get(char_type& __c) { - int_type __ch = get(); - if (__ch != traits_type::eof()) - __c = traits_type::to_char_type(__ch); - return *this; - } - - inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 - basic_istream& get(char_type* __s, streamsize __n) - { return get(__s, __n, this->widen('\n')); } - - basic_istream& get(char_type* __s, streamsize __n, char_type __dlm); - - inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 - basic_istream& get(basic_streambuf& __sb) - { return get(__sb, this->widen('\n')); } - - basic_istream& get(basic_streambuf& __sb, char_type __dlm); - - inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 - basic_istream& getline(char_type* __s, streamsize __n) - { return getline(__s, __n, this->widen('\n')); } - - basic_istream& getline(char_type* __s, streamsize __n, char_type __dlm); - - basic_istream& ignore(streamsize __n = 1, int_type __dlm = traits_type::eof()); - int_type peek(); - basic_istream& read (char_type* __s, streamsize __n); - streamsize readsome(char_type* __s, streamsize __n); - - basic_istream& putback(char_type __c); - basic_istream& unget(); - int sync(); - - pos_type tellg(); - basic_istream& seekg(pos_type __pos); - basic_istream& seekg(off_type __off, ios_base::seekdir __dir); -}; - -template -class _LIBCPP_TEMPLATE_VIS basic_istream<_CharT, _Traits>::sentry -{ - bool __ok_; - -public: - explicit sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false); -// ~sentry() = default; - - _LIBCPP_INLINE_VISIBILITY - explicit operator bool() const {return __ok_;} - - sentry(const sentry&) = delete; - sentry& operator=(const sentry&) = delete; -}; - template basic_istream<_CharT, _Traits>::sentry::sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws) @@ -1370,273 +1089,13 @@ return __is; } -template -struct __is_istreamable : false_type { }; - -template -struct __is_istreamable<_Stream, _Tp, decltype( - declval<_Stream>() >> declval<_Tp>(), void() -)> : true_type { }; - -template , - __is_istreamable<_Stream&, _Tp&&> >::value ->::type> -_LIBCPP_INLINE_VISIBILITY -_Stream&& operator>>(_Stream&& __is, _Tp&& __x) -{ - __is >> _VSTD::forward<_Tp>(__x); - return _VSTD::move(__is); -} - -template -class _LIBCPP_TEMPLATE_VIS basic_iostream - : public basic_istream<_CharT, _Traits>, - public basic_ostream<_CharT, _Traits> -{ -public: - // types: - typedef _CharT char_type; - typedef _Traits traits_type; - typedef typename traits_type::int_type int_type; - typedef typename traits_type::pos_type pos_type; - typedef typename traits_type::off_type off_type; - - // constructor/destructor - inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 - explicit basic_iostream(basic_streambuf* __sb) - : basic_istream<_CharT, _Traits>(__sb) - {} - - ~basic_iostream() override; -protected: - inline _LIBCPP_INLINE_VISIBILITY - basic_iostream(basic_iostream&& __rhs); - - // assign/swap - inline _LIBCPP_INLINE_VISIBILITY - basic_iostream& operator=(basic_iostream&& __rhs); - - inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 - void swap(basic_iostream& __rhs) - { basic_istream::swap(__rhs); } -}; - -template -basic_iostream<_CharT, _Traits>::basic_iostream(basic_iostream&& __rhs) - : basic_istream<_CharT, _Traits>(_VSTD::move(__rhs)) -{ -} - -template -basic_iostream<_CharT, _Traits>& -basic_iostream<_CharT, _Traits>::operator=(basic_iostream&& __rhs) -{ - swap(__rhs); - return *this; -} - -template -basic_iostream<_CharT, _Traits>::~basic_iostream() -{ -} - -template -_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - basic_string<_CharT, _Traits, _Allocator>& __str) -{ - ios_base::iostate __state = ios_base::goodbit; - typename basic_istream<_CharT, _Traits>::sentry __sen(__is); - if (__sen) - { -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif - __str.clear(); - streamsize __n = __is.width(); - if (__n <= 0) - __n = __str.max_size(); - if (__n <= 0) - __n = numeric_limits::max(); - streamsize __c = 0; - const ctype<_CharT>& __ct = use_facet >(__is.getloc()); - while (__c < __n) - { - typename _Traits::int_type __i = __is.rdbuf()->sgetc(); - if (_Traits::eq_int_type(__i, _Traits::eof())) - { - __state |= ios_base::eofbit; - break; - } - _CharT __ch = _Traits::to_char_type(__i); - if (__ct.is(__ct.space, __ch)) - break; - __str.push_back(__ch); - ++__c; - __is.rdbuf()->sbumpc(); - } - __is.width(0); - if (__c == 0) - __state |= ios_base::failbit; -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __state |= ios_base::badbit; - __is.__setstate_nothrow(__state); - if (__is.exceptions() & ios_base::badbit) - { - throw; - } - } -#endif - __is.setstate(__state); - } - return __is; -} - -template -_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& -getline(basic_istream<_CharT, _Traits>& __is, - basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm) -{ - ios_base::iostate __state = ios_base::goodbit; - typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true); - if (__sen) - { -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif - __str.clear(); - streamsize __extr = 0; - while (true) - { - typename _Traits::int_type __i = __is.rdbuf()->sbumpc(); - if (_Traits::eq_int_type(__i, _Traits::eof())) - { - __state |= ios_base::eofbit; - break; - } - ++__extr; - _CharT __ch = _Traits::to_char_type(__i); - if (_Traits::eq(__ch, __dlm)) - break; - __str.push_back(__ch); - if (__str.size() == __str.max_size()) - { - __state |= ios_base::failbit; - break; - } - } - if (__extr == 0) - __state |= ios_base::failbit; -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __state |= ios_base::badbit; - __is.__setstate_nothrow(__state); - if (__is.exceptions() & ios_base::badbit) - { - throw; - } - } -#endif - __is.setstate(__state); - } - return __is; -} - -template -inline _LIBCPP_INLINE_VISIBILITY -basic_istream<_CharT, _Traits>& -getline(basic_istream<_CharT, _Traits>& __is, - basic_string<_CharT, _Traits, _Allocator>& __str) -{ - return getline(__is, __str, __is.widen('\n')); -} - -template -inline _LIBCPP_INLINE_VISIBILITY -basic_istream<_CharT, _Traits>& -getline(basic_istream<_CharT, _Traits>&& __is, - basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm) -{ - return getline(__is, __str, __dlm); -} - -template -inline _LIBCPP_INLINE_VISIBILITY -basic_istream<_CharT, _Traits>& -getline(basic_istream<_CharT, _Traits>&& __is, - basic_string<_CharT, _Traits, _Allocator>& __str) -{ - return getline(__is, __str, __is.widen('\n')); -} - -template -_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x) -{ - ios_base::iostate __state = ios_base::goodbit; - typename basic_istream<_CharT, _Traits>::sentry __sen(__is); - if (__sen) - { -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif - basic_string<_CharT, _Traits> __str; - const ctype<_CharT>& __ct = use_facet >(__is.getloc()); - size_t __c = 0; - _CharT __zero = __ct.widen('0'); - _CharT __one = __ct.widen('1'); - while (__c != _Size) - { - typename _Traits::int_type __i = __is.rdbuf()->sgetc(); - if (_Traits::eq_int_type(__i, _Traits::eof())) - { - __state |= ios_base::eofbit; - break; - } - _CharT __ch = _Traits::to_char_type(__i); - if (!_Traits::eq(__ch, __zero) && !_Traits::eq(__ch, __one)) - break; - __str.push_back(__ch); - ++__c; - __is.rdbuf()->sbumpc(); - } - __x = bitset<_Size>(__str); - if (_Size > 0 && __c == 0) - __state |= ios_base::failbit; -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __state |= ios_base::badbit; - __is.__setstate_nothrow(__state); - if (__is.exceptions() & ios_base::badbit) - { - throw; - } - } -#endif - __is.setstate(__state); - } - return __is; -} - extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_istream; #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_istream; #endif -extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_iostream; _LIBCPP_END_NAMESPACE_STD _LIBCPP_POP_MACROS -#endif // _LIBCPP_ISTREAM +#endif // _LIBCPP___ISTREAM_BASIC_ISTREAM_DEF_H diff --git a/libcxx/include/istream b/libcxx/include/istream --- a/libcxx/include/istream +++ b/libcxx/include/istream @@ -159,9 +159,9 @@ */ #include <__assert> // all public C++ headers provide the assertion handler -#include <__config> -#include <__iterator/istreambuf_iterator.h> -#include <__utility/forward.h> +#include <__istream/basic_iostream.h> +#include <__istream/basic_istream.h> +#include <__istream/basic_istream_def.h> #include #include @@ -169,1474 +169,4 @@ # pragma GCC system_header #endif -_LIBCPP_PUSH_MACROS -#include <__undef_macros> - - -_LIBCPP_BEGIN_NAMESPACE_STD - -template -class _LIBCPP_TEMPLATE_VIS basic_istream - : virtual public basic_ios<_CharT, _Traits> -{ - streamsize __gc_; -public: - // types (inherited from basic_ios (27.5.4)): - typedef _CharT char_type; - typedef _Traits traits_type; - typedef typename traits_type::int_type int_type; - typedef typename traits_type::pos_type pos_type; - typedef typename traits_type::off_type off_type; - - // 27.7.1.1.1 Constructor/destructor: - inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 - explicit basic_istream(basic_streambuf* __sb) : __gc_(0) - { this->init(__sb); } - ~basic_istream() override; -protected: - inline _LIBCPP_INLINE_VISIBILITY - basic_istream(basic_istream&& __rhs); - - // 27.7.1.1.2 Assign/swap: - inline _LIBCPP_INLINE_VISIBILITY - basic_istream& operator=(basic_istream&& __rhs); - - inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 - void swap(basic_istream& __rhs) { - _VSTD::swap(__gc_, __rhs.__gc_); - basic_ios::swap(__rhs); - } - - basic_istream (const basic_istream& __rhs) = delete; - basic_istream& operator=(const basic_istream& __rhs) = delete; -public: - - // 27.7.1.1.3 Prefix/suffix: - class _LIBCPP_TEMPLATE_VIS sentry; - - // 27.7.1.2 Formatted input: - inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 - basic_istream& operator>>(basic_istream& (*__pf)(basic_istream&)) - { return __pf(*this); } - - inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 - basic_istream& operator>>(basic_ios& - (*__pf)(basic_ios&)) - { __pf(*this); return *this; } - - inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 - basic_istream& operator>>(ios_base& (*__pf)(ios_base&)) - { __pf(*this); return *this; } - - basic_istream& operator>>(basic_streambuf* __sb); - basic_istream& operator>>(bool& __n); - basic_istream& operator>>(short& __n); - basic_istream& operator>>(unsigned short& __n); - basic_istream& operator>>(int& __n); - basic_istream& operator>>(unsigned int& __n); - basic_istream& operator>>(long& __n); - basic_istream& operator>>(unsigned long& __n); - basic_istream& operator>>(long long& __n); - basic_istream& operator>>(unsigned long long& __n); - basic_istream& operator>>(float& __f); - basic_istream& operator>>(double& __f); - basic_istream& operator>>(long double& __f); - basic_istream& operator>>(void*& __p); - - // 27.7.1.3 Unformatted input: - _LIBCPP_INLINE_VISIBILITY - streamsize gcount() const {return __gc_;} - int_type get(); - - inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 - basic_istream& get(char_type& __c) { - int_type __ch = get(); - if (__ch != traits_type::eof()) - __c = traits_type::to_char_type(__ch); - return *this; - } - - inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 - basic_istream& get(char_type* __s, streamsize __n) - { return get(__s, __n, this->widen('\n')); } - - basic_istream& get(char_type* __s, streamsize __n, char_type __dlm); - - inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 - basic_istream& get(basic_streambuf& __sb) - { return get(__sb, this->widen('\n')); } - - basic_istream& get(basic_streambuf& __sb, char_type __dlm); - - inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 - basic_istream& getline(char_type* __s, streamsize __n) - { return getline(__s, __n, this->widen('\n')); } - - basic_istream& getline(char_type* __s, streamsize __n, char_type __dlm); - - basic_istream& ignore(streamsize __n = 1, int_type __dlm = traits_type::eof()); - int_type peek(); - basic_istream& read (char_type* __s, streamsize __n); - streamsize readsome(char_type* __s, streamsize __n); - - basic_istream& putback(char_type __c); - basic_istream& unget(); - int sync(); - - pos_type tellg(); - basic_istream& seekg(pos_type __pos); - basic_istream& seekg(off_type __off, ios_base::seekdir __dir); -}; - -template -class _LIBCPP_TEMPLATE_VIS basic_istream<_CharT, _Traits>::sentry -{ - bool __ok_; - -public: - explicit sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false); -// ~sentry() = default; - - _LIBCPP_INLINE_VISIBILITY - explicit operator bool() const {return __ok_;} - - sentry(const sentry&) = delete; - sentry& operator=(const sentry&) = delete; -}; - -template -basic_istream<_CharT, _Traits>::sentry::sentry(basic_istream<_CharT, _Traits>& __is, - bool __noskipws) - : __ok_(false) -{ - if (__is.good()) - { - if (__is.tie()) - __is.tie()->flush(); - if (!__noskipws && (__is.flags() & ios_base::skipws)) - { - typedef istreambuf_iterator<_CharT, _Traits> _Ip; - const ctype<_CharT>& __ct = use_facet >(__is.getloc()); - _Ip __i(__is); - _Ip __eof; - for (; __i != __eof; ++__i) - if (!__ct.is(__ct.space, *__i)) - break; - if (__i == __eof) - __is.setstate(ios_base::failbit | ios_base::eofbit); - } - __ok_ = __is.good(); - } - else - __is.setstate(ios_base::failbit); -} - -template -basic_istream<_CharT, _Traits>::basic_istream(basic_istream&& __rhs) - : __gc_(__rhs.__gc_) -{ - __rhs.__gc_ = 0; - this->move(__rhs); -} - -template -basic_istream<_CharT, _Traits>& -basic_istream<_CharT, _Traits>::operator=(basic_istream&& __rhs) -{ - swap(__rhs); - return *this; -} - -template -basic_istream<_CharT, _Traits>::~basic_istream() -{ -} - -template -_LIBCPP_INLINE_VISIBILITY -basic_istream<_CharT, _Traits>& -__input_arithmetic(basic_istream<_CharT, _Traits>& __is, _Tp& __n) { - ios_base::iostate __state = ios_base::goodbit; - typename basic_istream<_CharT, _Traits>::sentry __s(__is); - if (__s) - { -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif // _LIBCPP_NO_EXCEPTIONS - typedef istreambuf_iterator<_CharT, _Traits> _Ip; - typedef num_get<_CharT, _Ip> _Fp; - use_facet<_Fp>(__is.getloc()).get(_Ip(__is), _Ip(), __is, __state, __n); -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __state |= ios_base::badbit; - __is.__setstate_nothrow(__state); - if (__is.exceptions() & ios_base::badbit) - { - throw; - } - } -#endif - __is.setstate(__state); - } - return __is; -} - -template -basic_istream<_CharT, _Traits>& -basic_istream<_CharT, _Traits>::operator>>(unsigned short& __n) -{ - return _VSTD::__input_arithmetic(*this, __n); -} - -template -basic_istream<_CharT, _Traits>& -basic_istream<_CharT, _Traits>::operator>>(unsigned int& __n) -{ - return _VSTD::__input_arithmetic(*this, __n); -} - -template -basic_istream<_CharT, _Traits>& -basic_istream<_CharT, _Traits>::operator>>(long& __n) -{ - return _VSTD::__input_arithmetic(*this, __n); -} - -template -basic_istream<_CharT, _Traits>& -basic_istream<_CharT, _Traits>::operator>>(unsigned long& __n) -{ - return _VSTD::__input_arithmetic(*this, __n); -} - -template -basic_istream<_CharT, _Traits>& -basic_istream<_CharT, _Traits>::operator>>(long long& __n) -{ - return _VSTD::__input_arithmetic(*this, __n); -} - -template -basic_istream<_CharT, _Traits>& -basic_istream<_CharT, _Traits>::operator>>(unsigned long long& __n) -{ - return _VSTD::__input_arithmetic(*this, __n); -} - -template -basic_istream<_CharT, _Traits>& -basic_istream<_CharT, _Traits>::operator>>(float& __n) -{ - return _VSTD::__input_arithmetic(*this, __n); -} - -template -basic_istream<_CharT, _Traits>& -basic_istream<_CharT, _Traits>::operator>>(double& __n) -{ - return _VSTD::__input_arithmetic(*this, __n); -} - -template -basic_istream<_CharT, _Traits>& -basic_istream<_CharT, _Traits>::operator>>(long double& __n) -{ - return _VSTD::__input_arithmetic(*this, __n); -} - -template -basic_istream<_CharT, _Traits>& -basic_istream<_CharT, _Traits>::operator>>(bool& __n) -{ - return _VSTD::__input_arithmetic(*this, __n); -} - -template -basic_istream<_CharT, _Traits>& -basic_istream<_CharT, _Traits>::operator>>(void*& __n) -{ - return _VSTD::__input_arithmetic(*this, __n); -} - -template -_LIBCPP_INLINE_VISIBILITY -basic_istream<_CharT, _Traits>& -__input_arithmetic_with_numeric_limits(basic_istream<_CharT, _Traits>& __is, _Tp& __n) { - ios_base::iostate __state = ios_base::goodbit; - typename basic_istream<_CharT, _Traits>::sentry __s(__is); - if (__s) - { -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif // _LIBCPP_NO_EXCEPTIONS - typedef istreambuf_iterator<_CharT, _Traits> _Ip; - typedef num_get<_CharT, _Ip> _Fp; - long __temp; - use_facet<_Fp>(__is.getloc()).get(_Ip(__is), _Ip(), __is, __state, __temp); - if (__temp < numeric_limits<_Tp>::min()) - { - __state |= ios_base::failbit; - __n = numeric_limits<_Tp>::min(); - } - else if (__temp > numeric_limits<_Tp>::max()) - { - __state |= ios_base::failbit; - __n = numeric_limits<_Tp>::max(); - } - else - { - __n = static_cast<_Tp>(__temp); - } -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __state |= ios_base::badbit; - __is.__setstate_nothrow(__state); - if (__is.exceptions() & ios_base::badbit) - { - throw; - } - } -#endif // _LIBCPP_NO_EXCEPTIONS - __is.setstate(__state); - } - return __is; -} - -template -basic_istream<_CharT, _Traits>& -basic_istream<_CharT, _Traits>::operator>>(short& __n) -{ - return _VSTD::__input_arithmetic_with_numeric_limits(*this, __n); -} - -template -basic_istream<_CharT, _Traits>& -basic_istream<_CharT, _Traits>::operator>>(int& __n) -{ - return _VSTD::__input_arithmetic_with_numeric_limits(*this, __n); -} - -template -_LIBCPP_INLINE_VISIBILITY -basic_istream<_CharT, _Traits>& -__input_c_string(basic_istream<_CharT, _Traits>& __is, _CharT* __p, size_t __n) -{ - ios_base::iostate __state = ios_base::goodbit; - typename basic_istream<_CharT, _Traits>::sentry __sen(__is); - if (__sen) - { -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif - _CharT* __s = __p; - const ctype<_CharT>& __ct = use_facet >(__is.getloc()); - while (__s != __p + (__n-1)) - { - typename _Traits::int_type __i = __is.rdbuf()->sgetc(); - if (_Traits::eq_int_type(__i, _Traits::eof())) - { - __state |= ios_base::eofbit; - break; - } - _CharT __ch = _Traits::to_char_type(__i); - if (__ct.is(__ct.space, __ch)) - break; - *__s++ = __ch; - __is.rdbuf()->sbumpc(); - } - *__s = _CharT(); - __is.width(0); - if (__s == __p) - __state |= ios_base::failbit; -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __state |= ios_base::badbit; - __is.__setstate_nothrow(__state); - if (__is.exceptions() & ios_base::badbit) - { - throw; - } - } -#endif - __is.setstate(__state); - } - return __is; -} - -#if _LIBCPP_STD_VER > 17 - -template -inline _LIBCPP_INLINE_VISIBILITY -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, _CharT (&__buf)[_Np]) -{ - size_t __n = _Np; - if (__is.width() > 0) - __n = _VSTD::min(size_t(__is.width()), _Np); - return _VSTD::__input_c_string(__is, __buf, __n); -} - -template -inline _LIBCPP_INLINE_VISIBILITY -basic_istream& -operator>>(basic_istream& __is, unsigned char (&__buf)[_Np]) -{ - return __is >> (char(&)[_Np])__buf; -} - -template -inline _LIBCPP_INLINE_VISIBILITY -basic_istream& -operator>>(basic_istream& __is, signed char (&__buf)[_Np]) -{ - return __is >> (char(&)[_Np])__buf; -} - -#else - -template -inline _LIBCPP_INLINE_VISIBILITY -basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, _CharT* __s) -{ - streamsize __n = __is.width(); - if (__n <= 0) - __n = numeric_limits::max() / sizeof(_CharT) - 1; - return _VSTD::__input_c_string(__is, __s, size_t(__n)); -} - -template -inline _LIBCPP_INLINE_VISIBILITY -basic_istream& -operator>>(basic_istream& __is, unsigned char* __s) -{ - return __is >> (char*)__s; -} - -template -inline _LIBCPP_INLINE_VISIBILITY -basic_istream& -operator>>(basic_istream& __is, signed char* __s) -{ - return __is >> (char*)__s; -} - -#endif // _LIBCPP_STD_VER > 17 - -template -_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, _CharT& __c) -{ - ios_base::iostate __state = ios_base::goodbit; - typename basic_istream<_CharT, _Traits>::sentry __sen(__is); - if (__sen) - { -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif - typename _Traits::int_type __i = __is.rdbuf()->sbumpc(); - if (_Traits::eq_int_type(__i, _Traits::eof())) - __state |= ios_base::eofbit | ios_base::failbit; - else - __c = _Traits::to_char_type(__i); -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __state |= ios_base::badbit; - __is.__setstate_nothrow(__state); - if (__is.exceptions() & ios_base::badbit) - { - throw; - } - } -#endif - __is.setstate(__state); - } - return __is; -} - -template -inline _LIBCPP_INLINE_VISIBILITY -basic_istream& -operator>>(basic_istream& __is, unsigned char& __c) -{ - return __is >> (char&)__c; -} - -template -inline _LIBCPP_INLINE_VISIBILITY -basic_istream& -operator>>(basic_istream& __is, signed char& __c) -{ - return __is >> (char&)__c; -} - -template -basic_istream<_CharT, _Traits>& -basic_istream<_CharT, _Traits>::operator>>(basic_streambuf* __sb) -{ - ios_base::iostate __state = ios_base::goodbit; - __gc_ = 0; - sentry __s(*this, true); - if (__s) - { - if (__sb) - { -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif // _LIBCPP_NO_EXCEPTIONS - while (true) - { - typename traits_type::int_type __i = this->rdbuf()->sgetc(); - if (traits_type::eq_int_type(__i, _Traits::eof())) - { - __state |= ios_base::eofbit; - break; - } - if (traits_type::eq_int_type( - __sb->sputc(traits_type::to_char_type(__i)), - traits_type::eof())) - break; - ++__gc_; - this->rdbuf()->sbumpc(); - } - if (__gc_ == 0) - __state |= ios_base::failbit; -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __state |= ios_base::badbit; - if (__gc_ == 0) - __state |= ios_base::failbit; - - this->__setstate_nothrow(__state); - if (this->exceptions() & ios_base::failbit || this->exceptions() & ios_base::badbit) - { - throw; - } - } -#endif // _LIBCPP_NO_EXCEPTIONS - } - else - { - __state |= ios_base::failbit; - } - this->setstate(__state); - } - return *this; -} - -template -typename basic_istream<_CharT, _Traits>::int_type -basic_istream<_CharT, _Traits>::get() -{ - ios_base::iostate __state = ios_base::goodbit; - __gc_ = 0; - int_type __r = traits_type::eof(); - sentry __s(*this, true); - if (__s) - { -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif - __r = this->rdbuf()->sbumpc(); - if (traits_type::eq_int_type(__r, traits_type::eof())) - __state |= ios_base::failbit | ios_base::eofbit; - else - __gc_ = 1; -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - this->__setstate_nothrow(this->rdstate() | ios_base::badbit); - if (this->exceptions() & ios_base::badbit) - { - throw; - } - } -#endif - this->setstate(__state); - } - return __r; -} - -template -basic_istream<_CharT, _Traits>& -basic_istream<_CharT, _Traits>::get(char_type* __s, streamsize __n, char_type __dlm) -{ - ios_base::iostate __state = ios_base::goodbit; - __gc_ = 0; - sentry __sen(*this, true); - if (__sen) - { - if (__n > 0) - { -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif - while (__gc_ < __n-1) - { - int_type __i = this->rdbuf()->sgetc(); - if (traits_type::eq_int_type(__i, traits_type::eof())) - { - __state |= ios_base::eofbit; - break; - } - char_type __ch = traits_type::to_char_type(__i); - if (traits_type::eq(__ch, __dlm)) - break; - *__s++ = __ch; - ++__gc_; - this->rdbuf()->sbumpc(); - } - if (__gc_ == 0) - __state |= ios_base::failbit; -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __state |= ios_base::badbit; - this->__setstate_nothrow(__state); - if (this->exceptions() & ios_base::badbit) - { - if (__n > 0) - *__s = char_type(); - throw; - } - } -#endif - } - else - { - __state |= ios_base::failbit; - } - - if (__n > 0) - *__s = char_type(); - this->setstate(__state); - } - if (__n > 0) - *__s = char_type(); - return *this; -} - -template -basic_istream<_CharT, _Traits>& -basic_istream<_CharT, _Traits>::get(basic_streambuf& __sb, - char_type __dlm) -{ - ios_base::iostate __state = ios_base::goodbit; - __gc_ = 0; - sentry __sen(*this, true); - if (__sen) - { -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif // _LIBCPP_NO_EXCEPTIONS - while (true) - { - typename traits_type::int_type __i = this->rdbuf()->sgetc(); - if (traits_type::eq_int_type(__i, traits_type::eof())) - { - __state |= ios_base::eofbit; - break; - } - char_type __ch = traits_type::to_char_type(__i); - if (traits_type::eq(__ch, __dlm)) - break; - if (traits_type::eq_int_type(__sb.sputc(__ch), traits_type::eof())) - break; - ++__gc_; - this->rdbuf()->sbumpc(); - } -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __state |= ios_base::badbit; - // according to the spec, exceptions here are caught but not rethrown - } -#endif // _LIBCPP_NO_EXCEPTIONS - if (__gc_ == 0) - __state |= ios_base::failbit; - this->setstate(__state); - } - return *this; -} - -template -basic_istream<_CharT, _Traits>& -basic_istream<_CharT, _Traits>::getline(char_type* __s, streamsize __n, char_type __dlm) -{ - ios_base::iostate __state = ios_base::goodbit; - __gc_ = 0; - sentry __sen(*this, true); - if (__sen) - { -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif // _LIBCPP_NO_EXCEPTIONS - while (true) - { - typename traits_type::int_type __i = this->rdbuf()->sgetc(); - if (traits_type::eq_int_type(__i, traits_type::eof())) - { - __state |= ios_base::eofbit; - break; - } - char_type __ch = traits_type::to_char_type(__i); - if (traits_type::eq(__ch, __dlm)) - { - this->rdbuf()->sbumpc(); - ++__gc_; - break; - } - if (__gc_ >= __n-1) - { - __state |= ios_base::failbit; - break; - } - *__s++ = __ch; - this->rdbuf()->sbumpc(); - ++__gc_; - } -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __state |= ios_base::badbit; - this->__setstate_nothrow(__state); - if (this->exceptions() & ios_base::badbit) - { - if (__n > 0) - *__s = char_type(); - if (__gc_ == 0) - __state |= ios_base::failbit; - throw; - } - } -#endif // _LIBCPP_NO_EXCEPTIONS - } - if (__n > 0) - *__s = char_type(); - if (__gc_ == 0) - __state |= ios_base::failbit; - this->setstate(__state); - return *this; -} - -template -basic_istream<_CharT, _Traits>& -basic_istream<_CharT, _Traits>::ignore(streamsize __n, int_type __dlm) -{ - ios_base::iostate __state = ios_base::goodbit; - __gc_ = 0; - sentry __sen(*this, true); - if (__sen) - { -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif // _LIBCPP_NO_EXCEPTIONS - if (__n == numeric_limits::max()) - { - while (true) - { - typename traits_type::int_type __i = this->rdbuf()->sbumpc(); - if (traits_type::eq_int_type(__i, traits_type::eof())) - { - __state |= ios_base::eofbit; - break; - } - ++__gc_; - if (traits_type::eq_int_type(__i, __dlm)) - break; - } - } - else - { - while (__gc_ < __n) - { - typename traits_type::int_type __i = this->rdbuf()->sbumpc(); - if (traits_type::eq_int_type(__i, traits_type::eof())) - { - __state |= ios_base::eofbit; - break; - } - ++__gc_; - if (traits_type::eq_int_type(__i, __dlm)) - break; - } - } -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __state |= ios_base::badbit; - this->__setstate_nothrow(__state); - if (this->exceptions() & ios_base::badbit) - { - throw; - } - } -#endif // _LIBCPP_NO_EXCEPTIONS - this->setstate(__state); - } - return *this; -} - -template -typename basic_istream<_CharT, _Traits>::int_type -basic_istream<_CharT, _Traits>::peek() -{ - ios_base::iostate __state = ios_base::goodbit; - __gc_ = 0; - int_type __r = traits_type::eof(); - sentry __sen(*this, true); - if (__sen) - { -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif // _LIBCPP_NO_EXCEPTIONS - __r = this->rdbuf()->sgetc(); - if (traits_type::eq_int_type(__r, traits_type::eof())) - __state |= ios_base::eofbit; -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __state |= ios_base::badbit; - this->__setstate_nothrow(__state); - if (this->exceptions() & ios_base::badbit) - { - throw; - } - } -#endif // _LIBCPP_NO_EXCEPTIONS - this->setstate(__state); - } - return __r; -} - -template -basic_istream<_CharT, _Traits>& -basic_istream<_CharT, _Traits>::read(char_type* __s, streamsize __n) -{ - ios_base::iostate __state = ios_base::goodbit; - __gc_ = 0; - sentry __sen(*this, true); - if (__sen) - { -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif // _LIBCPP_NO_EXCEPTIONS - __gc_ = this->rdbuf()->sgetn(__s, __n); - if (__gc_ != __n) - __state |= ios_base::failbit | ios_base::eofbit; -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __state |= ios_base::badbit; - this->__setstate_nothrow(__state); - if (this->exceptions() & ios_base::badbit) - { - throw; - } - } -#endif // _LIBCPP_NO_EXCEPTIONS - } - else - { - __state |= ios_base::failbit; - } - this->setstate(__state); - return *this; -} - -template -streamsize -basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __n) -{ - ios_base::iostate __state = ios_base::goodbit; - __gc_ = 0; - sentry __sen(*this, true); - if (__sen) - { -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif // _LIBCPP_NO_EXCEPTIONS - streamsize __c = this->rdbuf()->in_avail(); - switch (__c) - { - case -1: - __state |= ios_base::eofbit; - break; - case 0: - break; - default: - __n = _VSTD::min(__c, __n); - __gc_ = this->rdbuf()->sgetn(__s, __n); - if (__gc_ != __n) - __state |= ios_base::failbit | ios_base::eofbit; - break; - } -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __state |= ios_base::badbit; - this->__setstate_nothrow(__state); - if (this->exceptions() & ios_base::badbit) - { - throw; - } - } -#endif // _LIBCPP_NO_EXCEPTIONS - } - else - { - __state |= ios_base::failbit; - } - this->setstate(__state); - return __gc_; -} - -template -basic_istream<_CharT, _Traits>& -basic_istream<_CharT, _Traits>::putback(char_type __c) -{ - ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit; - __gc_ = 0; - this->clear(__state); - sentry __sen(*this, true); - if (__sen) - { -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif // _LIBCPP_NO_EXCEPTIONS - if (this->rdbuf() == nullptr || this->rdbuf()->sputbackc(__c) == traits_type::eof()) - __state |= ios_base::badbit; -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __state |= ios_base::badbit; - this->__setstate_nothrow(__state); - if (this->exceptions() & ios_base::badbit) - { - throw; - } - } -#endif // _LIBCPP_NO_EXCEPTIONS - } - else - { - __state |= ios_base::failbit; - } - this->setstate(__state); - return *this; -} - -template -basic_istream<_CharT, _Traits>& -basic_istream<_CharT, _Traits>::unget() -{ - ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit; - __gc_ = 0; - this->clear(__state); - sentry __sen(*this, true); - if (__sen) - { -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif // _LIBCPP_NO_EXCEPTIONS - if (this->rdbuf() == nullptr || this->rdbuf()->sungetc() == traits_type::eof()) - __state |= ios_base::badbit; -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __state |= ios_base::badbit; - this->__setstate_nothrow(__state); - if (this->exceptions() & ios_base::badbit) - { - throw; - } - } -#endif // _LIBCPP_NO_EXCEPTIONS - } - else - { - __state |= ios_base::failbit; - } - this->setstate(__state); - return *this; -} - -template -int -basic_istream<_CharT, _Traits>::sync() -{ - ios_base::iostate __state = ios_base::goodbit; - int __r = 0; - sentry __sen(*this, true); - if (__sen) - { -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif // _LIBCPP_NO_EXCEPTIONS - if (this->rdbuf() == nullptr) - return -1; - if (this->rdbuf()->pubsync() == -1) - { - __state |= ios_base::badbit; - return -1; - } -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __state |= ios_base::badbit; - this->__setstate_nothrow(__state); - if (this->exceptions() & ios_base::badbit) - { - throw; - } - } -#endif // _LIBCPP_NO_EXCEPTIONS - this->setstate(__state); - } - return __r; -} - -template -typename basic_istream<_CharT, _Traits>::pos_type -basic_istream<_CharT, _Traits>::tellg() -{ - ios_base::iostate __state = ios_base::goodbit; - pos_type __r(-1); - sentry __sen(*this, true); - if (__sen) - { -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif // _LIBCPP_NO_EXCEPTIONS - __r = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in); -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __state |= ios_base::badbit; - this->__setstate_nothrow(__state); - if (this->exceptions() & ios_base::badbit) - { - throw; - } - } -#endif // _LIBCPP_NO_EXCEPTIONS - this->setstate(__state); - } - return __r; -} - -template -basic_istream<_CharT, _Traits>& -basic_istream<_CharT, _Traits>::seekg(pos_type __pos) -{ - ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit; - this->clear(__state); - sentry __sen(*this, true); - if (__sen) - { -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif // _LIBCPP_NO_EXCEPTIONS - if (this->rdbuf()->pubseekpos(__pos, ios_base::in) == pos_type(-1)) - __state |= ios_base::failbit; -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __state |= ios_base::badbit; - this->__setstate_nothrow(__state); - if (this->exceptions() & ios_base::badbit) - { - throw; - } - } -#endif // _LIBCPP_NO_EXCEPTIONS - this->setstate(__state); - } - return *this; -} - -template -basic_istream<_CharT, _Traits>& -basic_istream<_CharT, _Traits>::seekg(off_type __off, ios_base::seekdir __dir) -{ - ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit; - this->clear(__state); - sentry __sen(*this, true); - if (__sen) - { -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif // _LIBCPP_NO_EXCEPTIONS - if (this->rdbuf()->pubseekoff(__off, __dir, ios_base::in) == pos_type(-1)) - __state |= ios_base::failbit; -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __state |= ios_base::badbit; - this->__setstate_nothrow(__state); - if (this->exceptions() & ios_base::badbit) - { - throw; - } - } -#endif // _LIBCPP_NO_EXCEPTIONS - this->setstate(__state); - } - return *this; -} - -template -_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& -ws(basic_istream<_CharT, _Traits>& __is) -{ - ios_base::iostate __state = ios_base::goodbit; - typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true); - if (__sen) - { -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif // _LIBCPP_NO_EXCEPTIONS - const ctype<_CharT>& __ct = use_facet >(__is.getloc()); - while (true) - { - typename _Traits::int_type __i = __is.rdbuf()->sgetc(); - if (_Traits::eq_int_type(__i, _Traits::eof())) - { - __state |= ios_base::eofbit; - break; - } - if (!__ct.is(__ct.space, _Traits::to_char_type(__i))) - break; - __is.rdbuf()->sbumpc(); - } -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __state |= ios_base::badbit; - __is.__setstate_nothrow(__state); - if (__is.exceptions() & ios_base::badbit) - { - throw; - } - } -#endif // _LIBCPP_NO_EXCEPTIONS - __is.setstate(__state); - } - return __is; -} - -template -struct __is_istreamable : false_type { }; - -template -struct __is_istreamable<_Stream, _Tp, decltype( - declval<_Stream>() >> declval<_Tp>(), void() -)> : true_type { }; - -template , - __is_istreamable<_Stream&, _Tp&&> >::value ->::type> -_LIBCPP_INLINE_VISIBILITY -_Stream&& operator>>(_Stream&& __is, _Tp&& __x) -{ - __is >> _VSTD::forward<_Tp>(__x); - return _VSTD::move(__is); -} - -template -class _LIBCPP_TEMPLATE_VIS basic_iostream - : public basic_istream<_CharT, _Traits>, - public basic_ostream<_CharT, _Traits> -{ -public: - // types: - typedef _CharT char_type; - typedef _Traits traits_type; - typedef typename traits_type::int_type int_type; - typedef typename traits_type::pos_type pos_type; - typedef typename traits_type::off_type off_type; - - // constructor/destructor - inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 - explicit basic_iostream(basic_streambuf* __sb) - : basic_istream<_CharT, _Traits>(__sb) - {} - - ~basic_iostream() override; -protected: - inline _LIBCPP_INLINE_VISIBILITY - basic_iostream(basic_iostream&& __rhs); - - // assign/swap - inline _LIBCPP_INLINE_VISIBILITY - basic_iostream& operator=(basic_iostream&& __rhs); - - inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 - void swap(basic_iostream& __rhs) - { basic_istream::swap(__rhs); } -}; - -template -basic_iostream<_CharT, _Traits>::basic_iostream(basic_iostream&& __rhs) - : basic_istream<_CharT, _Traits>(_VSTD::move(__rhs)) -{ -} - -template -basic_iostream<_CharT, _Traits>& -basic_iostream<_CharT, _Traits>::operator=(basic_iostream&& __rhs) -{ - swap(__rhs); - return *this; -} - -template -basic_iostream<_CharT, _Traits>::~basic_iostream() -{ -} - -template -_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, - basic_string<_CharT, _Traits, _Allocator>& __str) -{ - ios_base::iostate __state = ios_base::goodbit; - typename basic_istream<_CharT, _Traits>::sentry __sen(__is); - if (__sen) - { -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif - __str.clear(); - streamsize __n = __is.width(); - if (__n <= 0) - __n = __str.max_size(); - if (__n <= 0) - __n = numeric_limits::max(); - streamsize __c = 0; - const ctype<_CharT>& __ct = use_facet >(__is.getloc()); - while (__c < __n) - { - typename _Traits::int_type __i = __is.rdbuf()->sgetc(); - if (_Traits::eq_int_type(__i, _Traits::eof())) - { - __state |= ios_base::eofbit; - break; - } - _CharT __ch = _Traits::to_char_type(__i); - if (__ct.is(__ct.space, __ch)) - break; - __str.push_back(__ch); - ++__c; - __is.rdbuf()->sbumpc(); - } - __is.width(0); - if (__c == 0) - __state |= ios_base::failbit; -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __state |= ios_base::badbit; - __is.__setstate_nothrow(__state); - if (__is.exceptions() & ios_base::badbit) - { - throw; - } - } -#endif - __is.setstate(__state); - } - return __is; -} - -template -_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& -getline(basic_istream<_CharT, _Traits>& __is, - basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm) -{ - ios_base::iostate __state = ios_base::goodbit; - typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true); - if (__sen) - { -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif - __str.clear(); - streamsize __extr = 0; - while (true) - { - typename _Traits::int_type __i = __is.rdbuf()->sbumpc(); - if (_Traits::eq_int_type(__i, _Traits::eof())) - { - __state |= ios_base::eofbit; - break; - } - ++__extr; - _CharT __ch = _Traits::to_char_type(__i); - if (_Traits::eq(__ch, __dlm)) - break; - __str.push_back(__ch); - if (__str.size() == __str.max_size()) - { - __state |= ios_base::failbit; - break; - } - } - if (__extr == 0) - __state |= ios_base::failbit; -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __state |= ios_base::badbit; - __is.__setstate_nothrow(__state); - if (__is.exceptions() & ios_base::badbit) - { - throw; - } - } -#endif - __is.setstate(__state); - } - return __is; -} - -template -inline _LIBCPP_INLINE_VISIBILITY -basic_istream<_CharT, _Traits>& -getline(basic_istream<_CharT, _Traits>& __is, - basic_string<_CharT, _Traits, _Allocator>& __str) -{ - return getline(__is, __str, __is.widen('\n')); -} - -template -inline _LIBCPP_INLINE_VISIBILITY -basic_istream<_CharT, _Traits>& -getline(basic_istream<_CharT, _Traits>&& __is, - basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm) -{ - return getline(__is, __str, __dlm); -} - -template -inline _LIBCPP_INLINE_VISIBILITY -basic_istream<_CharT, _Traits>& -getline(basic_istream<_CharT, _Traits>&& __is, - basic_string<_CharT, _Traits, _Allocator>& __str) -{ - return getline(__is, __str, __is.widen('\n')); -} - -template -_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& -operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x) -{ - ios_base::iostate __state = ios_base::goodbit; - typename basic_istream<_CharT, _Traits>::sentry __sen(__is); - if (__sen) - { -#ifndef _LIBCPP_NO_EXCEPTIONS - try - { -#endif - basic_string<_CharT, _Traits> __str; - const ctype<_CharT>& __ct = use_facet >(__is.getloc()); - size_t __c = 0; - _CharT __zero = __ct.widen('0'); - _CharT __one = __ct.widen('1'); - while (__c != _Size) - { - typename _Traits::int_type __i = __is.rdbuf()->sgetc(); - if (_Traits::eq_int_type(__i, _Traits::eof())) - { - __state |= ios_base::eofbit; - break; - } - _CharT __ch = _Traits::to_char_type(__i); - if (!_Traits::eq(__ch, __zero) && !_Traits::eq(__ch, __one)) - break; - __str.push_back(__ch); - ++__c; - __is.rdbuf()->sbumpc(); - } - __x = bitset<_Size>(__str); - if (_Size > 0 && __c == 0) - __state |= ios_base::failbit; -#ifndef _LIBCPP_NO_EXCEPTIONS - } - catch (...) - { - __state |= ios_base::badbit; - __is.__setstate_nothrow(__state); - if (__is.exceptions() & ios_base::badbit) - { - throw; - } - } -#endif - __is.setstate(__state); - } - return __is; -} - -extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_istream; -#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS -extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_istream; -#endif -extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_iostream; - -_LIBCPP_END_NAMESPACE_STD - -_LIBCPP_POP_MACROS - -#endif // _LIBCPP_ISTREAM +#endif // _LIBCPP_ISTREAM \ No newline at end of file diff --git a/libcxx/include/module.modulemap.in b/libcxx/include/module.modulemap.in --- a/libcxx/include/module.modulemap.in +++ b/libcxx/include/module.modulemap.in @@ -766,6 +766,12 @@ header "istream" // FIXME: should re-export ios, streambuf? export * + + module __istream { + module basic_iostream { private header "__istream/basic_iostream.h" } + module basic_istream { private header "__istream/basic_istream.h" } + module basic_istream_def { private header "__istream/basic_istream_def.h" } + } } module iterator { header "iterator" diff --git a/libcxx/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.fail.cpp b/libcxx/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.fail.cpp --- a/libcxx/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.fail.cpp +++ b/libcxx/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.fail.cpp @@ -30,8 +30,8 @@ // expected-error@fstream:* {{only virtual member functions can be marked 'override'}} // expected-error@fstream:* {{only virtual member functions can be marked 'override'}} // expected-error@fstream:* {{only virtual member functions can be marked 'override'}} -// expected-error@istream:* {{only virtual member functions can be marked 'override'}} -// expected-error@istream:* {{only virtual member functions can be marked 'override'}} +// expected-error@__istream/basic_istream.h:* {{only virtual member functions can be marked 'override'}} +// expected-error@__istream/basic_iostream.h:* {{only virtual member functions can be marked 'override'}} // FIXME: As of commit r324062 Clang incorrectly generates a diagnostic about mismatching // exception specifications for types which are already invalid for one reason or another. diff --git a/libcxx/test/libcxx/input.output/iostream.format/input.streams/traits_mismatch.fail.cpp b/libcxx/test/libcxx/input.output/iostream.format/input.streams/traits_mismatch.fail.cpp --- a/libcxx/test/libcxx/input.output/iostream.format/input.streams/traits_mismatch.fail.cpp +++ b/libcxx/test/libcxx/input.output/iostream.format/input.streams/traits_mismatch.fail.cpp @@ -26,7 +26,7 @@ int main(int, char**) { // expected-error-re@ios:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}} -// expected-error@istream:* {{only virtual member functions can be marked 'override'}} +// expected-error@__istream/basic_istream.h:* {{only virtual member functions can be marked 'override'}} return 0; } diff --git a/libcxx/test/libcxx/private_headers.verify.cpp b/libcxx/test/libcxx/private_headers.verify.cpp --- a/libcxx/test/libcxx/private_headers.verify.cpp +++ b/libcxx/test/libcxx/private_headers.verify.cpp @@ -377,6 +377,9 @@ #include <__fwd/string_view.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/string_view.h'}} #include <__fwd/tuple.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/tuple.h'}} #include <__ios/fpos.h> // expected-error@*:* {{use of private header from outside its module: '__ios/fpos.h'}} +#include <__istream/basic_iostream.h> // expected-error@*:* {{use of private header from outside its module: '__istream/basic_iostream.h'}} +#include <__istream/basic_istream.h> // expected-error@*:* {{use of private header from outside its module: '__istream/basic_istream.h'}} +#include <__istream/basic_istream_def.h> // expected-error@*:* {{use of private header from outside its module: '__istream/basic_istream_def.h'}} #include <__iterator/access.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/access.h'}} #include <__iterator/advance.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/advance.h'}} #include <__iterator/back_insert_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/back_insert_iterator.h'}}