[libc++] split `<istream>` header

[huixie90]

Summary

<istream> defines basic_istream and basic_iostream. The basic_iostream brings all the dependencies to <ostream>.
While implementing <ranges>'s std::views::istream, we need the declaration of basic_istream and all its member >> and free >>,
because the concept checks the validity of >>. To avoid adding too many dependencies to <ranges>, it would be good idea to split
basic_istream and basic_iostream. Also, we only need the declarations of >> to pass the concept check, we don't need the extra
dependencies coming from the implementations, namely <locale> and its indirect dependencies (__locale isn't enough). Luckily, the basic_istream's member definition is out of line, so there is not much work to do
other than split the files. Also there is not much SFINAE going so keeping declaration and definition separate won't cause too much code duplication

[huixie90]

CI

[huixie90]

ci

[huixie90]

CI

[ldionne]

The approach we generally take is to create a libcxx/include/__fwd/foo.h header. Would that work here?

libcxx/include/__istream/basic_iostream.h

267

No newline! Please add one!

[huixie90]

In D133560#3796745, @ldionne wrote:

The approach we generally take is to create a libcxx/include/__fwd/foo.h header. Would that work here?

Do you mean by creating a header that only contains the forward declaration like

template <class _Chart>
class basic_istream;

But the std::ranges::istream_view class itself has a constraint that >> needs to be valid

template <class _Val, class _CharT, class _Traits>
concept __stream_extractable = requires(basic_istream<_CharT, _Traits>& __is, _Val& __t) { __is >> __t; };

template <movable _Val, class _CharT, class _Traits = char_traits<_CharT>>
  requires default_initializable<_Val> && __stream_extractable<_Val, _CharT, _Traits>
class basic_istream_view;

That means the declaration of basic_istream_view already requires all the member >> and free >> from the basic_istream. So only a forward declaration of basic_istream isn't enough.

And this is the main reason I made the basic_istream.h header contains all the >> declarations.

[ldionne]

I think this can be pretty much abandoned and the forward declaration of basic_istream folded into the istream_view patch itself.

libcxx/include/__istream/basic_istream.h

2

In light of the survey of other implementations we just did during live review (https://godbolt.org/z/G6EbqvY57), I suggest we:

1. Add a __fwd/basic_istream.h header that forward declares the class itself, but nothing else.
2. Include __fwd/basic_istream.h from istream_view.h, but not all of iostream or even a clever subset of it.

The result will be that users can't use istream_view without including <istream> themselves, however that's what other implementations do. And the alternative would be to pull in large parts of iostream and the localization library, and that's unacceptable.

libcxx/include/CMakeLists.txt

set(files
   __fwd/get.h
   __fwd/hash.h
   __fwd/pair.h
   __fwd/span.h
   __fwd/string_view.h
   __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
   __iterator/bounded_iter.h
   __iterator/common_iterator.h
   __iterator/concepts.h
   __iterator/counted_iterator.h
   __iterator/data.h

libcxx/include/__istream/basic_iostream.h

+//===----------------------------------------------------------------------===//
+//
+// 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 <ostream>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _CharT, class _Traits>
+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<char_type, traits_type>* __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<char_type, traits_type>::swap(__rhs); }
+};
+
+template <class _CharT, class _Traits>
+basic_iostream<_CharT, _Traits>::basic_iostream(basic_iostream&& __rhs)
+    : basic_istream<_CharT, _Traits>(_VSTD::move(__rhs))
+{
+}
+
+template <class _CharT, class _Traits>
+basic_iostream<_CharT, _Traits>&
+basic_iostream<_CharT, _Traits>::operator=(basic_iostream&& __rhs)
+{
+    swap(__rhs);
+    return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_iostream<_CharT, _Traits>::~basic_iostream()
+{
+}
+
+template<class _CharT, class _Traits, class _Allocator>
+_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<streamsize>::max();
+            streamsize __c = 0;
+            const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__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<class _CharT, class _Traits, class _Allocator>
+_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<class _CharT, class _Traits, class _Allocator>
+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<class _CharT, class _Traits, class _Allocator>
+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<class _CharT, class _Traits, class _Allocator>
+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 <class _CharT, class _Traits, size_t _Size>
+_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<ctype<_CharT> >(__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<char>;
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ISTREAM_BASIC_IOSTREAM_H
 No newline at end of file

libcxx/include/__istream/basic_istream.h

+//===----------------------------------------------------------------------===//
+//
+// 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 <ios>
+
+#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 _CharT, class _Traits>
+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<char_type, traits_type>* __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<char_type, traits_type>::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<char_type, traits_type>&
+                              (*__pf)(basic_ios<char_type, traits_type>&))
+    { __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<char_type, traits_type>* __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<char_type, traits_type>& __sb)
+    { return get(__sb, this->widen('\n')); }
+
+    basic_istream& get(basic_streambuf<char_type, traits_type>& __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 _CharT, class _Traits>
+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<class _CharT, class _Traits, size_t _Np>
+inline _LIBCPP_INLINE_VISIBILITY
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is, _CharT (&__buf)[_Np]);
+
+template<class _Traits, size_t _Np>
+inline _LIBCPP_INLINE_VISIBILITY
+basic_istream<char, _Traits>&
+operator>>(basic_istream<char, _Traits>& __is, unsigned char (&__buf)[_Np]);
+
+template<class _Traits, size_t _Np>
+inline _LIBCPP_INLINE_VISIBILITY
+basic_istream<char, _Traits>&
+operator>>(basic_istream<char, _Traits>& __is, signed char (&__buf)[_Np]);
+
+#else
+
+template<class _CharT, class _Traits>
+inline _LIBCPP_INLINE_VISIBILITY
+basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is, _CharT* __s);
+
+template<class _Traits>
+inline _LIBCPP_INLINE_VISIBILITY
+basic_istream<char, _Traits>&
+operator>>(basic_istream<char, _Traits>& __is, unsigned char* __s);
+
+template<class _Traits>
+inline _LIBCPP_INLINE_VISIBILITY
+basic_istream<char, _Traits>&
+operator>>(basic_istream<char, _Traits>& __is, signed char* __s);
+#endif // _LIBCPP_STD_VER > 17
+
+template<class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is, _CharT& __c);
+
+template<class _Traits>
+inline _LIBCPP_INLINE_VISIBILITY
+basic_istream<char, _Traits>&
+operator>>(basic_istream<char, _Traits>& __is, unsigned char& __c);
+
+template<class _Traits>
+inline _LIBCPP_INLINE_VISIBILITY
+basic_istream<char, _Traits>&
+operator>>(basic_istream<char, _Traits>& __is, signed char& __c);
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
+ws(basic_istream<_CharT, _Traits>& __is);
+
+template <class _Stream, class _Tp, class = void>
+struct __is_istreamable : false_type { };
+
+template <class _Stream, class _Tp>
+struct __is_istreamable<_Stream, _Tp, decltype(
+    declval<_Stream>() >> declval<_Tp>(), void()
+)> : true_type { };
+
+template <class _Stream, class _Tp, class = typename enable_if<
+    _And<is_base_of<ios_base, _Stream>,
+         __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

