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