TeaSpeak/spdlog
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Fix issue #64 (clang build fails due to details/format.h diagnostic pop without prior push)

Browse Source
This commit is contained in:
gabime 2015-03-21 13:29:53 +02:00
parent 3556c87a51
commit 6fe03c7780
1 changed files with 27 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
include/spdlog/details/format.h
View File

@ -102,6 +102,7 @@ inline uint32_t clzll(uint64_t x) {
#endif #endif
#ifdef __clang__ #ifdef __clang__
# pragma clang diagnostic push
# pragma clang diagnostic ignored "-Wdocumentation" # pragma clang diagnostic ignored "-Wdocumentation"
#endif #endif
@ -174,7 +175,6 @@ inline uint32_t clzll(uint64_t x) {
#endif #endif
namespace fmt { namespace fmt {
// Fix the warning about long long on older versions of GCC // Fix the warning about long long on older versions of GCC
// that don't support the diagnostic pragma. // that don't support the diagnostic pragma.
FMT_GCC_EXTENSION typedef long long LongLong; FMT_GCC_EXTENSION typedef long long LongLong;
@ -288,7 +288,6 @@ public:
}; };
namespace internal { namespace internal {
// The number of characters to store in the MemoryBuffer object itself // The number of characters to store in the MemoryBuffer object itself
// to avoid dynamic memory allocation. // to avoid dynamic memory allocation.
enum { INLINE_BUFFER_SIZE = 500 }; enum { INLINE_BUFFER_SIZE = 500 };
@ -379,7 +378,7 @@ void Buffer<T>::append(const T *begin, const T *end) {
// A memory buffer for POD types with the first SIZE elements stored in // A memory buffer for POD types with the first SIZE elements stored in
// the object itself. // the object itself.
template <typename T, std::size_t SIZE, typename Allocator = std::allocator<T> > template <typename T, std::size_t SIZE, typename Allocator = std::allocator<T> >
class MemoryBuffer : private Allocator, public Buffer<T> { class MemoryBuffer : private Allocator, public Buffer < T > {
private: private:
T data_[SIZE]; T data_[SIZE];
@ -516,7 +515,7 @@ template <typename Char>
class CharTraits; class CharTraits;
template <> template <>
class CharTraits<char> : public BasicCharTraits<char> { class CharTraits<char> : public BasicCharTraits < char > {
private: private:
// Conversion from wchar_t to char is not allowed. // Conversion from wchar_t to char is not allowed.
static char convert(wchar_t); static char convert(wchar_t);
@ -533,7 +532,7 @@ public:
}; };
template <> template <>
class CharTraits<wchar_t> : public BasicCharTraits<wchar_t> { class CharTraits<wchar_t> : public BasicCharTraits < wchar_t > {
public: public:
static wchar_t convert(char value) { static wchar_t convert(char value) {
return value; return value;
@ -557,7 +556,7 @@ struct SignChecker {
}; };
template <> template <>
struct SignChecker<false> { struct SignChecker < false > {
template <typename T> template <typename T>
static bool is_negative(T) { static bool is_negative(T) {
return false; return false;
@ -578,7 +577,7 @@ struct TypeSelector {
}; };
template <> template <>
struct TypeSelector<false> { struct TypeSelector < false > {
typedef uint64_t Type; typedef uint64_t Type;
}; };
@ -754,7 +753,7 @@ struct NonZero {
}; };
template <> template <>
struct NonZero<0> { struct NonZero < 0 > {
enum { VALUE = 1 }; enum { VALUE = 1 };
}; };
@ -815,7 +814,7 @@ struct WCharHelper {
}; };
template <typename T> template <typename T>
struct WCharHelper<T, wchar_t> { struct WCharHelper < T, wchar_t > {
typedef T Supported; typedef T Supported;
typedef None<T> Unsupported; typedef None<T> Unsupported;
}; };
@ -929,7 +928,7 @@ public:
#define FMT_MAKE_WSTR_VALUE(Type, TYPE) \ #define FMT_MAKE_WSTR_VALUE(Type, TYPE) \
MakeValue(typename WCharHelper<Type, Char>::Supported value) { \ MakeValue(typename WCharHelper<Type, Char>::Supported value) { \
set_string(value); \ set_string(value); \
} \ } \
static uint64_t type(Type) { return Arg::TYPE; } static uint64_t type(Type) { return Arg::TYPE; }
FMT_MAKE_WSTR_VALUE(wchar_t *, WSTRING) FMT_MAKE_WSTR_VALUE(wchar_t *, WSTRING)
@ -943,7 +942,7 @@ public:
template <typename T> template <typename T>
MakeValue(const T &value) { MakeValue(const T &value) {
custom.value = &value; custom.value = &value;
custom.format = &format_custom_arg<T>; custom.format = &format_custom_arg < T > ;
} }
template <typename T> template <typename T>
static uint64_t type(const T &) { static uint64_t type(const T &) {
@ -1111,7 +1110,6 @@ public:
struct FormatSpec; struct FormatSpec;
namespace internal { namespace internal {
class FormatterBase { class FormatterBase {
private: private:
ArgList args_; ArgList args_;
@ -1360,26 +1358,26 @@ IntFormatSpec<int, AlignTypeSpec<TYPE_CODE>, Char> pad(
#define FMT_DEFINE_INT_FORMATTERS(TYPE) \ #define FMT_DEFINE_INT_FORMATTERS(TYPE) \
inline IntFormatSpec<TYPE, TypeSpec<'b'> > bin(TYPE value) { \ inline IntFormatSpec<TYPE, TypeSpec<'b'> > bin(TYPE value) { \
return IntFormatSpec<TYPE, TypeSpec<'b'> >(value, TypeSpec<'b'>()); \ return IntFormatSpec<TYPE, TypeSpec<'b'> >(value, TypeSpec<'b'>()); \
} \ } \
\ \
inline IntFormatSpec<TYPE, TypeSpec<'o'> > oct(TYPE value) { \ inline IntFormatSpec<TYPE, TypeSpec<'o'> > oct(TYPE value) { \
return IntFormatSpec<TYPE, TypeSpec<'o'> >(value, TypeSpec<'o'>()); \ return IntFormatSpec<TYPE, TypeSpec<'o'> >(value, TypeSpec<'o'>()); \
} \ } \
\ \
inline IntFormatSpec<TYPE, TypeSpec<'x'> > hex(TYPE value) { \ inline IntFormatSpec<TYPE, TypeSpec<'x'> > hex(TYPE value) { \
return IntFormatSpec<TYPE, TypeSpec<'x'> >(value, TypeSpec<'x'>()); \ return IntFormatSpec<TYPE, TypeSpec<'x'> >(value, TypeSpec<'x'>()); \
} \ } \
\ \
inline IntFormatSpec<TYPE, TypeSpec<'X'> > hexu(TYPE value) { \ inline IntFormatSpec<TYPE, TypeSpec<'X'> > hexu(TYPE value) { \
return IntFormatSpec<TYPE, TypeSpec<'X'> >(value, TypeSpec<'X'>()); \ return IntFormatSpec<TYPE, TypeSpec<'X'> >(value, TypeSpec<'X'>()); \
} \ } \
\ \
template <char TYPE_CODE> \ template <char TYPE_CODE> \
inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE> > pad( \ inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE> > pad( \
IntFormatSpec<TYPE, TypeSpec<TYPE_CODE> > f, unsigned width) { \ IntFormatSpec<TYPE, TypeSpec<TYPE_CODE> > f, unsigned width) { \
return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE> >( \ return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE> >( \
f.value(), AlignTypeSpec<TYPE_CODE>(width, ' ')); \ f.value(), AlignTypeSpec<TYPE_CODE>(width, ' ')); \
} \ } \
\ \
/* For compatibility with older compilers we provide two overloads for pad, */ \ /* For compatibility with older compilers we provide two overloads for pad, */ \
/* one that takes a fill character and one that doesn't. In the future this */ \ /* one that takes a fill character and one that doesn't. In the future this */ \
@ -1391,20 +1389,20 @@ inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char> pad( \
unsigned width, Char fill) { \ unsigned width, Char fill) { \
return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char>( \ return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char>( \
f.value(), AlignTypeSpec<TYPE_CODE>(width, fill)); \ f.value(), AlignTypeSpec<TYPE_CODE>(width, fill)); \
} \ } \
\ \
inline IntFormatSpec<TYPE, AlignTypeSpec<0> > pad( \ inline IntFormatSpec<TYPE, AlignTypeSpec<0> > pad( \
TYPE value, unsigned width) { \ TYPE value, unsigned width) { \
return IntFormatSpec<TYPE, AlignTypeSpec<0> >( \ return IntFormatSpec<TYPE, AlignTypeSpec<0> >( \
value, AlignTypeSpec<0>(width, ' ')); \ value, AlignTypeSpec<0>(width, ' ')); \
} \ } \
\ \
template <typename Char> \ template <typename Char> \
inline IntFormatSpec<TYPE, AlignTypeSpec<0>, Char> pad( \ inline IntFormatSpec<TYPE, AlignTypeSpec<0>, Char> pad( \
TYPE value, unsigned width, Char fill) { \ TYPE value, unsigned width, Char fill) { \
return IntFormatSpec<TYPE, AlignTypeSpec<0>, Char>( \ return IntFormatSpec<TYPE, AlignTypeSpec<0>, Char>( \
value, AlignTypeSpec<0>(width, fill)); \ value, AlignTypeSpec<0>(width, fill)); \
} }
FMT_DEFINE_INT_FORMATTERS(int) FMT_DEFINE_INT_FORMATTERS(int)
FMT_DEFINE_INT_FORMATTERS(long) FMT_DEFINE_INT_FORMATTERS(long)
@ -1506,9 +1504,9 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
const fmt::internal::Value values[ \ const fmt::internal::Value values[ \
fmt::internal::NonZero<sizeof...(Args)>::VALUE] = { \ fmt::internal::NonZero<sizeof...(Args)>::VALUE] = { \
fmt::internal::MakeValue<Char>(args)... \ fmt::internal::MakeValue<Char>(args)... \
}; \ }; \
func(arg1, ArgList(fmt::internal::make_type(args...), values)); \ func(arg1, ArgList(fmt::internal::make_type(args...), values)); \
} }
// Defines a variadic constructor. // Defines a variadic constructor.
# define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \ # define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \
@ -1518,9 +1516,9 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
const fmt::internal::Value values[ \ const fmt::internal::Value values[ \
fmt::internal::NonZero<sizeof...(Args)>::VALUE] = { \ fmt::internal::NonZero<sizeof...(Args)>::VALUE] = { \
MakeValue<Char>(args)... \ MakeValue<Char>(args)... \
}; \ }; \
func(arg0, arg1, ArgList(fmt::internal::make_type(args...), values)); \ func(arg0, arg1, ArgList(fmt::internal::make_type(args...), values)); \
} }
#else #else
@ -1535,7 +1533,7 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
const fmt::internal::Value vals[] = {FMT_GEN(n, FMT_MAKE_REF)}; \ const fmt::internal::Value vals[] = {FMT_GEN(n, FMT_MAKE_REF)}; \
func(arg1, fmt::ArgList( \ func(arg1, fmt::ArgList( \
fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), vals)); \ fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), vals)); \
} }
// Emulates a variadic function returning void on a pre-C++11 compiler. // Emulates a variadic function returning void on a pre-C++11 compiler.
# define FMT_VARIADIC_VOID(func, arg_type) \ # define FMT_VARIADIC_VOID(func, arg_type) \
@ -1552,7 +1550,7 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
const fmt::internal::Value vals[] = {FMT_GEN(n, FMT_MAKE_REF)}; \ const fmt::internal::Value vals[] = {FMT_GEN(n, FMT_MAKE_REF)}; \
func(arg0, arg1, fmt::ArgList( \ func(arg0, arg1, fmt::ArgList( \
fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), vals)); \ fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), vals)); \
} }
// Emulates a variadic constructor on a pre-C++11 compiler. // Emulates a variadic constructor on a pre-C++11 compiler.
# define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \ # define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \
@ -1740,8 +1738,8 @@ private:
template<typename T> template<typename T>
void append_float_length(Char *&, T) {} void append_float_length(Char *&, T) {}
friend class internal::ArgFormatter<Char>; friend class internal::ArgFormatter < Char > ;
friend class internal::PrintfFormatter<Char>; friend class internal::PrintfFormatter < Char > ;
protected: protected:
/** /**
@ -2283,7 +2281,7 @@ accessed as a C string with ``out.c_str()``.
\endrst \endrst
*/ */
template <typename Char, typename Allocator = std::allocator<Char> > template <typename Char, typename Allocator = std::allocator<Char> >
class BasicMemoryWriter : public BasicWriter<Char> { class BasicMemoryWriter : public BasicWriter < Char > {
private: private:
internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE, Allocator> buffer_; internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE, Allocator> buffer_;