mirror of
https://github.com/fmtlib/fmt.git
synced 2025-01-12 15:39:09 +00:00
Remove FMT_USE_VARIADIC_TEMPLATES
This commit is contained in:
Victor Zverovich
parent
9bb213e920
commit
92605eb4f7
119
fmt/format.h
119
fmt/format.h
@ -131,15 +131,6 @@ typedef __int64 intmax_t;
|
||||
# define FMT_HAS_CPP_ATTRIBUTE(x) 0
|
||||
#endif
|
||||
|
||||
#ifndef FMT_USE_VARIADIC_TEMPLATES
|
||||
// Variadic templates are available in GCC since version 4.4
|
||||
// (http://gcc.gnu.org/projects/cxx0x.html) and in Visual C++
|
||||
// since version 2013.
|
||||
# define FMT_USE_VARIADIC_TEMPLATES \
|
||||
(FMT_HAS_FEATURE(cxx_variadic_templates) || \
|
||||
(FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1800)
|
||||
#endif
|
||||
|
||||
#ifndef FMT_USE_RVALUE_REFERENCES
|
||||
// Don't use rvalue references when compiling with clang and an old libstdc++
|
||||
// as the latter doesn't provide std::move.
|
||||
@ -219,7 +210,7 @@ typedef __int64 intmax_t;
|
||||
// for variadic templates is added here just in case.
|
||||
// For Intel's compiler both it and the system gcc/msc must support UDLs.
|
||||
# define FMT_USE_USER_DEFINED_LITERALS \
|
||||
FMT_USE_VARIADIC_TEMPLATES && FMT_USE_RVALUE_REFERENCES && \
|
||||
FMT_USE_RVALUE_REFERENCES && \
|
||||
(FMT_HAS_FEATURE(cxx_user_literals) || \
|
||||
(FMT_GCC_VERSION >= 407 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900) && \
|
||||
(!defined(FMT_ICC_VERSION) || FMT_ICC_VERSION >= 1500)
|
||||
@ -841,7 +832,7 @@ struct FMT_API BasicData {
|
||||
#ifndef FMT_USE_EXTERN_TEMPLATES
|
||||
// Clang doesn't have a feature check for extern templates so we check
|
||||
// for variadic templates which were introduced in the same version.
|
||||
# define FMT_USE_EXTERN_TEMPLATES (__clang__ && FMT_USE_VARIADIC_TEMPLATES)
|
||||
# define FMT_USE_EXTERN_TEMPLATES (__clang__)
|
||||
#endif
|
||||
|
||||
#if FMT_USE_EXTERN_TEMPLATES && !defined(FMT_HEADER_ONLY)
|
||||
@ -2131,32 +2122,10 @@ struct ArgArray<N, false/*IsPacked*/> {
|
||||
static Arg make(const T &value) { return MakeArg<Formatter>(value); }
|
||||
};
|
||||
|
||||
#if FMT_USE_VARIADIC_TEMPLATES
|
||||
template <typename Arg, typename... Args>
|
||||
inline uint64_t make_type(const Arg &first, const Args & ... tail) {
|
||||
return make_type(first) | (make_type(tail...) << 4);
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
struct ArgType {
|
||||
uint64_t type;
|
||||
|
||||
ArgType() : type(0) {}
|
||||
|
||||
template <typename T>
|
||||
ArgType(const T &arg) : type(make_type(arg)) {}
|
||||
};
|
||||
|
||||
# define FMT_ARG_TYPE_DEFAULT(n) ArgType t##n = ArgType()
|
||||
|
||||
inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
|
||||
return t0.type | (t1.type << 4) | (t2.type << 8) | (t3.type << 12) |
|
||||
(t4.type << 16) | (t5.type << 20) | (t6.type << 24) | (t7.type << 28) |
|
||||
(t8.type << 32) | (t9.type << 36) | (t10.type << 40) | (t11.type << 44) |
|
||||
(t12.type << 48) | (t13.type << 52) | (t14.type << 56);
|
||||
}
|
||||
#endif
|
||||
} // namespace internal
|
||||
|
||||
# define FMT_MAKE_TEMPLATE_ARG(n) typename T##n
|
||||
@ -2167,7 +2136,6 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
|
||||
# define FMT_ASSIGN_wchar_t(n) \
|
||||
arr[n] = fmt::internal::MakeValue< fmt::BasicFormatter<wchar_t> >(v##n)
|
||||
|
||||
#if FMT_USE_VARIADIC_TEMPLATES
|
||||
// Defines a variadic function returning void.
|
||||
# define FMT_VARIADIC_VOID(func, arg_type) \
|
||||
template <typename... Args> \
|
||||
@ -2188,53 +2156,6 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
|
||||
func(arg0, arg1, fmt::ArgList(fmt::internal::make_type(args...), array)); \
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
# define FMT_MAKE_REF(n) \
|
||||
fmt::internal::MakeValue< fmt::BasicFormatter<Char> >(v##n)
|
||||
# define FMT_MAKE_REF2(n) v##n
|
||||
|
||||
// Defines a wrapper for a function taking one argument of type arg_type
|
||||
// and n additional arguments of arbitrary types.
|
||||
# define FMT_WRAP1(func, arg_type, n) \
|
||||
template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
|
||||
inline void func(arg_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \
|
||||
const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \
|
||||
func(arg1, fmt::ArgList( \
|
||||
fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \
|
||||
}
|
||||
|
||||
// Emulates a variadic function returning void on a pre-C++11 compiler.
|
||||
# define FMT_VARIADIC_VOID(func, arg_type) \
|
||||
inline void func(arg_type arg) { func(arg, fmt::ArgList()); } \
|
||||
FMT_WRAP1(func, arg_type, 1) FMT_WRAP1(func, arg_type, 2) \
|
||||
FMT_WRAP1(func, arg_type, 3) FMT_WRAP1(func, arg_type, 4) \
|
||||
FMT_WRAP1(func, arg_type, 5) FMT_WRAP1(func, arg_type, 6) \
|
||||
FMT_WRAP1(func, arg_type, 7) FMT_WRAP1(func, arg_type, 8) \
|
||||
FMT_WRAP1(func, arg_type, 9) FMT_WRAP1(func, arg_type, 10)
|
||||
|
||||
# define FMT_CTOR(ctor, func, arg0_type, arg1_type, n) \
|
||||
template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
|
||||
ctor(arg0_type arg0, arg1_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \
|
||||
const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \
|
||||
func(arg0, arg1, fmt::ArgList( \
|
||||
fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \
|
||||
}
|
||||
|
||||
// Emulates a variadic constructor on a pre-C++11 compiler.
|
||||
# define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \
|
||||
FMT_CTOR(ctor, func, arg0_type, arg1_type, 1) \
|
||||
FMT_CTOR(ctor, func, arg0_type, arg1_type, 2) \
|
||||
FMT_CTOR(ctor, func, arg0_type, arg1_type, 3) \
|
||||
FMT_CTOR(ctor, func, arg0_type, arg1_type, 4) \
|
||||
FMT_CTOR(ctor, func, arg0_type, arg1_type, 5) \
|
||||
FMT_CTOR(ctor, func, arg0_type, arg1_type, 6) \
|
||||
FMT_CTOR(ctor, func, arg0_type, arg1_type, 7) \
|
||||
FMT_CTOR(ctor, func, arg0_type, arg1_type, 8) \
|
||||
FMT_CTOR(ctor, func, arg0_type, arg1_type, 9) \
|
||||
FMT_CTOR(ctor, func, arg0_type, arg1_type, 10)
|
||||
#endif
|
||||
|
||||
// Generates a comma-separated list with results of applying f to pairs
|
||||
// (argument, index).
|
||||
#define FMT_FOR_EACH1(f, x0) f(x0, 0)
|
||||
@ -3365,8 +3286,7 @@ void arg(WStringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;
|
||||
#define FMT_ADD_ARG_NAME(type, index) type arg##index
|
||||
#define FMT_GET_ARG_NAME(type, index) arg##index
|
||||
|
||||
#if FMT_USE_VARIADIC_TEMPLATES
|
||||
# define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \
|
||||
#define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \
|
||||
template <typename... Args> \
|
||||
ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \
|
||||
const Args & ... args) { \
|
||||
@ -3376,39 +3296,6 @@ void arg(WStringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;
|
||||
call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), \
|
||||
fmt::ArgList(fmt::internal::make_type(args...), array)); \
|
||||
}
|
||||
#else
|
||||
// Defines a wrapper for a function taking __VA_ARGS__ arguments
|
||||
// and n additional arguments of arbitrary types.
|
||||
# define FMT_WRAP(Char, ReturnType, func, call, n, ...) \
|
||||
template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
|
||||
inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \
|
||||
FMT_GEN(n, FMT_MAKE_ARG)) { \
|
||||
fmt::internal::ArgArray<n>::Type arr; \
|
||||
FMT_GEN(n, FMT_ASSIGN_##Char); \
|
||||
call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList( \
|
||||
fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), arr)); \
|
||||
}
|
||||
|
||||
# define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \
|
||||
inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__)) { \
|
||||
call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList()); \
|
||||
} \
|
||||
FMT_WRAP(Char, ReturnType, func, call, 1, __VA_ARGS__) \
|
||||
FMT_WRAP(Char, ReturnType, func, call, 2, __VA_ARGS__) \
|
||||
FMT_WRAP(Char, ReturnType, func, call, 3, __VA_ARGS__) \
|
||||
FMT_WRAP(Char, ReturnType, func, call, 4, __VA_ARGS__) \
|
||||
FMT_WRAP(Char, ReturnType, func, call, 5, __VA_ARGS__) \
|
||||
FMT_WRAP(Char, ReturnType, func, call, 6, __VA_ARGS__) \
|
||||
FMT_WRAP(Char, ReturnType, func, call, 7, __VA_ARGS__) \
|
||||
FMT_WRAP(Char, ReturnType, func, call, 8, __VA_ARGS__) \
|
||||
FMT_WRAP(Char, ReturnType, func, call, 9, __VA_ARGS__) \
|
||||
FMT_WRAP(Char, ReturnType, func, call, 10, __VA_ARGS__) \
|
||||
FMT_WRAP(Char, ReturnType, func, call, 11, __VA_ARGS__) \
|
||||
FMT_WRAP(Char, ReturnType, func, call, 12, __VA_ARGS__) \
|
||||
FMT_WRAP(Char, ReturnType, func, call, 13, __VA_ARGS__) \
|
||||
FMT_WRAP(Char, ReturnType, func, call, 14, __VA_ARGS__) \
|
||||
FMT_WRAP(Char, ReturnType, func, call, 15, __VA_ARGS__)
|
||||
#endif // FMT_USE_VARIADIC_TEMPLATES
|
||||
|
||||
/**
|
||||
\rst
|
||||
|
||||
@ -76,13 +76,6 @@ int result;
|
||||
MAKE_TEST(test_func)
|
||||
|
||||
typedef char Char;
|
||||
FMT_WRAP1(test_func, const char *, 1)
|
||||
|
||||
TEST(UtilTest, Wrap1) {
|
||||
result = 0;
|
||||
test_func("", 42);
|
||||
EXPECT_EQ(42, result);
|
||||
}
|
||||
|
||||
MAKE_TEST(test_variadic_void)
|
||||
FMT_VARIADIC_VOID(test_variadic_void, const char *)
|
||||
|
||||
Loading…
Reference in New Issue
Block a user