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