xref: /freebsd/contrib/llvm-project/libcxx/include/ostream (revision b3edf446)

// -*- 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_OSTREAM
#define _LIBCPP_OSTREAM

/*
    ostream synopsis

template <class charT, class traits = char_traits<charT> >
class basic_ostream
    : 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.2.2 Constructor/destructor:
    explicit basic_ostream(basic_streambuf<char_type,traits>* sb);
    basic_ostream(basic_ostream&& rhs);
    virtual ~basic_ostream();

    // 27.7.2.3 Assign/swap
    basic_ostream& operator=(const basic_ostream& rhs) = delete; // C++14
    basic_ostream& operator=(basic_ostream&& rhs);
    void swap(basic_ostream& rhs);

    // 27.7.2.4 Prefix/suffix:
    class sentry;

    // 27.7.2.6 Formatted output:
    basic_ostream& operator<<(basic_ostream& (*pf)(basic_ostream&));
    basic_ostream& operator<<(basic_ios<charT, traits>& (*pf)(basic_ios<charT,traits>&));
    basic_ostream& operator<<(ios_base& (*pf)(ios_base&));
    basic_ostream& operator<<(bool n);
    basic_ostream& operator<<(short n);
    basic_ostream& operator<<(unsigned short n);
    basic_ostream& operator<<(int n);
    basic_ostream& operator<<(unsigned int n);
    basic_ostream& operator<<(long n);
    basic_ostream& operator<<(unsigned long n);
    basic_ostream& operator<<(long long n);
    basic_ostream& operator<<(unsigned long long n);
    basic_ostream& operator<<(float f);
    basic_ostream& operator<<(double f);
    basic_ostream& operator<<(long double f);
    basic_ostream& operator<<(const void* p);
    basic_ostream& operator<<(const volatile void* val); // C++23
    basic_ostream& operator<<(basic_streambuf<char_type,traits>* sb);
    basic_ostream& operator<<(nullptr_t);

    // 27.7.2.7 Unformatted output:
    basic_ostream& put(char_type c);
    basic_ostream& write(const char_type* s, streamsize n);
    basic_ostream& flush();

    // 27.7.2.5 seeks:
    pos_type tellp();
    basic_ostream& seekp(pos_type);
    basic_ostream& seekp(off_type, ios_base::seekdir);
protected:
    basic_ostream(const basic_ostream& rhs) = delete;
    basic_ostream(basic_ostream&& rhs);
    // 27.7.3.3 Assign/swap
    basic_ostream& operator=(basic_ostream& rhs) = delete;
    basic_ostream& operator=(const basic_ostream&& rhs);
    void swap(basic_ostream& rhs);
};

// 27.7.2.6.4 character inserters

template<class charT, class traits>
  basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, charT);

template<class charT, class traits>
  basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, char);

template<class traits>
  basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, char);

// signed and unsigned

template<class traits>
  basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, signed char);

template<class traits>
  basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, unsigned char);

// NTBS
template<class charT, class traits>
  basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, const charT*);

template<class charT, class traits>
  basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, const char*);

template<class traits>
  basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, const char*);

// signed and unsigned
template<class traits>
basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, const signed char*);

template<class traits>
  basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, const unsigned char*);

// swap:
template <class charT, class traits>
  void swap(basic_ostream<charT, traits>& x, basic_ostream<charT, traits>& y);

template <class charT, class traits>
  basic_ostream<charT,traits>& endl(basic_ostream<charT,traits>& os);

template <class charT, class traits>
  basic_ostream<charT,traits>& ends(basic_ostream<charT,traits>& os);

template <class charT, class traits>
  basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os);

// rvalue stream insertion
template <class Stream, class T>
  Stream&& operator<<(Stream&& os, const T& x);

template<class traits>
basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, wchar_t) = delete;               // since C++20
template<class traits>
basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, char8_t) = delete;               // since C++20
template<class traits>
basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, char16_t) = delete;              // since C++20
template<class traits>
basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, char32_t) = delete;              // since C++20
template<class traits>
basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, char8_t) = delete;         // since C++20
template<class traits>
basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, char16_t) = delete;        // since C++20
template<class traits>
basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, char32_t) = delete;        // since C++20
template<class traits>
basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const wchar_t*) = delete;        // since C++20
template<class traits>
basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const char8_t*) = delete;        // since C++20
template<class traits>
basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const char16_t*) = delete;       // since C++20
template<class traits>
basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const char32_t*) = delete;       // since C++20
template<class traits>
basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, const char8_t*) = delete;  // since C++20
template<class traits>
basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, const char16_t*) = delete; // since C++20
template<class traits>
basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, const char32_t*) = delete; // since C++20

// [ostream.formatted.print], print functions
template<class... Args>                                                                                // since C++23
  void print(ostream& os, format_string<Args...> fmt, Args&&... args);
template<class... Args>                                                                                // since C++23
  void println(ostream& os, format_string<Args...> fmt, Args&&... args);

void vprint_unicode(ostream& os, string_view fmt, format_args args);                                   // since C++23
void vprint_nonunicode(ostream& os, string_view fmt, format_args args);                                // since C++23
}  // std

*/

