1// -*- C++ -*- 2//===----------------------------------------------------------------------===// 3// 4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5// See https://llvm.org/LICENSE.txt for license information. 6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7// 8//===----------------------------------------------------------------------===// 9 10#ifndef _LIBCPP_PRINT 11#define _LIBCPP_PRINT 12 13/* 14namespace std { 15 // [print.fun], print functions 16 template<class... Args> 17 void print(format_string<Args...> fmt, Args&&... args); 18 void println(); // Since C++26 19 template<class... Args> 20 void print(FILE* stream, format_string<Args...> fmt, Args&&... args); 21 void println(FILE* stream); // Since C++26 22 23 template<class... Args> 24 void println(format_string<Args...> fmt, Args&&... args); 25 template<class... Args> 26 void println(FILE* stream, format_string<Args...> fmt, Args&&... args); 27 28 void vprint_unicode(string_view fmt, format_args args); 29 void vprint_unicode(FILE* stream, string_view fmt, format_args args); 30 31 void vprint_nonunicode(string_view fmt, format_args args); 32 void vprint_nonunicode(FILE* stream, string_view fmt, format_args args); 33} 34*/ 35 36#include <__assert> 37#include <__concepts/same_as.h> 38#include <__config> 39#include <__system_error/system_error.h> 40#include <__utility/forward.h> 41#include <cerrno> 42#include <cstdio> 43#include <format> 44#include <string> 45#include <string_view> 46#include <version> 47 48#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 49# pragma GCC system_header 50#endif 51 52_LIBCPP_BEGIN_NAMESPACE_STD 53 54#ifdef _LIBCPP_WIN32API 55_LIBCPP_EXPORTED_FROM_ABI bool __is_windows_terminal(FILE* __stream); 56 57# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 58// A wrapper for WriteConsoleW which is used to write to the Windows 59// console. This function is in the dylib to avoid pulling in windows.h 60// in the library headers. The function itself uses some private parts 61// of the dylib too. 62// 63// The function does not depend on the language standard used. Guarding 64// it with C++23 would fail since the dylib is currently built using C++20. 65// 66// Note the function is only implemented on the Windows platform. 67_LIBCPP_EXPORTED_FROM_ABI void __write_to_windows_console(FILE* __stream, wstring_view __view); 68# endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS 69#elif __has_include(<unistd.h>) 70_LIBCPP_EXPORTED_FROM_ABI bool __is_posix_terminal(FILE* __stream); 71#endif // _LIBCPP_WIN32API 72 73#if _LIBCPP_STD_VER >= 23 74 75# ifndef _LIBCPP_HAS_NO_UNICODE 76// This is the code to transcode UTF-8 to UTF-16. This is used on 77// Windows for the native Unicode API. The code is modeled to make it 78// easier to extend to 79// 80// P2728R0 Unicode in the Library, Part 1: UTF Transcoding 81// 82// This paper is still under heavy development so it makes no sense yet 83// to strictly follow the paper. 84namespace __unicode { 85 86// The names of these concepts are modelled after P2728R0, but the 87// implementation is not. char16_t may contain 32-bits so depending on the 88// number of bits is an issue. 89# ifdef _LIBCPP_SHORT_WCHAR 90template <class _Tp> 91concept __utf16_code_unit = 92 same_as<_Tp, char16_t> 93# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 94 || same_as<_Tp, wchar_t> 95# endif 96 ; 97template <class _Tp> 98concept __utf32_code_unit = same_as<_Tp, char32_t>; 99# else // _LIBCPP_SHORT_WCHAR 100template <class _Tp> 101concept __utf16_code_unit = same_as<_Tp, char16_t>; 102template <class _Tp> 103concept __utf32_code_unit = 104 same_as<_Tp, char32_t> 105# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 106 || same_as<_Tp, wchar_t> 107# endif 108 ; 109# endif // _LIBCPP_SHORT_WCHAR 110 111// Pass by reference since an output_iterator may not be copyable. 112template <class _OutIt> 113_LIBCPP_HIDE_FROM_ABI constexpr void __encode(_OutIt&, char32_t) = delete; 114 115template <class _OutIt> 116 requires __utf16_code_unit<iter_value_t<_OutIt>> 117_LIBCPP_HIDE_FROM_ABI constexpr void __encode(_OutIt& __out_it, char32_t __value) { 118 // [print.fun]/7 : "if `out` contains invalid code units, the behavior is undefined and implementations are encouraged 119 // to diagnose it". 120 _LIBCPP_ASSERT_UNCATEGORIZED(__is_scalar_value(__value), "an invalid unicode scalar value results in invalid UTF-16"); 121 122 if (__value < 0x10000) { 123 *__out_it++ = __value; 124 return; 125 } 126 127 __value -= 0x10000; 128 *__out_it++ = 0xd800 + (__value >> 10); 129 *__out_it++ = 0xdc00 + (__value & 0x3FF); 130} 131 132template <class _OutIt> 133 requires __utf32_code_unit<iter_value_t<_OutIt>> 134_LIBCPP_HIDE_FROM_ABI constexpr void __encode(_OutIt& __out_it, char32_t __value) { 135 // [print.fun]/7 : "if `out` contains invalid code units, the behavior is undefined and implementations are encouraged 136 // to diagnose it". 137 _LIBCPP_ASSERT_UNCATEGORIZED(__is_scalar_value(__value), "an invalid unicode scalar value results in invalid UTF-32"); 138 *__out_it++ = __value; 139} 140 141template <class _OutIt, input_iterator _InIt> 142 requires output_iterator<_OutIt, const iter_value_t<_OutIt>&> && (!same_as<iter_value_t<_OutIt>, iter_value_t<_InIt>>) 143_LIBCPP_HIDE_FROM_ABI constexpr _OutIt __transcode(_InIt __first, _InIt __last, _OutIt __out_it) { 144 // The __code_point_view has a basic_string_view interface. 145 // When transcoding becomes part of the standard we probably want to 146 // look at smarter algorithms. 147 // For example, when processing a code point that is encoded in 148 // 1 to 3 code units in UTF-8, the result will always be encoded 149 // in 1 code unit in UTF-16 (code points that require 4 code 150 // units in UTF-8 will require 2 code units in UTF-16). 151 // 152 // Note if P2728 is accepted types like int may become valid. In that case 153 // the __code_point_view should use a span. Libc++ will remove support for 154 // char_traits<int>. 155 156 // TODO PRINT Validate with clang-tidy 157 // NOLINTNEXTLINE(bugprone-dangling-handle) 158 basic_string_view<iter_value_t<_InIt>> __data{__first, __last}; 159 __code_point_view<iter_value_t<_InIt>> __view{__data.begin(), __data.end()}; 160 while (!__view.__at_end()) 161 __unicode::__encode(__out_it, __view.__consume().__code_point); 162 return __out_it; 163} 164 165} // namespace __unicode 166 167# endif // _LIBCPP_HAS_NO_UNICODE 168 169namespace __print { 170 171// [print.fun]/2 172// Effects: If the ordinary literal encoding ([lex.charset]) is UTF-8, equivalent to: 173// vprint_unicode(stream, fmt.str, make_format_args(args...)); 174// Otherwise, equivalent to: 175// vprint_nonunicode(stream, fmt.str, make_format_args(args...)); 176// 177// Based on the compiler and its compilation flags this value is or is 178// not true. As mentioned in P2093R14 this only affects Windows. The 179// test below could also be done for 180// - GCC using __GNUC_EXECUTION_CHARSET_NAME 181// https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html 182// - Clang using __clang_literal_encoding__ 183// https://clang.llvm.org/docs/LanguageExtensions.html#builtin-macros 184// (note at the time of writing Clang is hard-coded to UTF-8.) 185// 186 187# ifdef _LIBCPP_HAS_NO_UNICODE 188inline constexpr bool __use_unicode_execution_charset = false; 189# elif defined(_MSVC_EXECUTION_CHARACTER_SET) 190// This is the same test MSVC STL uses in their implementation of <print> 191// See: https://learn.microsoft.com/en-us/windows/win32/intl/code-page-identifiers 192inline constexpr bool __use_unicode_execution_charset = _MSVC_EXECUTION_CHARACTER_SET == 65001; 193# else 194inline constexpr bool __use_unicode_execution_charset = true; 195# endif 196 197_LIBCPP_HIDE_FROM_ABI inline bool __is_terminal([[maybe_unused]] FILE* __stream) { 198 // The macro _LIBCPP_TESTING_PRINT_IS_TERMINAL is used to change 199 // the behavior in the test. This is not part of the public API. 200# ifdef _LIBCPP_TESTING_PRINT_IS_TERMINAL 201 return _LIBCPP_TESTING_PRINT_IS_TERMINAL(__stream); 202# elif _LIBCPP_AVAILABILITY_HAS_PRINT == 0 203 return false; 204# elif defined(_LIBCPP_WIN32API) 205 return std::__is_windows_terminal(__stream); 206# elif __has_include(<unistd.h>) 207 return std::__is_posix_terminal(__stream); 208# else 209# error "Provide a way to determine whether a FILE* is a terminal" 210# endif 211} 212 213template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563). 214_LIBCPP_HIDE_FROM_ABI inline void 215__vprint_nonunicode(FILE* __stream, string_view __fmt, format_args __args, bool __write_nl) { 216 _LIBCPP_ASSERT_NON_NULL(__stream, "__stream must be a valid pointer to an output C stream"); 217 string __str = std::vformat(__fmt, __args); 218 if (__write_nl) 219 __str.push_back('\n'); 220 221 size_t __size = fwrite(__str.data(), 1, __str.size(), __stream); 222 if (__size < __str.size()) { 223 if (std::feof(__stream)) 224 std::__throw_system_error(EIO, "EOF while writing the formatted output"); 225 std::__throw_system_error(std::ferror(__stream), "failed to write formatted output"); 226 } 227} 228 229# ifndef _LIBCPP_HAS_NO_UNICODE 230 231// Note these helper functions are mainly used to aid testing. 232// On POSIX systems and Windows the output is no longer considered a 233// terminal when the output is redirected. Typically during testing the 234// output is redirected to be able to capture it. This makes it hard to 235// test this code path. 236template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563). 237_LIBCPP_HIDE_FROM_ABI inline void 238__vprint_unicode_posix(FILE* __stream, string_view __fmt, format_args __args, bool __write_nl, bool __is_terminal) { 239 // TODO PRINT Should flush errors throw too? 240 if (__is_terminal) 241 std::fflush(__stream); 242 243 __print::__vprint_nonunicode(__stream, __fmt, __args, __write_nl); 244} 245 246# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 247template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563). 248_LIBCPP_HIDE_FROM_ABI inline void 249__vprint_unicode_windows(FILE* __stream, string_view __fmt, format_args __args, bool __write_nl, bool __is_terminal) { 250 if (!__is_terminal) 251 return __print::__vprint_nonunicode(__stream, __fmt, __args, __write_nl); 252 253 // TODO PRINT Should flush errors throw too? 254 std::fflush(__stream); 255 256 string __str = std::vformat(__fmt, __args); 257 // UTF-16 uses the same number or less code units than UTF-8. 258 // However the size of the code unit is 16 bits instead of 8 bits. 259 // 260 // The buffer uses the worst-case estimate and should never resize. 261 // However when the string is large this could lead to OOM. Using a 262 // smaller size might work, but since the buffer uses a grow factor 263 // the final size might be larger when the estimate is wrong. 264 // 265 // TODO PRINT profile and improve the speed of this code. 266 __format::__retarget_buffer<wchar_t> __buffer{__str.size()}; 267 __unicode::__transcode(__str.begin(), __str.end(), __buffer.__make_output_iterator()); 268 if (__write_nl) 269 __buffer.push_back(L'\n'); 270 271 [[maybe_unused]] wstring_view __view = __buffer.__view(); 272 273 // The macro _LIBCPP_TESTING_PRINT_WRITE_TO_WINDOWS_CONSOLE_FUNCTION is used to change 274 // the behavior in the test. This is not part of the public API. 275# ifdef _LIBCPP_TESTING_PRINT_WRITE_TO_WINDOWS_CONSOLE_FUNCTION 276 _LIBCPP_TESTING_PRINT_WRITE_TO_WINDOWS_CONSOLE_FUNCTION(__stream, __view); 277# elif defined(_LIBCPP_WIN32API) 278 std::__write_to_windows_console(__stream, __view); 279# else 280 std::__throw_runtime_error("No defintion of _LIBCPP_TESTING_PRINT_WRITE_TO_WINDOWS_CONSOLE_FUNCTION and " 281 "__write_to_windows_console is not available."); 282# endif 283} 284# endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS 285 286template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563). 287_LIBCPP_HIDE_FROM_ABI inline void 288__vprint_unicode([[maybe_unused]] FILE* __stream, 289 [[maybe_unused]] string_view __fmt, 290 [[maybe_unused]] format_args __args, 291 [[maybe_unused]] bool __write_nl) { 292 _LIBCPP_ASSERT_NON_NULL(__stream, "__stream must be a valid pointer to an output C stream"); 293 294 // [print.fun] 295 // 7 - Effects: If stream refers to a terminal capable of displaying 296 // Unicode, writes out to the terminal using the native Unicode 297 // API; if out contains invalid code units, the behavior is 298 // undefined and implementations are encouraged to diagnose it. 299 // Otherwise writes out to stream unchanged. If the native 300 // Unicode API is used, the function flushes stream before 301 // writing out. 302 // 8 - Throws: Any exception thrown by the call to vformat 303 // ([format.err.report]). system_error if writing to the terminal 304 // or stream fails. May throw bad_alloc. 305 // 9 - Recommended practice: If invoking the native Unicode API 306 // requires transcoding, implementations should substitute 307 // invalid code units with U+FFFD replacement character per the 308 // Unicode Standard, Chapter 3.9 U+FFFD Substitution in 309 // Conversion. 310 311 // On non-Windows platforms the Unicode API is the normal file I/O API 312 // so there the call can be forwarded to the non_unicode API. On 313 // Windows there is a different API. This API requires transcoding. 314 315# ifndef _LIBCPP_WIN32API 316 __print::__vprint_unicode_posix(__stream, __fmt, __args, __write_nl, __print::__is_terminal(__stream)); 317# elif !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS) 318 __print::__vprint_unicode_windows(__stream, __fmt, __args, __write_nl, __print::__is_terminal(__stream)); 319# else 320# error "Windows builds with wchar_t disabled are not supported." 321# endif 322} 323 324# endif // _LIBCPP_HAS_NO_UNICODE 325 326} // namespace __print 327 328template <class... _Args> 329_LIBCPP_HIDE_FROM_ABI void print(FILE* __stream, format_string<_Args...> __fmt, _Args&&... __args) { 330# ifndef _LIBCPP_HAS_NO_UNICODE 331 if constexpr (__print::__use_unicode_execution_charset) 332 __print::__vprint_unicode(__stream, __fmt.get(), std::make_format_args(__args...), false); 333 else 334 __print::__vprint_nonunicode(__stream, __fmt.get(), std::make_format_args(__args...), false); 335# else // _LIBCPP_HAS_NO_UNICODE 336 __print::__vprint_nonunicode(__stream, __fmt.get(), std::make_format_args(__args...), false); 337# endif // _LIBCPP_HAS_NO_UNICODE 338} 339 340template <class... _Args> 341_LIBCPP_HIDE_FROM_ABI void print(format_string<_Args...> __fmt, _Args&&... __args) { 342 std::print(stdout, __fmt, std::forward<_Args>(__args)...); 343} 344 345template <class... _Args> 346_LIBCPP_HIDE_FROM_ABI void println(FILE* __stream, format_string<_Args...> __fmt, _Args&&... __args) { 347# ifndef _LIBCPP_HAS_NO_UNICODE 348 // Note the wording in the Standard is inefficient. The output of 349 // std::format is a std::string which is then copied. This solution 350 // just appends a newline at the end of the output. 351 if constexpr (__print::__use_unicode_execution_charset) 352 __print::__vprint_unicode(__stream, __fmt.get(), std::make_format_args(__args...), true); 353 else 354 __print::__vprint_nonunicode(__stream, __fmt.get(), std::make_format_args(__args...), true); 355# else // _LIBCPP_HAS_NO_UNICODE 356 __print::__vprint_nonunicode(__stream, __fmt.get(), std::make_format_args(__args...), true); 357# endif // _LIBCPP_HAS_NO_UNICODE 358} 359 360template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563). 361_LIBCPP_HIDE_FROM_ABI inline void println(FILE* __stream) { 362 std::print(__stream, "\n"); 363} 364 365template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563). 366_LIBCPP_HIDE_FROM_ABI inline void println() { 367 println(stdout); 368} 369 370template <class... _Args> 371_LIBCPP_HIDE_FROM_ABI void println(format_string<_Args...> __fmt, _Args&&... __args) { 372 std::println(stdout, __fmt, std::forward<_Args>(__args)...); 373} 374 375# ifndef _LIBCPP_HAS_NO_UNICODE 376template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563). 377_LIBCPP_HIDE_FROM_ABI inline void vprint_unicode(FILE* __stream, string_view __fmt, format_args __args) { 378 __print::__vprint_unicode(__stream, __fmt, __args, false); 379} 380 381template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563). 382_LIBCPP_HIDE_FROM_ABI inline void vprint_unicode(string_view __fmt, format_args __args) { 383 std::vprint_unicode(stdout, __fmt, __args); 384} 385 386# endif // _LIBCPP_HAS_NO_UNICODE 387 388template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563). 389_LIBCPP_HIDE_FROM_ABI inline void vprint_nonunicode(FILE* __stream, string_view __fmt, format_args __args) { 390 __print::__vprint_nonunicode(__stream, __fmt, __args, false); 391} 392 393template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563). 394_LIBCPP_HIDE_FROM_ABI inline void vprint_nonunicode(string_view __fmt, format_args __args) { 395 std::vprint_nonunicode(stdout, __fmt, __args); 396} 397 398#endif // _LIBCPP_STD_VER >= 23 399 400_LIBCPP_END_NAMESPACE_STD 401 402#endif // _LIBCPP_PRINT 403