forked from OSchip/llvm-project
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
|