#include <__assert> // all public C++ headers provide the assertion handler
#include <__availability>
#include <__config>
#include <__exception/operations.h>
#include <__fwd/ostream.h>
#include <__memory/shared_ptr.h>
#include <__memory/unique_ptr.h>
#include <__system_error/error_code.h>
#include <__type_traits/conjunction.h>
#include <__type_traits/enable_if.h>
#include <__type_traits/is_base_of.h>
#include <__type_traits/void_t.h>
#include <__utility/declval.h>
#include <bitset>
#include <cstdio>
#include <format>
#include <ios>
#include <locale>
#include <new>
#include <print>
#include <streambuf>
#include <string_view>
#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_ostream : 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.2.2 Constructor/destructor:
  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 explicit basic_ostream(basic_streambuf<char_type, traits_type>* __sb) {
    this->init(__sb);
  }
  ~basic_ostream() override;

protected:
  inline _LIBCPP_HIDE_FROM_ABI basic_ostream(basic_ostream&& __rhs);

  // 27.7.2.3 Assign/swap
  inline _LIBCPP_HIDE_FROM_ABI basic_ostream& operator=(basic_ostream&& __rhs);

  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 void swap(basic_ostream& __rhs) {
    basic_ios<char_type, traits_type>::swap(__rhs);
  }

  basic_ostream(const basic_ostream& __rhs)            = delete;
  basic_ostream& operator=(const basic_ostream& __rhs) = delete;

public:
  // 27.7.2.4 Prefix/suffix:
  class _LIBCPP_TEMPLATE_VIS sentry;

  // 27.7.2.6 Formatted output:
  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&)) {
    return __pf(*this);
  }

  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream&
  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_ostream& operator<<(ios_base& (*__pf)(ios_base&)) {
    __pf(*this);
    return *this;
  }

  basic_ostream& operator<<(bool __n);
  basic_ostream& operator<<(short __n);
  basic_ostream& operator<<(unsigned short __n);
  basic_ostream& operator<<(int __n);
  basic_ostream& operator<<(unsigned int __n);
  basic_ostream& operator<<(long __n);
  basic_ostream& operator<<(unsigned long __n);
  basic_ostream& operator<<(long long __n);
  basic_ostream& operator<<(unsigned long long __n);
  basic_ostream& operator<<(float __f);
  basic_ostream& operator<<(double __f);
  basic_ostream& operator<<(long double __f);
  basic_ostream& operator<<(const void* __p);

#if _LIBCPP_STD_VER >= 23
  _LIBCPP_HIDE_FROM_ABI basic_ostream& operator<<(const volatile void* __p) {
    return operator<<(const_cast<const void*>(__p));
  }
#endif

  basic_ostream& operator<<(basic_streambuf<char_type, traits_type>* __sb);

#if _LIBCPP_STD_VER >= 17
  // LWG 2221 - nullptr. This is not backported to older standards modes.
  // See https://reviews.llvm.org/D127033 for more info on the rationale.
  _LIBCPP_HIDE_FROM_ABI basic_ostream& operator<<(nullptr_t) { return *this << "nullptr"; }
