44 # define FMT_SECURE_SCL _SECURE_SCL 46 # define FMT_SECURE_SCL 0 54 # define FMT_MSC_VER _MSC_VER 56 # define FMT_MSC_VER 0 59 #if FMT_MSC_VER && FMT_MSC_VER <= 1500 67 #if !defined(FMT_HEADER_ONLY) && defined(_WIN32) 69 # define FMT_API __declspec(dllexport) 70 # elif defined(FMT_SHARED) 71 # define FMT_API __declspec(dllimport) 79 # define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) 80 # define FMT_GCC_EXTENSION __extension__ 81 # if FMT_GCC_VERSION >= 406 82 # pragma GCC diagnostic push 85 # pragma GCC diagnostic ignored "-Wlong-long" 88 # pragma GCC diagnostic ignored "-Wshadow" 91 # pragma GCC diagnostic ignored "-Wsign-conversion" 93 # if __cplusplus >= 201103L || defined __GXX_EXPERIMENTAL_CXX0X__ 94 # define FMT_HAS_GXX_CXX11 1 97 # define FMT_GCC_EXTENSION 100 #if defined(__INTEL_COMPILER) 101 # define FMT_ICC_VERSION __INTEL_COMPILER 103 # define FMT_ICC_VERSION __ICL 106 #if defined(__clang__) && !defined(FMT_ICC_VERSION) 107 # pragma clang diagnostic push 108 # pragma clang diagnostic ignored "-Wdocumentation-unknown-command" 109 # pragma clang diagnostic ignored "-Wpadded" 112 #ifdef __GNUC_LIBSTD__ 113 # define FMT_GNUC_LIBSTD_VERSION (__GNUC_LIBSTD__ * 100 + __GNUC_LIBSTD_MINOR__) 117 # define FMT_HAS_FEATURE(x) __has_feature(x) 119 # define FMT_HAS_FEATURE(x) 0 123 # define FMT_HAS_BUILTIN(x) __has_builtin(x) 125 # define FMT_HAS_BUILTIN(x) 0 128 #ifdef __has_cpp_attribute 129 # define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x) 131 # define FMT_HAS_CPP_ATTRIBUTE(x) 0 134 #ifndef FMT_USE_VARIADIC_TEMPLATES 138 # define FMT_USE_VARIADIC_TEMPLATES \ 139 (FMT_HAS_FEATURE(cxx_variadic_templates) || \ 140 (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1800) 143 #ifndef FMT_USE_RVALUE_REFERENCES 146 # if defined(FMT_GNUC_LIBSTD_VERSION) && FMT_GNUC_LIBSTD_VERSION <= 402 147 # define FMT_USE_RVALUE_REFERENCES 0 149 # define FMT_USE_RVALUE_REFERENCES \ 150 (FMT_HAS_FEATURE(cxx_rvalue_references) || \ 151 (FMT_GCC_VERSION >= 403 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1600) 155 #if FMT_USE_RVALUE_REFERENCES 160 #if defined(__GNUC__) && !defined(__EXCEPTIONS) 161 # define FMT_EXCEPTIONS 0 163 #if FMT_MSC_VER && !_HAS_EXCEPTIONS 164 # define FMT_EXCEPTIONS 0 166 #ifndef FMT_EXCEPTIONS 167 # define FMT_EXCEPTIONS 1 172 # define FMT_THROW(x) throw x 174 # define FMT_THROW(x) assert(false) 179 #ifndef FMT_USE_NOEXCEPT 180 # define FMT_USE_NOEXCEPT 0 185 # if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \ 186 (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || \ 188 # define FMT_NOEXCEPT noexcept 190 # define FMT_NOEXCEPT throw() 193 # define FMT_NOEXCEPT 199 #ifndef FMT_USE_DELETED_FUNCTIONS 200 # define FMT_USE_DELETED_FUNCTIONS 0 203 #if FMT_USE_DELETED_FUNCTIONS || FMT_HAS_FEATURE(cxx_deleted_functions) || \ 204 (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1800 205 # define FMT_DELETED_OR_UNDEFINED = delete 206 # define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \ 207 TypeName(const TypeName&) = delete; \ 208 TypeName& operator=(const TypeName&) = delete 210 # define FMT_DELETED_OR_UNDEFINED 211 # define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \ 212 TypeName(const TypeName&); \ 213 TypeName& operator=(const TypeName&) 216 #ifndef FMT_USE_USER_DEFINED_LITERALS 221 # define FMT_USE_USER_DEFINED_LITERALS \ 222 FMT_USE_VARIADIC_TEMPLATES && FMT_USE_RVALUE_REFERENCES && \ 223 (FMT_HAS_FEATURE(cxx_user_literals) || \ 224 (FMT_GCC_VERSION >= 407 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900) && \ 225 (!defined(FMT_ICC_VERSION) || FMT_ICC_VERSION >= 1500) 229 # define FMT_ASSERT(condition, message) assert((condition) && message) 232 #if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clz) 233 # define FMT_BUILTIN_CLZ(n) __builtin_clz(n) 236 #if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clzll) 237 # define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n) 244 #if FMT_MSC_VER && !defined(FMT_BUILTIN_CLZLL) 249 # pragma intrinsic(_BitScanReverse) 252 _BitScanReverse(&r, x);
258 # pragma warning(suppress: 6102) 261 # define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n) 264 # pragma intrinsic(_BitScanReverse64) 270 _BitScanReverse64(&r, x);
273 if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32)))
274 return 63 - (r + 32);
277 _BitScanReverse(&r, static_cast<uint32_t>(x));
284 # pragma warning(suppress: 6102) 287 # define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n) 296 operator int()
const {
return 0; }
311 template <
typename T>
322 class numeric_limits<
fmt::internal::DummyInt> :
323 public std::numeric_limits<int> {
326 template <
typename T>
332 sizeof(
isinf(x)) ==
sizeof(
int))) {
333 return isinf(x) != 0;
335 return !
_finite(static_cast<double>(x));
339 template <
typename T>
343 sizeof(
isnan(x)) ==
sizeof(
int))) {
344 return isnan(x) != 0;
346 return _isnan(static_cast<double>(x)) != 0;
354 if (x < 0)
return true;
355 if (!isnotanumber(x))
return false;
356 int dec = 0, sign = 0;
358 _ecvt_s(buffer,
sizeof(buffer), x, 0, &dec, &sign);
371 #if FMT_USE_RVALUE_REFERENCES 375 template <
typename Char>
381 template <
typename Char>
384 template <
typename Impl,
typename Char>
387 template <
typename CharType,
415 template <
typename Char>
432 : data_(s), size_(
std::char_traits<Char>::
length(s)) {}
440 : data_(s.c_str()), size_(s.
size()) {}
448 return std::basic_string<Char>(data_, size_);
452 const Char *
data()
const {
return data_; }
455 std::size_t
size()
const {
return size_; }
460 int result = std::char_traits<Char>::compare(data_, other.
data_, size);
462 result = size_ == other.
size_ ? 0 : (size_ < other.
size_ ? -1 : 1);
514 template <
typename Char>
531 const Char *
c_str()
const {
return data_; }
541 :
std::runtime_error(message.c_str()) {}
548 template <
typename T>
551 #define FMT_SPECIALIZE_MAKE_UNSIGNED(T, U) \ 553 struct MakeUnsigned<T> { typedef U Type; } 563 template <
typename Int>
575 template <
typename T>
576 inline stdext::checked_array_iterator<T*>
make_ptr(T *ptr, std::size_t
size) {
577 return stdext::checked_array_iterator<T*>(ptr,
size);
580 template <
typename T>
581 inline T *
make_ptr(T *ptr, std::size_t) {
return ptr; }
590 template <
typename T>
600 Buffer(T *ptr = 0, std::size_t capacity = 0)
601 : ptr_(ptr), size_(0), capacity_(capacity) {}
609 virtual void grow(std::size_t
size) = 0;
615 std::size_t
size()
const {
return size_; }
624 if (new_size > capacity_)
635 if (capacity > capacity_)
642 if (size_ == capacity_)
644 ptr_[size_++] =
value;
648 template <
typename U>
649 void append(
const U *begin,
const U *
end);
655 template <
typename T>
656 template <
typename U>
659 if (new_size > capacity_)
661 std::uninitialized_copy(begin, end,
670 template <
typename T, std::
size_t SIZE,
typename Allocator = std::allocator<T> >
677 if (this->ptr_ != data_) Allocator::deallocate(this->ptr_, this->capacity_);
681 void grow(std::size_t
size);
685 : Allocator(alloc),
Buffer<T>(data_, SIZE) {}
688 #if FMT_USE_RVALUE_REFERENCES 692 Allocator &this_alloc = *
this, &other_alloc = other;
694 this->size_ = other.
size_;
698 std::uninitialized_copy(other.
data_, other.
data_ + this->size_,
701 this->ptr_ = other.
ptr_;
714 assert(
this != &other);
725 template <
typename T, std::
size_t SIZE,
typename Allocator>
727 std::size_t new_capacity = this->capacity_ + this->capacity_ / 2;
728 if (size > new_capacity)
730 T *new_ptr = this->allocate(new_capacity);
732 std::uninitialized_copy(this->ptr_, this->ptr_ + this->size_,
734 std::size_t old_capacity = this->capacity_;
735 T *old_ptr = this->ptr_;
736 this->capacity_ = new_capacity;
737 this->ptr_ = new_ptr;
741 if (old_ptr != data_)
742 Allocator::deallocate(old_ptr, old_capacity);
746 template <
typename Char>
752 FMT_API void grow(std::size_t size);
755 template <
typename Char>
759 typedef stdext::checked_array_iterator<Char*>
CharPtr;
766 template <
typename Char>
779 template <
typename T>
780 FMT_API static int format_float(
char *
buffer, std::size_t size,
790 template <
typename T>
791 FMT_API static int format_float(
wchar_t *
buffer, std::size_t size,
796 template <
bool IsSigned>
798 template <
typename T>
804 template <
typename T>
810 template <
typename T>
816 template <
bool FitsIn32Bits>
822 template <
typename T>
834 template <
typename T =
void>
838 static const char DIGITS[];
841 #ifndef FMT_USE_EXTERN_TEMPLATES 844 # define FMT_USE_EXTERN_TEMPLATES (__clang__ && FMT_USE_VARIADIC_TEMPLATES) 847 #if FMT_USE_EXTERN_TEMPLATES && !defined(FMT_HEADER_ONLY) 853 #ifdef FMT_BUILTIN_CLZLL 859 int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;
870 if (n < 10)
return count;
871 if (n < 100)
return count + 1;
872 if (n < 1000)
return count + 2;
873 if (n < 10000)
return count + 3;
880 #ifdef FMT_BUILTIN_CLZ 883 int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;
890 template <
typename Char>
905 template <
typename Char>
907 if (++digit_index_ % 3 != 0)
909 buffer -= sep_.
size();
910 std::uninitialized_copy(sep_.
data(), sep_.
data() + sep_.
size(),
918 template <
typename UInt,
typename Char,
typename ThousandsSep>
921 buffer += num_digits;
922 while (value >= 100) {
926 unsigned index =
static_cast<unsigned>((value % 100) * 2);
934 *--buffer =
static_cast<char>(
'0' +
value);
937 unsigned index =
static_cast<unsigned>(value * 2);
943 template <
typename UInt,
typename Char>
949 # define FMT_USE_WINDOWS_H 0 950 #elif !defined(FMT_USE_WINDOWS_H) 951 # define FMT_USE_WINDOWS_H 1 956 #if FMT_USE_WINDOWS_H 964 FMT_API explicit UTF8ToUTF16(StringRef
s);
966 size_t size()
const {
return buffer_.
size() - 1; }
967 const wchar_t *c_str()
const {
return &buffer_[0]; }
968 std::wstring str()
const {
return std::wstring(&buffer_[0],
size()); }
979 FMT_API explicit UTF16ToUTF8(WStringRef
s);
981 size_t size()
const {
return buffer_.
size() - 1; }
982 const char *c_str()
const {
return &buffer_[0]; }
997 template <
typename Char>
1004 void *formatter,
const void *
arg,
void *format_str_ptr);
1042 template <
typename Char>
1045 template <
typename T =
void>
1050 template <
typename T,
typename Char>
1056 template <
typename T>
1065 template <
typename T>
1072 template<
typename T,
bool ENABLE_CONVERSION>
1077 template<
typename T,
bool ENABLE_CONVERSION>
1082 template<
typename T>
1090 template<
typename T>
1092 enum { enable_conversion =
sizeof(
convert(get<T>())) ==
sizeof(Yes) };
1096 #define FMT_DISABLE_CONVERSION_TO_INT(Type) \ 1098 struct ConvertToInt<Type> { enum { value = 0 }; } 1105 template<
bool B,
class T =
void>
1111 template<
bool B,
class T,
class F>
1114 template<
class T,
class F>
1124 template <
typename T>
1134 template <
typename LConv>
1137 return lc->thousands_sep;
1142 #define FMT_CONCAT(a, b) a##b 1144 #if FMT_GCC_VERSION >= 407 1145 # define FMT_UNUSED __attribute__((unused)) 1150 #ifndef FMT_USE_STATIC_ASSERT 1151 # define FMT_USE_STATIC_ASSERT 0 1154 #if FMT_USE_STATIC_ASSERT || FMT_HAS_FEATURE(cxx_static_assert) || \ 1155 (FMT_GCC_VERSION >= 403 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1600 1156 # define FMT_STATIC_ASSERT(cond, message) static_assert(cond, message) 1158 # define FMT_CONCAT_(a, b) FMT_CONCAT(a, b) 1159 # define FMT_STATIC_ASSERT(cond, message) \ 1160 typedef int FMT_CONCAT_(Assert, __LINE__)[(cond) ? 1 : -1] FMT_UNUSED 1163 template <
typename Formatter,
typename Char,
typename T>
1166 "Cannot format argument. To enable the use of ostream " 1167 "operator<< include fmt/ostream.h. Otherwise provide " 1168 "an overload of format_arg.");
1172 template <
typename Formatter>
1175 typedef typename Formatter::Char
Char;
1183 template <
typename T>
1185 template <
typename T>
1192 #if !FMT_MSC_VER || defined(_NATIVE_WCHAR_T_DEFINED) 1201 string.value = str.
data();
1202 string.size = str.
size();
1206 wstring.value = str.
data();
1207 wstring.size = str.
size();
1211 template <
typename T>
1213 void *formatter,
const void *
arg,
void *format_str_ptr) {
1214 format_arg(*static_cast<Formatter*>(formatter),
1215 *static_cast<const Char**>(format_str_ptr),
1216 *static_cast<const T*>(arg));
1222 #define FMT_MAKE_VALUE_(Type, field, TYPE, rhs) \ 1223 MakeValue(Type value) { field = rhs; } \ 1224 static uint64_t type(Type) { return Arg::TYPE; } 1226 #define FMT_MAKE_VALUE(Type, field, TYPE) \ 1227 FMT_MAKE_VALUE_(Type, field, TYPE, value) 1239 int_value =
static_cast<int>(
value);
1241 long_long_value =
value;
1248 if (
const_check(
sizeof(
unsigned long) ==
sizeof(
unsigned)))
1249 uint_value =
static_cast<unsigned>(
value);
1251 ulong_long_value =
value;
1254 return sizeof(
unsigned long) ==
sizeof(
unsigned) ?
1267 #if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) 1274 #define FMT_MAKE_STR_VALUE(Type, TYPE) \ 1275 MakeValue(Type value) { set_string(value); } \ 1276 static uint64_t type(Type) { return Arg::TYPE; } 1288 #define FMT_MAKE_WSTR_VALUE(Type, TYPE) \ 1289 MakeValue(typename WCharHelper<Type, Char>::Supported value) { \ 1290 set_string(value); \ 1292 static uint64_t type(Type) { return Arg::TYPE; } 1302 template <typename T>
1306 custom.value = &
value;
1307 custom.format = &format_custom_arg<T>;
1310 template <
typename T>
1316 template <
typename T>
1323 template <
typename Char_>
1326 template <
typename Char_>
1330 template <
typename Formatter>
1337 template <
typename T>
1344 template <
typename Char>
1348 template <
typename T>
1359 template <
typename Char>
1380 unsigned shift = index * 4;
1386 template <
typename Char>
1391 enum { MAX_PACKED_ARGS = 16 };
1396 : types_(types), values_(values) {}
1398 : types_(types), args_(args) {}
1405 if (index < MAX_PACKED_ARGS) {
1409 val = use_values ? values_[
index] : args_[
index];
1410 arg.
type = arg_type;
1419 for (
unsigned i = MAX_PACKED_ARGS; i <=
index; ++i) {
1423 return args_[
index];
1427 #define FMT_DISPATCH(call) static_cast<Impl*>(this)->call 1453 template <
typename Impl,
typename Result>
1497 template <
typename T>
1513 template <
typename T>
1602 template <
char TYPE>
1607 bool flag(
unsigned)
const {
return false; }
1621 unsigned width()
const {
return width_; }
1622 wchar_t fill()
const {
return fill_; }
1630 :
WidthSpec(width, fill), align_(align) {}
1638 template <
char TYPE>
1642 bool flag(
unsigned)
const {
return false; }
1653 unsigned width = 0,
char type = 0,
wchar_t fill =
' ')
1654 :
AlignSpec(
width, fill), flags_(0), precision_(-1), type_(type) {}
1656 bool flag(
unsigned f)
const {
return (flags_ & f) != 0; }
1658 char type()
const {
return type_; }
1662 template <
typename T,
typename SpecT = TypeSpec<0>,
typename Char =
char>
1669 : SpecT(spec), value_(val) {}
1675 template <
typename Char>
1681 template <
typename FillChar>
1687 const Char *
str()
const {
return str_; }
1726 template <
char TYPE_CODE,
typename Char>
1728 int value,
unsigned width, Char fill =
' ');
1730 #define FMT_DEFINE_INT_FORMATTERS(TYPE) \ 1731 inline IntFormatSpec<TYPE, TypeSpec<'b'> > bin(TYPE value) { \ 1732 return IntFormatSpec<TYPE, TypeSpec<'b'> >(value, TypeSpec<'b'>()); \ 1735 inline IntFormatSpec<TYPE, TypeSpec<'o'> > oct(TYPE value) { \ 1736 return IntFormatSpec<TYPE, TypeSpec<'o'> >(value, TypeSpec<'o'>()); \ 1739 inline IntFormatSpec<TYPE, TypeSpec<'x'> > hex(TYPE value) { \ 1740 return IntFormatSpec<TYPE, TypeSpec<'x'> >(value, TypeSpec<'x'>()); \ 1743 inline IntFormatSpec<TYPE, TypeSpec<'X'> > hexu(TYPE value) { \ 1744 return IntFormatSpec<TYPE, TypeSpec<'X'> >(value, TypeSpec<'X'>()); \ 1747 template <char TYPE_CODE> \ 1748 inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE> > pad( \ 1749 IntFormatSpec<TYPE, TypeSpec<TYPE_CODE> > f, unsigned width) { \ 1750 return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE> >( \ 1751 f.value(), AlignTypeSpec<TYPE_CODE>(width, ' ')); \ 1758 template <char TYPE_CODE, typename Char> \ 1759 inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char> pad( \ 1760 IntFormatSpec<TYPE, TypeSpec<TYPE_CODE>, Char> f, \ 1761 unsigned width, Char fill) { \ 1762 return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char>( \ 1763 f.value(), AlignTypeSpec<TYPE_CODE>(width, fill)); \ 1766 inline IntFormatSpec<TYPE, AlignTypeSpec<0> > pad( \ 1767 TYPE value, unsigned width) { \ 1768 return IntFormatSpec<TYPE, AlignTypeSpec<0> >( \ 1769 value, AlignTypeSpec<0>(width, ' ')); \ 1772 template <typename Char> \ 1773 inline IntFormatSpec<TYPE, AlignTypeSpec<0>, Char> pad( \ 1774 TYPE value, unsigned width, Char fill) { \ 1775 return IntFormatSpec<TYPE, AlignTypeSpec<0>, Char>( \ 1776 value, AlignTypeSpec<0>(width, fill)); \ 1798 template <typename Char>
1800 const Char *str,
unsigned width, Char fill = ' ') {
1805 const wchar_t *str,
unsigned width,
char fill =
' ') {
1811 template <
typename Char>
1814 typedef std::vector<
1816 typedef typename MapType::value_type
Pair;
1825 for (
typename MapType::const_iterator it = map_.begin(),
end = map_.end();
1827 if (it->first == name)
1834 template <
typename Impl,
typename Char>
1845 writer_.
write_int(reinterpret_cast<uintptr_t>(p), spec_);
1853 const char *str_value = value ?
"true" :
"false";
1865 : writer_(w), spec_(s) {}
1867 template <
typename T>
1870 template <
typename T>
1875 return visit_any_int(value);
1885 if (spec_.
align_ == ALIGN_NUMERIC || spec_.
flags_ != 0)
1889 CharPtr out = CharPtr();
1890 const unsigned CHAR_WIDTH = 1;
1891 if (spec_.
width_ > CHAR_WIDTH) {
1894 std::uninitialized_fill_n(out, spec_.
width_ - CHAR_WIDTH, fill);
1895 out += spec_.
width_ - CHAR_WIDTH;
1900 std::uninitialized_fill_n(out + CHAR_WIDTH,
1901 spec_.
width_ - CHAR_WIDTH, fill);
1910 if (spec_.
type_ ==
'p')
1911 return write_pointer(value);
1928 write_pointer(value);
1938 FMT_API Arg do_get_arg(
unsigned arg_index,
const char *&error);
1945 next_arg_index_ = 0;
1950 if (next_arg_index_ >= 0)
1952 error =
"cannot switch from manual to automatic argument indexing";
1959 return check_no_auto_index(error) ? do_get_arg(arg_index, error) :
Arg();
1963 if (next_arg_index_ > 0) {
1964 error =
"cannot switch from automatic to manual argument indexing";
1967 next_arg_index_ = -1;
1971 template <
typename Char>
1996 template <
typename Impl,
typename Char>
2014 formatter_(formatter), format_(fmt) {}
2023 template <
typename Char>
2033 template <
typename CharType,
typename ArgFormatter>
2080 # define FMT_GEN(n, f) FMT_GEN##n(f) 2081 # define FMT_GEN1(f) f(0) 2082 # define FMT_GEN2(f) FMT_GEN1(f), f(1) 2083 # define FMT_GEN3(f) FMT_GEN2(f), f(2) 2084 # define FMT_GEN4(f) FMT_GEN3(f), f(3) 2085 # define FMT_GEN5(f) FMT_GEN4(f), f(4) 2086 # define FMT_GEN6(f) FMT_GEN5(f), f(5) 2087 # define FMT_GEN7(f) FMT_GEN6(f), f(6) 2088 # define FMT_GEN8(f) FMT_GEN7(f), f(7) 2089 # define FMT_GEN9(f) FMT_GEN8(f), f(8) 2090 # define FMT_GEN10(f) FMT_GEN9(f), f(9) 2091 # define FMT_GEN11(f) FMT_GEN10(f), f(10) 2092 # define FMT_GEN12(f) FMT_GEN11(f), f(11) 2093 # define FMT_GEN13(f) FMT_GEN12(f), f(12) 2094 # define FMT_GEN14(f) FMT_GEN13(f), f(13) 2095 # define FMT_GEN15(f) FMT_GEN14(f), f(14) 2100 template <
typename T>
2105 template <
unsigned N,
bool= (N < ArgList::MAX_PACKED_ARGS)>
2108 template <
unsigned N>
2112 template <
typename Formatter,
typename T>
2126 template <
unsigned N>
2130 template <
typename Formatter,
typename T>
2134 #if FMT_USE_VARIADIC_TEMPLATES 2135 template <
typename Arg,
typename... Args>
2147 template <
typename T>
2151 # define FMT_ARG_TYPE_DEFAULT(n) ArgType t##n = ArgType() 2154 return t0.type | (
t1.type << 4) | (t2.type << 8) | (t3.type << 12) |
2155 (t4.type << 16) | (t5.type << 20) | (t6.type << 24) | (t7.type << 28) |
2156 (t8.type << 32) | (t9.type << 36) | (t10.type << 40) | (t11.type << 44) |
2157 (t12.type << 48) | (t13.type << 52) | (t14.type << 56);
2162 # define FMT_MAKE_TEMPLATE_ARG(n) typename T##n 2163 # define FMT_MAKE_ARG_TYPE(n) T##n 2164 # define FMT_MAKE_ARG(n) const T##n &v##n 2165 # define FMT_ASSIGN_char(n) \ 2166 arr[n] = fmt::internal::MakeValue< fmt::BasicFormatter<char> >(v##n) 2167 # define FMT_ASSIGN_wchar_t(n) \ 2168 arr[n] = fmt::internal::MakeValue< fmt::BasicFormatter<wchar_t> >(v##n) 2170 #if FMT_USE_VARIADIC_TEMPLATES 2172 # define FMT_VARIADIC_VOID(func, arg_type) \ 2173 template <typename... Args> \ 2174 void func(arg_type arg0, const Args & ... args) { \ 2175 typedef fmt::internal::ArgArray<sizeof...(Args)> ArgArray; \ 2176 typename ArgArray::Type array{ \ 2177 ArgArray::template make<fmt::BasicFormatter<Char> >(args)...}; \ 2178 func(arg0, fmt::ArgList(fmt::internal::make_type(args...), array)); \ 2182 # define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \ 2183 template <typename... Args> \ 2184 ctor(arg0_type arg0, arg1_type arg1, const Args & ... args) { \ 2185 typedef fmt::internal::ArgArray<sizeof...(Args)> ArgArray; \ 2186 typename ArgArray::Type array{ \ 2187 ArgArray::template make<fmt::BasicFormatter<Char> >(args)...}; \ 2188 func(arg0, arg1, fmt::ArgList(fmt::internal::make_type(args...), array)); \ 2193 # define FMT_MAKE_REF(n) \ 2194 fmt::internal::MakeValue< fmt::BasicFormatter<Char> >(v##n) 2195 # define FMT_MAKE_REF2(n) v##n 2199 # define FMT_WRAP1(func, arg_type, n) \ 2200 template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \ 2201 inline void func(arg_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \ 2202 const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \ 2203 func(arg1, fmt::ArgList( \ 2204 fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \ 2208 # define FMT_VARIADIC_VOID(func, arg_type) \ 2209 inline void func(arg_type arg) { func(arg, fmt::ArgList()); } \ 2210 FMT_WRAP1(func, arg_type, 1) FMT_WRAP1(func, arg_type, 2) \ 2211 FMT_WRAP1(func, arg_type, 3) FMT_WRAP1(func, arg_type, 4) \ 2212 FMT_WRAP1(func, arg_type, 5) FMT_WRAP1(func, arg_type, 6) \ 2213 FMT_WRAP1(func, arg_type, 7) FMT_WRAP1(func, arg_type, 8) \ 2214 FMT_WRAP1(func, arg_type, 9) FMT_WRAP1(func, arg_type, 10) 2216 # define FMT_CTOR(ctor, func, arg0_type, arg1_type, n) \ 2217 template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \ 2218 ctor(arg0_type arg0, arg1_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \ 2219 const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \ 2220 func(arg0, arg1, fmt::ArgList( \ 2221 fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \ 2225 # define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \ 2226 FMT_CTOR(ctor, func, arg0_type, arg1_type, 1) \ 2227 FMT_CTOR(ctor, func, arg0_type, arg1_type, 2) \ 2228 FMT_CTOR(ctor, func, arg0_type, arg1_type, 3) \ 2229 FMT_CTOR(ctor, func, arg0_type, arg1_type, 4) \ 2230 FMT_CTOR(ctor, func, arg0_type, arg1_type, 5) \ 2231 FMT_CTOR(ctor, func, arg0_type, arg1_type, 6) \ 2232 FMT_CTOR(ctor, func, arg0_type, arg1_type, 7) \ 2233 FMT_CTOR(ctor, func, arg0_type, arg1_type, 8) \ 2234 FMT_CTOR(ctor, func, arg0_type, arg1_type, 9) \ 2235 FMT_CTOR(ctor, func, arg0_type, arg1_type, 10) 2240 #define FMT_FOR_EACH1(f, x0) f(x0, 0) 2241 #define FMT_FOR_EACH2(f, x0, x1) \ 2242 FMT_FOR_EACH1(f, x0), f(x1, 1) 2243 #define FMT_FOR_EACH3(f, x0, x1, x2) \ 2244 FMT_FOR_EACH2(f, x0 ,x1), f(x2, 2) 2245 #define FMT_FOR_EACH4(f, x0, x1, x2, x3) \ 2246 FMT_FOR_EACH3(f, x0, x1, x2), f(x3, 3) 2247 #define FMT_FOR_EACH5(f, x0, x1, x2, x3, x4) \ 2248 FMT_FOR_EACH4(f, x0, x1, x2, x3), f(x4, 4) 2249 #define FMT_FOR_EACH6(f, x0, x1, x2, x3, x4, x5) \ 2250 FMT_FOR_EACH5(f, x0, x1, x2, x3, x4), f(x5, 5) 2251 #define FMT_FOR_EACH7(f, x0, x1, x2, x3, x4, x5, x6) \ 2252 FMT_FOR_EACH6(f, x0, x1, x2, x3, x4, x5), f(x6, 6) 2253 #define FMT_FOR_EACH8(f, x0, x1, x2, x3, x4, x5, x6, x7) \ 2254 FMT_FOR_EACH7(f, x0, x1, x2, x3, x4, x5, x6), f(x7, 7) 2255 #define FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8) \ 2256 FMT_FOR_EACH8(f, x0, x1, x2, x3, x4, x5, x6, x7), f(x8, 8) 2257 #define FMT_FOR_EACH10(f, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) \ 2258 FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8), f(x9, 9) 2266 void init(
int err_code, CStringRef format_str,
ArgList args);
2295 init(error_code, message,
ArgList());
2341 template <
typename Char>
2353 static Char *
get(CharPtr
p) {
return p.base(); }
2355 static Char *
get(Char *
p) {
return p; }
2360 static CharPtr fill_padding(CharPtr
buffer,
2361 unsigned total_size, std::size_t content_size,
wchar_t fill);
2366 std::size_t size = buffer_.
size();
2367 buffer_.
resize(size + n);
2372 template <
typename UInt>
2375 Char *ptr =
get(grow_buffer(prefix_size + num_digits));
2381 template <
typename Int>
2384 MainType abs_value =
static_cast<MainType
>(
value);
2386 abs_value = 0 - abs_value;
2387 *write_unsigned_decimal(abs_value, 1) =
'-';
2389 write_unsigned_decimal(abs_value, 0);
2395 const EmptySpec &,
const char *prefix,
unsigned prefix_size) {
2396 unsigned size = prefix_size + num_digits;
2397 CharPtr
p = grow_buffer(size);
2398 std::uninitialized_copy(prefix, prefix + prefix_size, p);
2399 return p + size - 1;
2402 template <
typename Spec>
2403 CharPtr prepare_int_buffer(
unsigned num_digits,
2404 const Spec &spec,
const char *prefix,
unsigned prefix_size);
2407 template <
typename T,
typename Spec>
2408 void write_int(T value, Spec spec);
2411 template <
typename T>
2412 void write_double(T value,
const FormatSpec &spec);
2415 template <
typename StrChar>
2416 CharPtr write_str(
const StrChar *
s, std::size_t size,
const AlignSpec &spec);
2418 template <
typename StrChar>
2426 void operator<<(typename internal::WCharHelper<wchar_t, Char>::Unsupported);
2433 *format_ptr++ =
'L';
2436 template<
typename T>
2439 template <
typename Impl,
typename Char_>
2442 template <
typename Impl,
typename Char_>
2468 const Char *
data() const FMT_NOEXCEPT {
return &buffer_[0]; }
2475 std::size_t size = buffer_.
size();
2477 buffer_[
size] =
'\0';
2486 std::basic_string<Char>
str()
const {
2487 return std::basic_string<Char>(&buffer_[0], buffer_.
size());
2521 write_decimal(value);
2525 return *this << IntFormatSpec<unsigned>(
value);
2528 write_decimal(value);
2532 return *this << IntFormatSpec<unsigned long>(
value);
2535 write_decimal(value);
2545 return *this << IntFormatSpec<ULongLong>(
value);
2568 buffer_.push_back(value);
2574 buffer_.push_back(value);
2584 const Char *str = value.data();
2585 buffer_.append(str, str + value.size());
2591 const char *str = value.data();
2592 buffer_.append(str, str + value.size());
2596 template <
typename T,
typename Spec,
typename FillChar>
2599 write_int(spec.value(), spec);
2603 template <
typename StrChar>
2605 const StrChar *
s = spec.
str();
2610 void clear() FMT_NOEXCEPT { buffer_.clear(); }
2615 template <
typename Char>
2616 template <
typename StrChar>
2618 const StrChar *
s, std::size_t size,
const AlignSpec &spec) {
2621 out = grow_buffer(spec.
width());
2624 std::uninitialized_fill_n(out, spec.
width() -
size, fill);
2627 out = fill_padding(out, spec.
width(),
size, fill);
2629 std::uninitialized_fill_n(out + size, spec.
width() -
size, fill);
2632 out = grow_buffer(size);
2634 std::uninitialized_copy(s, s + size, out);
2638 template <
typename Char>
2639 template <
typename StrChar>
2646 const StrChar *str_value = s.
value;
2647 std::size_t str_size = s.
size;
2648 if (str_size == 0) {
2654 if (spec.
precision_ >= 0 && precision < str_size)
2656 write_str(str_value, str_size, spec);
2659 template <
typename Char>
2663 std::size_t content_size,
wchar_t fill) {
2664 std::size_t padding = total_size - content_size;
2665 std::size_t left_padding = padding / 2;
2667 std::uninitialized_fill_n(buffer, left_padding, fill_char);
2668 buffer += left_padding;
2670 std::uninitialized_fill_n(buffer + content_size,
2671 padding - left_padding, fill_char);
2675 template <
typename Char>
2676 template <
typename Spec>
2679 unsigned num_digits,
const Spec &spec,
2680 const char *prefix,
unsigned prefix_size) {
2681 unsigned width = spec.width();
2684 if (spec.precision() >
static_cast<int>(num_digits)) {
2687 if (prefix_size > 0 && prefix[prefix_size - 1] ==
'0')
2689 unsigned number_size =
2691 AlignSpec subspec(number_size,
'0', ALIGN_NUMERIC);
2692 if (number_size >= width)
2693 return prepare_int_buffer(num_digits, subspec, prefix, prefix_size);
2694 buffer_.reserve(width);
2695 unsigned fill_size = width - number_size;
2697 CharPtr p = grow_buffer(fill_size);
2698 std::uninitialized_fill(p, p + fill_size, fill);
2701 num_digits, subspec, prefix, prefix_size);
2703 CharPtr p = grow_buffer(fill_size);
2704 std::uninitialized_fill(p, p + fill_size, fill);
2708 unsigned size = prefix_size + num_digits;
2709 if (width <= size) {
2711 std::uninitialized_copy(prefix, prefix + prefix_size, p);
2712 return p + size - 1;
2717 std::uninitialized_copy(prefix, prefix + prefix_size, p);
2719 std::uninitialized_fill(p, end, fill);
2721 p = fill_padding(p, width, size, fill);
2722 std::uninitialized_copy(prefix, prefix + prefix_size, p);
2725 if (align == ALIGN_NUMERIC) {
2726 if (prefix_size != 0) {
2727 p = std::uninitialized_copy(prefix, prefix + prefix_size, p);
2728 size -= prefix_size;
2731 std::uninitialized_copy(prefix, prefix + prefix_size, end - size);
2733 std::uninitialized_fill(p, end - size, fill);
2739 template <
typename Char>
2740 template <
typename T,
typename Spec>
2742 unsigned prefix_size = 0;
2744 UnsignedType abs_value =
static_cast<UnsignedType
>(
value);
2745 char prefix[4] =
"";
2749 abs_value = 0 - abs_value;
2751 prefix[0] = spec.flag(
PLUS_FLAG) ?
'+' :
' ';
2754 switch (spec.type()) {
2757 CharPtr p = prepare_int_buffer(num_digits, spec, prefix, prefix_size) + 1;
2761 case 'x':
case 'X': {
2762 UnsignedType n = abs_value;
2764 prefix[prefix_size++] =
'0';
2765 prefix[prefix_size++] = spec.type();
2767 unsigned num_digits = 0;
2770 }
while ((n >>= 4) != 0);
2771 Char *
p =
get(prepare_int_buffer(
2772 num_digits, spec, prefix, prefix_size));
2774 const char *digits = spec.type() ==
'x' ?
2775 "0123456789abcdef" :
"0123456789ABCDEF";
2777 *p-- = digits[n & 0xf];
2778 }
while ((n >>= 4) != 0);
2781 case 'b':
case 'B': {
2782 UnsignedType n = abs_value;
2784 prefix[prefix_size++] =
'0';
2785 prefix[prefix_size++] = spec.type();
2787 unsigned num_digits = 0;
2790 }
while ((n >>= 1) != 0);
2791 Char *
p =
get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
2794 *p-- =
static_cast<Char
>(
'0' + (n & 1));
2795 }
while ((n >>= 1) != 0);
2799 UnsignedType n = abs_value;
2801 prefix[prefix_size++] =
'0';
2802 unsigned num_digits = 0;
2805 }
while ((n >>= 3) != 0);
2806 Char *
p =
get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
2809 *p-- =
static_cast<Char
>(
'0' + (n & 7));
2810 }
while ((n >>= 3) != 0);
2816 unsigned size =
static_cast<unsigned>(
2817 num_digits + sep.
size() * ((num_digits - 1) / 3));
2818 CharPtr p = prepare_int_buffer(size, spec, prefix, prefix_size) + 1;
2824 spec.type(), spec.flag(
CHAR_FLAG) ?
"char" :
"integer");
2829 template <
typename Char>
2830 template <
typename T>
2833 char type = spec.
type();
2839 case 'e':
case 'f':
case 'g':
case 'a':
2847 case 'E':
case 'G':
case 'A':
2868 std::size_t nan_size = 4;
2869 const char *nan = upper ?
" NAN" :
" nan";
2874 CharPtr out = write_str(nan, nan_size, spec);
2883 std::size_t inf_size = 4;
2884 const char *inf = upper ?
" INF" :
" inf";
2889 CharPtr out = write_str(inf, inf_size, spec);
2895 std::size_t
offset = buffer_.size();
2896 unsigned width = spec.
width();
2898 buffer_.reserve(buffer_.size() + (width > 1u ? width : 1u));
2905 enum { MAX_FORMAT_SIZE = 10};
2906 Char
format[MAX_FORMAT_SIZE];
2907 Char *format_ptr =
format;
2908 *format_ptr++ =
'%';
2909 unsigned width_for_sprintf =
width;
2911 *format_ptr++ =
'#';
2913 width_for_sprintf = 0;
2916 *format_ptr++ =
'-';
2918 *format_ptr++ =
'*';
2921 *format_ptr++ =
'.';
2922 *format_ptr++ =
'*';
2925 append_float_length(format_ptr, value);
2926 *format_ptr++ =
type;
2934 std::size_t buffer_size = buffer_.capacity() -
offset;
2939 if (buffer_size == 0) {
2940 buffer_.reserve(offset + 1);
2941 buffer_size = buffer_.capacity() -
offset;
2944 start = &buffer_[
offset];
2946 start, buffer_size, format, width_for_sprintf, spec.
precision(),
value);
2949 if (offset + n < buffer_.capacity())
2951 buffer_.reserve(offset + n + 1);
2955 buffer_.reserve(buffer_.capacity() + 1);
2961 *(start - 1) = sign;
2964 *(start - 1) = fill;
2969 width = spec.
width();
2971 std::memmove(
get(p) + (width - n) / 2,
get(p), n *
sizeof(Char));
2972 fill_padding(p, spec.
width(),
n, fill);
2975 if (spec.
fill() !=
' ' || sign) {
2976 while (*start ==
' ')
2979 *(start - 1) = sign;
3018 template <
typename Char,
typename Allocator = std::allocator<Char> >
3027 #if FMT_USE_RVALUE_REFERENCES 3073 template <
typename Char>
3086 :
BasicWriter<Char>(buffer_), buffer_(array, size) {}
3094 template <std::
size_t SIZE>
3107 #if FMT_USE_WINDOWS_H 3112 FMT_API void init(
int error_code, CStringRef format_str,
ArgList args);
3143 WindowsError(
int error_code, CStringRef message) {
3144 init(error_code, message,
ArgList());
3151 FMT_API void report_windows_error(
int error_code,
3177 w.
write(format_str, args);
3183 w.
write(format_str, args);
3216 enum {BUFFER_SIZE = std::numeric_limits<ULongLong>::digits10 + 3};
3217 mutable char buffer_[BUFFER_SIZE];
3222 char *buffer_end = buffer_ + BUFFER_SIZE - 1;
3223 while (value >= 100) {
3227 unsigned index =
static_cast<unsigned>((value % 100) * 2);
3233 *--buffer_end =
static_cast<char>(
'0' +
value);
3236 unsigned index =
static_cast<unsigned>(value * 2);
3243 ULongLong abs_value =
static_cast<ULongLong
>(
value);
3244 bool negative = value < 0;
3246 abs_value = 0 - abs_value;
3269 const char *
data()
const {
return str_; }
3276 buffer_[BUFFER_SIZE - 1] =
'\0';
3291 template <
typename T>
3294 MainType abs_value =
static_cast<MainType
>(
value);
3297 abs_value = 0 - abs_value;
3299 if (abs_value < 100) {
3300 if (abs_value < 10) {
3301 *buffer++ =
static_cast<char>(
'0' + abs_value);
3304 unsigned index =
static_cast<unsigned>(abs_value * 2);
3311 buffer += num_digits;
3324 template <
typename T>
3329 template <
typename T>
3336 template <
typename Char>
3338 template <
typename Char>
3347 # pragma GCC system_header 3351 #define FMT_EXPAND(args) args 3355 #define FMT_NARG(...) FMT_NARG_(__VA_ARGS__, FMT_RSEQ_N()) 3356 #define FMT_NARG_(...) FMT_EXPAND(FMT_ARG_N(__VA_ARGS__)) 3357 #define FMT_ARG_N(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N 3358 #define FMT_RSEQ_N() 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 3360 #define FMT_FOR_EACH_(N, f, ...) \ 3361 FMT_EXPAND(FMT_CONCAT(FMT_FOR_EACH, N)(f, __VA_ARGS__)) 3362 #define FMT_FOR_EACH(f, ...) \ 3363 FMT_EXPAND(FMT_FOR_EACH_(FMT_NARG(__VA_ARGS__), f, __VA_ARGS__)) 3365 #define FMT_ADD_ARG_NAME(type, index) type arg##index 3366 #define FMT_GET_ARG_NAME(type, index) arg##index 3368 #if FMT_USE_VARIADIC_TEMPLATES 3369 # define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \ 3370 template <typename... Args> \ 3371 ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \ 3372 const Args & ... args) { \ 3373 typedef fmt::internal::ArgArray<sizeof...(Args)> ArgArray; \ 3374 typename ArgArray::Type array{ \ 3375 ArgArray::template make<fmt::BasicFormatter<Char> >(args)...}; \ 3376 call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), \ 3377 fmt::ArgList(fmt::internal::make_type(args...), array)); \ 3382 # define FMT_WRAP(Char, ReturnType, func, call, n, ...) \ 3383 template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \ 3384 inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \ 3385 FMT_GEN(n, FMT_MAKE_ARG)) { \ 3386 fmt::internal::ArgArray<n>::Type arr; \ 3387 FMT_GEN(n, FMT_ASSIGN_##Char); \ 3388 call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList( \ 3389 fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), arr)); \ 3392 # define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \ 3393 inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__)) { \ 3394 call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList()); \ 3396 FMT_WRAP(Char, ReturnType, func, call, 1, __VA_ARGS__) \ 3397 FMT_WRAP(Char, ReturnType, func, call, 2, __VA_ARGS__) \ 3398 FMT_WRAP(Char, ReturnType, func, call, 3, __VA_ARGS__) \ 3399 FMT_WRAP(Char, ReturnType, func, call, 4, __VA_ARGS__) \ 3400 FMT_WRAP(Char, ReturnType, func, call, 5, __VA_ARGS__) \ 3401 FMT_WRAP(Char, ReturnType, func, call, 6, __VA_ARGS__) \ 3402 FMT_WRAP(Char, ReturnType, func, call, 7, __VA_ARGS__) \ 3403 FMT_WRAP(Char, ReturnType, func, call, 8, __VA_ARGS__) \ 3404 FMT_WRAP(Char, ReturnType, func, call, 9, __VA_ARGS__) \ 3405 FMT_WRAP(Char, ReturnType, func, call, 10, __VA_ARGS__) \ 3406 FMT_WRAP(Char, ReturnType, func, call, 11, __VA_ARGS__) \ 3407 FMT_WRAP(Char, ReturnType, func, call, 12, __VA_ARGS__) \ 3408 FMT_WRAP(Char, ReturnType, func, call, 13, __VA_ARGS__) \ 3409 FMT_WRAP(Char, ReturnType, func, call, 14, __VA_ARGS__) \ 3410 FMT_WRAP(Char, ReturnType, func, call, 15, __VA_ARGS__) 3411 #endif // FMT_USE_VARIADIC_TEMPLATES 3440 #define FMT_VARIADIC(ReturnType, func, ...) \ 3441 FMT_VARIADIC_(char, ReturnType, func, return func, __VA_ARGS__) 3443 #define FMT_VARIADIC_W(ReturnType, func, ...) \ 3444 FMT_VARIADIC_(wchar_t, ReturnType, func, return func, __VA_ARGS__) 3446 #define FMT_CAPTURE_ARG_(id, index) ::fmt::arg(#id, id) 3448 #define FMT_CAPTURE_ARG_W_(id, index) ::fmt::arg(L###id, id) 3464 #define FMT_CAPTURE(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_, __VA_ARGS__) 3466 #define FMT_CAPTURE_W(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_W_, __VA_ARGS__) 3476 template <
typename Char>
3478 return (
'a' <= c && c <=
'z') || (
'A' <= c && c <=
'Z') ||
'_' == c;
3483 template <
typename Char>
3485 assert(
'0' <= *s && *s <=
'9');
3488 unsigned new_value = value * 10 + (*s++ -
'0');
3490 if (new_value < value) {
3491 value = (std::numeric_limits<unsigned>::max)();
3495 }
while (
'0' <= *s && *s <=
'9');
3497 unsigned max_int = (std::numeric_limits<int>::max)();
3498 if (value > max_int)
3506 fmt::format(
"format specifier '{}' requires numeric argument", spec);
3511 template <
typename Char>
3513 char sign =
static_cast<char>(*s);
3517 "format specifier '{}' requires signed argument", sign)));
3523 template <
typename Char,
typename AF>
3526 if (check_no_auto_index(error)) {
3531 error =
"argument not found";
3536 template <
typename Char,
typename AF>
3538 const char *error = 0;
3543 *s !=
'}' && *s !=
':' ?
"invalid format string" : error));
3548 template <
typename Char,
typename AF>
3556 const char *error = 0;
3563 template <
typename Char,
typename ArgFormatter>
3567 const Char *
s = format_str;
3577 const Char *
p = s + 1;
3596 if (
c ==
'}')
break;
3602 if (spec.
align_ == ALIGN_NUMERIC)
3640 if (
'0' <= *s && *s <=
'9') {
3642 }
else if (*s ==
'{') {
3645 parse_arg_name(s) : parse_arg_index(s);
3648 ULongLong value = 0;
3649 switch (width_arg.
type) {
3669 if (value > (std::numeric_limits<int>::max)())
3678 if (
'0' <= *s && *s <=
'9') {
3680 }
else if (*s ==
'{') {
3683 parse_arg_name(s) : parse_arg_index(s);
3686 ULongLong value = 0;
3687 switch (precision_arg.
type) {
3707 if (value > (std::numeric_limits<int>::max)())
3715 fmt::format(
"precision not allowed in {} format specifier",
3721 if (*s !=
'}' && *s)
3722 spec.
type_ =
static_cast<char>(*s++);
3729 ArgFormatter(*
this, spec, s - 1).visit(arg);
3733 template <
typename Char,
typename AF>
3739 if (c !=
'{' && c !=
'}')
continue;
3741 write(writer_, start, s);
3747 write(writer_, start, s - 1);
3749 parse_arg_name(s) : parse_arg_index(s);
3750 start = s =
format(s, arg);
3752 write(writer_, start, s);
3756 #if FMT_USE_USER_DEFINED_LITERALS 3760 template <
typename Char>
3764 template <
typename... Args>
3765 auto operator()(Args && ... args)
const 3766 -> decltype(
format(str, std::forward<Args>(args)...)) {
3767 return format(str, std::forward<Args>(args)...);
3771 template <
typename Char>
3775 template <
typename T>
3777 return {str, std::forward<T>(
value)};
3783 inline namespace literals {
3795 inline internal::UdlFormat<char>
3796 operator"" _format(
const char *
s, std::size_t) {
return {s}; }
3797 inline internal::UdlFormat<wchar_t>
3798 operator"" _format(
const wchar_t *s, std::size_t) {
return {s}; }
3810 inline internal::UdlArg<char>
3811 operator"" _a(
const char *s, std::size_t) {
return {s}; }
3812 inline internal::UdlArg<wchar_t>
3813 operator"" _a(
const wchar_t *s, std::size_t) {
return {s}; }
3817 #endif // FMT_USE_USER_DEFINED_LITERALS 3820 #if FMT_GCC_VERSION >= 406 3821 # pragma GCC diagnostic pop 3824 #if defined(__clang__) && !defined(FMT_ICC_VERSION) 3825 # pragma clang diagnostic pop 3828 #ifdef FMT_HEADER_ONLY 3829 # define FMT_FUNC inline 3835 #endif // FMT_FORMAT_H_ GLsizei GLenum GLuint GLuint GLsizei GLchar * message
static bool isnegative(double x)
void format_decimal(Char *buffer, UInt value, unsigned num_digits, ThousandsSep thousands_sep)
void set_string(WStringRef str)
std::vector< std::pair< fmt::BasicStringRef< Char >, internal::Arg > > MapType
Result visit_custom(Arg::CustomValue)
static Value make(const T &value)
CharPtr write_str(const StrChar *s, std::size_t size, const AlignSpec &spec)
StringRef thousands_sep(LConv *lc, LConvCheck< char *LConv::*,&LConv::thousands_sep >=0)
friend bool operator==(BasicStringRef lhs, BasicStringRef rhs)
FMT_FUNC void print_colored(Color c, CStringRef format, ArgList args)
void push_back(const T &value)
const internal::Arg * args_
bool is_negative(T value)
void format_arg(Formatter &, const Char *, const T &)
BasicCStringRef(const Char *s)
static const uint32_t POWERS_OF_10_32[]
BasicStringRef< Char > name
Result visit_string(Arg::StringValue< char >)
ThousandsSep(fmt::StringRef sep)
Result visit_pointer(const void *)
IntFormatSpec< int, AlignTypeSpec< TYPE_CODE >, Char > pad(int value, unsigned width, Char fill= ' ')
IntFormatSpec< int, TypeSpec<'x'> > hex(int value)
static uint64_t type(long)
void operator()(Char *&buffer)
BasicWriter & operator<<(long double value)
GLuint GLuint GLsizei GLenum type
Result visit_uint(unsigned value)
IntFormatSpec< int, TypeSpec<'o'> > oct(int value)
BasicCStringRef(const std::basic_string< Char > &s)
T * make_ptr(T *ptr, std::size_t)
FMT_API void report_unknown_type(char code, const char *type)
Result visit_bool(bool value)
CharPtr grow_buffer(std::size_t n)
FMT_FUNC void write(std::ostream &os, Writer &w)
MakeValue(const NamedArg< Char_ > &value)
long double long_double_value
std::string format(CStringRef format_str, ArgList args)
const Char * data() const FMT_NOEXCEPT
Result visit_ulong_long(ULongLong value)
friend bool operator<(BasicStringRef lhs, BasicStringRef rhs)
static bool isinfinity(T x)
StringValue< char > string
void append_float_length(Char *&, T)
GLuint const GLfloat * val
SystemError(int error_code, CStringRef message)
const Char * c_str() const
Result visit_long_long(LongLong value)
FMT_GCC_EXTENSION typedef unsigned long long ULongLong
static Char cast(int value)
int compare(BasicStringRef other) const
GLuint GLfloat GLfloat GLfloat GLfloat GLfloat GLfloat GLfloat GLfloat GLfloat t1
GLsizei const GLfloat * value
void write_decimal(Int value)
Result visit_any_double(T)
const T & operator[](std::size_t index) const
friend bool operator>(BasicStringRef lhs, BasicStringRef rhs)
GLint GLenum GLsizei GLint GLsizei const void * data
typedef void(GLAPIENTRY *PFNGLCOPYTEXSUBIMAGE3DPROC)(GLenum target
FMT_FUNC void format_system_error(Writer &out, int error_code, StringRef message) FMT_NOEXCEPT
void append_float_length(Char *&format_ptr, long double)
unsigned parse_nonnegative_int(const Char *&s)
BasicWriter & operator<<(long value)
ArgList(ULongLong types, const internal::Arg *args)
BasicMemoryWriter(const Allocator &alloc=Allocator())
bool flag(unsigned) const
internal::Arg::Type type(unsigned index) const
GLint GLsizei const GLuint64 * values
GLuint GLsizei GLsizei * length
const Char * c_str() const
internal::Arg operator[](unsigned index) const
Yes & convert(fmt::ULongLong)
FMT_FUNC void report_system_error(int error_code, fmt::StringRef message) FMT_NOEXCEPT
GLdouble GLdouble GLdouble b
BasicWriter & operator<<(unsigned long value)
Buffer(T *ptr=0, std::size_t capacity=0)
MakeValue(typename WCharHelper< wchar_t, Char >::Supported value)
StringValue< signed char > sstring
const Char * data() const
typedef BOOL(WINAPI *PFNWGLSETSTEREOEMITTERSTATE3DLPROC)(HDC hDC
const internal::Arg * find(const fmt::BasicStringRef< Char > &name) const
BasicStringRef(const Char *s)
typedef INT(WINAPI *PFNWGLGETGPUINFOAMDPROC)(UINT id
internal::MemoryBuffer< Char, internal::INLINE_BUFFER_SIZE, Allocator > buffer_
BasicStringRef< wchar_t > WStringRef
static uint64_t type(const NamedArg< Char_ > &)
static uint64_t type(unsigned long)
static uint64_t type(const T &)
static uint64_t type(wchar_t)
void grow(std::size_t size)
AlignTypeSpec(unsigned width, wchar_t fill)
CharPtr prepare_int_buffer(unsigned num_digits, const EmptySpec &, const char *prefix, unsigned prefix_size)
BasicStringRef< char > StringRef
WidthSpec(unsigned width, wchar_t fill)
BasicStringRef(const std::basic_string< Char > &s)
fmt::BufferedFile & move(fmt::BufferedFile &f)
BasicStringRef(const Char *s, std::size_t size)
FMT_DISABLE_CONVERSION_TO_INT(float)
Result visit_wstring(Arg::StringValue< wchar_t >)
Result visit_double(double value)
BasicMemoryWriter< char > MemoryWriter
GLubyte GLubyte GLubyte GLubyte w
NamedArg(BasicStringRef< Char > argname, const T &value)
Result visit_long_double(long double value)
void write(BasicCStringRef< Char > format, ArgList args)
ULongLong ulong_long_value
Result visit_char(int value)
bool flag(unsigned) const
GLenum GLint GLint * precision
BasicArrayWriter(Char(&array)[SIZE])
void write_double(T value, const FormatSpec &spec)
AlignSpec(unsigned width, wchar_t fill, Alignment align=ALIGN_DEFAULT)
IntFormatSpec< int, TypeSpec<'X'> > hexu(int value)
ArgList(ULongLong types, const internal::Value *values)
BasicWriter & operator<<(double value)
static wchar_t convert(char value)
BasicCStringRef< char > CStringRef
StringValue< unsigned char > ustring
void reserve(std::size_t capacity)
GLuint GLuint GLsizei count
BasicWriter< char > Writer
static char convert(char value)
static Arg make(const T &value)
unsigned __int64 uint64_t
typedef int(WINAPI *PFNWGLRELEASEPBUFFERDCARBPROC)(HPBUFFERARB hPbuffer
void report_unhandled_arg()
MakeUnsigned< Int >::Type to_unsigned(Int value)
void check_sign(const Char *&s, const Arg &arg)
BasicCStringRef< wchar_t > WCStringRef
static bool isnotanumber(T x)
No & operator<<(std::ostream &, int)
Buffer< Char > & buffer() FMT_NOEXCEPT
BasicWriter & operator<<(typename internal::WCharHelper< StringRef, Char >::Supported value)
Char * write_unsigned_decimal(UInt value, unsigned prefix_size=0)
BasicWriter & operator<<(unsigned value)
MemoryBuffer(const Allocator &alloc=Allocator())
BasicWriter< wchar_t > WWriter
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
internal::CharTraits< Char >::CharPtr CharPtr
void clear() FMT_NOEXCEPT
GLsizei GLenum GLenum * types
BasicArrayWriter< char > ArrayWriter
BasicWriter & operator<<(char value)
static CharPtr fill_padding(CharPtr buffer, unsigned total_size, std::size_t content_size, wchar_t fill)
const internal::Value * values_
Result visit_int(int value)
FMT_SPECIALIZE_MAKE_UNSIGNED(char, unsigned char)
GLint GLint GLint GLint GLint x
static const uint64_t POWERS_OF_10_64[]
internal::NamedArg< char > arg(StringRef name, const T &arg)
internal::FixedBuffer< Char > buffer_
GLdouble GLdouble GLdouble r
void require_numeric_argument(const Arg &arg, char spec)
FMT_FUNC void print(std::FILE *f, CStringRef format_str, ArgList args)
Result visit_cstring(const char *)
unsigned count_digits(uint64_t n)
BasicWriter & operator<<(LongLong value)
friend bool operator>=(BasicStringRef lhs, BasicStringRef rhs)
std::size_t capacity() const
void resize(std::size_t new_size)
GLuint const GLchar * name
void set_string(StringRef str)
FixedBuffer(Char *array, std::size_t size)
GLuint GLfloat GLfloat GLfloat GLfloat GLfloat GLfloat GLfloat t0
void clear() FMT_NOEXCEPT
BasicWriter & operator<<(ULongLong value)
static bool is_negative(T)
T & operator[](std::size_t index)
typedef UINT(WINAPI *PFNWGLGETCONTEXTGPUIDAMDPROC)(HGLRC hglrc)
void append(const U *begin, const U *end)
IntFormatSpec< int, TypeSpec<'b'> > bin(int value)
Result visit(const Arg &arg)
BasicWriter(Buffer< Char > &b)
friend bool operator<=(BasicStringRef lhs, BasicStringRef rhs)
static void format_custom_arg(void *formatter, const void *arg, void *format_str_ptr)
BasicMemoryWriter< wchar_t > WMemoryWriter
MakeValue(unsigned long value)
Allocator get_allocator() const
GLsizei const void * pointer
BasicArrayWriter(Char *array, std::size_t size)
GLint GLint GLint GLint GLint GLint GLsizei width
StringValue< wchar_t > wstring
Result visit_unhandled_arg()
static bool is_negative(T value)
BasicWriter & operator<<(typename internal::WCharHelper< wchar_t, Char >::Supported value)
friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs)
std::basic_string< Char > str() const
std::numeric_limits< fmt::internal::DummyInt > FPUtil
static wchar_t convert(wchar_t value)
std::basic_string< Char > to_string() const
GLsizei const GLchar *const * string
MakeValue(const T &value, typename EnableIf< ConvertToInt< T >::value, int >::type=0)
void write_int(T value, Spec spec)
static const char DIGITS[]
GenericMemoryBuffer MemoryBuffer
BasicArrayWriter< wchar_t > WArrayWriter
FMT_GCC_EXTENSION typedef long long LongLong
bool is_name_start(Char c)