include/print - llvm-project/libcxx - Git at Google

 // -*- 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_PRINT
 #define _LIBCPP_PRINT

 /*
 namespace std {
   // [print.fun], print functions
   template<class... Args>
     void print(format_string<Args...> fmt, Args&&... args);
   void println();                                                          // Since C++26
   template<class... Args>
     void print(FILE* stream, format_string<Args...> fmt, Args&&... args);
   void println(FILE* stream);                                              // Since C++26

   template<class... Args>
     void println(format_string<Args...> fmt, Args&&... args);
   template<class... Args>
     void println(FILE* stream, format_string<Args...> fmt, Args&&... args);

   void vprint_unicode(string_view fmt, format_args args);
   void vprint_unicode(FILE* stream, string_view fmt, format_args args);

   void vprint_nonunicode(string_view fmt, format_args args);
   void vprint_nonunicode(FILE* stream, string_view fmt, format_args args);
 }
 */

 #include <__assert>
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__system_error/system_error.h>
 #include <__utility/forward.h>
 #include <cerrno>
 #include <cstdio>
 #include <format>
 #include <string>
 #include <string_view>
 #include <version>

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

 _LIBCPP_BEGIN_NAMESPACE_STD

 #ifdef _LIBCPP_WIN32API
 _LIBCPP_EXPORTED_FROM_ABI bool __is_windows_terminal(FILE* __stream);

 #  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 // A wrapper for WriteConsoleW which is used to write to the Windows
 // console. This function is in the dylib to avoid pulling in windows.h
 // in the library headers. The function itself uses some private parts
 // of the dylib too.
 //
 // The function does not depend on the language standard used. Guarding
 // it with C++23 would fail since the dylib is currently built using C++20.
 //
 // Note the function is only implemented on the Windows platform.
 _LIBCPP_EXPORTED_FROM_ABI void __write_to_windows_console(FILE* __stream, wstring_view __view);
 #  endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #elif __has_include(<unistd.h>)
 _LIBCPP_EXPORTED_FROM_ABI bool __is_posix_terminal(FILE* __stream);
 #endif // _LIBCPP_WIN32API

 #if _LIBCPP_STD_VER >= 23

 #  ifndef _LIBCPP_HAS_NO_UNICODE
 // This is the code to transcode UTF-8 to UTF-16. This is used on
 // Windows for the native Unicode API. The code is modeled to make it
 // easier to extend to
 //
 //  P2728R0 Unicode in the Library, Part 1: UTF Transcoding
 //
 // This paper is still under heavy development so it makes no sense yet
 // to strictly follow the paper.
 namespace __unicode {

 // The names of these concepts are modelled after P2728R0, but the
 // implementation is not. char16_t may contain 32-bits so depending on the
 // number of bits is an issue.
 #    ifdef _LIBCPP_SHORT_WCHAR
 template <class _Tp>
 concept __utf16_code_unit =
     same_as<_Tp, char16_t>
 #      ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
     || same_as<_Tp, wchar_t>
 #      endif
     ;
 template <class _Tp>
 concept __utf32_code_unit = same_as<_Tp, char32_t>;
 #    else // _LIBCPP_SHORT_WCHAR
 template <class _Tp>
 concept __utf16_code_unit = same_as<_Tp, char16_t>;
 template <class _Tp>
 concept __utf32_code_unit =
     same_as<_Tp, char32_t>
 #      ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
     || same_as<_Tp, wchar_t>
 #      endif
     ;
 #    endif // _LIBCPP_SHORT_WCHAR

 // Pass by reference since an output_iterator may not be copyable.
 template <class _OutIt>
 _LIBCPP_HIDE_FROM_ABI constexpr void __encode(_OutIt&, char32_t) = delete;

 template <class _OutIt>
   requires __utf16_code_unit<iter_value_t<_OutIt>>
 _LIBCPP_HIDE_FROM_ABI constexpr void __encode(_OutIt& __out_it, char32_t __value) {
   // [print.fun]/7 : "if `out` contains invalid code units, the behavior is undefined and implementations are encouraged
   // to diagnose it".
   _LIBCPP_ASSERT_UNCATEGORIZED(__is_scalar_value(__value), "an invalid unicode scalar value results in invalid UTF-16");

   if (__value < 0x10000) {
     *__out_it++ = __value;
     return;
   }

   __value -= 0x10000;
   *__out_it++ = 0xd800 + (__value >> 10);
   *__out_it++ = 0xdc00 + (__value & 0x3FF);
 }

 template <class _OutIt>
   requires __utf32_code_unit<iter_value_t<_OutIt>>
 _LIBCPP_HIDE_FROM_ABI constexpr void __encode(_OutIt& __out_it, char32_t __value) {
   // [print.fun]/7 : "if `out` contains invalid code units, the behavior is undefined and implementations are encouraged
   // to diagnose it".
   _LIBCPP_ASSERT_UNCATEGORIZED(__is_scalar_value(__value), "an invalid unicode scalar value results in invalid UTF-32");
   *__out_it++ = __value;
 }

 template <class _OutIt, input_iterator _InIt>
   requires output_iterator<_OutIt, const iter_value_t<_OutIt>&> && (!same_as<iter_value_t<_OutIt>, iter_value_t<_InIt>>)
 _LIBCPP_HIDE_FROM_ABI constexpr _OutIt __transcode(_InIt __first, _InIt __last, _OutIt __out_it) {
   // The __code_point_view has a basic_string_view interface.
   // When transcoding becomes part of the standard we probably want to
   // look at smarter algorithms.
   // For example, when processing a code point that is encoded in
   // 1 to 3 code units in UTF-8, the result will always be encoded
   // in 1 code unit in UTF-16 (code points that require 4 code
   // units in UTF-8 will require 2 code units in UTF-16).
   //
   // Note if P2728 is accepted types like int may become valid. In that case
   // the __code_point_view should use a span. Libc++ will remove support for
   // char_traits<int>.

   // TODO PRINT Validate with clang-tidy
   // NOLINTNEXTLINE(bugprone-dangling-handle)
   basic_string_view<iter_value_t<_InIt>> __data{__first, __last};
   __code_point_view<iter_value_t<_InIt>> __view{__data.begin(), __data.end()};
   while (!__view.__at_end())
     __unicode::__encode(__out_it, __view.__consume().__code_point);
   return __out_it;
 }

 } // namespace __unicode

 #  endif //  _LIBCPP_HAS_NO_UNICODE

 namespace __print {

 // [print.fun]/2
 //   Effects: If the ordinary literal encoding ([lex.charset]) is UTF-8, equivalent to:
 //     vprint_unicode(stream, fmt.str, make_format_args(args...));
 //   Otherwise, equivalent to:
 //     vprint_nonunicode(stream, fmt.str, make_format_args(args...));
 //
 // Based on the compiler and its compilation flags this value is or is
 // not true. As mentioned in P2093R14 this only affects Windows. The
 // test below could also be done for
 // - GCC using __GNUC_EXECUTION_CHARSET_NAME
 //   https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html
 // - Clang using __clang_literal_encoding__
 //   https://clang.llvm.org/docs/LanguageExtensions.html#builtin-macros
 //   (note at the time of writing Clang is hard-coded to UTF-8.)
 //

 #  ifdef _LIBCPP_HAS_NO_UNICODE
 inline constexpr bool __use_unicode_execution_charset = false;
 #  elif defined(_MSVC_EXECUTION_CHARACTER_SET)
 // This is the same test MSVC STL uses in their implementation of <print>
 // See: https://learn.microsoft.com/en-us/windows/win32/intl/code-page-identifiers
 inline constexpr bool __use_unicode_execution_charset = _MSVC_EXECUTION_CHARACTER_SET == 65001;
 #  else
 inline constexpr bool __use_unicode_execution_charset = true;
 #  endif

 _LIBCPP_HIDE_FROM_ABI inline bool __is_terminal([[maybe_unused]] FILE* __stream) {
   // The macro _LIBCPP_TESTING_PRINT_IS_TERMINAL is used to change
   // the behavior in the test. This is not part of the public API.
 #  ifdef _LIBCPP_TESTING_PRINT_IS_TERMINAL
   return _LIBCPP_TESTING_PRINT_IS_TERMINAL(__stream);
 #  elif _LIBCPP_AVAILABILITY_HAS_PRINT == 0
   return false;
 #  elif defined(_LIBCPP_WIN32API)
   return std::__is_windows_terminal(__stream);
 #  elif __has_include(<unistd.h>)
   return std::__is_posix_terminal(__stream);
 #  else
 #    error "Provide a way to determine whether a FILE* is a terminal"
 #  endif
 }

 template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
 _LIBCPP_HIDE_FROM_ABI inline void
 __vprint_nonunicode(FILE* __stream, string_view __fmt, format_args __args, bool __write_nl) {
   _LIBCPP_ASSERT_NON_NULL(__stream, "__stream must be a valid pointer to an output C stream");
   string __str = std::vformat(__fmt, __args);
   if (__write_nl)
     __str.push_back('\n');

   size_t __size = fwrite(__str.data(), 1, __str.size(), __stream);
   if (__size < __str.size()) {
     if (std::feof(__stream))
       std::__throw_system_error(EIO, "EOF while writing the formatted output");
     std::__throw_system_error(std::ferror(__stream), "failed to write formatted output");
   }
 }

 #  ifndef _LIBCPP_HAS_NO_UNICODE

 // Note these helper functions are mainly used to aid testing.
 // On POSIX systems and Windows the output is no longer considered a
 // terminal when the output is redirected. Typically during testing the
 // output is redirected to be able to capture it. This makes it hard to
 // test this code path.
 template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
 _LIBCPP_HIDE_FROM_ABI inline void
 __vprint_unicode_posix(FILE* __stream, string_view __fmt, format_args __args, bool __write_nl, bool __is_terminal) {
   // TODO PRINT Should flush errors throw too?
   if (__is_terminal)
     std::fflush(__stream);

   __print::__vprint_nonunicode(__stream, __fmt, __args, __write_nl);
 }

 #    ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
 _LIBCPP_HIDE_FROM_ABI inline void
 __vprint_unicode_windows(FILE* __stream, string_view __fmt, format_args __args, bool __write_nl, bool __is_terminal) {
   if (!__is_terminal)
     return __print::__vprint_nonunicode(__stream, __fmt, __args, __write_nl);

   // TODO PRINT Should flush errors throw too?
   std::fflush(__stream);

   string __str = std::vformat(__fmt, __args);
   // UTF-16 uses the same number or less code units than UTF-8.
   // However the size of the code unit is 16 bits instead of 8 bits.
   //
   // The buffer uses the worst-case estimate and should never resize.
   // However when the string is large this could lead to OOM. Using a
   // smaller size might work, but since the buffer uses a grow factor
   // the final size might be larger when the estimate is wrong.
   //
   // TODO PRINT profile and improve the speed of this code.
   __format::__retarget_buffer<wchar_t> __buffer{__str.size()};
   __unicode::__transcode(__str.begin(), __str.end(), __buffer.__make_output_iterator());
   if (__write_nl)
     __buffer.push_back(L'\n');

   [[maybe_unused]] wstring_view __view = __buffer.__view();

   // The macro _LIBCPP_TESTING_PRINT_WRITE_TO_WINDOWS_CONSOLE_FUNCTION is used to change
   // the behavior in the test. This is not part of the public API.
 #      ifdef _LIBCPP_TESTING_PRINT_WRITE_TO_WINDOWS_CONSOLE_FUNCTION
   _LIBCPP_TESTING_PRINT_WRITE_TO_WINDOWS_CONSOLE_FUNCTION(__stream, __view);
 #      elif defined(_LIBCPP_WIN32API)
   std::__write_to_windows_console(__stream, __view);
 #      else
   std::__throw_runtime_error("No defintion of _LIBCPP_TESTING_PRINT_WRITE_TO_WINDOWS_CONSOLE_FUNCTION and "
                              "__write_to_windows_console is not available.");
 #      endif
 }
 #    endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS

 template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
 _LIBCPP_HIDE_FROM_ABI inline void
 __vprint_unicode([[maybe_unused]] FILE* __stream,
                  [[maybe_unused]] string_view __fmt,
                  [[maybe_unused]] format_args __args,
                  [[maybe_unused]] bool __write_nl) {
   _LIBCPP_ASSERT_NON_NULL(__stream, "__stream must be a valid pointer to an output C stream");

   // [print.fun]
   //   7 - Effects: If stream refers to a terminal capable of displaying
   //       Unicode, 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.
   //       Otherwise writes out to stream unchanged. If the native
   //       Unicode API is used, the function flushes stream before
   //       writing out.
   //   8 - Throws: Any exception thrown by the call to vformat
   //       ([format.err.report]). system_error if writing to the terminal
   //       or stream fails. May throw bad_alloc.
   //   9 - Recommended practice: If invoking the native Unicode API
   //       requires transcoding, implementations should substitute
   //       invalid code units with U+FFFD replacement character per the
   //       Unicode Standard, Chapter 3.9 U+FFFD Substitution in
   //       Conversion.

   // On non-Windows platforms the Unicode API is the normal file I/O API
   // so there the call can be forwarded to the non_unicode API. On
   // Windows there is a different API. This API requires transcoding.

 #    ifndef _LIBCPP_WIN32API
   __print::__vprint_unicode_posix(__stream, __fmt, __args, __write_nl, __print::__is_terminal(__stream));
 #    elif !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
   __print::__vprint_unicode_windows(__stream, __fmt, __args, __write_nl, __print::__is_terminal(__stream));
 #    else
 #      error "Windows builds with wchar_t disabled are not supported."
 #    endif
 }

 #  endif // _LIBCPP_HAS_NO_UNICODE

 } // namespace __print

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

 template <class... _Args>
 _LIBCPP_HIDE_FROM_ABI void print(format_string<_Args...> __fmt, _Args&&... __args) {
   std::print(stdout, __fmt, std::forward<_Args>(__args)...);
 }

 template <class... _Args>
 _LIBCPP_HIDE_FROM_ABI void println(FILE* __stream, 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)
     __print::__vprint_unicode(__stream, __fmt.get(), std::make_format_args(__args...), true);
   else
     __print::__vprint_nonunicode(__stream, __fmt.get(), std::make_format_args(__args...), true);
 #  else  // _LIBCPP_HAS_NO_UNICODE
   __print::__vprint_nonunicode(__stream, __fmt.get(), std::make_format_args(__args...), true);
 #  endif // _LIBCPP_HAS_NO_UNICODE
 }

 template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
 _LIBCPP_HIDE_FROM_ABI inline void println(FILE* __stream) {
   std::print(__stream, "\n");
 }

 template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
 _LIBCPP_HIDE_FROM_ABI inline void println() {
   println(stdout);
 }

 template <class... _Args>
 _LIBCPP_HIDE_FROM_ABI void println(format_string<_Args...> __fmt, _Args&&... __args) {
   std::println(stdout, __fmt, std::forward<_Args>(__args)...);
 }

 #  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 inline void vprint_unicode(FILE* __stream, string_view __fmt, format_args __args) {
   __print::__vprint_unicode(__stream, __fmt, __args, false);
 }

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

 #  endif // _LIBCPP_HAS_NO_UNICODE

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

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

 #endif // _LIBCPP_STD_VER >= 23

 _LIBCPP_END_NAMESPACE_STD

 #endif // _LIBCPP_PRINT
	// -- 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_PRINT
	#define _LIBCPP_PRINT

	/*
	namespace std {
	// [print.fun], print functions
	template<class... Args>
	void print(format_string<Args...> fmt, Args&&... args);
	void println(); // Since C++26
	template<class... Args>
	void print(FILE* stream, format_string<Args...> fmt, Args&&... args);
	void println(FILE* stream); // Since C++26

	template<class... Args>
	void println(format_string<Args...> fmt, Args&&... args);
	template<class... Args>
	void println(FILE* stream, format_string<Args...> fmt, Args&&... args);

	void vprint_unicode(string_view fmt, format_args args);
	void vprint_unicode(FILE* stream, string_view fmt, format_args args);

	void vprint_nonunicode(string_view fmt, format_args args);
	void vprint_nonunicode(FILE* stream, string_view fmt, format_args args);
	}
	*/

	#include <__assert>
	#include <__concepts/same_as.h>
	#include <__config>
	#include <__system_error/system_error.h>
	#include <__utility/forward.h>
	#include <cerrno>
	#include <cstdio>
	#include <format>
	#include <string>
	#include <string_view>
	#include <version>

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	# pragma GCC system_header
	#endif

	_LIBCPP_BEGIN_NAMESPACE_STD

	#ifdef _LIBCPP_WIN32API
	_LIBCPP_EXPORTED_FROM_ABI bool __is_windows_terminal(FILE* __stream);

	# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
	// A wrapper for WriteConsoleW which is used to write to the Windows
	// console. This function is in the dylib to avoid pulling in windows.h
	// in the library headers. The function itself uses some private parts
	// of the dylib too.
	//
	// The function does not depend on the language standard used. Guarding
	// it with C++23 would fail since the dylib is currently built using C++20.
	//
	// Note the function is only implemented on the Windows platform.
	_LIBCPP_EXPORTED_FROM_ABI void __write_to_windows_console(FILE* __stream, wstring_view __view);
	# endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
	#elif __has_include(<unistd.h>)
	_LIBCPP_EXPORTED_FROM_ABI bool __is_posix_terminal(FILE* __stream);
	#endif // _LIBCPP_WIN32API

	#if _LIBCPP_STD_VER >= 23

	# ifndef _LIBCPP_HAS_NO_UNICODE
	// This is the code to transcode UTF-8 to UTF-16. This is used on
	// Windows for the native Unicode API. The code is modeled to make it
	// easier to extend to
	//
	// P2728R0 Unicode in the Library, Part 1: UTF Transcoding
	//
	// This paper is still under heavy development so it makes no sense yet
	// to strictly follow the paper.
	namespace __unicode {

	// The names of these concepts are modelled after P2728R0, but the
	// implementation is not. char16_t may contain 32-bits so depending on the
	// number of bits is an issue.
	# ifdef _LIBCPP_SHORT_WCHAR
	template <class _Tp>
	concept __utf16_code_unit =
	same_as<_Tp, char16_t>
	# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
	\|\| same_as<_Tp, wchar_t>
	# endif
	;
	template <class _Tp>
	concept __utf32_code_unit = same_as<_Tp, char32_t>;
	# else // _LIBCPP_SHORT_WCHAR
	template <class _Tp>
	concept __utf16_code_unit = same_as<_Tp, char16_t>;
	template <class _Tp>
	concept __utf32_code_unit =
	same_as<_Tp, char32_t>
	# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
	\|\| same_as<_Tp, wchar_t>
	# endif
	;
	# endif // _LIBCPP_SHORT_WCHAR

	// Pass by reference since an output_iterator may not be copyable.
	template <class _OutIt>
	_LIBCPP_HIDE_FROM_ABI constexpr void __encode(_OutIt&, char32_t) = delete;

	template <class _OutIt>
	requires __utf16_code_unit<iter_value_t<_OutIt>>
	_LIBCPP_HIDE_FROM_ABI constexpr void __encode(_OutIt& __out_it, char32_t __value) {
	// [print.fun]/7 : "if `out` contains invalid code units, the behavior is undefined and implementations are encouraged
	// to diagnose it".
	_LIBCPP_ASSERT_UNCATEGORIZED(__is_scalar_value(__value), "an invalid unicode scalar value results in invalid UTF-16");

	if (__value < 0x10000) {
	*__out_it++ = __value;
	return;
	}

	__value -= 0x10000;
	*__out_it++ = 0xd800 + (__value >> 10);
	*__out_it++ = 0xdc00 + (__value & 0x3FF);
	}

	template <class _OutIt>
	requires __utf32_code_unit<iter_value_t<_OutIt>>
	_LIBCPP_HIDE_FROM_ABI constexpr void __encode(_OutIt& __out_it, char32_t __value) {
	// [print.fun]/7 : "if `out` contains invalid code units, the behavior is undefined and implementations are encouraged
	// to diagnose it".
	_LIBCPP_ASSERT_UNCATEGORIZED(__is_scalar_value(__value), "an invalid unicode scalar value results in invalid UTF-32");
	*__out_it++ = __value;
	}

	template <class _OutIt, input_iterator _InIt>
	requires output_iterator<_OutIt, const iter_value_t<_OutIt>&> && (!same_as<iter_value_t<_OutIt>, iter_value_t<_InIt>>)
	_LIBCPP_HIDE_FROM_ABI constexpr _OutIt __transcode(_InIt __first, _InIt __last, _OutIt __out_it) {
	// The __code_point_view has a basic_string_view interface.
	// When transcoding becomes part of the standard we probably want to
	// look at smarter algorithms.
	// For example, when processing a code point that is encoded in
	// 1 to 3 code units in UTF-8, the result will always be encoded
	// in 1 code unit in UTF-16 (code points that require 4 code
	// units in UTF-8 will require 2 code units in UTF-16).
	//
	// Note if P2728 is accepted types like int may become valid. In that case
	// the __code_point_view should use a span. Libc++ will remove support for
	// char_traits<int>.

	// TODO PRINT Validate with clang-tidy
	// NOLINTNEXTLINE(bugprone-dangling-handle)
	basic_string_view<iter_value_t<_InIt>> __data{__first, __last};
	__code_point_view<iter_value_t<_InIt>> __view{__data.begin(), __data.end()};
	while (!__view.__at_end())
	__unicode::__encode(__out_it, __view.__consume().__code_point);
	return __out_it;
	}

	} // namespace __unicode

	# endif // _LIBCPP_HAS_NO_UNICODE

	namespace __print {

	// [print.fun]/2
	// Effects: If the ordinary literal encoding ([lex.charset]) is UTF-8, equivalent to:
	// vprint_unicode(stream, fmt.str, make_format_args(args...));
	// Otherwise, equivalent to:
	// vprint_nonunicode(stream, fmt.str, make_format_args(args...));
	//
	// Based on the compiler and its compilation flags this value is or is
	// not true. As mentioned in P2093R14 this only affects Windows. The
	// test below could also be done for
	// - GCC using __GNUC_EXECUTION_CHARSET_NAME
	// https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html
	// - Clang using __clang_literal_encoding__
	// https://clang.llvm.org/docs/LanguageExtensions.html#builtin-macros
	// (note at the time of writing Clang is hard-coded to UTF-8.)
	//

	# ifdef _LIBCPP_HAS_NO_UNICODE
	inline constexpr bool __use_unicode_execution_charset = false;
	# elif defined(_MSVC_EXECUTION_CHARACTER_SET)
	// This is the same test MSVC STL uses in their implementation of <print>
	// See: https://learn.microsoft.com/en-us/windows/win32/intl/code-page-identifiers
	inline constexpr bool __use_unicode_execution_charset = _MSVC_EXECUTION_CHARACTER_SET == 65001;
	# else
	inline constexpr bool __use_unicode_execution_charset = true;
	# endif

	_LIBCPP_HIDE_FROM_ABI inline bool __is_terminal([[maybe_unused]] FILE* __stream) {
	// The macro _LIBCPP_TESTING_PRINT_IS_TERMINAL is used to change
	// the behavior in the test. This is not part of the public API.
	# ifdef _LIBCPP_TESTING_PRINT_IS_TERMINAL
	return _LIBCPP_TESTING_PRINT_IS_TERMINAL(__stream);
	# elif _LIBCPP_AVAILABILITY_HAS_PRINT == 0
	return false;
	# elif defined(_LIBCPP_WIN32API)
	return std::__is_windows_terminal(__stream);
	# elif __has_include(<unistd.h>)
	return std::__is_posix_terminal(__stream);
	# else
	# error "Provide a way to determine whether a FILE* is a terminal"
	# endif
	}

	template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
	_LIBCPP_HIDE_FROM_ABI inline void
	__vprint_nonunicode(FILE* __stream, string_view __fmt, format_args __args, bool __write_nl) {
	_LIBCPP_ASSERT_NON_NULL(__stream, "__stream must be a valid pointer to an output C stream");
	string __str = std::vformat(__fmt, __args);
	if (__write_nl)
	__str.push_back('\n');

	size_t __size = fwrite(__str.data(), 1, __str.size(), __stream);
	if (__size < __str.size()) {
	if (std::feof(__stream))
	std::__throw_system_error(EIO, "EOF while writing the formatted output");
	std::__throw_system_error(std::ferror(__stream), "failed to write formatted output");
	}
	}

	# ifndef _LIBCPP_HAS_NO_UNICODE

	// Note these helper functions are mainly used to aid testing.
	// On POSIX systems and Windows the output is no longer considered a
	// terminal when the output is redirected. Typically during testing the
	// output is redirected to be able to capture it. This makes it hard to
	// test this code path.
	template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
	_LIBCPP_HIDE_FROM_ABI inline void
	__vprint_unicode_posix(FILE* __stream, string_view __fmt, format_args __args, bool __write_nl, bool __is_terminal) {
	// TODO PRINT Should flush errors throw too?
	if (__is_terminal)
	std::fflush(__stream);

	__print::__vprint_nonunicode(__stream, __fmt, __args, __write_nl);
	}

	# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
	template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
	_LIBCPP_HIDE_FROM_ABI inline void
	__vprint_unicode_windows(FILE* __stream, string_view __fmt, format_args __args, bool __write_nl, bool __is_terminal) {
	if (!__is_terminal)
	return __print::__vprint_nonunicode(__stream, __fmt, __args, __write_nl);

	// TODO PRINT Should flush errors throw too?
	std::fflush(__stream);

	string __str = std::vformat(__fmt, __args);
	// UTF-16 uses the same number or less code units than UTF-8.
	// However the size of the code unit is 16 bits instead of 8 bits.
	//
	// The buffer uses the worst-case estimate and should never resize.
	// However when the string is large this could lead to OOM. Using a
	// smaller size might work, but since the buffer uses a grow factor
	// the final size might be larger when the estimate is wrong.
	//
	// TODO PRINT profile and improve the speed of this code.
	__format::__retarget_buffer<wchar_t> __buffer{__str.size()};
	__unicode::__transcode(__str.begin(), __str.end(), __buffer.__make_output_iterator());
	if (__write_nl)
	__buffer.push_back(L'\n');

	[[maybe_unused]] wstring_view __view = __buffer.__view();

	// The macro _LIBCPP_TESTING_PRINT_WRITE_TO_WINDOWS_CONSOLE_FUNCTION is used to change
	// the behavior in the test. This is not part of the public API.
	# ifdef _LIBCPP_TESTING_PRINT_WRITE_TO_WINDOWS_CONSOLE_FUNCTION
	_LIBCPP_TESTING_PRINT_WRITE_TO_WINDOWS_CONSOLE_FUNCTION(__stream, __view);
	# elif defined(_LIBCPP_WIN32API)
	std::__write_to_windows_console(__stream, __view);
	# else
	std::__throw_runtime_error("No defintion of _LIBCPP_TESTING_PRINT_WRITE_TO_WINDOWS_CONSOLE_FUNCTION and "
	"__write_to_windows_console is not available.");
	# endif
	}
	# endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS

	template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
	_LIBCPP_HIDE_FROM_ABI inline void
	__vprint_unicode([[maybe_unused]] FILE* __stream,
	[[maybe_unused]] string_view __fmt,
	[[maybe_unused]] format_args __args,
	[[maybe_unused]] bool __write_nl) {
	_LIBCPP_ASSERT_NON_NULL(__stream, "__stream must be a valid pointer to an output C stream");

	// [print.fun]
	// 7 - Effects: If stream refers to a terminal capable of displaying
	// Unicode, 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.
	// Otherwise writes out to stream unchanged. If the native
	// Unicode API is used, the function flushes stream before
	// writing out.
	// 8 - Throws: Any exception thrown by the call to vformat
	// ([format.err.report]). system_error if writing to the terminal
	// or stream fails. May throw bad_alloc.
	// 9 - Recommended practice: If invoking the native Unicode API
	// requires transcoding, implementations should substitute
	// invalid code units with U+FFFD replacement character per the
	// Unicode Standard, Chapter 3.9 U+FFFD Substitution in
	// Conversion.

	// On non-Windows platforms the Unicode API is the normal file I/O API
	// so there the call can be forwarded to the non_unicode API. On
	// Windows there is a different API. This API requires transcoding.

	# ifndef _LIBCPP_WIN32API
	__print::__vprint_unicode_posix(__stream, __fmt, __args, __write_nl, __print::__is_terminal(__stream));
	# elif !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
	__print::__vprint_unicode_windows(__stream, __fmt, __args, __write_nl, __print::__is_terminal(__stream));
	# else
	# error "Windows builds with wchar_t disabled are not supported."
	# endif
	}

	# endif // _LIBCPP_HAS_NO_UNICODE

	} // namespace __print

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

	template <class... _Args>
	_LIBCPP_HIDE_FROM_ABI void print(format_string<_Args...> __fmt, _Args&&... __args) {
	std::print(stdout, __fmt, std::forward<_Args>(__args)...);
	}

	template <class... _Args>
	_LIBCPP_HIDE_FROM_ABI void println(FILE* __stream, 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)
	__print::__vprint_unicode(__stream, __fmt.get(), std::make_format_args(__args...), true);
	else
	__print::__vprint_nonunicode(__stream, __fmt.get(), std::make_format_args(__args...), true);
	# else // _LIBCPP_HAS_NO_UNICODE
	__print::__vprint_nonunicode(__stream, __fmt.get(), std::make_format_args(__args...), true);
	# endif // _LIBCPP_HAS_NO_UNICODE
	}

	template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
	_LIBCPP_HIDE_FROM_ABI inline void println(FILE* __stream) {
	std::print(__stream, "\n");
	}

	template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
	_LIBCPP_HIDE_FROM_ABI inline void println() {
	println(stdout);
	}

	template <class... _Args>
	_LIBCPP_HIDE_FROM_ABI void println(format_string<_Args...> __fmt, _Args&&... __args) {
	std::println(stdout, __fmt, std::forward<_Args>(__args)...);
	}

	# 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 inline void vprint_unicode(FILE* __stream, string_view __fmt, format_args __args) {
	__print::__vprint_unicode(__stream, __fmt, __args, false);
	}

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

	# endif // _LIBCPP_HAS_NO_UNICODE

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

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

	#endif // _LIBCPP_STD_VER >= 23

	_LIBCPP_END_NAMESPACE_STD

	#endif // _LIBCPP_PRINT