#endif

  // 27.7.2.7 Unformatted output:
  basic_ostream& put(char_type __c);
  basic_ostream& write(const char_type* __s, streamsize __n);
  basic_ostream& flush();

  // 27.7.2.5 seeks:
  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 pos_type tellp();
  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream& seekp(pos_type __pos);
  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream& seekp(off_type __off, ios_base::seekdir __dir);

protected:
  _LIBCPP_HIDE_FROM_ABI basic_ostream() {} // extension, intentially does not initialize
};

template <class _CharT, class _Traits>
class _LIBCPP_TEMPLATE_VIS basic_ostream<_CharT, _Traits>::sentry {
  bool __ok_;
  basic_ostream<_CharT, _Traits>& __os_;

public:
  explicit sentry(basic_ostream<_CharT, _Traits>& __os);
  ~sentry();
  sentry(const sentry&)            = delete;
  sentry& operator=(const sentry&) = delete;

  _LIBCPP_HIDE_FROM_ABI explicit operator bool() const { return __ok_; }
};

template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>::sentry::sentry(basic_ostream<_CharT, _Traits>& __os) : __ok_(false), __os_(__os) {
  if (__os.good()) {
    if (__os.tie())
      __os.tie()->flush();
    __ok_ = true;
  }
}

template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>::sentry::~sentry() {
  if (__os_.rdbuf() && __os_.good() && (__os_.flags() & ios_base::unitbuf) && !uncaught_exception()) {
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
    try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
      if (__os_.rdbuf()->pubsync() == -1)
        __os_.setstate(ios_base::badbit);
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
    } catch (...) {
    }
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
  }
}

template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>::basic_ostream(basic_ostream&& __rhs) {
  this->move(__rhs);
}

template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator=(basic_ostream&& __rhs) {
  swap(__rhs);
  return *this;
}

template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>::~basic_ostream() {}

template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>&
basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_type>* __sb) {
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
    sentry __s(*this);
    if (__s) {
      if (__sb) {
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
        try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
          typedef istreambuf_iterator<_CharT, _Traits> _Ip;
          typedef ostreambuf_iterator<_CharT, _Traits> _Op;
          _Ip __i(__sb);
          _Ip __eof;
          _Op __o(*this);
          size_t __c = 0;
          for (; __i != __eof; ++__i, ++__o, ++__c) {
            *__o = *__i;
            if (__o.failed())
              break;
          }
          if (__c == 0)
            this->setstate(ios_base::failbit);
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
        } catch (...) {
          this->__set_failbit_and_consider_rethrow();
        }
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
      } else
        this->setstate(ios_base::badbit);
    }
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  } catch (...) {
    this->__set_badbit_and_consider_rethrow();
  }
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
  return *this;
}

template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(bool __n) {
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
    sentry __s(*this);
    if (__s) {
      typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
      const _Fp& __f = std::use_facet<_Fp>(this->getloc());
      if (__f.put(*this, *this, this->fill(), __n).failed())
        this->setstate(ios_base::badbit | ios_base::failbit);
    }
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  } catch (...) {
    this->__set_badbit_and_consider_rethrow();
  }
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
  return *this;
}

template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(short __n) {
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
    sentry __s(*this);
    if (__s) {
      ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
      typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
      const _Fp& __f = std::use_facet<_Fp>(this->getloc());
      if (__f.put(*this,
                  *this,
                  this->fill(),
                  __flags == ios_base::oct || __flags == ios_base::hex
                      ? static_cast<long>(static_cast<unsigned short>(__n))
                      : static_cast<long>(__n))
              .failed())
        this->setstate(ios_base::badbit | ios_base::failbit);
    }
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  } catch (...) {
    this->__set_badbit_and_consider_rethrow();
  }
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
  return *this;
}

template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(unsigned short __n) {
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
    sentry __s(*this);
    if (__s) {
      typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
      const _Fp& __f = std::use_facet<_Fp>(this->getloc());
      if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed())
        this->setstate(ios_base::badbit | ios_base::failbit);
    }
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  } catch (...) {
    this->__set_badbit_and_consider_rethrow();
  }
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
  return *this;
}