libcxx/include/__istream/basic_istream_def.h

-// -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
-#define _LIBCPP_ISTREAM
+#ifndef _LIBCPP___ISTREAM_BASIC_ISTREAM_DEF_H
+#define _LIBCPP___ISTREAM_BASIC_ISTREAM_DEF_H
 
-/*
-    istream synopsis
-
-template <class charT, class traits = char_traits<charT> >
-class basic_istream
-    : virtual public basic_ios<charT,traits>
-{
-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<char_type, traits_type>* 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<char_type, traits_type>&
-                              (*pf)(basic_ios<char_type, traits_type>&));
-    basic_istream& operator>>(ios_base& (*pf)(ios_base&));
-    basic_istream& operator>>(basic_streambuf<char_type, traits_type>* 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<char_type,traits_type>& sb);
-    basic_istream& get(basic_streambuf<char_type,traits_type>& 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<class charT, class traits>
-  basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>&, charT&);
-
-template<class traits>
-  basic_istream<char,traits>& operator>>(basic_istream<char,traits>&, unsigned char&);
-
-template<class traits>
-  basic_istream<char,traits>& operator>>(basic_istream<char,traits>&, signed char&);
-
-template<class charT, class traits>
-  basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>&, charT*);
-
-template<class traits>
-  basic_istream<char,traits>& operator>>(basic_istream<char,traits>&, unsigned char*);
-
-template<class traits>
-  basic_istream<char,traits>& operator>>(basic_istream<char,traits>&, signed char*);
-
-template <class charT, class traits>
-  void
-  swap(basic_istream<charT, traits>& x, basic_istream<charT, traits>& y);
-
-typedef basic_istream<char> istream;
-typedef basic_istream<wchar_t> wistream;
-
-template <class charT, class traits = char_traits<charT> >
-class 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
-    explicit basic_iostream(basic_streambuf<char_type, traits_type>* sb);
-    basic_iostream(basic_iostream&& rhs);
-    virtual ~basic_iostream();
-
-    // assign/swap
-    basic_iostream& operator=(basic_iostream&& rhs);
-    void swap(basic_iostream& rhs);
-};
-
-template <class charT, class traits>
-  void
-  swap(basic_iostream<charT, traits>& x, basic_iostream<charT, traits>& y);
-
-typedef basic_iostream<char> iostream;
-typedef basic_iostream<wchar_t> wiostream;
-
-template <class charT, class traits>
-  basic_istream<charT,traits>&
-  ws(basic_istream<charT,traits>& is);
-
-// rvalue stream extraction
-template <class Stream, class T>
-  Stream&& operator>>(Stream&& is, T&& x);
-
-}  // std
-
-*/
-
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__iterator/istreambuf_iterator.h>
-#include <__utility/forward.h>
-#include <ostream>
-#include <version>
+#include <__istream/basic_istream.h>
+#include <locale>
 
 #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 _CharT, class _Traits>
