libcxx/include/__format/format_arg_store.h

   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