aboutsummaryrefslogtreecommitdiffstats
path: root/contrib/libs/cxxsupp/libcxx/include/print
blob: d119c8bda749768caf863fddf19269d968a05f9f (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
// -*- 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);
  template<class... Args>
    void print(FILE* stream, format_string<Args...> fmt, Args&&... args);

  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> // all public C++ headers provide the assertion handler
#include <__concepts/same_as.h>
#include <__config>
#include <__format/buffer.h>
#include <__format/format_arg_store.h>
#include <__format/format_args.h>
#include <__format/format_context.h>
#include <__format/format_error.h>
#include <__format/format_functions.h>
#include <__format/unicode.h>
#include <__system_error/system_error.h>
#include <__utility/forward.h>
#include <cerrno>
#include <cstdio>
#include <string>
#include <string_view>
#include <version>

#if __has_include(<unistd.h>)
#  include <unistd.h>
#endif

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

_LIBCPP_BEGIN_NAMESPACE_STD

#ifdef _WIN32
_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

#endif // _WIN32

#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) {
  _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) {
  _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 = 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 = _MSVC_EXECUTION_CHARACTER_SET == 65001;
#  else
inline constexpr bool __use_unicode = true;
#  endif

_LIBCPP_HIDE_FROM_ABI inline bool __is_terminal(FILE* __stream) {
#  ifdef _WIN32
  return std::__is_windows_terminal(__stream);
#  elif __has_include(<unistd.h>)
  return isatty(fileno(__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_UNCATEGORIZED(__stream, "__stream is 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(_WIN32)
  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_UNCATEGORIZED(__stream, "__stream is 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 _WIN32
  __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)
    __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)
    __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... _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