-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<char_type, traits_type>* __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<char_type, traits_type>::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<char_type, traits_type>&
-                              (*__pf)(basic_ios<char_type, traits_type>&))
-    { __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<char_type, traits_type>* __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<char_type, traits_type>& __sb)
-    { return get(__sb, this->widen('\n')); }
-
-    basic_istream& get(basic_streambuf<char_type, traits_type>& __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 _CharT, class _Traits>
-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 <class _CharT, class _Traits>
 basic_istream<_CharT, _Traits>::sentry::sentry(basic_istream<_CharT, _Traits>& __is,
                                                bool __noskipws)
     : __ok_(false)
 {
     if (__is.good())
     {
         if (__is.tie())
             __is.tie()->flush();
#ifndef _LIBCPP_NO_EXCEPTIONS
             }
         }
 #endif // _LIBCPP_NO_EXCEPTIONS
         __is.setstate(__state);
     }
     return __is;
 }
 
-template <class _Stream, class _Tp, class = void>
-struct __is_istreamable : false_type { };
-
-template <class _Stream, class _Tp>
-struct __is_istreamable<_Stream, _Tp, decltype(
-    declval<_Stream>() >> declval<_Tp>(), void()
-)> : true_type { };
-
-template <class _Stream, class _Tp, class = typename enable_if<
-    _And<is_base_of<ios_base, _Stream>,
-         __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 _CharT, class _Traits>
-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<char_type, traits_type>* __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<char_type, traits_type>::swap(__rhs); }
-};
-
-template <class _CharT, class _Traits>
-basic_iostream<_CharT, _Traits>::basic_iostream(basic_iostream&& __rhs)
-    : basic_istream<_CharT, _Traits>(_VSTD::move(__rhs))
-{
-}
-
-template <class _CharT, class _Traits>
-basic_iostream<_CharT, _Traits>&
-basic_iostream<_CharT, _Traits>::operator=(basic_iostream&& __rhs)
-{
-    swap(__rhs);
-    return *this;
-}
-
-template <class _CharT, class _Traits>
-basic_iostream<_CharT, _Traits>::~basic_iostream()
-{
-}
-
-template<class _CharT, class _Traits, class _Allocator>
-_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<streamsize>::max();
-            streamsize __c = 0;
-            const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__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<class _CharT, class _Traits, class _Allocator>
-_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<class _CharT, class _Traits, class _Allocator>
-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<class _CharT, class _Traits, class _Allocator>
-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<class _CharT, class _Traits, class _Allocator>
-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 <class _CharT, class _Traits, size_t _Size>
-_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<ctype<_CharT> >(__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<char>;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_istream<wchar_t>;
 #endif
-extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_iostream<char>;
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
-#endif // _LIBCPP_ISTREAM
+#endif // _LIBCPP___ISTREAM_BASIC_ISTREAM_DEF_H

libcxx/include/istream

 template <class Stream, class T>
   Stream&& operator>>(Stream&& is, T&& x);
 
 }  // std
 
 */
 
 #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 <ostream>
 #include <version>
 