template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(int __n) {
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
    sentry __s(*this);
    if (__s) {
      ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
      typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
      const _Fp& __f = std::use_facet<_Fp>(this->getloc());
      if (__f.put(*this,
                  *this,
                  this->fill(),
                  __flags == ios_base::oct || __flags == ios_base::hex
                      ? static_cast<long>(static_cast<unsigned int>(__n))
                      : static_cast<long>(__n))
              .failed())
        this->setstate(ios_base::badbit | ios_base::failbit);
    }
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  } catch (...) {
    this->__set_badbit_and_consider_rethrow();
  }
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
  return *this;
}

template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(unsigned int __n) {
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
    sentry __s(*this);
    if (__s) {
      typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
      const _Fp& __f = std::use_facet<_Fp>(this->getloc());
      if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed())
        this->setstate(ios_base::badbit | ios_base::failbit);
    }
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  } catch (...) {
    this->__set_badbit_and_consider_rethrow();
  }
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
  return *this;
}

template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(long __n) {
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
    sentry __s(*this);
    if (__s) {
      typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
      const _Fp& __f = std::use_facet<_Fp>(this->getloc());
      if (__f.put(*this, *this, this->fill(), __n).failed())
        this->setstate(ios_base::badbit | ios_base::failbit);
    }
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  } catch (...) {
    this->__set_badbit_and_consider_rethrow();
  }
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
  return *this;
}

template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(unsigned long __n) {
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
    sentry __s(*this);
    if (__s) {
      typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
      const _Fp& __f = std::use_facet<_Fp>(this->getloc());
      if (__f.put(*this, *this, this->fill(), __n).failed())
        this->setstate(ios_base::badbit | ios_base::failbit);
    }
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  } catch (...) {
    this->__set_badbit_and_consider_rethrow();
  }
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
  return *this;
}

template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(long long __n) {
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
    sentry __s(*this);
    if (__s) {
      typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
      const _Fp& __f = std::use_facet<_Fp>(this->getloc());
      if (__f.put(*this, *this, this->fill(), __n).failed())
        this->setstate(ios_base::badbit | ios_base::failbit);
    }
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  } catch (...) {
    this->__set_badbit_and_consider_rethrow();
  }
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
  return *this;
}

template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(unsigned long long __n) {
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
    sentry __s(*this);
    if (__s) {
      typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
      const _Fp& __f = std::use_facet<_Fp>(this->getloc());
      if (__f.put(*this, *this, this->fill(), __n).failed())
        this->setstate(ios_base::badbit | ios_base::failbit);
    }
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  } catch (...) {
    this->__set_badbit_and_consider_rethrow();
  }
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
  return *this;
}

template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(float __n) {
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
    sentry __s(*this);
    if (__s) {
      typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
      const _Fp& __f = std::use_facet<_Fp>(this->getloc());
      if (__f.put(*this, *this, this->fill(), static_cast<double>(__n)).failed())
        this->setstate(ios_base::badbit | ios_base::failbit);
    }
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  } catch (...) {
    this->__set_badbit_and_consider_rethrow();
  }
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
  return *this;
}

template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(double __n) {
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
    sentry __s(*this);
    if (__s) {
      typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
      const _Fp& __f = std::use_facet<_Fp>(this->getloc());
      if (__f.put(*this, *this, this->fill(), __n).failed())
        this->setstate(ios_base::badbit | ios_base::failbit);
    }
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  } catch (...) {
    this->__set_badbit_and_consider_rethrow();
  }
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
  return *this;
}

template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(long double __n) {
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
    sentry __s(*this);
    if (__s) {
      typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
      const _Fp& __f = std::use_facet<_Fp>(this->getloc());
      if (__f.put(*this, *this, this->fill(), __n).failed())
        this->setstate(ios_base::badbit | ios_base::failbit);
    }
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  } catch (...) {
    this->__set_badbit_and_consider_rethrow();
  }
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
  return *this;
}

