mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-04-24 00:46:06 +00:00
Code Issues Projects Releases Wiki Activity
llvm-project/libcxx/include/print
Nikolas Klauser b9a2658a3e
[libc++][C++03] Use __cxx03/ headers in C++03 mode (#109002) 
This patch implements the forwarding to frozen C++03 headers as
discussed in
https://discourse.llvm.org/t/rfc-freezing-c-03-headers-in-libc. In the
RFC, we initially proposed selecting the right headers from the Clang
driver, however consensus seemed to steer towards handling this in the
library itself. This patch implements that direction.

At a high level, the changes basically amount to making each public
header look like this:

```
// inside <vector>
#ifdef _LIBCPP_CXX03_LANG
#  include <__cxx03/vector>
#else
  // normal <vector> content
#endif
```

In most cases, public headers are simple umbrella headers so there isn't
much code in the #else branch. In other cases, the #else branch contains
the actual implementation of the header.
2024-12-21 13:01:48 +01:00

408 lines
17 KiB
C++
Raw Permalink Blame History

// -*- 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);
}
*/
#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
# include <__cxx03/print>
#else
# include <__assert>
# include <__concepts/same_as.h>
# include <__config>
# include <__system_error/throw_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);
# if _LIBCPP_HAS_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_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
# if _LIBCPP_HAS_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>
# if _LIBCPP_HAS_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>
# if _LIBCPP_HAS_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_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.)
//
# if !_LIBCPP_HAS_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 || !_LIBCPP_HAS_TERMINAL
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");
}
}
# if _LIBCPP_HAS_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);
}
# if _LIBCPP_HAS_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_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 _LIBCPP_HAS_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_UNICODE
} // namespace __print
template <class... _Args>
_LIBCPP_HIDE_FROM_ABI void print(FILE* __stream, format_string<_Args...> __fmt, _Args&&... __args) {
# if _LIBCPP_HAS_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_UNICODE
__print::__vprint_nonunicode(__stream, __fmt.get(), std::make_format_args(__args...), false);
# endif // _LIBCPP_HAS_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) {
# if _LIBCPP_HAS_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_UNICODE
__print::__vprint_nonunicode(__stream, __fmt.get(), std::make_format_args(__args...), true);
# endif // _LIBCPP_HAS_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)...);
}
# if _LIBCPP_HAS_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_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 // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
#endif // _LIBCPP_PRINT
Reference in New Issue View Git Blame Copy Permalink