-#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 _CharT, class _Traits>
-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<char_type, traits_type>* __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<char_type, traits_type>::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<char_type, traits_type>&
-                              (*__pf)(basic_ios<char_type, traits_type>&))
-    { __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<char_type, traits_type>* __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<char_type, traits_type>& __sb)
-    { return get(__sb, this->widen('\n')); }
-
-    basic_istream& get(basic_streambuf<char_type, traits_type>& __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 _CharT, class _Traits>
-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 <class _CharT, class _Traits>
-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<ctype<_CharT> >(__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 <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>::basic_istream(basic_istream&& __rhs)
-    : __gc_(__rhs.__gc_)
-{
-    __rhs.__gc_ = 0;
-    this->move(__rhs);
-}
-
-template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator=(basic_istream&& __rhs)
-{
-    swap(__rhs);
-    return *this;
-}
-
-template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>::~basic_istream()
-{
-}
-
-template <class _Tp, class _CharT, class _Traits>
-_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 <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(unsigned short& __n)
-{
-    return _VSTD::__input_arithmetic<unsigned short>(*this, __n);
-}
-
-template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(unsigned int& __n)
-{
-    return _VSTD::__input_arithmetic<unsigned int>(*this, __n);
-}
-
-template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(long& __n)
-{
-    return _VSTD::__input_arithmetic<long>(*this, __n);
-}
-
-template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(unsigned long& __n)
-{
-    return _VSTD::__input_arithmetic<unsigned long>(*this, __n);
-}
-
-template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(long long& __n)
-{
-    return _VSTD::__input_arithmetic<long long>(*this, __n);
-}
-
-template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(unsigned long long& __n)
-{
-    return _VSTD::__input_arithmetic<unsigned long long>(*this, __n);
-}
-
-template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(float& __n)
-{
-    return _VSTD::__input_arithmetic<float>(*this, __n);
-}
-
-template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(double& __n)
-{
-    return _VSTD::__input_arithmetic<double>(*this, __n);
-}
-
-template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(long double& __n)
-{
-    return _VSTD::__input_arithmetic<long double>(*this, __n);
-}
-
-template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(bool& __n)
-{
-    return _VSTD::__input_arithmetic<bool>(*this, __n);
-}
-
-template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(void*& __n)
-{
-    return _VSTD::__input_arithmetic<void*>(*this, __n);
-}
-
-template <class _Tp, class _CharT, class _Traits>
-_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 <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(short& __n)
-{
-    return _VSTD::__input_arithmetic_with_numeric_limits<short>(*this, __n);
-}
-
-template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(int& __n)
-{
-    return _VSTD::__input_arithmetic_with_numeric_limits<int>(*this, __n);
-}
-
-template<class _CharT, class _Traits>
-_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<ctype<_CharT> >(__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<class _CharT, class _Traits, size_t _Np>
-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<class _Traits, size_t _Np>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<char, _Traits>&
-operator>>(basic_istream<char, _Traits>& __is, unsigned char (&__buf)[_Np])
-{
-    return __is >> (char(&)[_Np])__buf;
-}
-
-template<class _Traits, size_t _Np>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<char, _Traits>&
-operator>>(basic_istream<char, _Traits>& __is, signed char (&__buf)[_Np])
-{
-    return __is >> (char(&)[_Np])__buf;
-}
-
-#else
-
-template<class _CharT, class _Traits>
-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<streamsize>::max() / sizeof(_CharT) - 1;
-    return _VSTD::__input_c_string(__is, __s, size_t(__n));
-}
-
-template<class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<char, _Traits>&
-operator>>(basic_istream<char, _Traits>& __is, unsigned char* __s)
-{
-    return __is >> (char*)__s;
-}
-
-template<class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<char, _Traits>&
-operator>>(basic_istream<char, _Traits>& __is, signed char* __s)
-{
-    return __is >> (char*)__s;
-}
-
-#endif // _LIBCPP_STD_VER > 17
-
-template<class _CharT, class _Traits>
-_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<class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<char, _Traits>&
-operator>>(basic_istream<char, _Traits>& __is, unsigned char& __c)
-{
-    return __is >> (char&)__c;
-}
-
-template<class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<char, _Traits>&
-operator>>(basic_istream<char, _Traits>& __is, signed char& __c)
-{
-    return __is >> (char&)__c;
-}
-
-template<class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(basic_streambuf<char_type, traits_type>* __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<class _CharT, class _Traits>
-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<class _CharT, class _Traits>
-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<class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::get(basic_streambuf<char_type, traits_type>& __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<class _CharT, class _Traits>
-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<class _CharT, class _Traits>
-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<streamsize>::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<class _CharT, class _Traits>
-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<class _CharT, class _Traits>
-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<class _CharT, class _Traits>
-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<class _CharT, class _Traits>
-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<class _CharT, class _Traits>
-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<class _CharT, class _Traits>
-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<class _CharT, class _Traits>
-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<class _CharT, class _Traits>
-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<class _CharT, class _Traits>
-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 <class _CharT, class _Traits>
-_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<ctype<_CharT> >(__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 <class _Stream, class _Tp, class = void>
-struct __is_istreamable : false_type { };
-
-template <class _Stream, class _Tp>
-struct __is_istreamable<_Stream, _Tp, decltype(
-    declval<_Stream>() >> declval<_Tp>(), void()
-)> : true_type { };
-
-template <class _Stream, class _Tp, class = typename enable_if<
-    _And<is_base_of<ios_base, _Stream>,
-         __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 _CharT, class _Traits>
-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<char_type, traits_type>* __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<char_type, traits_type>::swap(__rhs); }
-};
-
-template <class _CharT, class _Traits>
-basic_iostream<_CharT, _Traits>::basic_iostream(basic_iostream&& __rhs)
-    : basic_istream<_CharT, _Traits>(_VSTD::move(__rhs))
-{
-}
-
-template <class _CharT, class _Traits>
-basic_iostream<_CharT, _Traits>&
-basic_iostream<_CharT, _Traits>::operator=(basic_iostream&& __rhs)
-{
-    swap(__rhs);
-    return *this;
-}
-
-template <class _CharT, class _Traits>
-basic_iostream<_CharT, _Traits>::~basic_iostream()
-{
-}
-
-template<class _CharT, class _Traits, class _Allocator>
-_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<streamsize>::max();
-            streamsize __c = 0;
-            const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__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<class _CharT, class _Traits, class _Allocator>
-_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<class _CharT, class _Traits, class _Allocator>
-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<class _CharT, class _Traits, class _Allocator>
-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<class _CharT, class _Traits, class _Allocator>
-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 <class _CharT, class _Traits, size_t _Size>
-_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<ctype<_CharT> >(__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<char>;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_istream<wchar_t>;
-#endif
-extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_iostream<char>;
-
-_LIBCPP_END_NAMESPACE_STD
-
-_LIBCPP_POP_MACROS
-
-#endif // _LIBCPP_ISTREAM
+#endif // _LIBCPP_ISTREAM

libcxx/include/module.modulemap.in

module iostream {
     export ostream
     export *
   }
   module istream {
     @requires_LIBCXX_ENABLE_LOCALIZATION@
     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"
     export *
 
     module __iterator {
       module access                { private header "__iterator/access.h" }
       module advance               { private header "__iterator/advance.h" }

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__fwd/array.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/array.h'}}
 #include <__fwd/get.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/get.h'}}
 #include <__fwd/hash.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/hash.h'}}
 #include <__fwd/pair.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/pair.h'}}
 #include <__fwd/span.h> // expected-error@*:* {{use of private header from outside its module: '__fwd/span.h'}}
 #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'}}
 #include <__iterator/bounded_iter.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/bounded_iter.h'}}
 #include <__iterator/common_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/common_iterator.h'}}
 #include <__iterator/concepts.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/concepts.h'}}
 #include <__iterator/counted_iterator.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/counted_iterator.h'}}
 #include <__iterator/data.h> // expected-error@*:* {{use of private header from outside its module: '__iterator/data.h'}}