template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(const void* __n) {
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
    sentry __s(*this);
    if (__s) {
      typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
      const _Fp& __f = std::use_facet<_Fp>(this->getloc());
      if (__f.put(*this, *this, this->fill(), __n).failed())
        this->setstate(ios_base::badbit | ios_base::failbit);
    }
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  } catch (...) {
    this->__set_badbit_and_consider_rethrow();
  }
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
  return *this;
}

template <class _CharT, class _Traits>
_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
__put_character_sequence(basic_ostream<_CharT, _Traits>& __os, const _CharT* __str, size_t __len) {
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
    typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
    if (__s) {
      typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
      if (std::__pad_and_output(
              _Ip(__os),
              __str,
              (__os.flags() & ios_base::adjustfield) == ios_base::left ? __str + __len : __str,
              __str + __len,
              __os,
              __os.fill())
              .failed())
        __os.setstate(ios_base::badbit | ios_base::failbit);
    }
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  } catch (...) {
    __os.__set_badbit_and_consider_rethrow();
  }
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
  return __os;
}

template <class _CharT, class _Traits>
_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, _CharT __c) {
  return std::__put_character_sequence(__os, &__c, 1);
}

template <class _CharT, class _Traits>
_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, char __cn) {
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
    typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
    if (__s) {
      _CharT __c = __os.widen(__cn);
      typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
      if (std::__pad_and_output(
              _Ip(__os),
              &__c,
              (__os.flags() & ios_base::adjustfield) == ios_base::left ? &__c + 1 : &__c,
              &__c + 1,
              __os,
              __os.fill())
              .failed())
        __os.setstate(ios_base::badbit | ios_base::failbit);
    }
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  } catch (...) {
    __os.__set_badbit_and_consider_rethrow();
  }
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
  return __os;
}

template <class _Traits>
_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& __os, char __c) {
  return std::__put_character_sequence(__os, &__c, 1);
}

template <class _Traits>
_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& __os, signed char __c) {
  return std::__put_character_sequence(__os, (char*)&__c, 1);
}

template <class _Traits>
_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& __os, unsigned char __c) {
  return std::__put_character_sequence(__os, (char*)&__c, 1);
}

template <class _CharT, class _Traits>
_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, const _CharT* __str) {
  return std::__put_character_sequence(__os, __str, _Traits::length(__str));
}

template <class _CharT, class _Traits>
_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __strn) {
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
    typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
    if (__s) {
      typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
      size_t __len   = char_traits<char>::length(__strn);
      const int __bs = 100;
      _CharT __wbb[__bs];
      _CharT* __wb = __wbb;
      unique_ptr<_CharT, void (*)(void*)> __h(0, free);
      if (__len > __bs) {
        __wb = (_CharT*)malloc(__len * sizeof(_CharT));
        if (__wb == 0)
          __throw_bad_alloc();
        __h.reset(__wb);
      }
      for (_CharT* __p = __wb; *__strn != '\0'; ++__strn, ++__p)
        *__p = __os.widen(*__strn);
      if (std::__pad_and_output(
              _Ip(__os),
              __wb,
              (__os.flags() & ios_base::adjustfield) == ios_base::left ? __wb + __len : __wb,
              __wb + __len,
              __os,
              __os.fill())
              .failed())
        __os.setstate(ios_base::badbit | ios_base::failbit);
    }
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  } catch (...) {
    __os.__set_badbit_and_consider_rethrow();
  }
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
  return __os;
}

template <class _Traits>
_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& __os, const char* __str) {
  return std::__put_character_sequence(__os, __str, _Traits::length(__str));
}

template <class _Traits>
_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __os, const signed char* __str) {
  const char* __s = (const char*)__str;
  return std::__put_character_sequence(__os, __s, _Traits::length(__s));
}

template <class _Traits>
_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>&
operator<<(basic_ostream<char, _Traits>& __os, const unsigned char* __str) {
  const char* __s = (const char*)__str;
  return std::__put_character_sequence(__os, __s, _Traits::length(__s));
}

