libcxx/include/__format/format_arg.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_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
  82 constexpr bool __use_packed_format_arg_store(size_t __size) { return __size <= __packed_types_max; }
  83
  84 _LIBCPP_HIDE_FROM_ABI
  85 constexpr __arg_t __get_packed_type(uint64_t __types, size_t __id) {
  86   _LIBCPP_ASSERT_UNCATEGORIZED(__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)
 100 __visit_format_arg(_Visitor&& __vis, basic_format_arg<_Context> __arg) {
 101   switch (__arg.__type_) {
 102   case __format::__arg_t::__none:
 103     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__monostate_);
 104   case __format::__arg_t::__boolean:
 105     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__boolean_);
 106   case __format::__arg_t::__char_type:
 107     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__char_type_);
 108   case __format::__arg_t::__int:
 109     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__int_);
 110   case __format::__arg_t::__long_long:
 111     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__long_long_);
 112   case __format::__arg_t::__i128:
 113 #  ifndef _LIBCPP_HAS_NO_INT128
 114     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__i128_);
 115 #  else
 116     __libcpp_unreachable();
 117 #  endif
 118   case __format::__arg_t::__unsigned:
 119     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__unsigned_);
 120   case __format::__arg_t::__unsigned_long_long:
 121     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__unsigned_long_long_);
 122   case __format::__arg_t::__u128:
 123 #  ifndef _LIBCPP_HAS_NO_INT128
 124     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__u128_);
 125 #  else
 126     __libcpp_unreachable();
 127 #  endif
 128   case __format::__arg_t::__float:
 129     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__float_);
 130   case __format::__arg_t::__double:
 131     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__double_);
 132   case __format::__arg_t::__long_double:
 133     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__long_double_);
 134   case __format::__arg_t::__const_char_type_ptr:
 135     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__const_char_type_ptr_);
 136   case __format::__arg_t::__string_view:
 137     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__string_view_);
 138   case __format::__arg_t::__ptr:
 139     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__ptr_);
 140   case __format::__arg_t::__handle:
 141     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis),
 142                          typename basic_format_arg<_Context>::handle{__arg.__value_.__handle_});
 143   }
 144
 145   __libcpp_unreachable();
 146 }
 147
 148 /// Contains the values used in basic_format_arg.
 149 ///
 150 /// This is a separate type so it's possible to store the values and types in
 151 /// separate arrays.
 152 template <class _Context>
 153 class __basic_format_arg_value {
 154   using _CharT = typename _Context::char_type;
 155
 156 public:
 157   /// Contains the implementation for basic_format_arg::handle.
 158   struct __handle {
 159     template <class _Tp>
 160     _LIBCPP_HIDE_FROM_ABI explicit __handle(_Tp& __v) noexcept
 161         : __ptr_(_VSTD::addressof(__v)),
 162           __format_([](basic_format_parse_context<_CharT>& __parse_ctx, _Context& __ctx, const void* __ptr) {
 163             using _Dp = remove_const_t<_Tp>;
 164             using _Qp = conditional_t<__formattable_with<const _Dp, _Context>, const _Dp, _Dp>;
 165             static_assert(__formattable_with<_Qp, _Context>, "Mandated by [format.arg]/10");
 166
 167             typename _Context::template formatter_type<_Dp> __f;
 168             __parse_ctx.advance_to(__f.parse(__parse_ctx));
 169             __ctx.advance_to(__f.format(*const_cast<_Qp*>(static_cast<const _Dp*>(__ptr)), __ctx));
 170           }) {}
 171
 172     const void* __ptr_;
 173     void (*__format_)(basic_format_parse_context<_CharT>&, _Context&, const void*);
 174   };
 175
 176   union {
 177     monostate __monostate_;
 178     bool __boolean_;
 179     _CharT __char_type_;
 180     int __int_;
 181     unsigned __unsigned_;
 182     long long __long_long_;
 183     unsigned long long __unsigned_long_long_;
 184 #  ifndef _LIBCPP_HAS_NO_INT128
 185     __int128_t __i128_;
 186     __uint128_t __u128_;
 187 #  endif
 188     float __float_;
 189     double __double_;
 190     long double __long_double_;
 191     const _CharT* __const_char_type_ptr_;
 192     basic_string_view<_CharT> __string_view_;
 193     const void* __ptr_;
 194     __handle __handle_;
 195   };
 196
 197   // These constructors contain the exact storage type used. If adjustments are
 198   // required, these will be done in __create_format_arg.
 199
 200   _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value() noexcept : __monostate_() {}
 201   _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(bool __value) noexcept : __boolean_(__value) {}
 202   _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(_CharT __value) noexcept : __char_type_(__value) {}
 203   _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(int __value) noexcept : __int_(__value) {}
 204   _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(unsigned __value) noexcept : __unsigned_(__value) {}
 205   _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(long long __value) noexcept : __long_long_(__value) {}
 206   _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(unsigned long long __value) noexcept
 207       : __unsigned_long_long_(__value) {}
 208 #  ifndef _LIBCPP_HAS_NO_INT128
 209   _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(__int128_t __value) noexcept : __i128_(__value) {}
 210   _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(__uint128_t __value) noexcept : __u128_(__value) {}
 211 #  endif
 212   _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(float __value) noexcept : __float_(__value) {}
 213   _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(double __value) noexcept : __double_(__value) {}
 214   _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(long double __value) noexcept : __long_double_(__value) {}
 215   _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(const _CharT* __value) noexcept : __const_char_type_ptr_(__value) {}
 216   _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(basic_string_view<_CharT> __value) noexcept
 217       : __string_view_(__value) {}
 218   _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(const void* __value) noexcept : __ptr_(__value) {}
 219   _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(__handle&& __value) noexcept : __handle_(std::move(__value)) {}
 220 };
 221
 222 template <class _Context>
 223 class _LIBCPP_TEMPLATE_VIS basic_format_arg {
 224 public:
 225   class _LIBCPP_TEMPLATE_VIS handle;
 226
 227   _LIBCPP_HIDE_FROM_ABI basic_format_arg() noexcept
 228       : __type_{__format::__arg_t::__none} {}
 229
 230   _LIBCPP_HIDE_FROM_ABI explicit operator bool() const noexcept {
 231     return __type_ != __format::__arg_t::__none;
 232   }
 233
 234 private:
 235   using char_type = typename _Context::char_type;
 236
 237   // TODO FMT Implement constrain [format.arg]/4
 238   // Constraints: The template specialization
 239   //   typename Context::template formatter_type<T>
 240   // meets the Formatter requirements ([formatter.requirements]).  The extent
 241   // to which an implementation determines that the specialization meets the
 242   // Formatter requirements is unspecified, except that as a minimum the
 243   // expression
 244   //   typename Context::template formatter_type<T>()
 245   //    .format(declval<const T&>(), declval<Context&>())
 246   // shall be well-formed when treated as an unevaluated operand.
 247
 248 public:
 249   __basic_format_arg_value<_Context> __value_;
 250   __format::__arg_t __type_;
 251
 252   _LIBCPP_HIDE_FROM_ABI explicit basic_format_arg(__format::__arg_t __type,
 253                                                   __basic_format_arg_value<_Context> __value) noexcept
 254       : __value_(__value), __type_(__type) {}
 255 };
 256
 257 template <class _Context>
 258 class _LIBCPP_TEMPLATE_VIS basic_format_arg<_Context>::handle {
 259 public:
 260   _LIBCPP_HIDE_FROM_ABI
 261   void format(basic_format_parse_context<char_type>& __parse_ctx, _Context& __ctx) const {
 262     __handle_.__format_(__parse_ctx, __ctx, __handle_.__ptr_);
 263   }
 264
 265   _LIBCPP_HIDE_FROM_ABI explicit handle(typename __basic_format_arg_value<_Context>::__handle& __handle) noexcept
 266       : __handle_(__handle) {}
 267
 268 private:
 269   typename __basic_format_arg_value<_Context>::__handle& __handle_;
 270 };
 271
 272 // This function is user facing, so it must wrap the non-standard types of
 273 // the "variant" in a handle to stay conforming. See __arg_t for more details.
 274 template <class _Visitor, class _Context>
 275 _LIBCPP_HIDE_FROM_ABI decltype(auto)
 276 visit_format_arg(_Visitor&& __vis, basic_format_arg<_Context> __arg) {
 277   switch (__arg.__type_) {
 278 #  ifndef _LIBCPP_HAS_NO_INT128
 279   case __format::__arg_t::__i128: {
 280     typename __basic_format_arg_value<_Context>::__handle __h{__arg.__value_.__i128_};
 281     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), typename basic_format_arg<_Context>::handle{__h});
 282   }
 283
 284   case __format::__arg_t::__u128: {
 285     typename __basic_format_arg_value<_Context>::__handle __h{__arg.__value_.__u128_};
 286     return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), typename basic_format_arg<_Context>::handle{__h});
 287   }
 288 #  endif
 289   default:
 290     return _VSTD::__visit_format_arg(_VSTD::forward<_Visitor>(__vis), __arg);
 291   }
 292 }
 293
 294 #endif //_LIBCPP_STD_VER >= 20
 295
 296 _LIBCPP_END_NAMESPACE_STD
 297
 298 #endif // _LIBCPP___FORMAT_FORMAT_ARG_H