master
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___FORMAT_FORMAT_ARG_H
11#define _LIBCPP___FORMAT_FORMAT_ARG_H
12
13#include <__assert>
14#include <__concepts/arithmetic.h>
15#include <__config>
16#include <__cstddef/size_t.h>
17#include <__format/concepts.h>
18#include <__format/format_parse_context.h>
19#include <__functional/invoke.h>
20#include <__fwd/format.h>
21#include <__memory/addressof.h>
22#include <__type_traits/conditional.h>
23#include <__type_traits/remove_const.h>
24#include <__utility/forward.h>
25#include <__utility/move.h>
26#include <__utility/unreachable.h>
27#include <__variant/monostate.h>
28#include <cstdint>
29#include <string_view>
30
31#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
32# pragma GCC system_header
33#endif
34
35_LIBCPP_PUSH_MACROS
36#include <__undef_macros>
37
38_LIBCPP_BEGIN_NAMESPACE_STD
39
40#if _LIBCPP_STD_VER >= 20
41
42namespace __format {
43/// The type stored in @ref basic_format_arg.
44///
45/// @note The 128-bit types are unconditionally in the list to avoid the values
46/// of the enums to depend on the availability of 128-bit integers.
47///
48/// @note The value is stored as a 5-bit value in the __packed_arg_t_bits. This
49/// limits the maximum number of elements to 32.
50/// When modifying update the test
51/// test/libcxx/utilities/format/format.arguments/format.arg/arg_t.compile.pass.cpp
52/// It could be packed in 4-bits but that means a new type directly becomes an
53/// ABI break. The packed type is 64-bit so this reduces the maximum number of
54/// packed elements from 16 to 12.
55///
56/// @note Some members of this enum are an extension. These extensions need
57/// special behaviour in visit_format_arg. There they need to be wrapped in a
58/// handle to satisfy the user observable behaviour. The internal function
59/// __visit_format_arg doesn't do this wrapping. So in the format functions
60/// this function is used to avoid unneeded overhead.
61enum class __arg_t : uint8_t {
62 __none,
63 __boolean,
64 __char_type,
65 __int,
66 __long_long,
67 __i128, // extension
68 __unsigned,
69 __unsigned_long_long,
70 __u128, // extension
71 __float,
72 __double,
73 __long_double,
74 __const_char_type_ptr,
75 __string_view,
76 __ptr,
77 __handle
78};
79
80inline constexpr unsigned __packed_arg_t_bits = 5;
81inline constexpr uint8_t __packed_arg_t_mask = 0x1f;
82
83inline constexpr unsigned __packed_types_storage_bits = 64;
84inline constexpr unsigned __packed_types_max = __packed_types_storage_bits / __packed_arg_t_bits;
85
86_LIBCPP_HIDE_FROM_ABI constexpr bool __use_packed_format_arg_store(size_t __size) {
87 return __size <= __packed_types_max;
88}
89
90_LIBCPP_HIDE_FROM_ABI constexpr __arg_t __get_packed_type(uint64_t __types, size_t __id) {
91 _LIBCPP_ASSERT_INTERNAL(__id <= __packed_types_max, "");
92
93 if (__id > 0)
94 __types >>= __id * __packed_arg_t_bits;
95
96 return static_cast<__format::__arg_t>(__types & __packed_arg_t_mask);
97}
98
99} // namespace __format
100
101// This function is not user observable, so it can directly use the non-standard
102// types of the "variant". See __arg_t for more details.
103template <class _Visitor, class _Context>
104_LIBCPP_HIDE_FROM_ABI decltype(auto) __visit_format_arg(_Visitor&& __vis, basic_format_arg<_Context> __arg) {
105 switch (__arg.__type_) {
106 case __format::__arg_t::__none:
107 return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__monostate_);
108 case __format::__arg_t::__boolean:
109 return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__boolean_);
110 case __format::__arg_t::__char_type:
111 return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__char_type_);
112 case __format::__arg_t::__int:
113 return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__int_);
114 case __format::__arg_t::__long_long:
115 return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__long_long_);
116 case __format::__arg_t::__i128:
117# if _LIBCPP_HAS_INT128
118 return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__i128_);
119# else
120 __libcpp_unreachable();
121# endif
122 case __format::__arg_t::__unsigned:
123 return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__unsigned_);
124 case __format::__arg_t::__unsigned_long_long:
125 return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__unsigned_long_long_);
126 case __format::__arg_t::__u128:
127# if _LIBCPP_HAS_INT128
128 return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__u128_);
129# else
130 __libcpp_unreachable();
131# endif
132 case __format::__arg_t::__float:
133 return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__float_);
134 case __format::__arg_t::__double:
135 return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__double_);
136 case __format::__arg_t::__long_double:
137 return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__long_double_);
138 case __format::__arg_t::__const_char_type_ptr:
139 return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__const_char_type_ptr_);
140 case __format::__arg_t::__string_view:
141 return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__string_view_);
142 case __format::__arg_t::__ptr:
143 return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__ptr_);
144 case __format::__arg_t::__handle:
145 return std::invoke(
146 std::forward<_Visitor>(__vis), typename basic_format_arg<_Context>::handle{__arg.__value_.__handle_});
147 }
148
149 __libcpp_unreachable();
150}
151
152# if _LIBCPP_STD_VER >= 26 && _LIBCPP_HAS_EXPLICIT_THIS_PARAMETER
153
154template <class _Rp, class _Visitor, class _Context>
155_LIBCPP_HIDE_FROM_ABI _Rp __visit_format_arg(_Visitor&& __vis, basic_format_arg<_Context> __arg) {
156 switch (__arg.__type_) {
157 case __format::__arg_t::__none:
158 return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__monostate_);
159 case __format::__arg_t::__boolean:
160 return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__boolean_);
161 case __format::__arg_t::__char_type:
162 return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__char_type_);
163 case __format::__arg_t::__int:
164 return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__int_);
165 case __format::__arg_t::__long_long:
166 return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__long_long_);
167 case __format::__arg_t::__i128:
168# if _LIBCPP_HAS_INT128
169 return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__i128_);
170# else
171 __libcpp_unreachable();
172# endif
173 case __format::__arg_t::__unsigned:
174 return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__unsigned_);
175 case __format::__arg_t::__unsigned_long_long:
176 return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__unsigned_long_long_);
177 case __format::__arg_t::__u128:
178# if _LIBCPP_HAS_INT128
179 return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__u128_);
180# else
181 __libcpp_unreachable();
182# endif
183 case __format::__arg_t::__float:
184 return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__float_);
185 case __format::__arg_t::__double:
186 return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__double_);
187 case __format::__arg_t::__long_double:
188 return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__long_double_);
189 case __format::__arg_t::__const_char_type_ptr:
190 return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__const_char_type_ptr_);
191 case __format::__arg_t::__string_view:
192 return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__string_view_);
193 case __format::__arg_t::__ptr:
194 return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__ptr_);
195 case __format::__arg_t::__handle:
196 return std::invoke_r<_Rp>(
197 std::forward<_Visitor>(__vis), typename basic_format_arg<_Context>::handle{__arg.__value_.__handle_});
198 }
199
200 __libcpp_unreachable();
201}
202
203# endif // _LIBCPP_STD_VER >= 26 && _LIBCPP_HAS_EXPLICIT_THIS_PARAMETER
204
205/// Contains the values used in basic_format_arg.
206///
207/// This is a separate type so it's possible to store the values and types in
208/// separate arrays.
209template <class _Context>
210class __basic_format_arg_value {
211 using _CharT _LIBCPP_NODEBUG = typename _Context::char_type;
212
213public:
214 /// Contains the implementation for basic_format_arg::handle.
215 struct __handle {
216 template <class _Tp>
217 _LIBCPP_HIDE_FROM_ABI explicit __handle(_Tp& __v) noexcept
218 : __ptr_(std::addressof(__v)),
219 __format_([](basic_format_parse_context<_CharT>& __parse_ctx, _Context& __ctx, const void* __ptr) {
220 using _Dp = remove_const_t<_Tp>;
221 using _Qp = conditional_t<__formattable_with<const _Dp, _Context>, const _Dp, _Dp>;
222 static_assert(__formattable_with<_Qp, _Context>, "Mandated by [format.arg]/10");
223
224 typename _Context::template formatter_type<_Dp> __f;
225 __parse_ctx.advance_to(__f.parse(__parse_ctx));
226 __ctx.advance_to(__f.format(*const_cast<_Qp*>(static_cast<const _Dp*>(__ptr)), __ctx));
227 }) {}
228
229 const void* __ptr_;
230 void (*__format_)(basic_format_parse_context<_CharT>&, _Context&, const void*);
231 };
232
233 union {
234 monostate __monostate_;
235 bool __boolean_;
236 _CharT __char_type_;
237 int __int_;
238 unsigned __unsigned_;
239 long long __long_long_;
240 unsigned long long __unsigned_long_long_;
241# if _LIBCPP_HAS_INT128
242 __int128_t __i128_;
243 __uint128_t __u128_;
244# endif
245 float __float_;
246 double __double_;
247 long double __long_double_;
248 const _CharT* __const_char_type_ptr_;
249 basic_string_view<_CharT> __string_view_;
250 const void* __ptr_;
251 __handle __handle_;
252 };
253
254 // These constructors contain the exact storage type used. If adjustments are
255 // required, these will be done in __create_format_arg.
256
257 _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value() noexcept : __monostate_() {}
258 _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(bool __value) noexcept : __boolean_(__value) {}
259 _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(_CharT __value) noexcept : __char_type_(__value) {}
260 _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(int __value) noexcept : __int_(__value) {}
261 _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(unsigned __value) noexcept : __unsigned_(__value) {}
262 _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(long long __value) noexcept : __long_long_(__value) {}
263 _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(unsigned long long __value) noexcept
264 : __unsigned_long_long_(__value) {}
265# if _LIBCPP_HAS_INT128
266 _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(__int128_t __value) noexcept : __i128_(__value) {}
267 _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(__uint128_t __value) noexcept : __u128_(__value) {}
268# endif
269 _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(float __value) noexcept : __float_(__value) {}
270 _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(double __value) noexcept : __double_(__value) {}
271 _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(long double __value) noexcept : __long_double_(__value) {}
272 _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(const _CharT* __value) noexcept : __const_char_type_ptr_(__value) {}
273 _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(basic_string_view<_CharT> __value) noexcept
274 : __string_view_(__value) {}
275 _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(const void* __value) noexcept : __ptr_(__value) {}
276 _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(__handle&& __value) noexcept : __handle_(std::move(__value)) {}
277};
278
279template <class _Context>
280class _LIBCPP_NO_SPECIALIZATIONS basic_format_arg {
281public:
282 class handle;
283
284 _LIBCPP_HIDE_FROM_ABI basic_format_arg() noexcept : __type_{__format::__arg_t::__none} {}
285
286 _LIBCPP_HIDE_FROM_ABI explicit operator bool() const noexcept { return __type_ != __format::__arg_t::__none; }
287
288# if _LIBCPP_STD_VER >= 26 && _LIBCPP_HAS_EXPLICIT_THIS_PARAMETER
289
290 // This function is user facing, so it must wrap the non-standard types of
291 // the "variant" in a handle to stay conforming. See __arg_t for more details.
292 template <class _Visitor>
293 _LIBCPP_HIDE_FROM_ABI decltype(auto) visit(this basic_format_arg __arg, _Visitor&& __vis) {
294 switch (__arg.__type_) {
295# if _LIBCPP_HAS_INT128
296 case __format::__arg_t::__i128: {
297 typename __basic_format_arg_value<_Context>::__handle __h{__arg.__value_.__i128_};
298 return std::invoke(std::forward<_Visitor>(__vis), typename basic_format_arg<_Context>::handle{__h});
299 }
300
301 case __format::__arg_t::__u128: {
302 typename __basic_format_arg_value<_Context>::__handle __h{__arg.__value_.__u128_};
303 return std::invoke(std::forward<_Visitor>(__vis), typename basic_format_arg<_Context>::handle{__h});
304 }
305# endif
306 default:
307 return std::__visit_format_arg(std::forward<_Visitor>(__vis), __arg);
308 }
309 }
310
311 // This function is user facing, so it must wrap the non-standard types of
312 // the "variant" in a handle to stay conforming. See __arg_t for more details.
313 template <class _Rp, class _Visitor>
314 _LIBCPP_HIDE_FROM_ABI _Rp visit(this basic_format_arg __arg, _Visitor&& __vis) {
315 switch (__arg.__type_) {
316# if _LIBCPP_HAS_INT128
317 case __format::__arg_t::__i128: {
318 typename __basic_format_arg_value<_Context>::__handle __h{__arg.__value_.__i128_};
319 return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), typename basic_format_arg<_Context>::handle{__h});
320 }
321
322 case __format::__arg_t::__u128: {
323 typename __basic_format_arg_value<_Context>::__handle __h{__arg.__value_.__u128_};
324 return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), typename basic_format_arg<_Context>::handle{__h});
325 }
326# endif
327 default:
328 return std::__visit_format_arg<_Rp>(std::forward<_Visitor>(__vis), __arg);
329 }
330 }
331
332# endif // _LIBCPP_STD_VER >= 26 && _LIBCPP_HAS_EXPLICIT_THIS_PARAMETER
333
334private:
335 using char_type = typename _Context::char_type;
336
337 // TODO FMT Implement constrain [format.arg]/4
338 // Constraints: The template specialization
339 // typename Context::template formatter_type<T>
340 // meets the Formatter requirements ([formatter.requirements]). The extent
341 // to which an implementation determines that the specialization meets the
342 // Formatter requirements is unspecified, except that as a minimum the
343 // expression
344 // typename Context::template formatter_type<T>()
345 // .format(declval<const T&>(), declval<Context&>())
346 // shall be well-formed when treated as an unevaluated operand.
347
348public:
349 __basic_format_arg_value<_Context> __value_;
350 __format::__arg_t __type_;
351
352 _LIBCPP_HIDE_FROM_ABI explicit basic_format_arg(__format::__arg_t __type,
353 __basic_format_arg_value<_Context> __value) noexcept
354 : __value_(__value), __type_(__type) {}
355};
356
357template <class _Context>
358class basic_format_arg<_Context>::handle {
359public:
360 _LIBCPP_HIDE_FROM_ABI void format(basic_format_parse_context<char_type>& __parse_ctx, _Context& __ctx) const {
361 __handle_.__format_(__parse_ctx, __ctx, __handle_.__ptr_);
362 }
363
364 _LIBCPP_HIDE_FROM_ABI explicit handle(typename __basic_format_arg_value<_Context>::__handle& __handle) noexcept
365 : __handle_(__handle) {}
366
367private:
368 typename __basic_format_arg_value<_Context>::__handle& __handle_;
369};
370
371// This function is user facing, so it must wrap the non-standard types of
372// the "variant" in a handle to stay conforming. See __arg_t for more details.
373template <class _Visitor, class _Context>
374# if _LIBCPP_STD_VER >= 26 && _LIBCPP_HAS_EXPLICIT_THIS_PARAMETER
375_LIBCPP_DEPRECATED_IN_CXX26
376# endif
377 _LIBCPP_HIDE_FROM_ABI decltype(auto)
378 visit_format_arg(_Visitor&& __vis, basic_format_arg<_Context> __arg) {
379 switch (__arg.__type_) {
380# if _LIBCPP_HAS_INT128
381 case __format::__arg_t::__i128: {
382 typename __basic_format_arg_value<_Context>::__handle __h{__arg.__value_.__i128_};
383 return std::invoke(std::forward<_Visitor>(__vis), typename basic_format_arg<_Context>::handle{__h});
384 }
385
386 case __format::__arg_t::__u128: {
387 typename __basic_format_arg_value<_Context>::__handle __h{__arg.__value_.__u128_};
388 return std::invoke(std::forward<_Visitor>(__vis), typename basic_format_arg<_Context>::handle{__h});
389 }
390# endif // _LIBCPP_STD_VER >= 26 && _LIBCPP_HAS_EXPLICIT_THIS_PARAMETER
391 default:
392 return std::__visit_format_arg(std::forward<_Visitor>(__vis), __arg);
393 }
394}
395
396#endif // _LIBCPP_STD_VER >= 20
397
398_LIBCPP_END_NAMESPACE_STD
399
400_LIBCPP_POP_MACROS
401
402#endif // _LIBCPP___FORMAT_FORMAT_ARG_H