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 <__utility/forward.h> 23#include <cstring> 24#include <string> 25#include <string_view> 26#include <type_traits> 27 28_LIBCPP_BEGIN_NAMESPACE_STD 29 30#if _LIBCPP_STD_VER > 17 31 32namespace __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> 37template <class _Context, class _Tp> 38consteval __arg_t __determine_arg_t(); 39 40// Boolean 41template <class, same_as<bool> _Tp> 42consteval __arg_t __determine_arg_t() { 43 return __arg_t::__boolean; 44} 45 46// Char 47template <class _Context, same_as<typename _Context::char_type> _Tp> 48consteval __arg_t __determine_arg_t() { 49 return __arg_t::__char_type; 50} 51# ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS 52template <class _Context, class _CharT> 53 requires(same_as<typename _Context::char_type, wchar_t> && same_as<_CharT, char>) 54consteval __arg_t __determine_arg_t() { 55 return __arg_t::__char_type; 56} 57# endif 58 59// Signed integers 60template <class, __libcpp_signed_integer _Tp> 61consteval __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 75template <class, __libcpp_unsigned_integer _Tp> 76consteval __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 90template <class, same_as<float> _Tp> 91consteval __arg_t __determine_arg_t() { 92 return __arg_t::__float; 93} 94template <class, same_as<double> _Tp> 95consteval __arg_t __determine_arg_t() { 96 return __arg_t::__double; 97} 98template <class, same_as<long double> _Tp> 99consteval __arg_t __determine_arg_t() { 100 return __arg_t::__long_double; 101} 102 103// Char pointer 104template <class _Context, class _Tp> 105 requires(same_as<typename _Context::char_type*, _Tp> || same_as<const typename _Context::char_type*, _Tp>) 106consteval __arg_t __determine_arg_t() { 107 return __arg_t::__const_char_type_ptr; 108} 109 110// Char array 111template <class _Context, class _Tp> 112 requires(is_array_v<_Tp> && same_as<_Tp, typename _Context::char_type[extent_v<_Tp>]>) 113consteval __arg_t __determine_arg_t() { 114 return __arg_t::__string_view; 115} 116 117// String view 118template <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>>) 121consteval __arg_t __determine_arg_t() { 122 return __arg_t::__string_view; 123} 124 125// String 126template <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>>) 130consteval __arg_t __determine_arg_t() { 131 return __arg_t::__string_view; 132} 133 134// Pointers 135template <class, class _Ptr> 136 requires(same_as<_Ptr, void*> || same_as<_Ptr, const void*> || same_as<_Ptr, nullptr_t>) 137consteval __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. That overload 146// is marked as deleted to fail creating a storage type for disabled formatters. 147template <class _Context, class _Tp> 148consteval __arg_t __determine_arg_t() { 149 return __arg_t::__handle; 150} 151 152template <class _Context, class _Tp> 153 requires(!__formattable<_Tp, typename _Context::char_type>) 154consteval __arg_t __determine_arg_t() = delete; 155 156template <class _Context, class _Tp> 157_LIBCPP_HIDE_FROM_ABI basic_format_arg<_Context> __create_format_arg(_Tp&& __value) noexcept { 158 constexpr __arg_t __arg = __determine_arg_t<_Context, remove_cvref_t<_Tp>>(); 159 static_assert(__arg != __arg_t::__none); 160 161 // Not all types can be used to directly initialize the 162 // __basic_format_arg_value. First handle all types needing adjustment, the 163 // final else requires no adjustment. 164 if constexpr (__arg == __arg_t::__char_type) 165 // On some platforms initializing a wchar_t from a char is a narrowing 166 // conversion. 167 return basic_format_arg<_Context>{__arg, static_cast<typename _Context::char_type>(__value)}; 168 else if constexpr (__arg == __arg_t::__int) 169 return basic_format_arg<_Context>{__arg, static_cast<int>(__value)}; 170 else if constexpr (__arg == __arg_t::__long_long) 171 return basic_format_arg<_Context>{__arg, static_cast<long long>(__value)}; 172 else if constexpr (__arg == __arg_t::__unsigned) 173 return basic_format_arg<_Context>{__arg, static_cast<unsigned>(__value)}; 174 else if constexpr (__arg == __arg_t::__unsigned_long_long) 175 return basic_format_arg<_Context>{__arg, static_cast<unsigned long long>(__value)}; 176 else if constexpr (__arg == __arg_t::__string_view) 177 // Using std::size on a character array will add the NUL-terminator to the size. 178 if constexpr (is_array_v<remove_cvref_t<_Tp>>) 179 return basic_format_arg<_Context>{ 180 __arg, basic_string_view<typename _Context::char_type>{__value, extent_v<remove_cvref_t<_Tp>> - 1}}; 181 else 182 // When the _Traits or _Allocator are different an implicit conversion will 183 // fail. 184 return basic_format_arg<_Context>{ 185 __arg, basic_string_view<typename _Context::char_type>{__value.data(), __value.size()}}; 186 else if constexpr (__arg == __arg_t::__ptr) 187 return basic_format_arg<_Context>{__arg, static_cast<const void*>(__value)}; 188 else if constexpr (__arg == __arg_t::__handle) 189 return basic_format_arg<_Context>{ 190 __arg, typename __basic_format_arg_value<_Context>::__handle{_VSTD::forward<_Tp>(__value)}}; 191 else 192 return basic_format_arg<_Context>{__arg, __value}; 193} 194 195template <class _Context, class... _Args> 196_LIBCPP_HIDE_FROM_ABI void __create_packed_storage(uint64_t& __types, __basic_format_arg_value<_Context>* __values, 197 _Args&&... __args) noexcept { 198 int __shift = 0; 199 ( 200 [&] { 201 basic_format_arg<_Context> __arg = __format::__create_format_arg<_Context>(__args); 202 if (__shift != 0) 203 __types |= static_cast<uint64_t>(__arg.__type_) << __shift; 204 else 205 // Assigns the initial value. 206 __types = static_cast<uint64_t>(__arg.__type_); 207 __shift += __packed_arg_t_bits; 208 *__values++ = __arg.__value_; 209 }(), 210 ...); 211} 212 213template <class _Context, class... _Args> 214_LIBCPP_HIDE_FROM_ABI void __store_basic_format_arg(basic_format_arg<_Context>* __data, _Args&&... __args) noexcept { 215 ([&] { *__data++ = __format::__create_format_arg<_Context>(__args); }(), ...); 216} 217 218template <class _Context, size_t N> 219struct __packed_format_arg_store { 220 __basic_format_arg_value<_Context> __values_[N]; 221 uint64_t __types_; 222}; 223 224template <class _Context, size_t N> 225struct __unpacked_format_arg_store { 226 basic_format_arg<_Context> __args_[N]; 227}; 228 229} // namespace __format 230 231template <class _Context, class... _Args> 232struct _LIBCPP_TEMPLATE_VIS __format_arg_store { 233 _LIBCPP_HIDE_FROM_ABI 234 __format_arg_store(_Args&... __args) noexcept { 235 if constexpr (sizeof...(_Args) != 0) { 236 if constexpr (__format::__use_packed_format_arg_store(sizeof...(_Args))) 237 __format::__create_packed_storage(__storage.__types_, __storage.__values_, __args...); 238 else 239 __format::__store_basic_format_arg<_Context>(__storage.__args_, __args...); 240 } 241 } 242 243 using _Storage = conditional_t<__format::__use_packed_format_arg_store(sizeof...(_Args)), 244 __format::__packed_format_arg_store<_Context, sizeof...(_Args)>, 245 __format::__unpacked_format_arg_store<_Context, sizeof...(_Args)>>; 246 247 _Storage __storage; 248}; 249 250#endif //_LIBCPP_STD_VER > 17 251 252_LIBCPP_END_NAMESPACE_STD 253 254#endif // _LIBCPP___FORMAT_FORMAT_ARG_STORE_H 255