[libcxx] Move the private header __std_stream into the src subdir

[mstorsjo]

Summary

This header isn't used by any public header, so there shouldn't
be any need to install it or treat it as a heder.

Once it's part of the src subdirectory, I guess one could consider
giving it a more traditional name too.

[philnik]

Thanks!

libcxx/include/CMakeLists.txt

set(files
   __ranges/subrange.h
   __ranges/take_view.h
   __ranges/take_while_view.h
   __ranges/transform_view.h
   __ranges/view_interface.h
   __ranges/views.h
   __ranges/zip_view.h
   __split_buffer
-  __std_stream
   __string/char_traits.h
   __string/constexpr_c_functions.h
   __string/extern_template_lists.h
   __support/android/locale_bionic.h
   __support/fuchsia/xlocale.h
   __support/ibm/gettod_zos.h
   __support/ibm/locale_mgmt_zos.h
   __support/ibm/nanosleep.h

libcxx/include/libcxx.imp

 [
   { include: [ "<__hash_table>", "private", "<unordered_map>", "public" ] },
   { include: [ "<__hash_table>", "private", "<unordered_set>", "public" ] },
   { include: [ "<__locale>", "private", "<locale>", "public" ] },
   { include: [ "<__node_handle>", "private", "<map>", "public" ] },
   { include: [ "<__node_handle>", "private", "<set>", "public" ] },
   { include: [ "<__node_handle>", "private", "<unordered_map>", "public" ] },
   { include: [ "<__node_handle>", "private", "<unordered_set>", "public" ] },
   { include: [ "<__split_buffer>", "private", "<deque>", "public" ] },
   { include: [ "<__split_buffer>", "private", "<vector>", "public" ] },
-  { include: [ "<__std_stream>", "private", "<iostream>", "public" ] },
   { include: [ "<__threading_support>", "private", "<atomic>", "public" ] },
   { include: [ "<__threading_support>", "private", "<mutex>", "public" ] },
   { include: [ "<__threading_support>", "private", "<semaphore>", "public" ] },
   { include: [ "<__threading_support>", "private", "<thread>", "public" ] },
   { include: [ "<__tree>", "private", "<map>", "public" ] },
   { include: [ "<__tree>", "private", "<set>", "public" ] },
   { include: [ "@<__algorithm/.*>", "private", "<algorithm>", "public" ] },
   { include: [ "@<__atomic/.*>", "private", "<atomic>", "public" ] },

libcxx/include/module.modulemap.in

   module __hash_table        {         header "__hash_table"        export * }
   module __locale            {
     @requires_LIBCXX_ENABLE_LOCALIZATION@
     private header "__locale" export *
   }
   module __mbstate_t         { private header "__mbstate_t.h"       export * }
   module __node_handle       { private header "__node_handle"       export * }
   module __split_buffer      { private header "__split_buffer"      export * }
-  module __std_stream        {
-    @requires_LIBCXX_ENABLE_LOCALIZATION@
-    private header "__std_stream" export *
-  }
   module __threading_support {         header "__threading_support" export * }
   module __tree              {         header "__tree"              export * }
   module __undef_macros      {         header "__undef_macros"      export * }
   module __verbose_abort     {         header "__verbose_abort"     export * }
 
   module experimental {
     requires cplusplus11
 

libcxx/src/__std_stream

 // -*- 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___STD_STREAM
 #define _LIBCPP___STD_STREAM
 
 #include <__config>
 #include <__locale>
 #include <cstdio>
 #include <istream>
 #include <ostream>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 static const int __limit = 8;
 
 // __stdinbuf
 
 template <class _CharT>
 class _LIBCPP_HIDDEN __stdinbuf
     : public basic_streambuf<_CharT, char_traits<_CharT> >
 {
 public:
     typedef _CharT                           char_type;
     typedef char_traits<char_type>           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;
     typedef typename traits_type::state_type state_type;
 
     __stdinbuf(FILE* __fp, state_type* __st);
 
 protected:
     virtual int_type underflow();
     virtual int_type uflow();
     virtual int_type pbackfail(int_type __c = traits_type::eof());
     virtual void imbue(const locale& __loc);
 
 private:
 
     FILE* __file_;
     const codecvt<char_type, char, state_type>* __cv_;
     state_type* __st_;
     int __encoding_;
     int_type __last_consumed_;
     bool __last_consumed_is_next_;
     bool __always_noconv_;
 
     __stdinbuf(const __stdinbuf&);
     __stdinbuf& operator=(const __stdinbuf&);
 
     int_type __getchar(bool __consume);
 };
 
 template <class _CharT>
 __stdinbuf<_CharT>::__stdinbuf(FILE* __fp, state_type* __st)
     : __file_(__fp),
       __st_(__st),
       __last_consumed_(traits_type::eof()),
       __last_consumed_is_next_(false)
 {
     imbue(this->getloc());
 }
 
 template <class _CharT>
 void
 __stdinbuf<_CharT>::imbue(const locale& __loc)
 {
     __cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc);
     __encoding_ = __cv_->encoding();
     __always_noconv_ = __cv_->always_noconv();
     if (__encoding_ > __limit)
         __throw_runtime_error("unsupported locale for standard input");
 }
 
 template <class _CharT>
 typename __stdinbuf<_CharT>::int_type
 __stdinbuf<_CharT>::underflow()
 {
     return __getchar(false);
 }
 
 template <class _CharT>
 typename __stdinbuf<_CharT>::int_type
 __stdinbuf<_CharT>::uflow()
 {
     return __getchar(true);
 }
 
 template <class _CharT>
 typename __stdinbuf<_CharT>::int_type
 __stdinbuf<_CharT>::__getchar(bool __consume)
 {
     if (__last_consumed_is_next_)
     {
         int_type __result = __last_consumed_;
         if (__consume)
         {
             __last_consumed_ = traits_type::eof();
             __last_consumed_is_next_ = false;
         }
         return __result;
     }
     char __extbuf[__limit];
     int __nread = _VSTD::max(1, __encoding_);
     for (int __i = 0; __i < __nread; ++__i)
     {
         int __c = getc(__file_);
         if (__c == EOF)
             return traits_type::eof();
         __extbuf[__i] = static_cast<char>(__c);
     }
     char_type __1buf;
     if (__always_noconv_)
         __1buf = static_cast<char_type>(__extbuf[0]);
     else
     {
         const char* __enxt;
         char_type* __inxt;
         codecvt_base::result __r;
         do
         {
             state_type __sv_st = *__st_;
             __r = __cv_->in(*__st_, __extbuf, __extbuf + __nread, __enxt,
                                    &__1buf, &__1buf + 1, __inxt);
             switch (__r)
             {
             case _VSTD::codecvt_base::ok:
                 break;
             case codecvt_base::partial:
                 *__st_ = __sv_st;
                 if (__nread == sizeof(__extbuf))
                     return traits_type::eof();
                 {
                     int __c = getc(__file_);
                     if (__c == EOF)
                         return traits_type::eof();
                     __extbuf[__nread] = static_cast<char>(__c);
                 }
                 ++__nread;
                 break;
             case codecvt_base::error:
                 return traits_type::eof();
             case _VSTD::codecvt_base::noconv:
                 __1buf = static_cast<char_type>(__extbuf[0]);
                 break;
             }
         } while (__r == _VSTD::codecvt_base::partial);
     }
     if (!__consume)
     {
         for (int __i = __nread; __i > 0;)
         {
             if (ungetc(traits_type::to_int_type(__extbuf[--__i]), __file_) == EOF)
                 return traits_type::eof();
         }
     }
     else
         __last_consumed_ = traits_type::to_int_type(__1buf);
     return traits_type::to_int_type(__1buf);
 }
 
 template <class _CharT>
 typename __stdinbuf<_CharT>::int_type
 __stdinbuf<_CharT>::pbackfail(int_type __c)
 {
     if (traits_type::eq_int_type(__c, traits_type::eof()))
     {
         if (!__last_consumed_is_next_)
         {
             __c = __last_consumed_;
             __last_consumed_is_next_ = !traits_type::eq_int_type(__last_consumed_,
                                                                  traits_type::eof());
         }
         return __c;
     }
     if (__last_consumed_is_next_)
     {
         char __extbuf[__limit];
         char* __enxt;
         const char_type __ci = traits_type::to_char_type(__last_consumed_);
         const char_type* __inxt;
         switch (__cv_->out(*__st_, &__ci, &__ci + 1, __inxt,
                                   __extbuf, __extbuf + sizeof(__extbuf), __enxt))
         {
         case _VSTD::codecvt_base::ok:
             break;
         case _VSTD::codecvt_base::noconv:
             __extbuf[0] = static_cast<char>(__last_consumed_);
             __enxt = __extbuf + 1;
             break;
         case codecvt_base::partial:
         case codecvt_base::error:
             return traits_type::eof();
         }
         while (__enxt > __extbuf)
             if (ungetc(*--__enxt, __file_) == EOF)
                 return traits_type::eof();
     }
     __last_consumed_ = __c;
     __last_consumed_is_next_ = true;
     return __c;
 }
 
 // __stdoutbuf
 
 template <class _CharT>
 class _LIBCPP_HIDDEN __stdoutbuf
     : public basic_streambuf<_CharT, char_traits<_CharT> >
 {
 public:
     typedef _CharT                           char_type;
     typedef char_traits<char_type>           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;
     typedef typename traits_type::state_type state_type;
 
     __stdoutbuf(FILE* __fp, state_type* __st);
 
 protected:
     virtual int_type overflow (int_type __c = traits_type::eof());
     virtual streamsize xsputn(const char_type* __s, streamsize __n);
     virtual int sync();
     virtual void imbue(const locale& __loc);
 
 private:
     FILE* __file_;
     const codecvt<char_type, char, state_type>* __cv_;
     state_type* __st_;
     bool __always_noconv_;
 
     __stdoutbuf(const __stdoutbuf&);
     __stdoutbuf& operator=(const __stdoutbuf&);
 };
 
 template <class _CharT>
 __stdoutbuf<_CharT>::__stdoutbuf(FILE* __fp, state_type* __st)
     : __file_(__fp),
       __cv_(&use_facet<codecvt<char_type, char, state_type> >(this->getloc())),
       __st_(__st),
       __always_noconv_(__cv_->always_noconv())
 {
 }
 
 template <class _CharT>
 typename __stdoutbuf<_CharT>::int_type
 __stdoutbuf<_CharT>::overflow(int_type __c)
 {
     char __extbuf[__limit];
     char_type __1buf;
     if (!traits_type::eq_int_type(__c, traits_type::eof()))
     {
         __1buf = traits_type::to_char_type(__c);
         if (__always_noconv_)
         {
             if (fwrite(&__1buf, sizeof(char_type), 1, __file_) != 1)
                 return traits_type::eof();
         }
         else
         {
             char* __extbe = __extbuf;
             codecvt_base::result __r;
             char_type* pbase = &__1buf;
             char_type* pptr = pbase + 1;
             do
             {
                 const char_type* __e;
                 __r = __cv_->out(*__st_, pbase, pptr, __e,
                                         __extbuf,
                                         __extbuf + sizeof(__extbuf),
                                         __extbe);
                 if (__e == pbase)
                     return traits_type::eof();
                 if (__r == codecvt_base::noconv)
                 {
                     if (fwrite(pbase, 1, 1, __file_) != 1)
                         return traits_type::eof();
                 }
                 else if (__r == codecvt_base::ok || __r == codecvt_base::partial)
                 {
                     size_t __nmemb = static_cast<size_t>(__extbe - __extbuf);
                     if (fwrite(__extbuf, 1, __nmemb, __file_) != __nmemb)
                         return traits_type::eof();
                     if (__r == codecvt_base::partial)
                     {
                         pbase = const_cast<char_type*>(__e);
                     }
                 }
                 else
                     return traits_type::eof();
             } while (__r == codecvt_base::partial);
         }
     }
     return traits_type::not_eof(__c);
 }
 
 template <class _CharT>
 streamsize
 __stdoutbuf<_CharT>::xsputn(const char_type* __s, streamsize __n)
 {
     if (__always_noconv_)
         return fwrite(__s, sizeof(char_type), __n, __file_);
     streamsize __i = 0;
     for (; __i < __n; ++__i, ++__s)
         if (overflow(traits_type::to_int_type(*__s)) == traits_type::eof())
             break;
     return __i;
 }
 
 template <class _CharT>
 int
 __stdoutbuf<_CharT>::sync()
 {
     char __extbuf[__limit];
     codecvt_base::result __r;
     do
     {
         char* __extbe;
         __r = __cv_->unshift(*__st_, __extbuf,
                                     __extbuf + sizeof(__extbuf),
                                     __extbe);
         size_t __nmemb = static_cast<size_t>(__extbe - __extbuf);
         if (fwrite(__extbuf, 1, __nmemb, __file_) != __nmemb)
             return -1;
     } while (__r == codecvt_base::partial);
     if (__r == codecvt_base::error)
         return -1;
     if (fflush(__file_))
         return -1;
     return 0;
 }
 
 template <class _CharT>
 void
 __stdoutbuf<_CharT>::imbue(const locale& __loc)
 {
     sync();
     __cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc);
     __always_noconv_ = __cv_->always_noconv();
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___STD_STREAM

libcxx/src/iostream.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include <__locale>
-#include <__std_stream>
+#include "__std_stream"
 #include <new>
 #include <string>
 
 #define _str(s) #s
 #define str(s) _str(s)
 #define _LIBCPP_ABI_NAMESPACE_STR str(_LIBCPP_ABI_NAMESPACE)
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__ranges/subrange.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/subrange.h'}}
 #include <__ranges/take_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/take_view.h'}}
 #include <__ranges/take_while_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/take_while_view.h'}}
 #include <__ranges/transform_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/transform_view.h'}}
 #include <__ranges/view_interface.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/view_interface.h'}}
 #include <__ranges/views.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/views.h'}}
 #include <__ranges/zip_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/zip_view.h'}}
 #include <__split_buffer> // expected-error@*:* {{use of private header from outside its module: '__split_buffer'}}
-#include <__std_stream> // expected-error@*:* {{use of private header from outside its module: '__std_stream'}}
 #include <__string/char_traits.h> // expected-error@*:* {{use of private header from outside its module: '__string/char_traits.h'}}
 #include <__string/constexpr_c_functions.h> // expected-error@*:* {{use of private header from outside its module: '__string/constexpr_c_functions.h'}}
 #include <__string/extern_template_lists.h> // expected-error@*:* {{use of private header from outside its module: '__string/extern_template_lists.h'}}
 #include <__thread/poll_with_backoff.h> // expected-error@*:* {{use of private header from outside its module: '__thread/poll_with_backoff.h'}}
 #include <__thread/timed_backoff_policy.h> // expected-error@*:* {{use of private header from outside its module: '__thread/timed_backoff_policy.h'}}
 #include <__tuple_dir/apply_cv.h> // expected-error@*:* {{use of private header from outside its module: '__tuple_dir/apply_cv.h'}}
 #include <__tuple_dir/make_tuple_types.h> // expected-error@*:* {{use of private header from outside its module: '__tuple_dir/make_tuple_types.h'}}
 #include <__tuple_dir/pair_like.h> // expected-error@*:* {{use of private header from outside its module: '__tuple_dir/pair_like.h'}}

libcxx/utils/data/ignore_format.txt

 libcxx/include/stack
 libcxx/include/stdatomic.h
 libcxx/include/stdbool.h
 libcxx/include/stddef.h
 libcxx/include/stdexcept
 libcxx/include/stdint.h
 libcxx/include/stdio.h
 libcxx/include/stdlib.h
-libcxx/include/__std_stream
 libcxx/include/streambuf
 libcxx/include/string
 libcxx/include/__string/char_traits.h
 libcxx/include/__string/extern_template_lists.h
 libcxx/include/string.h
 libcxx/include/string_view
 libcxx/include/strstream
 libcxx/include/__support/android/locale_bionic.h

 libcxx/src/mutex_destructor.cpp
 libcxx/src/new.cpp
 libcxx/src/optional.cpp
 libcxx/src/random.cpp
 libcxx/src/random_shuffle.cpp
 libcxx/src/regex.cpp
 libcxx/src/shared_mutex.cpp
 libcxx/src/stdexcept.cpp
+libcxx/src/__std_stream
 libcxx/src/string.cpp
 libcxx/src/strstream.cpp
 libcxx/src/support/ibm/mbsnrtowcs.cpp
 libcxx/src/support/ibm/wcsnrtombs.cpp
 libcxx/src/support/ibm/xlocale_zos.cpp
 libcxx/src/support/runtime/exception_fallback.ipp
 libcxx/src/support/runtime/exception_glibcxx.ipp
 libcxx/src/support/runtime/exception_libcxxabi.ipp

libcxx/utils/generate_iwyu_mapping.py

for i in detail_files:
         elif i == '__debug': continue
         elif i == '__errc': continue
         elif i == '__hash_table': public = ['unordered_map', 'unordered_set']
         elif i == '__locale': public = ['locale']
         elif i == '__mbstate_t.h': continue
         elif i == '__mutex_base': continue
         elif i == '__node_handle': public = ['map', 'set', 'unordered_map', 'unordered_set']
         elif i == '__split_buffer': public = ['deque', 'vector']
-        elif i == '__std_stream': public = ['iostream']
         elif i == '__threading_support': public = ['atomic', 'mutex', 'semaphore', 'thread']
         elif i == '__tree': public = ['map', 'set']
         elif i == '__undef_macros': continue
         elif i == '__verbose_abort': continue
         else: panic()
 
         for p in public:
             result.append(f'{generate(f"<{i}>", p)},')