template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::put(char_type __c) {
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
    sentry __s(*this);
    if (__s) {
      typedef ostreambuf_iterator<_CharT, _Traits> _Op;
      _Op __o(*this);
      *__o = __c;
      if (__o.failed())
        this->setstate(ios_base::badbit);
    }
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  } catch (...) {
    this->__set_badbit_and_consider_rethrow();
  }
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
  return *this;
}

template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::write(const char_type* __s, streamsize __n) {
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
    sentry __sen(*this);
    if (__sen && __n) {
      if (this->rdbuf()->sputn(__s, __n) != __n)
        this->setstate(ios_base::badbit);
    }
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  } catch (...) {
    this->__set_badbit_and_consider_rethrow();
  }
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
  return *this;
}

template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::flush() {
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  try {
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
    if (this->rdbuf()) {
      sentry __s(*this);
      if (__s) {
        if (this->rdbuf()->pubsync() == -1)
          this->setstate(ios_base::badbit);
      }
    }
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  } catch (...) {
    this->__set_badbit_and_consider_rethrow();
  }
#endif // _LIBCPP_HAS_NO_EXCEPTIONS
  return *this;
}

template <class _CharT, class _Traits>
typename basic_ostream<_CharT, _Traits>::pos_type basic_ostream<_CharT, _Traits>::tellp() {
  if (this->fail())
    return pos_type(-1);
  return this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
}

template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::seekp(pos_type __pos) {
  sentry __s(*this);
  if (!this->fail()) {
    if (this->rdbuf()->pubseekpos(__pos, ios_base::out) == pos_type(-1))
      this->setstate(ios_base::failbit);
  }
  return *this;
}

template <class _CharT, class _Traits>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::seekp(off_type __off, ios_base::seekdir __dir) {
  sentry __s(*this);
  if (!this->fail()) {
    if (this->rdbuf()->pubseekoff(__off, __dir, ios_base::out) == pos_type(-1))
      this->setstate(ios_base::failbit);
  }
  return *this;
}

template <class _CharT, class _Traits>
_LIBCPP_HIDE_FROM_ABI inline basic_ostream<_CharT, _Traits>& endl(basic_ostream<_CharT, _Traits>& __os) {
  __os.put(__os.widen('\n'));
  __os.flush();
  return __os;
}

template <class _CharT, class _Traits>
_LIBCPP_HIDE_FROM_ABI inline basic_ostream<_CharT, _Traits>& ends(basic_ostream<_CharT, _Traits>& __os) {
  __os.put(_CharT());
  return __os;
}

template <class _CharT, class _Traits>
_LIBCPP_HIDE_FROM_ABI inline basic_ostream<_CharT, _Traits>& flush(basic_ostream<_CharT, _Traits>& __os) {
  __os.flush();
  return __os;
}

template <class _Stream, class _Tp, class = void>
struct __is_ostreamable : false_type {};

template <class _Stream, class _Tp>
struct __is_ostreamable<_Stream, _Tp, decltype(std::declval<_Stream>() << std::declval<_Tp>(), void())> : true_type {};

template <class _Stream,
          class _Tp,
          __enable_if_t<_And<is_base_of<ios_base, _Stream>, __is_ostreamable<_Stream&, const _Tp&> >::value, int> = 0>
_LIBCPP_HIDE_FROM_ABI _Stream&& operator<<(_Stream&& __os, const _Tp& __x) {
  __os << __x;
  return std::move(__os);
}

template <class _CharT, class _Traits, class _Allocator>
basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, const basic_string<_CharT, _Traits, _Allocator>& __str) {
  return std::__put_character_sequence(__os, __str.data(), __str.size());
}

template <class _CharT, class _Traits>
_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, basic_string_view<_CharT, _Traits> __sv) {
  return std::__put_character_sequence(__os, __sv.data(), __sv.size());
}

template <class _CharT, class _Traits>
inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __ec) {
  return __os << __ec.category().name() << ':' << __ec.value();
}

template <class _CharT, class _Traits, class _Yp>
inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p) {
  return __os << __p.get();
}

template <
    class _CharT,
    class _Traits,
    class _Yp,
    class _Dp,
    __enable_if_t<is_same<void,
                          __void_t<decltype((std::declval<basic_ostream<_CharT, _Traits>&>()
                                             << std::declval<typename unique_ptr<_Yp, _Dp>::pointer>()))> >::value,
                  int> = 0>
inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, unique_ptr<_Yp, _Dp> const& __p) {
  return __os << __p.get();
}

template <class _CharT, class _Traits, size_t _Size>
_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x) {
  return __os << __x.template to_string<_CharT, _Traits>(std::use_facet<ctype<_CharT> >(__os.getloc()).widen('0'),
                                                         std::use_facet<ctype<_CharT> >(__os.getloc()).widen('1'));
}

#if _LIBCPP_STD_VER >= 20

#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
template <class _Traits>
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, wchar_t) = delete;

template <class _Traits>
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const wchar_t*) = delete;

template <class _Traits>
basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char16_t) = delete;

template <class _Traits>
basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char32_t) = delete;

template <class _Traits>
basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char16_t*) = delete;

template <class _Traits>
basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char32_t*) = delete;

#  endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS

#  ifndef _LIBCPP_HAS_NO_CHAR8_T
template <class _Traits>
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char8_t) = delete;

template <class _Traits>
basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char8_t) = delete;

template <class _Traits>
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char8_t*) = delete;

template <class _Traits>
basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char8_t*) = delete;
#  endif

template <class _Traits>
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char16_t) = delete;

template <class _Traits>
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char32_t) = delete;

template <class _Traits>
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char16_t*) = delete;

template <class _Traits>
basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char32_t*) = delete;

#endif // _LIBCPP_STD_VER >= 20

extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<char>;
#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<wchar_t>;
#endif

#if _LIBCPP_STD_VER >= 23

template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
_LIBCPP_HIDE_FROM_ABI inline void
__vprint_nonunicode(ostream& __os, string_view __fmt, format_args __args, bool __write_nl) {
  // [ostream.formatted.print]/3
  // Effects: Behaves as a formatted output function
  // ([ostream.formatted.reqmts]) of os, except that:
  // - failure to generate output is reported as specified below, and
  // - any exception thrown by the call to vformat is propagated without regard
  //   to the value of os.exceptions() and without turning on ios_base::badbit
  //   in the error state of os.
  // After constructing a sentry object, the function initializes an automatic
  // variable via
  //   string out = vformat(os.getloc(), fmt, args);

  ostream::sentry __s(__os);
  if (__s) {
    string __o = std::vformat(__os.getloc(), __fmt, __args);
    if (__write_nl)
      __o += '\n';

    const char* __str = __o.data();
    size_t __len      = __o.size();

#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
    try {
#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
      typedef ostreambuf_iterator<char> _Ip;
      if (std::__pad_and_output(
              _Ip(__os),
              __str,
              (__os.flags() & ios_base::adjustfield) == ios_base::left ? __str + __len : __str,
              __str + __len,
              __os,
              __os.fill())
              .failed())
        __os.setstate(ios_base::badbit | ios_base::failbit);

#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
    } catch (...) {
      __os.__set_badbit_and_consider_rethrow();
    }
#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
  }
}

template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
_LIBCPP_HIDE_FROM_ABI inline void vprint_nonunicode(ostream& __os, string_view __fmt, format_args __args) {
  std::__vprint_nonunicode(__os, __fmt, __args, false);
}

// Returns the FILE* associated with the __os.
// Returns a nullptr when no FILE* is associated with __os.
// This function is in the dylib since the type of the buffer associated
// with std::cout, std::cerr, and std::clog is only known in the dylib.
//
// This function implements part of the implementation-defined behavior
// of [ostream.formatted.print]/3
//   If the function is vprint_unicode and os is a stream that refers to
//   a terminal capable of displaying Unicode which is determined in an
//   implementation-defined manner, writes out to the terminal using the
//   native Unicode API;
// Whether the returned FILE* is "a terminal capable of displaying Unicode"
// is determined in the same way as the print(FILE*, ...) overloads.
_LIBCPP_EXPORTED_FROM_ABI FILE* __get_ostream_file(ostream& __os);

