ade6d0d8fa
This implements the handler according to P0645. P2418 changes the wording in the Standard. That isn't implemented and requires changes in more places. LWG3631 applies modifications to P2418, but is currently unresolved. Implements parts of: * P0645 Text Formatting Depends on D115989 Reviewed By: ldionne, #libc Differential Revision: https://reviews.llvm.org/D115991
294 lines
10 KiB
C++
294 lines
10 KiB
C++
// -*- C++ -*-
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef _LIBCPP___FORMAT_FORMAT_ARG_H
|
|
#define _LIBCPP___FORMAT_FORMAT_ARG_H
|
|
|
|
#include <__concepts/arithmetic.h>
|
|
#include <__config>
|
|
#include <__format/format_error.h>
|
|
#include <__format/format_fwd.h>
|
|
#include <__format/format_parse_context.h>
|
|
#include <__functional_base>
|
|
#include <__memory/addressof.h>
|
|
#include <__variant/monostate.h>
|
|
#include <string>
|
|
#include <string_view>
|
|
|
|
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
|
#pragma GCC system_header
|
|
#endif
|
|
|
|
_LIBCPP_PUSH_MACROS
|
|
#include <__undef_macros>
|
|
|
|
_LIBCPP_BEGIN_NAMESPACE_STD
|
|
|
|
#if _LIBCPP_STD_VER > 17
|
|
|
|
// TODO FMT Remove this once we require compilers with proper C++20 support.
|
|
// If the compiler has no concepts support, the format header will be disabled.
|
|
// Without concepts support enable_if needs to be used and that too much effort
|
|
// to support compilers with partial C++20 support.
|
|
#if !defined(_LIBCPP_HAS_NO_CONCEPTS)
|
|
|
|
namespace __format {
|
|
/// The type stored in @ref basic_format_arg.
|
|
///
|
|
/// @note The 128-bit types are unconditionally in the list to avoid the values
|
|
/// of the enums to depend on the availability of 128-bit integers.
|
|
enum class _LIBCPP_ENUM_VIS __arg_t : uint8_t {
|
|
__none,
|
|
__boolean,
|
|
__char_type,
|
|
__int,
|
|
__long_long,
|
|
__i128,
|
|
__unsigned,
|
|
__unsigned_long_long,
|
|
__u128,
|
|
__float,
|
|
__double,
|
|
__long_double,
|
|
__const_char_type_ptr,
|
|
__string_view,
|
|
__ptr,
|
|
__handle
|
|
};
|
|
} // namespace __format
|
|
|
|
template <class _Visitor, class _Context>
|
|
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT decltype(auto)
|
|
visit_format_arg(_Visitor&& __vis, basic_format_arg<_Context> __arg) {
|
|
switch (__arg.__type_) {
|
|
case __format::__arg_t::__none:
|
|
return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), monostate{});
|
|
case __format::__arg_t::__boolean:
|
|
return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__boolean);
|
|
case __format::__arg_t::__char_type:
|
|
return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__char_type);
|
|
case __format::__arg_t::__int:
|
|
return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__int);
|
|
case __format::__arg_t::__long_long:
|
|
return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__long_long);
|
|
case __format::__arg_t::__i128:
|
|
#ifndef _LIBCPP_HAS_NO_INT128
|
|
return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__i128);
|
|
#else
|
|
_LIBCPP_UNREACHABLE();
|
|
#endif
|
|
case __format::__arg_t::__unsigned:
|
|
return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__unsigned);
|
|
case __format::__arg_t::__unsigned_long_long:
|
|
return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis),
|
|
__arg.__unsigned_long_long);
|
|
case __format::__arg_t::__u128:
|
|
#ifndef _LIBCPP_HAS_NO_INT128
|
|
return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__u128);
|
|
#else
|
|
_LIBCPP_UNREACHABLE();
|
|
#endif
|
|
case __format::__arg_t::__float:
|
|
return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__float);
|
|
case __format::__arg_t::__double:
|
|
return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__double);
|
|
case __format::__arg_t::__long_double:
|
|
return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__long_double);
|
|
case __format::__arg_t::__const_char_type_ptr:
|
|
return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis),
|
|
__arg.__const_char_type_ptr);
|
|
case __format::__arg_t::__string_view:
|
|
return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__string_view);
|
|
case __format::__arg_t::__ptr:
|
|
return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__ptr);
|
|
case __format::__arg_t::__handle:
|
|
return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__handle);
|
|
}
|
|
_LIBCPP_UNREACHABLE();
|
|
}
|
|
|
|
template <class _Context>
|
|
class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FORMAT basic_format_arg {
|
|
public:
|
|
class _LIBCPP_TEMPLATE_VIS handle;
|
|
|
|
_LIBCPP_HIDE_FROM_ABI basic_format_arg() noexcept
|
|
: __type_{__format::__arg_t::__none} {}
|
|
|
|
_LIBCPP_HIDE_FROM_ABI explicit operator bool() const noexcept {
|
|
return __type_ != __format::__arg_t::__none;
|
|
}
|
|
|
|
private:
|
|
using char_type = typename _Context::char_type;
|
|
|
|
// TODO FMT Implement constrain [format.arg]/4
|
|
// Constraints: The template specialization
|
|
// typename Context::template formatter_type<T>
|
|
// meets the Formatter requirements ([formatter.requirements]). The extent
|
|
// to which an implementation determines that the specialization meets the
|
|
// Formatter requirements is unspecified, except that as a minimum the
|
|
// expression
|
|
// typename Context::template formatter_type<T>()
|
|
// .format(declval<const T&>(), declval<Context&>())
|
|
// shall be well-formed when treated as an unevaluated operand.
|
|
|
|
template <class _Ctx, class... _Args>
|
|
_LIBCPP_HIDE_FROM_ABI
|
|
_LIBCPP_AVAILABILITY_FORMAT friend __format_arg_store<_Ctx, _Args...>
|
|
_VSTD::make_format_args(const _Args&...);
|
|
|
|
template <class _Visitor, class _Ctx>
|
|
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FORMAT friend decltype(auto)
|
|
_VSTD::visit_format_arg(_Visitor&& __vis, basic_format_arg<_Ctx> __arg);
|
|
|
|
union {
|
|
bool __boolean;
|
|
char_type __char_type;
|
|
int __int;
|
|
unsigned __unsigned;
|
|
long long __long_long;
|
|
unsigned long long __unsigned_long_long;
|
|
#ifndef _LIBCPP_HAS_NO_INT128
|
|
__int128_t __i128;
|
|
__uint128_t __u128;
|
|
#endif
|
|
float __float;
|
|
double __double;
|
|
long double __long_double;
|
|
const char_type* __const_char_type_ptr;
|
|
basic_string_view<char_type> __string_view;
|
|
const void* __ptr;
|
|
handle __handle;
|
|
};
|
|
__format::__arg_t __type_;
|
|
|
|
_LIBCPP_HIDE_FROM_ABI explicit basic_format_arg(bool __v) noexcept
|
|
: __boolean(__v), __type_(__format::__arg_t::__boolean) {}
|
|
|
|
template <class _Tp>
|
|
_LIBCPP_HIDE_FROM_ABI explicit basic_format_arg(_Tp __v) noexcept
|
|
requires(same_as<_Tp, char_type> ||
|
|
(same_as<_Tp, char> && same_as<char_type, wchar_t>))
|
|
: __char_type(__v), __type_(__format::__arg_t::__char_type) {}
|
|
|
|
template <__libcpp_signed_integer _Tp>
|
|
_LIBCPP_HIDE_FROM_ABI explicit basic_format_arg(_Tp __v) noexcept {
|
|
if constexpr (sizeof(_Tp) <= sizeof(int)) {
|
|
__int = static_cast<int>(__v);
|
|
__type_ = __format::__arg_t::__int;
|
|
} else if constexpr (sizeof(_Tp) <= sizeof(long long)) {
|
|
__long_long = static_cast<long long>(__v);
|
|
__type_ = __format::__arg_t::__long_long;
|
|
}
|
|
#ifndef _LIBCPP_HAS_NO_INT128
|
|
else if constexpr (sizeof(_Tp) == sizeof(__int128_t)) {
|
|
__i128 = __v;
|
|
__type_ = __format::__arg_t::__i128;
|
|
}
|
|
#endif
|
|
else
|
|
static_assert(sizeof(_Tp) == 0, "An unsupported signed integer was used");
|
|
}
|
|
|
|
template <__libcpp_unsigned_integer _Tp>
|
|
_LIBCPP_HIDE_FROM_ABI explicit basic_format_arg(_Tp __v) noexcept {
|
|
if constexpr (sizeof(_Tp) <= sizeof(unsigned)) {
|
|
__unsigned = static_cast<unsigned>(__v);
|
|
__type_ = __format::__arg_t::__unsigned;
|
|
} else if constexpr (sizeof(_Tp) <= sizeof(unsigned long long)) {
|
|
__unsigned_long_long = static_cast<unsigned long long>(__v);
|
|
__type_ = __format::__arg_t::__unsigned_long_long;
|
|
}
|
|
#ifndef _LIBCPP_HAS_NO_INT128
|
|
else if constexpr (sizeof(_Tp) == sizeof(__int128_t)) {
|
|
__u128 = __v;
|
|
__type_ = __format::__arg_t::__u128;
|
|
}
|
|
#endif
|
|
else
|
|
static_assert(sizeof(_Tp) == 0,
|
|
"An unsupported unsigned integer was used");
|
|
}
|
|
|
|
_LIBCPP_HIDE_FROM_ABI explicit basic_format_arg(float __v) noexcept
|
|
: __float(__v), __type_(__format::__arg_t::__float) {}
|
|
|
|
_LIBCPP_HIDE_FROM_ABI explicit basic_format_arg(double __v) noexcept
|
|
: __double(__v), __type_(__format::__arg_t::__double) {}
|
|
|
|
_LIBCPP_HIDE_FROM_ABI explicit basic_format_arg(long double __v) noexcept
|
|
: __long_double(__v), __type_(__format::__arg_t::__long_double) {}
|
|
|
|
// Note not a 'noexcept' function.
|
|
_LIBCPP_HIDE_FROM_ABI explicit basic_format_arg(const char_type* __s)
|
|
: __const_char_type_ptr(__s),
|
|
__type_(__format::__arg_t::__const_char_type_ptr) {
|
|
_LIBCPP_ASSERT(__s, "Used a nullptr argument to initialize a C-string");
|
|
}
|
|
|
|
template <class _Traits>
|
|
_LIBCPP_HIDE_FROM_ABI explicit basic_format_arg(
|
|
basic_string_view<char_type, _Traits> __s) noexcept
|
|
: __string_view{__s.data(), __s.size()},
|
|
__type_(__format::__arg_t::__string_view) {}
|
|
|
|
template <class _Traits, class _Allocator>
|
|
_LIBCPP_HIDE_FROM_ABI explicit basic_format_arg(
|
|
const basic_string<char_type, _Traits, _Allocator>& __s) noexcept
|
|
: __string_view{__s.data(), __s.size()},
|
|
__type_(__format::__arg_t::__string_view) {}
|
|
|
|
_LIBCPP_HIDE_FROM_ABI
|
|
explicit basic_format_arg(nullptr_t) noexcept
|
|
: __ptr(nullptr), __type_(__format::__arg_t::__ptr) {}
|
|
|
|
template <class _Tp>
|
|
requires is_void_v<_Tp> _LIBCPP_HIDE_FROM_ABI explicit basic_format_arg(_Tp* __p) noexcept
|
|
: __ptr(__p), __type_(__format::__arg_t::__ptr) {}
|
|
|
|
template <class _Tp>
|
|
_LIBCPP_HIDE_FROM_ABI explicit basic_format_arg(const _Tp& __v) noexcept
|
|
: __handle(__v), __type_(__format::__arg_t::__handle) {}
|
|
};
|
|
|
|
template <class _Context>
|
|
class _LIBCPP_TEMPLATE_VIS basic_format_arg<_Context>::handle {
|
|
friend class basic_format_arg<_Context>;
|
|
|
|
public:
|
|
_LIBCPP_HIDE_FROM_ABI
|
|
void format(basic_format_parse_context<char_type>& __parse_ctx, _Context& __ctx) const {
|
|
__format_(__parse_ctx, __ctx, __ptr_);
|
|
}
|
|
|
|
private:
|
|
const void* __ptr_;
|
|
void (*__format_)(basic_format_parse_context<char_type>&, _Context&, const void*);
|
|
|
|
template <class _Tp>
|
|
_LIBCPP_HIDE_FROM_ABI explicit handle(const _Tp& __v) noexcept
|
|
: __ptr_(_VSTD::addressof(__v)),
|
|
__format_([](basic_format_parse_context<char_type>& __parse_ctx, _Context& __ctx, const void* __ptr) {
|
|
typename _Context::template formatter_type<_Tp> __f;
|
|
__parse_ctx.advance_to(__f.parse(__parse_ctx));
|
|
__ctx.advance_to(__f.format(*static_cast<const _Tp*>(__ptr), __ctx));
|
|
}) {}
|
|
};
|
|
|
|
#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)
|
|
|
|
#endif //_LIBCPP_STD_VER > 17
|
|
|
|
_LIBCPP_END_NAMESPACE_STD
|
|
|
|
_LIBCPP_POP_MACROS
|
|
|
|
#endif // _LIBCPP___FORMAT_FORMAT_ARG_H
|