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