#  ifndef _LIBCPP_HAS_NO_UNICODE
template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
_LIBCPP_HIDE_FROM_ABI void
__vprint_unicode(ostream& __os, string_view __fmt, format_args __args, bool __write_nl) {
#if _LIBCPP_AVAILABILITY_HAS_PRINT == 0
  return std::__vprint_nonunicode(__os, __fmt, __args, __write_nl);
#else
  FILE* __file = std::__get_ostream_file(__os);
  if (!__file || !__print::__is_terminal(__file))
    return std::__vprint_nonunicode(__os, __fmt, __args, __write_nl);

  // [ostream.formatted.print]/3
  //    If the function is vprint_unicode and os is a stream that refers to a
  //    terminal capable of displaying Unicode which is determined in an
  //    implementation-defined manner, writes out to the terminal using the
  //    native Unicode API; if out contains invalid code units, the behavior is
  //    undefined and implementations are encouraged to diagnose it. If the
  //    native Unicode API is used, the function flushes os before writing out.
  //
  // This is the path for the native API, start with flushing.
  __os.flush();

#    ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  try {
#    endif // _LIBCPP_HAS_NO_EXCEPTIONS
    ostream::sentry __s(__os);
    if (__s) {
#    ifndef _LIBCPP_WIN32API
      __print::__vprint_unicode_posix(__file, __fmt, __args, __write_nl, true);
#    elif !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
    __print::__vprint_unicode_windows(__file, __fmt, __args, __write_nl, true);
#    else
#      error "Windows builds with wchar_t disabled are not supported."
#    endif
    }

#    ifndef _LIBCPP_HAS_NO_EXCEPTIONS
  } catch (...) {
    __os.__set_badbit_and_consider_rethrow();
  }
#    endif // _LIBCPP_HAS_NO_EXCEPTIONS
#endif // _LIBCPP_AVAILABILITY_HAS_PRINT
}

template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
_LIBCPP_HIDE_FROM_ABI inline void
vprint_unicode(ostream& __os, string_view __fmt, format_args __args) {
  std::__vprint_unicode(__os, __fmt, __args, false);
}
#  endif // _LIBCPP_HAS_NO_UNICODE

template <class... _Args>
_LIBCPP_HIDE_FROM_ABI void
print(ostream& __os, format_string<_Args...> __fmt, _Args&&... __args) {
#  ifndef _LIBCPP_HAS_NO_UNICODE
  if constexpr (__print::__use_unicode_execution_charset)
    std::__vprint_unicode(__os, __fmt.get(), std::make_format_args(__args...), false);
  else
    std::__vprint_nonunicode(__os, __fmt.get(), std::make_format_args(__args...), false);
#  else  // _LIBCPP_HAS_NO_UNICODE
  std::__vprint_nonunicode(__os, __fmt.get(), std::make_format_args(__args...), false);
#  endif // _LIBCPP_HAS_NO_UNICODE
}

template <class... _Args>
_LIBCPP_HIDE_FROM_ABI void
println(ostream& __os, format_string<_Args...> __fmt, _Args&&... __args) {
#  ifndef _LIBCPP_HAS_NO_UNICODE
  // Note the wording in the Standard is inefficient. The output of
  // std::format is a std::string which is then copied. This solution
  // just appends a newline at the end of the output.
  if constexpr (__print::__use_unicode_execution_charset)
    std::__vprint_unicode(__os, __fmt.get(), std::make_format_args(__args...), true);
  else
    std::__vprint_nonunicode(__os, __fmt.get(), std::make_format_args(__args...), true);
#  else  // _LIBCPP_HAS_NO_UNICODE
  std::__vprint_nonunicode(__os, __fmt.get(), std::make_format_args(__args...), true);
#  endif // _LIBCPP_HAS_NO_UNICODE
}

#endif // _LIBCPP_STD_VER >= 23

_LIBCPP_END_NAMESPACE_STD

_LIBCPP_POP_MACROS

#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
#  include <atomic>
#  include <concepts>
#  include <cstdlib>
#  include <iosfwd>
#  include <iterator>
#  include <stdexcept>
#  include <type_traits>
#endif

#endif // _LIBCPP_OSTREAM