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_STORE_H
11 #define _LIBCPP___FORMAT_FORMAT_ARG_STORE_H
12 
13 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
14 #  pragma GCC system_header
15 #endif
16 
17 #include <__concepts/arithmetic.h>
18 #include <__concepts/same_as.h>
19 #include <__config>
20 #include <__format/concepts.h>
21 #include <__format/format_arg.h>
22 #include <__type_traits/conditional.h>
23 #include <__type_traits/extent.h>
24 #include <__type_traits/remove_const.h>
25 #include <string>
26 #include <string_view>
27 
28 _LIBCPP_BEGIN_NAMESPACE_STD
29 
30 #if _LIBCPP_STD_VER >= 20
31 
32 namespace __format {
33 
34 /// \returns The @c __arg_t based on the type of the formatting argument.
35 ///
36 /// \pre \c __formattable<_Tp, typename _Context::char_type>
37 template <class _Context, class _Tp>
38 consteval __arg_t __determine_arg_t();
39 
40 // Boolean
41 template <class, same_as<bool> _Tp>
42 consteval __arg_t __determine_arg_t() {
43   return __arg_t::__boolean;
44 }
45 
46 // Char
47 template <class _Context, same_as<typename _Context::char_type> _Tp>
48 consteval __arg_t __determine_arg_t() {
49   return __arg_t::__char_type;
50 }
51 #  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
52 template <class _Context, class _CharT>
53   requires(same_as<typename _Context::char_type, wchar_t> && same_as<_CharT, char>)
54 consteval __arg_t __determine_arg_t() {
55   return __arg_t::__char_type;
56 }
57 #  endif
58 
59 // Signed integers
60 template <class, __libcpp_signed_integer _Tp>
61 consteval __arg_t __determine_arg_t() {
62   if constexpr (sizeof(_Tp) <= sizeof(int))
63     return __arg_t::__int;
64   else if constexpr (sizeof(_Tp) <= sizeof(long long))
65     return __arg_t::__long_long;
66 #  ifndef _LIBCPP_HAS_NO_INT128
67   else if constexpr (sizeof(_Tp) == sizeof(__int128_t))
68     return __arg_t::__i128;
69 #  endif
70   else
71     static_assert(sizeof(_Tp) == 0, "an unsupported signed integer was used");
72 }
73 
74 // Unsigned integers
75 template <class, __libcpp_unsigned_integer _Tp>
76 consteval __arg_t __determine_arg_t() {
77   if constexpr (sizeof(_Tp) <= sizeof(unsigned))
78     return __arg_t::__unsigned;
79   else if constexpr (sizeof(_Tp) <= sizeof(unsigned long long))
80     return __arg_t::__unsigned_long_long;
81 #  ifndef _LIBCPP_HAS_NO_INT128
82   else if constexpr (sizeof(_Tp) == sizeof(__uint128_t))
83     return __arg_t::__u128;
84 #  endif
85   else
86     static_assert(sizeof(_Tp) == 0, "an unsupported unsigned integer was used");
87 }
88 
89 // Floating-point
90 template <class, same_as<float> _Tp>
91 consteval __arg_t __determine_arg_t() {
92   return __arg_t::__float;
93 }
94 template <class, same_as<double> _Tp>
95 consteval __arg_t __determine_arg_t() {
96   return __arg_t::__double;
97 }
98 template <class, same_as<long double> _Tp>
99 consteval __arg_t __determine_arg_t() {
100   return __arg_t::__long_double;
101 }
102 
103 // Char pointer
104 template <class _Context, class _Tp>
105   requires(same_as<typename _Context::char_type*, _Tp> || same_as<const typename _Context::char_type*, _Tp>)
106 consteval __arg_t __determine_arg_t() {
107   return __arg_t::__const_char_type_ptr;
108 }
109 
110 // Char array
111 template <class _Context, class _Tp>
112   requires(is_array_v<_Tp> && same_as<_Tp, typename _Context::char_type[extent_v<_Tp>]>)
113 consteval __arg_t __determine_arg_t() {
114   return __arg_t::__string_view;
115 }
116 
117 // String view
118 template <class _Context, class _Tp>
119   requires(same_as<typename _Context::char_type, typename _Tp::value_type> &&
120            same_as<_Tp, basic_string_view<typename _Tp::value_type, typename _Tp::traits_type>>)
121 consteval __arg_t __determine_arg_t() {
122   return __arg_t::__string_view;
123 }
124 
125 // String
126 template <class _Context, class _Tp>
127   requires(
128       same_as<typename _Context::char_type, typename _Tp::value_type> &&
129       same_as<_Tp, basic_string<typename _Tp::value_type, typename _Tp::traits_type, typename _Tp::allocator_type>>)
130 consteval __arg_t __determine_arg_t() {
131   return __arg_t::__string_view;
132 }
133 
134 // Pointers
135 template <class, class _Ptr>
136   requires(same_as<_Ptr, void*> || same_as<_Ptr, const void*> || same_as<_Ptr, nullptr_t>)
137 consteval __arg_t __determine_arg_t() {
138   return __arg_t::__ptr;
139 }
140 
141 // Handle
142 //
143 // Note this version can't be constrained avoiding ambiguous overloads.
144 // That means it can be instantiated by disabled formatters. To solve this, a
145 // constrained version for not formattable formatters is added.
146 template <class _Context, class _Tp>
147 consteval __arg_t __determine_arg_t() {
148   return __arg_t::__handle;
149 }
150 
151 // The overload for not formattable types allows triggering the static
152 // assertion below.
153 template <class _Context, class _Tp>
154   requires(!__formattable<_Tp, typename _Context::char_type>)
155 consteval __arg_t __determine_arg_t() {
156   return __arg_t::__none;
157 }
158 
159 // Pseudo constuctor for basic_format_arg
160 //
161 // Modeled after template<class T> explicit basic_format_arg(T& v) noexcept;
162 // [format.arg]/4-6
163 template <class _Context, class _Tp>
164 _LIBCPP_HIDE_FROM_ABI basic_format_arg<_Context> __create_format_arg(_Tp& __value) noexcept {
165   using _Dp               = remove_const_t<_Tp>;
166   constexpr __arg_t __arg = __determine_arg_t<_Context, _Dp>();
167   static_assert(__arg != __arg_t::__none, "the supplied type is not formattable");
168 
169   static_assert(__formattable_with<_Tp, _Context>);
170 
171   // Not all types can be used to directly initialize the
172   // __basic_format_arg_value.  First handle all types needing adjustment, the
173   // final else requires no adjustment.
174   if constexpr (__arg == __arg_t::__char_type)
175     // On some platforms initializing a wchar_t from a char is a narrowing
176     // conversion.
177     return basic_format_arg<_Context>{__arg, static_cast<typename _Context::char_type>(__value)};
178   else if constexpr (__arg == __arg_t::__int)
179     return basic_format_arg<_Context>{__arg, static_cast<int>(__value)};
180   else if constexpr (__arg == __arg_t::__long_long)
181     return basic_format_arg<_Context>{__arg, static_cast<long long>(__value)};
182   else if constexpr (__arg == __arg_t::__unsigned)
183     return basic_format_arg<_Context>{__arg, static_cast<unsigned>(__value)};
184   else if constexpr (__arg == __arg_t::__unsigned_long_long)
185     return basic_format_arg<_Context>{__arg, static_cast<unsigned long long>(__value)};
186   else if constexpr (__arg == __arg_t::__string_view)
187     // Using std::size on a character array will add the NUL-terminator to the size.
188     if constexpr (is_array_v<_Dp>)
189       return basic_format_arg<_Context>{
190           __arg, basic_string_view<typename _Context::char_type>{__value, extent_v<_Dp> - 1}};
191     else
192       // When the _Traits or _Allocator are different an implicit conversion will
193       // fail.
194       return basic_format_arg<_Context>{
195           __arg, basic_string_view<typename _Context::char_type>{__value.data(), __value.size()}};
196   else if constexpr (__arg == __arg_t::__ptr)
197     return basic_format_arg<_Context>{__arg, static_cast<const void*>(__value)};
198   else if constexpr (__arg == __arg_t::__handle)
199     return basic_format_arg<_Context>{__arg, typename __basic_format_arg_value<_Context>::__handle{__value}};
200   else
201     return basic_format_arg<_Context>{__arg, __value};
202 }
203 
204 template <class _Context, class... _Args>
205 _LIBCPP_HIDE_FROM_ABI void __create_packed_storage(uint64_t& __types, __basic_format_arg_value<_Context>* __values,
206                                                    _Args&&... __args) noexcept {
207   int __shift = 0;
208   (
209       [&] {
210         basic_format_arg<_Context> __arg = __format::__create_format_arg<_Context>(__args);
211         if (__shift != 0)
212           __types |= static_cast<uint64_t>(__arg.__type_) << __shift;
213         else
214           // Assigns the initial value.
215           __types = static_cast<uint64_t>(__arg.__type_);
216         __shift += __packed_arg_t_bits;
217         *__values++ = __arg.__value_;
218       }(),
219       ...);
220 }
221 
222 template <class _Context, class... _Args>
223 _LIBCPP_HIDE_FROM_ABI void __store_basic_format_arg(basic_format_arg<_Context>* __data, _Args&&... __args) noexcept {
224   ([&] { *__data++ = __format::__create_format_arg<_Context>(__args); }(), ...);
225 }
226 
227 template <class _Context, size_t N>
228 struct __packed_format_arg_store {
229   __basic_format_arg_value<_Context> __values_[N];
230   uint64_t __types_ = 0;
231 };
232 
233 template <class _Context, size_t N>
234 struct __unpacked_format_arg_store {
235   basic_format_arg<_Context> __args_[N];
236 };
237 
238 } // namespace __format
239 
240 template <class _Context, class... _Args>
241 struct _LIBCPP_TEMPLATE_VIS __format_arg_store {
242   _LIBCPP_HIDE_FROM_ABI
243   __format_arg_store(_Args&... __args) noexcept {
244     if constexpr (sizeof...(_Args) != 0) {
245       if constexpr (__format::__use_packed_format_arg_store(sizeof...(_Args)))
246         __format::__create_packed_storage(__storage.__types_, __storage.__values_, __args...);
247       else
248         __format::__store_basic_format_arg<_Context>(__storage.__args_, __args...);
249     }
250   }
251 
252   using _Storage = conditional_t<__format::__use_packed_format_arg_store(sizeof...(_Args)),
253                                  __format::__packed_format_arg_store<_Context, sizeof...(_Args)>,
254                                  __format::__unpacked_format_arg_store<_Context, sizeof...(_Args)>>;
255 
256   _Storage __storage;
257 };
258 
259 #endif //_LIBCPP_STD_VER >= 20
260 
261 _LIBCPP_END_NAMESPACE_STD
262 
263 #endif // _LIBCPP___FORMAT_FORMAT_ARG_STORE_H
264