46 #define FMT_VERSION 40100 48 #if defined(__has_include) 49 #define FMT_HAS_INCLUDE(x) __has_include(x) 51 #define FMT_HAS_INCLUDE(x) 0 54 #if (FMT_HAS_INCLUDE(<string_view>) && __cplusplus > 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910) 55 #include <string_view> 56 #define FMT_HAS_STRING_VIEW 1 58 #define FMT_HAS_STRING_VIEW 0 61 #if defined _SECURE_SCL && _SECURE_SCL 62 #define FMT_SECURE_SCL _SECURE_SCL 64 #define FMT_SECURE_SCL 0 72 #define FMT_MSC_VER _MSC_VER 77 #if FMT_MSC_VER && FMT_MSC_VER <= 1500 78 typedef unsigned __int32 uint32_t;
79 typedef unsigned __int64 uint64_t;
80 typedef __int64 intmax_t;
85 #if !defined(FMT_HEADER_ONLY) && defined(_WIN32) 87 #define FMT_API __declspec(dllexport) 88 #elif defined(FMT_SHARED) 89 #define FMT_API __declspec(dllimport) 97 #define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) 98 #define FMT_GCC_EXTENSION __extension__ 99 #if FMT_GCC_VERSION >= 406 100 #pragma GCC diagnostic push 103 #pragma GCC diagnostic ignored "-Wlong-long" 106 #pragma GCC diagnostic ignored "-Wshadow" 109 #pragma GCC diagnostic ignored "-Wsign-conversion" 111 #if __cplusplus >= 201103L || defined __GXX_EXPERIMENTAL_CXX0X__ 112 #define FMT_HAS_GXX_CXX11 1 115 #define FMT_GCC_VERSION 0 116 #define FMT_GCC_EXTENSION 117 #define FMT_HAS_GXX_CXX11 0 120 #if defined(__INTEL_COMPILER) 121 #define FMT_ICC_VERSION __INTEL_COMPILER 123 #define FMT_ICC_VERSION __ICL 126 #if defined(__clang__) && !defined(FMT_ICC_VERSION) 127 #define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) 128 #pragma clang diagnostic push 129 #pragma clang diagnostic ignored "-Wdocumentation-unknown-command" 130 #pragma clang diagnostic ignored "-Wpadded" 133 #ifdef __GNUC_LIBSTD__ 134 #define FMT_GNUC_LIBSTD_VERSION (__GNUC_LIBSTD__ * 100 + __GNUC_LIBSTD_MINOR__) 138 #define FMT_HAS_FEATURE(x) __has_feature(x) 140 #define FMT_HAS_FEATURE(x) 0 144 #define FMT_HAS_BUILTIN(x) __has_builtin(x) 146 #define FMT_HAS_BUILTIN(x) 0 149 #ifdef __has_cpp_attribute 150 #define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x) 152 #define FMT_HAS_CPP_ATTRIBUTE(x) 0 155 #if FMT_HAS_CPP_ATTRIBUTE(maybe_unused) 156 #define FMT_HAS_CXX17_ATTRIBUTE_MAYBE_UNUSED 159 #elif defined(_MSVC_LANG) && _MSVC_LANG > 201402 && _MSC_VER >= 1910 160 #define FMT_HAS_CXX17_ATTRIBUTE_MAYBE_UNUSED 163 #ifdef FMT_HAS_CXX17_ATTRIBUTE_MAYBE_UNUSED 164 #define FMT_MAYBE_UNUSED [[maybe_unused]] 166 #elif defined(__GNUC__) 167 #define FMT_MAYBE_UNUSED __attribute__((unused)) 169 #define FMT_MAYBE_UNUSED 173 #if defined(__MINGW32__) || defined(__MINGW64__) 174 #define FMT_NORETURN __attribute__((noreturn)) 175 #elif FMT_HAS_CPP_ATTRIBUTE(noreturn) && __cplusplus >= 201103L 176 #define FMT_NORETURN [[noreturn]] 181 #ifndef FMT_USE_VARIADIC_TEMPLATES 185 #define FMT_USE_VARIADIC_TEMPLATES \ 186 (FMT_HAS_FEATURE(cxx_variadic_templates) || (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1800) 189 #ifndef FMT_USE_RVALUE_REFERENCES 192 #if defined(FMT_GNUC_LIBSTD_VERSION) && FMT_GNUC_LIBSTD_VERSION <= 402 193 #define FMT_USE_RVALUE_REFERENCES 0 195 #define FMT_USE_RVALUE_REFERENCES \ 196 (FMT_HAS_FEATURE(cxx_rvalue_references) || (FMT_GCC_VERSION >= 403 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1600) 200 #if __cplusplus >= 201103L || FMT_MSC_VER >= 1700 201 #define FMT_USE_ALLOCATOR_TRAITS 1 203 #define FMT_USE_ALLOCATOR_TRAITS 0 207 #if defined(__GNUC__) && !defined(__EXCEPTIONS) 208 #define FMT_EXCEPTIONS 0 210 #if FMT_MSC_VER && !_HAS_EXCEPTIONS 211 #define FMT_EXCEPTIONS 0 213 #ifndef FMT_EXCEPTIONS 214 #define FMT_EXCEPTIONS 1 219 #define FMT_THROW(x) throw x 221 #define FMT_THROW(x) assert(false) 226 #ifndef FMT_USE_NOEXCEPT 227 #define FMT_USE_NOEXCEPT 0 230 #if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900 231 #define FMT_DETECTED_NOEXCEPT noexcept 233 #define FMT_DETECTED_NOEXCEPT throw() 238 #define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT 247 #define FMT_DTOR_NOEXCEPT FMT_DETECTED_NOEXCEPT 249 #define FMT_DTOR_NOEXCEPT FMT_NOEXCEPT 253 #if (defined(FMT_USE_OVERRIDE) && FMT_USE_OVERRIDE) || FMT_HAS_FEATURE(cxx_override) || (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || \ 255 #define FMT_OVERRIDE override 262 #if FMT_HAS_FEATURE(cxx_nullptr) || (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1600 263 #define FMT_NULL nullptr 265 #define FMT_NULL NULL 271 #ifndef FMT_USE_DELETED_FUNCTIONS 272 #define FMT_USE_DELETED_FUNCTIONS 0 275 #if FMT_USE_DELETED_FUNCTIONS || FMT_HAS_FEATURE(cxx_deleted_functions) || (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || \ 277 #define FMT_DELETED_OR_UNDEFINED = delete 278 #define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \ 279 TypeName(const TypeName &) = delete; \ 280 TypeName &operator=(const TypeName &) = delete 282 #define FMT_DELETED_OR_UNDEFINED 283 #define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \ 284 TypeName(const TypeName &); \ 285 TypeName &operator=(const TypeName &) 288 #ifndef FMT_USE_DEFAULTED_FUNCTIONS 289 #define FMT_USE_DEFAULTED_FUNCTIONS 0 292 #ifndef FMT_DEFAULTED_COPY_CTOR 293 #if FMT_USE_DEFAULTED_FUNCTIONS || FMT_HAS_FEATURE(cxx_defaulted_functions) || (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || \ 295 #define FMT_DEFAULTED_COPY_CTOR(TypeName) TypeName(const TypeName &) = default; 297 #define FMT_DEFAULTED_COPY_CTOR(TypeName) 301 #ifndef FMT_USE_USER_DEFINED_LITERALS 306 #if FMT_USE_VARIADIC_TEMPLATES && FMT_USE_RVALUE_REFERENCES && \ 307 (FMT_HAS_FEATURE(cxx_user_literals) || (FMT_GCC_VERSION >= 407 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900) && \ 308 (!defined(FMT_ICC_VERSION) || FMT_ICC_VERSION >= 1500) 309 #define FMT_USE_USER_DEFINED_LITERALS 1 311 #define FMT_USE_USER_DEFINED_LITERALS 0 315 #ifndef FMT_USE_EXTERN_TEMPLATES 316 #define FMT_USE_EXTERN_TEMPLATES (FMT_CLANG_VERSION >= 209 || (FMT_GCC_VERSION >= 303 && FMT_HAS_GXX_CXX11)) 319 #ifdef FMT_HEADER_ONLY 321 #undef FMT_USE_EXTERN_TEMPLATES 322 #define FMT_USE_EXTERN_TEMPLATES 0 326 #define FMT_ASSERT(condition, message) assert((condition) && message) 332 #if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clz) 333 #define FMT_BUILTIN_CLZ(n) __builtin_clz(n) 336 #if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clzll) 337 #define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n) 345 #if FMT_MSC_VER && !defined(FMT_BUILTIN_CLZLL) && !defined(_MANAGED) 352 #pragma intrinsic(_BitScanReverse) 354 inline uint32_t clz(uint32_t x)
357 _BitScanReverse(&r, x);
363 #pragma warning(suppress : 6102) 366 #define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n) 369 #if defined(_WIN64) && !defined(__clang__) 370 #pragma intrinsic(_BitScanReverse64) 373 inline uint32_t clzll(uint64_t x)
377 _BitScanReverse64(&r, x);
380 if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32)))
381 return 63 - (r + 32);
384 _BitScanReverse(&r, static_cast<uint32_t>(x));
391 #pragma warning(suppress : 6102) 394 #define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n) 441 inline T const_check(T value)
454 class numeric_limits<
fmt::internal::DummyInt> :
public std::numeric_limits<int>
459 static bool isinfinity(T x)
464 if (const_check(
sizeof(isinf(x)) ==
sizeof(
bool) ||
sizeof(isinf(x)) ==
sizeof(
int)))
466 return isinf(x) != 0;
468 return !_finite(static_cast<double>(x));
473 static bool isnotanumber(T x)
476 if (const_check(
sizeof(isnan(x)) ==
sizeof(
bool) ||
sizeof(isnan(x)) ==
sizeof(
int)))
478 return isnan(x) != 0;
480 return _isnan(static_cast<double>(x)) != 0;
484 static bool isnegative(
double x)
487 if (const_check(
sizeof(signbit(x)) ==
sizeof(
bool) ||
sizeof(signbit(x)) ==
sizeof(
int)))
489 return signbit(x) != 0;
493 if (!isnotanumber(x))
495 int dec = 0, sign = 0;
497 _ecvt_s(buffer,
sizeof(buffer), x, 0, &dec, &sign);
507 FMT_GCC_EXTENSION
typedef long long LongLong;
508 FMT_GCC_EXTENSION
typedef unsigned long long ULongLong;
510 #if FMT_USE_RVALUE_REFERENCES 514 template<
typename Char>
520 template<
typename Char>
525 template<
typename Impl,
typename Char,
typename Spec = fmt::FormatSpec>
528 template<
typename CharType,
typename ArgFormatter = fmt::ArgFormatter<CharType>>
556 template<
typename Char>
579 , size_(
std::char_traits<Char>::length(s))
588 template<
typename Allocator>
589 BasicStringRef(
const std::basic_string<Char, std::char_traits<Char>, Allocator> &s)
595 #if FMT_HAS_STRING_VIEW 601 BasicStringRef(
const std::basic_string_view<Char, std::char_traits<Char>> &s)
612 explicit operator std::basic_string_view<Char>()
const FMT_NOEXCEPT
614 return std::basic_string_view<Char>(data_, size_);
625 return std::basic_string<Char>(data_, size_);
643 std::size_t size = size_ < other.size_ ? size_ : other.size_;
644 int result = std::char_traits<Char>::compare(data_, other.data_, size);
646 result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
652 return lhs.compare(rhs) == 0;
656 return lhs.compare(rhs) != 0;
660 return lhs.compare(rhs) < 0;
664 return lhs.compare(rhs) <= 0;
668 return lhs.compare(rhs) > 0;
672 return lhs.compare(rhs) >= 0;
704 template<
typename Char>
722 template<
typename Allocator>
743 : std::runtime_error(message.
c_str())
747 : std::runtime_error(ferr)
750 FMT_API ~
FormatError() FMT_DTOR_NOEXCEPT FMT_OVERRIDE;
762 #define FMT_SPECIALIZE_MAKE_UNSIGNED(T, U) \ 764 struct MakeUnsigned<T> \ 769 FMT_SPECIALIZE_MAKE_UNSIGNED(
char,
unsigned char);
770 FMT_SPECIALIZE_MAKE_UNSIGNED(
signed char,
unsigned char);
771 FMT_SPECIALIZE_MAKE_UNSIGNED(
short,
unsigned short);
772 FMT_SPECIALIZE_MAKE_UNSIGNED(
int,
unsigned);
773 FMT_SPECIALIZE_MAKE_UNSIGNED(
long,
unsigned long);
774 FMT_SPECIALIZE_MAKE_UNSIGNED(LongLong, ULongLong);
777 template<
typename Int>
778 inline typename MakeUnsigned<Int>::Type to_unsigned(Int value)
780 FMT_ASSERT(value >= 0,
"negative value");
781 return static_cast<typename MakeUnsigned<Int>::Type
>(value);
788 INLINE_BUFFER_SIZE = 500
794 inline stdext::checked_array_iterator<T *> make_ptr(T *ptr, std::size_t size)
796 return stdext::checked_array_iterator<T *>(ptr, size);
800 inline T *make_ptr(T *ptr, std::size_t)
816 FMT_DISALLOW_COPY_AND_ASSIGN(
Buffer);
821 std::size_t capacity_;
823 Buffer(T *ptr = FMT_NULL, std::size_t capacity = 0)
826 , capacity_(capacity)
836 virtual void grow(std::size_t size) = 0;
858 if (new_size > capacity_)
870 if (capacity > capacity_)
874 void clear() FMT_NOEXCEPT
879 void push_back(
const T &value)
881 if (size_ == capacity_)
883 ptr_[size_++] = value;
888 void append(
const U *begin,
const U *end);
890 T &operator[](std::size_t index)
894 const T &operator[](std::size_t index)
const 904 FMT_ASSERT(end >= begin,
"negative value");
905 std::size_t new_size = size_ +
static_cast<std::size_t
>(end - begin);
906 if (new_size > capacity_)
908 std::uninitialized_copy(begin, end, internal::make_ptr(ptr_, capacity_) + size_);
916 template<
typename T, std::
size_t SIZE,
typename Allocator = std::allocator<T>>
925 if (this->ptr_ != data_)
926 Allocator::deallocate(this->ptr_, this->capacity_);
930 void grow(std::size_t size) FMT_OVERRIDE;
933 explicit MemoryBuffer(
const Allocator &alloc = Allocator())
943 #if FMT_USE_RVALUE_REFERENCES 948 Allocator &this_alloc = *
this, &other_alloc = other;
949 this_alloc = std::move(other_alloc);
950 this->size_ = other.size_;
951 this->capacity_ = other.capacity_;
952 if (other.ptr_ == other.data_)
955 std::uninitialized_copy(other.data_, other.data_ + this->size_, make_ptr(data_, this->capacity_));
959 this->ptr_ = other.ptr_;
962 other.ptr_ = other.data_;
974 assert(
this != &other);
982 Allocator get_allocator()
const 988 template<
typename T, std::
size_t SIZE,
typename Allocator>
991 std::size_t new_capacity = this->capacity_ + this->capacity_ / 2;
992 if (size > new_capacity)
994 #if FMT_USE_ALLOCATOR_TRAITS 995 T *new_ptr = std::allocator_traits<Allocator>::allocate(*
this, new_capacity, FMT_NULL);
997 T *new_ptr = this->allocate(new_capacity, FMT_NULL);
1000 std::uninitialized_copy(this->ptr_, this->ptr_ + this->size_, make_ptr(new_ptr, new_capacity));
1001 std::size_t old_capacity = this->capacity_;
1002 T *old_ptr = this->ptr_;
1003 this->capacity_ = new_capacity;
1004 this->ptr_ = new_ptr;
1008 if (old_ptr != data_)
1009 Allocator::deallocate(old_ptr, old_capacity);
1013 template<
typename Char>
1023 FMT_API
void grow(std::size_t size) FMT_OVERRIDE;
1026 template<
typename Char>
1031 typedef stdext::checked_array_iterator<Char *> CharPtr;
1033 typedef Char *CharPtr;
1035 static Char cast(
int value)
1037 return static_cast<Char
>(value);
1041 template<
typename Char>
1049 static char convert(
wchar_t);
1052 static char convert(
char value)
1058 template<
typename T>
1059 FMT_API
static int format_float(
char *buffer, std::size_t size,
const char *format,
unsigned width,
int precision, T value);
1062 #if FMT_USE_EXTERN_TEMPLATES 1064 char *buffer, std::size_t size,
const char *format,
unsigned width,
int precision,
double value);
1066 char *buffer, std::size_t size,
const char *format,
unsigned width,
int precision,
long double value);
1073 static wchar_t convert(
char value)
1077 static wchar_t convert(
wchar_t value)
1082 template<
typename T>
1083 FMT_API
static int format_float(
wchar_t *buffer, std::size_t size,
const wchar_t *format,
unsigned width,
int precision, T value);
1086 #if FMT_USE_EXTERN_TEMPLATES 1088 wchar_t *buffer, std::size_t size,
const wchar_t *format,
unsigned width,
int precision,
double value);
1090 wchar_t *buffer, std::size_t size,
const wchar_t *format,
unsigned width,
int precision,
long double value);
1094 template<
bool IsSigned>
1097 template<
typename T>
1098 static bool is_negative(T value)
1107 template<
typename T>
1108 static bool is_negative(T)
1116 template<
typename T>
1117 inline bool is_negative(T value)
1123 template<
bool FitsIn32Bits>
1126 typedef uint32_t Type;
1132 typedef uint64_t Type;
1135 template<
typename T>
1143 FMT_API FMT_NORETURN
void report_unknown_type(
char code,
const char *type);
1147 template<
typename T =
void>
1150 static const uint32_t POWERS_OF_10_32[];
1151 static const uint64_t POWERS_OF_10_64[];
1152 static const char DIGITS[];
1155 #if FMT_USE_EXTERN_TEMPLATES 1161 #ifdef FMT_BUILTIN_CLZLL 1164 inline unsigned count_digits(uint64_t n)
1168 int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;
1169 return to_unsigned(t) - (n < Data::POWERS_OF_10_64[t]) + 1;
1173 inline unsigned count_digits(uint64_t n)
1195 #ifdef FMT_BUILTIN_CLZ 1197 inline unsigned count_digits(uint32_t n)
1199 int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;
1200 return to_unsigned(t) - (n < Data::POWERS_OF_10_32[t]) + 1;
1207 template<
typename Char>
1208 void operator()(Char *)
1220 unsigned digit_index_;
1229 template<
typename Char>
1230 void operator()(Char *&buffer)
1232 if (++digit_index_ % 3 != 0)
1234 buffer -= sep_.
size();
1235 std::uninitialized_copy(sep_.
data(), sep_.
data() + sep_.
size(), internal::make_ptr(buffer, sep_.
size()));
1242 template<
typename UInt,
typename Char,
typename ThousandsSep>
1243 inline void format_decimal(Char *buffer, UInt value,
unsigned num_digits,
ThousandsSep thousands_sep)
1245 buffer += num_digits;
1246 while (value >= 100)
1251 unsigned index =
static_cast<unsigned>((value % 100) * 2);
1253 *--buffer = Data::DIGITS[index + 1];
1254 thousands_sep(buffer);
1255 *--buffer = Data::DIGITS[index];
1256 thousands_sep(buffer);
1260 *--buffer =
static_cast<char>(
'0' + value);
1263 unsigned index =
static_cast<unsigned>(value * 2);
1264 *--buffer = Data::DIGITS[index + 1];
1265 thousands_sep(buffer);
1266 *--buffer = Data::DIGITS[index];
1269 template<
typename UInt,
typename Char>
1270 inline void format_decimal(Char *buffer, UInt value,
unsigned num_digits)
1277 #define FMT_USE_WINDOWS_H 0 1278 #elif !defined(FMT_USE_WINDOWS_H) 1279 #define FMT_USE_WINDOWS_H 1 1284 #if FMT_USE_WINDOWS_H 1293 FMT_API
explicit UTF8ToUTF16(StringRef s);
1294 operator WStringRef()
const 1296 return WStringRef(&buffer_[0], size());
1300 return buffer_.
size() - 1;
1302 const wchar_t *c_str()
const 1306 std::wstring str()
const 1308 return std::wstring(&buffer_[0], size());
1321 FMT_API
explicit UTF16ToUTF8(WStringRef s);
1322 operator StringRef()
const 1324 return StringRef(&buffer_[0], size());
1328 return buffer_.
size() - 1;
1330 const char *c_str()
const 1334 std::string str()
const 1336 return std::string(&buffer_[0], size());
1342 FMT_API
int convert(WStringRef s);
1351 template<
typename Char>
1358 typedef void (*FormatFunc)(
void *formatter,
const void *arg,
void *format_str_ptr);
1369 unsigned uint_value;
1370 LongLong long_long_value;
1371 ULongLong ulong_long_value;
1372 double double_value;
1373 long double long_double_value;
1374 const void *pointer;
1393 LAST_INTEGER_TYPE = CHAR,
1397 LAST_NUMERIC_TYPE = LONG_DOUBLE,
1413 template<
typename Char>
1415 template<
typename Char,
typename T>
1418 template<
typename T =
void>
1425 template<
typename T,
typename Char>
1429 typedef T Unsupported;
1432 template<
typename T>
1435 typedef T Supported;
1439 typedef char Yes[1];
1442 template<
typename T>
1446 Yes &convert(fmt::ULongLong);
1449 template<
typename T,
bool ENABLE_CONVERSION>
1454 value = ENABLE_CONVERSION
1458 template<
typename T,
bool ENABLE_CONVERSION>
1467 template<
typename T>
1477 template<
typename T>
1482 enable_conversion =
sizeof(fmt::internal::convert(get<T>())) ==
sizeof(Yes)
1490 #define FMT_DISABLE_CONVERSION_TO_INT(Type) \ 1492 struct ConvertToInt<Type> \ 1501 FMT_DISABLE_CONVERSION_TO_INT(
float);
1502 FMT_DISABLE_CONVERSION_TO_INT(
double);
1503 FMT_DISABLE_CONVERSION_TO_INT(
long double);
1505 template<
bool B,
class T =
void>
1516 template<
bool B,
class T,
class F>
1522 template<
class T,
class F>
1547 template<
typename T>
1556 template<
typename T, T>
1565 template<
typename LConv>
1568 return lc->thousands_sep;
1576 #define FMT_CONCAT(a, b) a##b 1578 #if FMT_GCC_VERSION >= 303 1579 #define FMT_UNUSED __attribute__((unused)) 1584 #ifndef FMT_USE_STATIC_ASSERT 1585 #define FMT_USE_STATIC_ASSERT 0 1588 #if FMT_USE_STATIC_ASSERT || FMT_HAS_FEATURE(cxx_static_assert) || (FMT_GCC_VERSION >= 403 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1600 1589 #define FMT_STATIC_ASSERT(cond, message) static_assert(cond, message) 1591 #define FMT_CONCAT_(a, b) FMT_CONCAT(a, b) 1592 #define FMT_STATIC_ASSERT(cond, message) typedef int FMT_CONCAT_(Assert, __LINE__)[(cond) ? 1 : -1] FMT_UNUSED 1595 template<
typename Formatter>
1596 void format_arg(Formatter &, ...)
1599 "operator<< include fmt/ostream.h. Otherwise provide " 1600 "an overload of format_arg.");
1604 template<
typename Formatter>
1608 typedef typename Formatter::Char Char;
1616 template<
typename T>
1618 template<
typename T>
1625 #if !FMT_MSC_VER || defined(_NATIVE_WCHAR_T_DEFINED) 1626 MakeValue(
typename WCharHelper<wchar_t, Char>::Unsupported);
1628 MakeValue(
typename WCharHelper<wchar_t *, Char>::Unsupported);
1629 MakeValue(
typename WCharHelper<const wchar_t *, Char>::Unsupported);
1630 MakeValue(
typename WCharHelper<const std::wstring &, Char>::Unsupported);
1631 #if FMT_HAS_STRING_VIEW 1632 MakeValue(
typename WCharHelper<const std::wstring_view &, Char>::Unsupported);
1634 MakeValue(
typename WCharHelper<WStringRef, Char>::Unsupported);
1636 void set_string(StringRef str)
1638 string.value = str.
data();
1639 string.size = str.
size();
1642 void set_string(WStringRef str)
1644 wstring.value = str.
data();
1645 wstring.size = str.
size();
1649 template<
typename T>
1650 static void format_custom_arg(
void *formatter,
const void *arg,
void *format_str_ptr)
1652 format_arg(*static_cast<Formatter *>(formatter), *static_cast<const Char **>(format_str_ptr), *static_cast<const T *>(arg));
1658 #define FMT_MAKE_VALUE_(Type, field, TYPE, rhs) \ 1659 MakeValue(Type value) \ 1663 static uint64_t type(Type) \ 1668 #define FMT_MAKE_VALUE(Type, field, TYPE) FMT_MAKE_VALUE_(Type, field, TYPE, value) 1670 FMT_MAKE_VALUE(
bool, int_value, BOOL)
1671 FMT_MAKE_VALUE(
short, int_value, INT)
1672 FMT_MAKE_VALUE(
unsigned short, uint_value, UINT)
1673 FMT_MAKE_VALUE(
int, int_value, INT)
1674 FMT_MAKE_VALUE(
unsigned, uint_value, UINT)
1680 if (const_check(
sizeof(
long) ==
sizeof(
int)))
1681 int_value =
static_cast<int>(value);
1683 long_long_value = value;
1685 static uint64_t type(
long)
1687 return sizeof(long) ==
sizeof(
int) ? Arg::INT : Arg::LONG_LONG;
1692 if (const_check(
sizeof(
unsigned long) ==
sizeof(
unsigned)))
1693 uint_value =
static_cast<unsigned>(value);
1695 ulong_long_value = value;
1697 static uint64_t type(
unsigned long)
1699 return sizeof(
unsigned long) ==
sizeof(
unsigned) ? Arg::UINT : Arg::ULONG_LONG;
1702 FMT_MAKE_VALUE(LongLong, long_long_value, LONG_LONG)
1703 FMT_MAKE_VALUE(ULongLong, ulong_long_value, ULONG_LONG)
1704 FMT_MAKE_VALUE(
float, double_value, DOUBLE)
1705 FMT_MAKE_VALUE(
double, double_value, DOUBLE)
1706 FMT_MAKE_VALUE(
long double, long_double_value, LONG_DOUBLE)
1707 FMT_MAKE_VALUE(
signed char, int_value, INT)
1708 FMT_MAKE_VALUE(
unsigned char, uint_value, UINT)
1709 FMT_MAKE_VALUE(
char, int_value, CHAR)
1711 #if __cplusplus >= 201103L 1712 template<typename T, typename = typename std::enable_if<std::is_enum<T>::value &&
ConvertToInt<T>::value>::type>
1718 template<typename T, typename = typename std::enable_if<std::is_enum<T>::value &&
ConvertToInt<T>::value>::type>
1719 static uint64_t type(T)
1725 #if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) 1730 static uint64_t type(
wchar_t)
1736 #define FMT_MAKE_STR_VALUE(Type, TYPE) \ 1737 MakeValue(Type value) \ 1739 set_string(value); \ 1741 static uint64_t type(Type) \ 1746 FMT_MAKE_VALUE(
char *,
string.value, CSTRING)
1747 FMT_MAKE_VALUE(
const char *,
string.value, CSTRING)
1748 FMT_MAKE_VALUE(
signed char *, sstring.value, CSTRING)
1749 FMT_MAKE_VALUE(
const signed char *, sstring.value, CSTRING)
1750 FMT_MAKE_VALUE(
unsigned char *, ustring.value, CSTRING)
1751 FMT_MAKE_VALUE(
const unsigned char *, ustring.value, CSTRING)
1752 FMT_MAKE_STR_VALUE(
const std::string &, STRING)
1753 #if FMT_HAS_STRING_VIEW 1754 FMT_MAKE_STR_VALUE(
const std::string_view &, STRING)
1756 FMT_MAKE_STR_VALUE(StringRef, STRING)
1757 FMT_MAKE_VALUE_(CStringRef,
string.value, CSTRING, value.c_str())
1759 #define FMT_MAKE_WSTR_VALUE(Type, TYPE) \
1762 set_string(value); \
1764 static uint64_t type(Type) \
1769 FMT_MAKE_WSTR_VALUE(
wchar_t *, WSTRING)
1770 FMT_MAKE_WSTR_VALUE(
const wchar_t *, WSTRING)
1771 FMT_MAKE_WSTR_VALUE(
const std::wstring &, WSTRING)
1772 #if FMT_HAS_STRING_VIEW 1773 FMT_MAKE_WSTR_VALUE(
const std::wstring_view &, WSTRING)
1775 FMT_MAKE_WSTR_VALUE(WStringRef, WSTRING)
1777 FMT_MAKE_VALUE(
void *, pointer, POINTER)
1778 FMT_MAKE_VALUE(
const void *, pointer, POINTER)
1780 template<
typename T>
1783 custom.value = &value;
1784 custom.format = &format_custom_arg<T>;
1787 template<
typename T>
1795 template<
typename Char_>
1800 template<
typename Char_,
typename T>
1806 template<
typename Char_>
1809 return Arg::NAMED_ARG;
1811 template<
typename Char_,
typename T>
1814 return Arg::NAMED_ARG;
1818 template<
typename Formatter>
1827 template<
typename T>
1835 template<
typename Char>
1840 template<
typename T>
1848 template<
typename Char,
typename T>
1861 : std::runtime_error(
"")
1865 : std::runtime_error(rerr)
1868 FMT_API ~
RuntimeError() FMT_DTOR_NOEXCEPT FMT_OVERRIDE;
1871 template<
typename Char>
1893 internal::Arg::Type type(
unsigned index)
const 1895 return type(types_, index);
1898 template<
typename Char>
1905 MAX_PACKED_ARGS = 16
1924 uint64_t types()
const 1934 bool use_values = type(MAX_PACKED_ARGS - 1) == Arg::NONE;
1935 if (index < MAX_PACKED_ARGS)
1937 Arg::Type arg_type = type(index);
1939 if (arg_type != Arg::NONE)
1940 val = use_values ? values_[index] : args_[index];
1941 arg.type = arg_type;
1948 arg.type = Arg::NONE;
1951 for (
unsigned i = MAX_PACKED_ARGS; i <= index; ++i)
1953 if (args_[i].type == Arg::NONE)
1956 return args_[index];
1959 static internal::Arg::Type type(uint64_t types,
unsigned index)
1961 unsigned shift = index * 4;
1962 uint64_t mask = 0xf;
1963 return static_cast<internal::Arg::Type
>((types & (mask << shift)) >> shift);
1967 #define FMT_DISPATCH(call) static_cast<Impl *>(this)->call 1993 template<
typename Impl,
typename Result>
2000 void report_unhandled_arg() {}
2002 Result visit_unhandled_arg()
2004 FMT_DISPATCH(report_unhandled_arg());
2011 return FMT_DISPATCH(visit_any_int(value));
2017 return FMT_DISPATCH(visit_any_int(value));
2023 return FMT_DISPATCH(visit_any_int(value));
2029 return FMT_DISPATCH(visit_any_int(value));
2035 return FMT_DISPATCH(visit_any_int(value));
2041 return FMT_DISPATCH(visit_any_int(value));
2045 template<
typename T>
2048 return FMT_DISPATCH(visit_unhandled_arg());
2054 return FMT_DISPATCH(visit_any_double(value));
2060 return FMT_DISPATCH(visit_any_double(value));
2064 template<
typename T>
2067 return FMT_DISPATCH(visit_unhandled_arg());
2073 return FMT_DISPATCH(visit_unhandled_arg());
2079 return FMT_DISPATCH(visit_unhandled_arg());
2085 return FMT_DISPATCH(visit_unhandled_arg());
2091 return FMT_DISPATCH(visit_unhandled_arg());
2097 return FMT_DISPATCH(visit_unhandled_arg());
2113 case Arg::NAMED_ARG:
2114 FMT_ASSERT(
false,
"invalid argument type");
2117 return FMT_DISPATCH(visit_int(arg.int_value));
2119 return FMT_DISPATCH(visit_uint(arg.uint_value));
2120 case Arg::LONG_LONG:
2121 return FMT_DISPATCH(visit_long_long(arg.long_long_value));
2122 case Arg::ULONG_LONG:
2123 return FMT_DISPATCH(visit_ulong_long(arg.ulong_long_value));
2125 return FMT_DISPATCH(visit_bool(arg.int_value != 0));
2127 return FMT_DISPATCH(visit_char(arg.int_value));
2129 return FMT_DISPATCH(visit_double(arg.double_value));
2130 case Arg::LONG_DOUBLE:
2131 return FMT_DISPATCH(visit_long_double(arg.long_double_value));
2133 return FMT_DISPATCH(visit_cstring(arg.string.value));
2135 return FMT_DISPATCH(visit_string(arg.string));
2137 return FMT_DISPATCH(visit_wstring(arg.wstring));
2139 return FMT_DISPATCH(visit_pointer(arg.pointer));
2141 return FMT_DISPATCH(visit_custom(arg.custom));
2175 Alignment align()
const 2177 return ALIGN_DEFAULT;
2179 unsigned width()
const 2183 int precision()
const 2187 bool flag(
unsigned)
const 2195 char type_prefix()
const 2219 unsigned width()
const 2223 wchar_t fill()
const 2234 AlignSpec(
unsigned width,
wchar_t fill, Alignment align = ALIGN_DEFAULT)
2240 Alignment align()
const 2245 int precision()
const 2260 bool flag(
unsigned)
const 2268 char type_prefix()
const 2281 FormatSpec(
unsigned width = 0,
char type = 0,
wchar_t fill =
' ')
2289 bool flag(
unsigned f)
const 2291 return (flags_ & f) != 0;
2293 int precision()
const 2301 char type_prefix()
const 2308 template<
typename T,
typename SpecT = TypeSpec<0>,
typename Char =
char>
2328 template<
typename Char>
2335 template<
typename FillChar>
2336 StrFormatSpec(
const Char *str,
unsigned width, FillChar fill)
2343 const Char *str()
const 2385 template<
char TYPE_CODE,
typename Char>
2388 #define FMT_DEFINE_INT_FORMATTERS(TYPE) \ 2389 inline IntFormatSpec<TYPE, TypeSpec<'b'>> bin(TYPE value) \ 2391 return IntFormatSpec<TYPE, TypeSpec<'b'>>(value, TypeSpec<'b'>()); \ 2394 inline IntFormatSpec<TYPE, TypeSpec<'o'>> oct(TYPE value) \ 2396 return IntFormatSpec<TYPE, TypeSpec<'o'>>(value, TypeSpec<'o'>()); \ 2399 inline IntFormatSpec<TYPE, TypeSpec<'x'>> hex(TYPE value) \ 2401 return IntFormatSpec<TYPE, TypeSpec<'x'>>(value, TypeSpec<'x'>()); \ 2404 inline IntFormatSpec<TYPE, TypeSpec<'X'>> hexu(TYPE value) \ 2406 return IntFormatSpec<TYPE, TypeSpec<'X'>>(value, TypeSpec<'X'>()); \ 2409 template<char TYPE_CODE> \ 2410 inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>> pad(IntFormatSpec<TYPE, TypeSpec<TYPE_CODE>> f, unsigned width) \ 2412 return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>>(f.value(), AlignTypeSpec<TYPE_CODE>(width, ' ')); \ 2419 template<char TYPE_CODE, typename Char> \ 2420 inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char> pad( \ 2421 IntFormatSpec<TYPE, TypeSpec<TYPE_CODE>, Char> f, unsigned width, Char fill) \ 2423 return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char>(f.value(), AlignTypeSpec<TYPE_CODE>(width, fill)); \ 2426 inline IntFormatSpec<TYPE, AlignTypeSpec<0>> pad(TYPE value, unsigned width) \ 2428 return IntFormatSpec<TYPE, AlignTypeSpec<0>>(value, AlignTypeSpec<0>(width, ' ')); \ 2431 template<typename Char> \ 2432 inline IntFormatSpec<TYPE, AlignTypeSpec<0>, Char> pad(TYPE value, unsigned width, Char fill) \ 2434 return IntFormatSpec<TYPE, AlignTypeSpec<0>, Char>(value, AlignTypeSpec<0>(width, fill)); \ 2437 FMT_DEFINE_INT_FORMATTERS(
int)
2438 FMT_DEFINE_INT_FORMATTERS(
long)
2439 FMT_DEFINE_INT_FORMATTERS(
unsigned)
2440 FMT_DEFINE_INT_FORMATTERS(
unsigned long)
2441 FMT_DEFINE_INT_FORMATTERS(LongLong)
2442 FMT_DEFINE_INT_FORMATTERS(ULongLong)
2456 template<
typename Char>
2467 namespace internal {
2469 template<
typename Char>
2473 typedef std::vector<std::pair<fmt::BasicStringRef<Char>,
internal::Arg>> MapType;
2474 typedef typename MapType::value_type Pair;
2479 void init(
const ArgList &args);
2484 for (
typename MapType::const_iterator it = map_.begin(), end = map_.end(); it != end; ++it)
2486 if (it->first == name)
2493 template<
typename Char>
2499 const NamedArg *named_arg = FMT_NULL;
2500 bool use_values = args.type(ArgList::MAX_PACKED_ARGS - 1) == internal::Arg::NONE;
2503 for (
unsigned i = 0; ; ++i)
2505 internal::Arg::Type arg_type = args.type(i);
2508 case internal::Arg::NONE:
2510 case internal::Arg::NAMED_ARG:
2511 named_arg =
static_cast<const NamedArg *
>(args.values_[i].pointer);
2512 map_.push_back(Pair(named_arg->name, *named_arg));
2521 for (
unsigned i = 0; i != ArgList::MAX_PACKED_ARGS; ++i)
2523 internal::Arg::Type arg_type = args.type(i);
2524 if (arg_type == internal::Arg::NAMED_ARG)
2526 named_arg =
static_cast<const NamedArg *
>(args.args_[i].pointer);
2527 map_.push_back(Pair(named_arg->name, *named_arg));
2530 for (
unsigned i = ArgList::MAX_PACKED_ARGS; ; ++i)
2532 switch (args.args_[i].type)
2534 case internal::Arg::NONE:
2536 case internal::Arg::NAMED_ARG:
2537 named_arg =
static_cast<const NamedArg *
>(args.args_[i].pointer);
2538 map_.push_back(Pair(named_arg->name, *named_arg));
2547 template<
typename Impl,
typename Char,
typename Spec = fmt::FormatSpec>
2556 void write_pointer(
const void *p)
2558 spec_.flags_ = HASH_FLAG;
2560 writer_.write_int(reinterpret_cast<uintptr_t>(p), spec_);
2576 void write(
bool value)
2578 const char *str_value = value ?
"true" :
"false";
2580 writer_.write_str(str, spec_);
2583 void write(
const char *value)
2586 writer_.write_str(str, spec_);
2590 typedef Spec SpecType;
2598 template<
typename T>
2599 void visit_any_int(T value)
2601 writer_.write_int(value, spec_);
2604 template<
typename T>
2605 void visit_any_double(T value)
2607 writer_.write_double(value, spec_);
2610 void visit_bool(
bool value)
2614 visit_any_int(value);
2620 void visit_char(
int value)
2622 if (spec_.type_ && spec_.type_ !=
'c')
2624 spec_.flags_ |= CHAR_FLAG;
2625 writer_.write_int(value, spec_);
2628 if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0)
2629 FMT_THROW(
FormatError(
"invalid format specifier for char"));
2630 typedef typename BasicWriter<Char>::CharPtr CharPtr;
2632 CharPtr out = CharPtr();
2633 const unsigned CHAR_SIZE = 1;
2634 if (spec_.width_ > CHAR_SIZE)
2636 out = writer_.grow_buffer(spec_.width_);
2637 if (spec_.align_ == ALIGN_RIGHT)
2639 std::uninitialized_fill_n(out, spec_.width_ - CHAR_SIZE, fill);
2640 out += spec_.width_ - CHAR_SIZE;
2642 else if (spec_.align_ == ALIGN_CENTER)
2644 out = writer_.fill_padding(out, spec_.width_, internal::const_check(CHAR_SIZE), fill);
2648 std::uninitialized_fill_n(out + CHAR_SIZE, spec_.width_ - CHAR_SIZE, fill);
2653 out = writer_.grow_buffer(CHAR_SIZE);
2658 void visit_cstring(
const char *value)
2660 if (spec_.type_ ==
'p')
2661 return write_pointer(value);
2668 writer_.write_str(value, spec_);
2675 writer_.write_str(value, spec_);
2678 void visit_pointer(
const void *value)
2680 if (spec_.type_ && spec_.type_ !=
'p')
2681 report_unknown_type(spec_.type_,
"pointer");
2682 write_pointer(value);
2690 int next_arg_index_;
2693 FMT_API
Arg do_get_arg(
unsigned arg_index,
const char *&error);
2704 next_arg_index_ = 0;
2708 Arg next_arg(
const char *&error)
2710 if (next_arg_index_ >= 0)
2711 return do_get_arg(internal::to_unsigned(next_arg_index_++), error);
2712 error =
"cannot switch from manual to automatic argument indexing";
2718 Arg get_arg(
unsigned arg_index,
const char *&error)
2720 return check_no_auto_index(error) ? do_get_arg(arg_index, error) :
Arg();
2723 bool check_no_auto_index(
const char *&error)
2725 if (next_arg_index_ > 0)
2727 error =
"cannot switch from automatic to manual argument indexing";
2730 next_arg_index_ = -1;
2734 template<
typename Char>
2738 w << BasicStringRef<Char>(start, internal::to_unsigned(end - start));
2760 template<
typename Impl,
typename Char,
typename Spec = fmt::FormatSpec>
2765 const Char *format_;
2778 , formatter_(formatter)
2786 c.format(&formatter_, c.value, &format_);
2791 template<
typename Char>
2803 template<
typename CharType,
typename ArgFormatter>
2816 using internal::FormatterBase::get_arg;
2852 const Char *format(
const Char *&format_str,
const internal::Arg &arg);
2857 #define FMT_GEN(n, f) FMT_GEN##n(f) 2858 #define FMT_GEN1(f) f(0) 2859 #define FMT_GEN2(f) FMT_GEN1(f), f(1) 2860 #define FMT_GEN3(f) FMT_GEN2(f), f(2) 2861 #define FMT_GEN4(f) FMT_GEN3(f), f(3) 2862 #define FMT_GEN5(f) FMT_GEN4(f), f(4) 2863 #define FMT_GEN6(f) FMT_GEN5(f), f(5) 2864 #define FMT_GEN7(f) FMT_GEN6(f), f(6) 2865 #define FMT_GEN8(f) FMT_GEN7(f), f(7) 2866 #define FMT_GEN9(f) FMT_GEN8(f), f(8) 2867 #define FMT_GEN10(f) FMT_GEN9(f), f(9) 2868 #define FMT_GEN11(f) FMT_GEN10(f), f(10) 2869 #define FMT_GEN12(f) FMT_GEN11(f), f(11) 2870 #define FMT_GEN13(f) FMT_GEN12(f), f(12) 2871 #define FMT_GEN14(f) FMT_GEN13(f), f(13) 2872 #define FMT_GEN15(f) FMT_GEN14(f), f(14) 2874 namespace internal {
2875 inline uint64_t make_type()
2880 template<
typename T>
2881 inline uint64_t make_type(
const T &arg)
2886 template<std::size_t N,
bool = (N < ArgList::MAX_PACKED_ARGS)>
2889 template<std::
size_t N>
2893 typedef Value Type[N > 0 ? N : +1];
2895 template<
typename Formatter,
typename T>
2896 static Value make(
const T &value)
2902 (void)result.custom.format;
2910 template<std::
size_t N>
2913 typedef Arg Type[N + 1];
2915 template<
typename Formatter,
typename T>
2916 static Arg make(
const T &value)
2922 #if FMT_USE_VARIADIC_TEMPLATES 2923 template<
typename Arg,
typename... Args>
2924 inline uint64_t make_type(
const Arg &first,
const Args &... tail)
2926 return make_type(first) | (make_type(tail...) << 4);
2940 template<
typename T>
2942 : type(make_type(arg))
2947 #define FMT_ARG_TYPE_DEFAULT(n) ArgType t##n = ArgType() 2949 inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT))
2951 return t0.type | (t1.type << 4) | (t2.type << 8) | (t3.type << 12) | (t4.type << 16) | (t5.type << 20) | (t6.type << 24) |
2952 (t7.type << 28) | (t8.type << 32) | (t9.type << 36) | (t10.type << 40) | (t11.type << 44) | (t12.type << 48) | (t13.type << 52) |
2958 #define FMT_MAKE_TEMPLATE_ARG(n) typename T##n 2959 #define FMT_MAKE_ARG_TYPE(n) T##n 2960 #define FMT_MAKE_ARG(n) const T##n &v##n 2961 #define FMT_ASSIGN_char(n) arr[n] = fmt::internal::MakeValue<fmt::BasicFormatter<char>>(v##n) 2962 #define FMT_ASSIGN_wchar_t(n) arr[n] = fmt::internal::MakeValue<fmt::BasicFormatter<wchar_t>>(v##n) 2964 #if FMT_USE_VARIADIC_TEMPLATES 2966 #define FMT_VARIADIC_VOID(func, arg_type) \ 2967 template<typename... Args> \ 2968 void func(arg_type arg0, const Args &... args) \ 2970 typedef fmt::internal::ArgArray<sizeof...(Args)> ArgArray; \ 2971 typename ArgArray::Type array{ArgArray::template make<fmt::BasicFormatter<Char>>(args)...}; \ 2972 func(arg0, fmt::ArgList(fmt::internal::make_type(args...), array)); \ 2976 #define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \ 2977 template<typename... Args> \ 2978 ctor(arg0_type arg0, arg1_type arg1, const Args &... args) \ 2980 typedef fmt::internal::ArgArray<sizeof...(Args)> ArgArray; \ 2981 typename ArgArray::Type array{ArgArray::template make<fmt::BasicFormatter<Char>>(args)...}; \ 2982 func(arg0, arg1, fmt::ArgList(fmt::internal::make_type(args...), array)); \ 2987 #define FMT_MAKE_REF(n) fmt::internal::MakeValue<fmt::BasicFormatter<Char>>(v##n) 2988 #define FMT_MAKE_REF2(n) v##n 2992 #define FMT_WRAP1(func, arg_type, n) \ 2993 template<FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \ 2994 inline void func(arg_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) \ 2996 const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \ 2997 func(arg1, fmt::ArgList(fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \ 3001 #define FMT_VARIADIC_VOID(func, arg_type) \ 3002 inline void func(arg_type arg) \ 3004 func(arg, fmt::ArgList()); \ 3006 FMT_WRAP1(func, arg_type, 1) \ 3007 FMT_WRAP1(func, arg_type, 2) \ 3008 FMT_WRAP1(func, arg_type, 3) \ 3009 FMT_WRAP1(func, arg_type, 4) \ 3010 FMT_WRAP1(func, arg_type, 5) \ 3011 FMT_WRAP1(func, arg_type, 6) \ 3012 FMT_WRAP1(func, arg_type, 7) FMT_WRAP1(func, arg_type, 8) FMT_WRAP1(func, arg_type, 9) FMT_WRAP1(func, arg_type, 10) 3014 #define FMT_CTOR(ctor, func, arg0_type, arg1_type, n) \ 3015 template<FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \ 3016 ctor(arg0_type arg0, arg1_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) \ 3018 const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \ 3019 func(arg0, arg1, fmt::ArgList(fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \ 3023 #define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \ 3024 FMT_CTOR(ctor, func, arg0_type, arg1_type, 1) \ 3025 FMT_CTOR(ctor, func, arg0_type, arg1_type, 2) \ 3026 FMT_CTOR(ctor, func, arg0_type, arg1_type, 3) \ 3027 FMT_CTOR(ctor, func, arg0_type, arg1_type, 4) \ 3028 FMT_CTOR(ctor, func, arg0_type, arg1_type, 5) \ 3029 FMT_CTOR(ctor, func, arg0_type, arg1_type, 6) \ 3030 FMT_CTOR(ctor, func, arg0_type, arg1_type, 7) \ 3031 FMT_CTOR(ctor, func, arg0_type, arg1_type, 8) \ 3032 FMT_CTOR(ctor, func, arg0_type, arg1_type, 9) \ 3033 FMT_CTOR(ctor, func, arg0_type, arg1_type, 10) 3038 #define FMT_FOR_EACH1(f, x0) f(x0, 0) 3039 #define FMT_FOR_EACH2(f, x0, x1) FMT_FOR_EACH1(f, x0), f(x1, 1) 3040 #define FMT_FOR_EACH3(f, x0, x1, x2) FMT_FOR_EACH2(f, x0, x1), f(x2, 2) 3041 #define FMT_FOR_EACH4(f, x0, x1, x2, x3) FMT_FOR_EACH3(f, x0, x1, x2), f(x3, 3) 3042 #define FMT_FOR_EACH5(f, x0, x1, x2, x3, x4) FMT_FOR_EACH4(f, x0, x1, x2, x3), f(x4, 4) 3043 #define FMT_FOR_EACH6(f, x0, x1, x2, x3, x4, x5) FMT_FOR_EACH5(f, x0, x1, x2, x3, x4), f(x5, 5) 3044 #define FMT_FOR_EACH7(f, x0, x1, x2, x3, x4, x5, x6) FMT_FOR_EACH6(f, x0, x1, x2, x3, x4, x5), f(x6, 6) 3045 #define FMT_FOR_EACH8(f, x0, x1, x2, x3, x4, x5, x6, x7) FMT_FOR_EACH7(f, x0, x1, x2, x3, x4, x5, x6), f(x7, 7) 3046 #define FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8) FMT_FOR_EACH8(f, x0, x1, x2, x3, x4, x5, x6, x7), f(x8, 8) 3047 #define FMT_FOR_EACH10(f, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8), f(x9, 9) 3056 FMT_API
void init(
int err_code, CStringRef format_str,
ArgList args);
3086 init(error_code, message,
ArgList());
3089 FMT_VARIADIC_CTOR(
SystemError, init,
int, CStringRef)
3091 FMT_API ~
SystemError() FMT_DTOR_NOEXCEPT FMT_OVERRIDE;
3093 int error_code()
const 3135 template<
typename Char>
3148 static Char *
get(CharPtr p)
3153 static Char *
get(Char *p)
3161 static CharPtr fill_padding(CharPtr buffer,
unsigned total_size, std::size_t content_size,
wchar_t fill);
3165 CharPtr grow_buffer(std::size_t n)
3167 std::size_t size = buffer_.
size();
3168 buffer_.
resize(size + n);
3169 return internal::make_ptr(&buffer_[size], n);
3173 template<
typename UInt>
3174 Char *write_unsigned_decimal(UInt value,
unsigned prefix_size = 0)
3176 unsigned num_digits = internal::count_digits(value);
3177 Char *ptr =
get(grow_buffer(prefix_size + num_digits));
3178 internal::format_decimal(ptr + prefix_size, value, num_digits);
3183 template<
typename Int>
3184 void write_decimal(Int value)
3187 MainType abs_value =
static_cast<MainType
>(value);
3188 if (internal::is_negative(value))
3190 abs_value = 0 - abs_value;
3191 *write_unsigned_decimal(abs_value, 1) =
'-';
3195 write_unsigned_decimal(abs_value, 0);
3200 CharPtr prepare_int_buffer(
unsigned num_digits,
const EmptySpec &,
const char *prefix,
unsigned prefix_size)
3202 unsigned size = prefix_size + num_digits;
3203 CharPtr p = grow_buffer(size);
3204 std::uninitialized_copy(prefix, prefix + prefix_size, p);
3205 return p + size - 1;
3208 template<
typename Spec>
3209 CharPtr prepare_int_buffer(
unsigned num_digits,
const Spec &spec,
const char *prefix,
unsigned prefix_size);
3212 template<
typename T,
typename Spec>
3213 void write_int(T value, Spec spec);
3216 template<
typename T,
typename Spec>
3217 void write_double(T value,
const Spec &spec);
3220 template<
typename StrChar>
3221 CharPtr write_str(
const StrChar *s, std::size_t size,
const AlignSpec &spec);
3223 template<
typename StrChar,
typename Spec>
3230 void operator<<(typename internal::WCharHelper<wchar_t, Char>::Unsupported);
3231 void operator<<(typename internal::WCharHelper<const wchar_t *, Char>::Unsupported);
3235 void append_float_length(Char *&format_ptr,
long double)
3237 *format_ptr++ =
'L';
3240 template<
typename T>
3241 void append_float_length(Char *&, T)
3245 template<
typename Impl,
typename Char_,
typename Spec_>
3248 template<
typename Impl,
typename Char_,
typename Spec_>
3273 return buffer_.
size();
3280 const Char *
data() const FMT_NOEXCEPT
3291 std::size_t size = buffer_.
size();
3293 buffer_[size] =
'\0';
3302 std::basic_string<Char>
str()
const 3304 return std::basic_string<Char>(&buffer_[0], buffer_.
size());
3340 write_decimal(value);
3345 return *this << IntFormatSpec<unsigned>(value);
3349 write_decimal(value);
3354 return *this << IntFormatSpec<unsigned long>(value);
3358 write_decimal(value);
3369 return *this << IntFormatSpec<ULongLong>(value);
3395 buffer_.push_back(value);
3399 BasicWriter &operator<<(typename internal::WCharHelper<wchar_t, Char>::Supported value)
3401 buffer_.push_back(value);
3412 const Char *str = value.data();
3413 buffer_.
append(str, str + value.size());
3417 BasicWriter &operator<<(typename internal::WCharHelper<StringRef, Char>::Supported value)
3419 const char *str = value.data();
3420 buffer_.
append(str, str + value.size());
3424 template<
typename T,
typename Spec,
typename FillChar>
3425 BasicWriter &operator<<(IntFormatSpec<T, Spec, FillChar> spec)
3428 write_int(spec.value(), spec);
3432 template<
typename StrChar>
3433 BasicWriter &operator<<(const StrFormatSpec<StrChar> &spec)
3435 const StrChar *s = spec.
str();
3436 write_str(s, std::char_traits<Char>::length(s), spec);
3440 void clear() FMT_NOEXCEPT
3451 template<
typename Char>
3452 template<
typename StrChar>
3455 CharPtr out = CharPtr();
3456 if (spec.width() > size)
3458 out = grow_buffer(spec.width());
3460 if (spec.align() == ALIGN_RIGHT)
3462 std::uninitialized_fill_n(out, spec.width() - size, fill);
3463 out += spec.width() - size;
3465 else if (spec.align() == ALIGN_CENTER)
3467 out = fill_padding(out, spec.width(), size, fill);
3471 std::uninitialized_fill_n(out + size, spec.width() - size, fill);
3476 out = grow_buffer(size);
3478 std::uninitialized_copy(s, s + size, out);
3482 template<
typename Char>
3483 template<
typename StrChar,
typename Spec>
3488 if (spec.type_ && spec.type_ !=
's')
3489 internal::report_unknown_type(spec.type_,
"string");
3490 const StrChar *str_value = s.value;
3491 std::size_t str_size = s.size;
3499 std::size_t precision =
static_cast<std::size_t
>(spec.precision_);
3500 if (spec.precision_ >= 0 && precision < str_size)
3501 str_size = precision;
3502 write_str(str_value, str_size, spec);
3505 template<
typename Char>
3507 CharPtr buffer,
unsigned total_size, std::size_t content_size,
wchar_t fill)
3509 std::size_t padding = total_size - content_size;
3510 std::size_t left_padding = padding / 2;
3512 std::uninitialized_fill_n(buffer, left_padding, fill_char);
3513 buffer += left_padding;
3514 CharPtr content = buffer;
3515 std::uninitialized_fill_n(buffer + content_size, padding - left_padding, fill_char);
3519 template<
typename Char>
3520 template<
typename Spec>
3522 unsigned num_digits,
const Spec &spec,
const char *prefix,
unsigned prefix_size)
3524 unsigned width = spec.width();
3525 Alignment align = spec.align();
3527 if (spec.precision() >
static_cast<int>(num_digits))
3531 if (prefix_size > 0 && prefix[prefix_size - 1] ==
'0')
3533 unsigned number_size = prefix_size + internal::to_unsigned(spec.precision());
3534 AlignSpec subspec(number_size,
'0', ALIGN_NUMERIC);
3535 if (number_size >= width)
3536 return prepare_int_buffer(num_digits, subspec, prefix, prefix_size);
3537 buffer_.reserve(width);
3538 unsigned fill_size = width - number_size;
3539 if (align != ALIGN_LEFT)
3541 CharPtr p = grow_buffer(fill_size);
3542 std::uninitialized_fill(p, p + fill_size, fill);
3544 CharPtr result = prepare_int_buffer(num_digits, subspec, prefix, prefix_size);
3545 if (align == ALIGN_LEFT)
3547 CharPtr p = grow_buffer(fill_size);
3548 std::uninitialized_fill(p, p + fill_size, fill);
3552 unsigned size = prefix_size + num_digits;
3555 CharPtr p = grow_buffer(size);
3556 std::uninitialized_copy(prefix, prefix + prefix_size, p);
3557 return p + size - 1;
3559 CharPtr p = grow_buffer(width);
3560 CharPtr end = p + width;
3561 if (align == ALIGN_LEFT)
3563 std::uninitialized_copy(prefix, prefix + prefix_size, p);
3565 std::uninitialized_fill(p, end, fill);
3567 else if (align == ALIGN_CENTER)
3569 p = fill_padding(p, width, size, fill);
3570 std::uninitialized_copy(prefix, prefix + prefix_size, p);
3575 if (align == ALIGN_NUMERIC)
3577 if (prefix_size != 0)
3579 p = std::uninitialized_copy(prefix, prefix + prefix_size, p);
3580 size -= prefix_size;
3585 std::uninitialized_copy(prefix, prefix + prefix_size, end - size);
3587 std::uninitialized_fill(p, end - size, fill);
3593 template<
typename Char>
3594 template<
typename T,
typename Spec>
3597 unsigned prefix_size = 0;
3599 UnsignedType abs_value =
static_cast<UnsignedType
>(value);
3600 char prefix[4] =
"";
3601 if (internal::is_negative(value))
3605 abs_value = 0 - abs_value;
3607 else if (spec.flag(SIGN_FLAG))
3609 prefix[0] = spec.flag(PLUS_FLAG) ?
'+' :
' ';
3612 switch (spec.type())
3617 unsigned num_digits = internal::count_digits(abs_value);
3618 CharPtr p = prepare_int_buffer(num_digits, spec, prefix, prefix_size) + 1;
3619 internal::format_decimal(
get(p), abs_value, 0);
3625 UnsignedType n = abs_value;
3626 if (spec.flag(HASH_FLAG))
3628 prefix[prefix_size++] =
'0';
3629 prefix[prefix_size++] = spec.type_prefix();
3631 unsigned num_digits = 0;
3635 }
while ((n >>= 4) != 0);
3636 Char *p =
get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
3638 const char *digits = spec.type() ==
'x' ?
"0123456789abcdef" :
"0123456789ABCDEF";
3641 *p-- = digits[n & 0xf];
3642 }
while ((n >>= 4) != 0);
3648 UnsignedType n = abs_value;
3649 if (spec.flag(HASH_FLAG))
3651 prefix[prefix_size++] =
'0';
3652 prefix[prefix_size++] = spec.type_prefix();
3654 unsigned num_digits = 0;
3658 }
while ((n >>= 1) != 0);
3659 Char *p =
get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
3663 *p-- =
static_cast<Char
>(
'0' + (n & 1));
3664 }
while ((n >>= 1) != 0);
3669 UnsignedType n = abs_value;
3670 if (spec.flag(HASH_FLAG))
3671 prefix[prefix_size++] =
'0';
3672 unsigned num_digits = 0;
3676 }
while ((n >>= 3) != 0);
3677 Char *p =
get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
3681 *p-- =
static_cast<Char
>(
'0' + (n & 7));
3682 }
while ((n >>= 3) != 0);
3687 unsigned num_digits = internal::count_digits(abs_value);
3689 #if !(defined(ANDROID) || defined(__ANDROID__)) 3690 sep = internal::thousands_sep(std::localeconv());
3692 unsigned size =
static_cast<unsigned>(num_digits + sep.
size() * ((num_digits - 1) / 3));
3693 CharPtr p = prepare_int_buffer(size, spec, prefix, prefix_size) + 1;
3698 internal::report_unknown_type(spec.type(), spec.flag(CHAR_FLAG) ?
"char" :
"integer");
3703 template<
typename Char>
3704 template<
typename T,
typename Spec>
3708 char type = spec.type();
3732 internal::report_unknown_type(type,
"double");
3739 if (internal::FPUtil::isnegative(static_cast<double>(value)))
3744 else if (spec.flag(SIGN_FLAG))
3746 sign = spec.flag(PLUS_FLAG) ?
'+' :
' ';
3749 if (internal::FPUtil::isnotanumber(value))
3753 std::size_t nan_size = 4;
3754 const char *nan = upper ?
" NAN" :
" nan";
3760 CharPtr out = write_str(nan, nan_size, spec);
3766 if (internal::FPUtil::isinfinity(value))
3770 std::size_t inf_size = 4;
3771 const char *inf = upper ?
" INF" :
" inf";
3777 CharPtr out = write_str(inf, inf_size, spec);
3783 std::size_t offset = buffer_.size();
3784 unsigned width = spec.width();
3787 buffer_.reserve(buffer_.size() + (width > 1u ? width : 1u));
3796 MAX_FORMAT_SIZE = 10
3798 Char format[MAX_FORMAT_SIZE];
3799 Char *format_ptr = format;
3800 *format_ptr++ =
'%';
3801 unsigned width_for_sprintf = width;
3802 if (spec.flag(HASH_FLAG))
3803 *format_ptr++ =
'#';
3804 if (spec.align() == ALIGN_CENTER)
3806 width_for_sprintf = 0;
3810 if (spec.align() == ALIGN_LEFT)
3811 *format_ptr++ =
'-';
3813 *format_ptr++ =
'*';
3815 if (spec.precision() >= 0)
3817 *format_ptr++ =
'.';
3818 *format_ptr++ =
'*';
3821 append_float_length(format_ptr, value);
3822 *format_ptr++ = type;
3828 Char *start = FMT_NULL;
3831 std::size_t buffer_size = buffer_.capacity() - offset;
3836 if (buffer_size == 0)
3838 buffer_.reserve(offset + 1);
3839 buffer_size = buffer_.capacity() - offset;
3842 start = &buffer_[offset];
3846 n = internal::to_unsigned(result);
3847 if (offset + n < buffer_.capacity())
3849 buffer_.reserve(offset + n + 1);
3855 buffer_.reserve(buffer_.capacity() + 1);
3860 if ((spec.align() != ALIGN_RIGHT && spec.align() != ALIGN_DEFAULT) || *start !=
' ')
3862 *(start - 1) = sign;
3867 *(start - 1) = fill;
3871 if (spec.align() == ALIGN_CENTER && spec.width() > n)
3873 width = spec.width();
3874 CharPtr p = grow_buffer(width);
3875 std::memmove(
get(p) + (width - n) / 2,
get(p), n *
sizeof(Char));
3876 fill_padding(p, spec.width(), n, fill);
3879 if (spec.fill() !=
' ' || sign)
3881 while (*start ==
' ')
3884 *(start - 1) = sign;
3923 template<
typename Char,
typename Allocator = std::allocator<Char>>
3936 #if FMT_USE_RVALUE_REFERENCES 3945 , buffer_(std::move(other.buffer_))
3956 buffer_ = std::move(other.buffer_);
3985 template<
typename Char>
4000 , buffer_(array, size)
4010 template<std::
size_t SIZE>
4013 , buffer_(array, SIZE)
4023 FMT_API
void report_system_error(
int error_code, StringRef message) FMT_NOEXCEPT;
4025 #if FMT_USE_WINDOWS_H 4031 FMT_API
void init(
int error_code, CStringRef format_str,
ArgList args);
4062 WindowsError(
int error_code, CStringRef message)
4064 init(error_code, message,
ArgList());
4066 FMT_VARIADIC_CTOR(WindowsError, init,
int, CStringRef)
4071 FMT_API
void report_windows_error(
int error_code, StringRef message) FMT_NOEXCEPT;
4093 FMT_API
void print_colored(Color c, CStringRef format,
ArgList args);
4104 inline std::string format(CStringRef format_str,
ArgList args)
4107 w.
write(format_str, args);
4111 inline std::wstring format(WCStringRef format_str,
ArgList args)
4114 w.
write(format_str, args);
4127 FMT_API
void print(std::FILE *f, CStringRef format_str,
ArgList args);
4138 FMT_API
void print(CStringRef format_str,
ArgList args);
4150 BUFFER_SIZE = std::numeric_limits<ULongLong>::digits10 + 3
4152 mutable char buffer_[BUFFER_SIZE];
4156 char *format_decimal(ULongLong value)
4158 char *buffer_end = buffer_ + BUFFER_SIZE - 1;
4159 while (value >= 100)
4164 unsigned index =
static_cast<unsigned>((value % 100) * 2);
4166 *--buffer_end = internal::Data::DIGITS[index + 1];
4167 *--buffer_end = internal::Data::DIGITS[index];
4171 *--buffer_end =
static_cast<char>(
'0' + value);
4174 unsigned index =
static_cast<unsigned>(value * 2);
4175 *--buffer_end = internal::Data::DIGITS[index + 1];
4176 *--buffer_end = internal::Data::DIGITS[index];
4180 void FormatSigned(LongLong value)
4182 ULongLong abs_value =
static_cast<ULongLong
>(value);
4183 bool negative = value < 0;
4185 abs_value = 0 - abs_value;
4186 str_ = format_decimal(abs_value);
4194 FormatSigned(value);
4198 FormatSigned(value);
4202 FormatSigned(value);
4205 : str_(format_decimal(value))
4209 : str_(format_decimal(value))
4213 : str_(format_decimal(value))
4220 return internal::to_unsigned(buffer_ - str_ + BUFFER_SIZE - 1);
4238 buffer_[BUFFER_SIZE - 1] =
'\0';
4249 return std::string(str_, size());
4256 template<
typename T>
4257 inline void format_decimal(
char *&buffer, T value)
4260 MainType abs_value =
static_cast<MainType
>(value);
4261 if (internal::is_negative(value))
4264 abs_value = 0 - abs_value;
4266 if (abs_value < 100)
4270 *buffer++ =
static_cast<char>(
'0' + abs_value);
4273 unsigned index =
static_cast<unsigned>(abs_value * 2);
4274 *buffer++ = internal::Data::DIGITS[index];
4275 *buffer++ = internal::Data::DIGITS[index + 1];
4278 unsigned num_digits = internal::count_digits(abs_value);
4279 internal::format_decimal(buffer, abs_value, num_digits);
4280 buffer += num_digits;
4293 template<
typename T>
4299 template<
typename T>
4307 template<
typename Char>
4309 template<
typename Char>
4318 #pragma GCC system_header 4322 #define FMT_EXPAND(args) args 4326 #define FMT_NARG(...) FMT_NARG_(__VA_ARGS__, FMT_RSEQ_N()) 4327 #define FMT_NARG_(...) FMT_EXPAND(FMT_ARG_N(__VA_ARGS__)) 4328 #define FMT_ARG_N(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N 4329 #define FMT_RSEQ_N() 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 4331 #define FMT_FOR_EACH_(N, f, ...) FMT_EXPAND(FMT_CONCAT(FMT_FOR_EACH, N)(f, __VA_ARGS__)) 4332 #define FMT_FOR_EACH(f, ...) FMT_EXPAND(FMT_FOR_EACH_(FMT_NARG(__VA_ARGS__), f, __VA_ARGS__)) 4334 #define FMT_ADD_ARG_NAME(type, index) type arg##index 4335 #define FMT_GET_ARG_NAME(type, index) arg##index 4337 #if FMT_USE_VARIADIC_TEMPLATES 4338 #define FMT_VARIADIC_(Const, Char, ReturnType, func, call, ...) \ 4339 template<typename... Args> \ 4340 ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), const Args &... args) Const \ 4342 typedef fmt::internal::ArgArray<sizeof...(Args)> ArgArray; \ 4343 typename ArgArray::Type array{ArgArray::template make<fmt::BasicFormatter<Char>>(args)...}; \ 4344 call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList(fmt::internal::make_type(args...), array)); \ 4349 #define FMT_WRAP(Const, Char, ReturnType, func, call, n, ...) \ 4350 template<FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \ 4351 inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), FMT_GEN(n, FMT_MAKE_ARG)) Const \ 4353 fmt::internal::ArgArray<n>::Type arr; \ 4354 FMT_GEN(n, FMT_ASSIGN_##Char); \ 4355 call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList(fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), arr)); \ 4358 #define FMT_VARIADIC_(Const, Char, ReturnType, func, call, ...) \ 4359 inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__)) Const \ 4361 call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList()); \ 4363 FMT_WRAP(Const, Char, ReturnType, func, call, 1, __VA_ARGS__) \ 4364 FMT_WRAP(Const, Char, ReturnType, func, call, 2, __VA_ARGS__) \ 4365 FMT_WRAP(Const, Char, ReturnType, func, call, 3, __VA_ARGS__) \ 4366 FMT_WRAP(Const, Char, ReturnType, func, call, 4, __VA_ARGS__) \ 4367 FMT_WRAP(Const, Char, ReturnType, func, call, 5, __VA_ARGS__) \ 4368 FMT_WRAP(Const, Char, ReturnType, func, call, 6, __VA_ARGS__) \ 4369 FMT_WRAP(Const, Char, ReturnType, func, call, 7, __VA_ARGS__) \ 4370 FMT_WRAP(Const, Char, ReturnType, func, call, 8, __VA_ARGS__) \ 4371 FMT_WRAP(Const, Char, ReturnType, func, call, 9, __VA_ARGS__) \ 4372 FMT_WRAP(Const, Char, ReturnType, func, call, 10, __VA_ARGS__) \ 4373 FMT_WRAP(Const, Char, ReturnType, func, call, 11, __VA_ARGS__) \ 4374 FMT_WRAP(Const, Char, ReturnType, func, call, 12, __VA_ARGS__) \ 4375 FMT_WRAP(Const, Char, ReturnType, func, call, 13, __VA_ARGS__) \ 4376 FMT_WRAP(Const, Char, ReturnType, func, call, 14, __VA_ARGS__) \ 4377 FMT_WRAP(Const, Char, ReturnType, func, call, 15, __VA_ARGS__) 4378 #endif // FMT_USE_VARIADIC_TEMPLATES 4407 #define FMT_VARIADIC(ReturnType, func, ...) FMT_VARIADIC_(, char, ReturnType, func, return func, __VA_ARGS__) 4409 #define FMT_VARIADIC_CONST(ReturnType, func, ...) FMT_VARIADIC_(const, char, ReturnType, func, return func, __VA_ARGS__) 4411 #define FMT_VARIADIC_W(ReturnType, func, ...) FMT_VARIADIC_(, wchar_t, ReturnType, func, return func, __VA_ARGS__) 4413 #define FMT_VARIADIC_CONST_W(ReturnType, func, ...) FMT_VARIADIC_(const, wchar_t, ReturnType, func, return func, __VA_ARGS__) 4415 #define FMT_CAPTURE_ARG_(id, index) ::fmt::arg(#id, id) 4417 #define FMT_CAPTURE_ARG_W_(id, index) ::fmt::arg(L## #id, id) 4433 #define FMT_CAPTURE(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_, __VA_ARGS__) 4435 #define FMT_CAPTURE_W(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_W_, __VA_ARGS__) 4438 FMT_VARIADIC(std::string, format, CStringRef)
4439 FMT_VARIADIC_W(std::wstring, format, WCStringRef)
4440 FMT_VARIADIC(
void, print, CStringRef)
4441 FMT_VARIADIC(
void, print, std::FILE *, CStringRef)
4442 FMT_VARIADIC(
void, print_colored, Color, CStringRef)
4444 namespace internal {
4445 template<
typename Char>
4446 inline bool is_name_start(Char c)
4448 return (
'a' <= c && c <=
'z') || (
'A' <= c && c <=
'Z') ||
'_' == c;
4453 template<
typename Char>
4454 unsigned parse_nonnegative_int(
const Char *&s)
4456 assert(
'0' <= *s && *s <=
'9');
4459 unsigned max_int = (std::numeric_limits<int>::max)();
4460 unsigned big = max_int / 10;
4466 value = max_int + 1;
4469 value = value * 10 + (*s -
'0');
4471 }
while (
'0' <= *s && *s <=
'9');
4473 if (value > max_int)
4478 inline void require_numeric_argument(
const Arg &arg,
char spec)
4480 if (arg.type > Arg::LAST_NUMERIC_TYPE)
4482 std::string message = fmt::format(
"format specifier '{}' requires numeric argument", spec);
4487 template<
typename Char>
4488 void check_sign(
const Char *&s,
const Arg &arg)
4490 char sign =
static_cast<char>(*s);
4491 require_numeric_argument(arg, sign);
4492 if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG)
4494 FMT_THROW(
FormatError(fmt::format(
"format specifier '{}' requires signed argument", sign)));
4500 template<
typename Char,
typename AF>
4503 if (check_no_auto_index(error))
4509 error =
"argument not found";
4514 template<
typename Char,
typename AF>
4517 const char *error = FMT_NULL;
4518 internal::Arg arg = *s < '0' || *s >
'9' ? next_arg(error) : get_arg(internal::parse_nonnegative_int(s), error);
4521 FMT_THROW(
FormatError(*s !=
'}' && *s !=
':' ?
"invalid format string" : error));
4526 template<
typename Char,
typename AF>
4529 assert(internal::is_name_start(*s));
4530 const Char *start = s;
4535 }
while (internal::is_name_start(c) || (
'0' <= c && c <=
'9'));
4536 const char *error = FMT_NULL;
4543 template<
typename Char,
typename ArgFormatter>
4547 const Char *s = format_str;
4551 if (arg.type == Arg::CUSTOM)
4553 arg.custom.format(
this, arg.custom.value, &s);
4560 const Char *p = s + 1;
4561 spec.align_ = ALIGN_DEFAULT;
4567 spec.align_ = ALIGN_LEFT;
4570 spec.align_ = ALIGN_RIGHT;
4573 spec.align_ = ALIGN_NUMERIC;
4576 spec.align_ = ALIGN_CENTER;
4579 if (spec.align_ != ALIGN_DEFAULT)
4586 FMT_THROW(
FormatError(
"invalid fill character '{'"));
4592 if (spec.align_ == ALIGN_NUMERIC)
4593 require_numeric_argument(arg,
'=');
4604 spec.flags_ |= SIGN_FLAG | PLUS_FLAG;
4608 spec.flags_ |= MINUS_FLAG;
4612 spec.flags_ |= SIGN_FLAG;
4618 require_numeric_argument(arg,
'#');
4619 spec.flags_ |= HASH_FLAG;
4626 require_numeric_argument(arg,
'0');
4627 spec.align_ = ALIGN_NUMERIC;
4633 if (
'0' <= *s && *s <=
'9')
4635 spec.width_ = internal::parse_nonnegative_int(s);
4640 Arg width_arg = internal::is_name_start(*s) ? parse_arg_name(s) : parse_arg_index(s);
4643 ULongLong value = 0;
4644 switch (width_arg.type)
4647 if (width_arg.int_value < 0)
4649 value = width_arg.int_value;
4652 value = width_arg.uint_value;
4654 case Arg::LONG_LONG:
4655 if (width_arg.long_long_value < 0)
4657 value = width_arg.long_long_value;
4659 case Arg::ULONG_LONG:
4660 value = width_arg.ulong_long_value;
4665 unsigned max_int = (std::numeric_limits<int>::max)();
4666 if (value > max_int)
4668 spec.width_ =
static_cast<int>(value);
4675 spec.precision_ = 0;
4676 if (
'0' <= *s && *s <=
'9')
4678 spec.precision_ = internal::parse_nonnegative_int(s);
4683 Arg precision_arg = internal::is_name_start(*s) ? parse_arg_name(s) : parse_arg_index(s);
4686 ULongLong value = 0;
4687 switch (precision_arg.type)
4690 if (precision_arg.int_value < 0)
4692 value = precision_arg.int_value;
4695 value = precision_arg.uint_value;
4697 case Arg::LONG_LONG:
4698 if (precision_arg.long_long_value < 0)
4700 value = precision_arg.long_long_value;
4702 case Arg::ULONG_LONG:
4703 value = precision_arg.ulong_long_value;
4706 FMT_THROW(
FormatError(
"precision is not integer"));
4708 unsigned max_int = (std::numeric_limits<int>::max)();
4709 if (value > max_int)
4711 spec.precision_ =
static_cast<int>(value);
4715 FMT_THROW(
FormatError(
"missing precision specifier"));
4717 if (arg.type <= Arg::LAST_INTEGER_TYPE || arg.type == Arg::POINTER)
4720 fmt::format(
"precision not allowed in {} format specifier", arg.type == Arg::POINTER ?
"pointer" :
"integer")));
4725 if (*s !=
'}' && *s)
4726 spec.type_ =
static_cast<char>(*s++);
4730 FMT_THROW(
FormatError(
"missing '}' in format string"));
4737 template<
typename Char,
typename AF>
4741 const Char *start = s;
4745 if (c !=
'{' && c !=
'}')
4749 write(writer_, start, s);
4754 FMT_THROW(
FormatError(
"unmatched '}' in format string"));
4755 write(writer_, start, s - 1);
4756 internal::Arg arg = internal::is_name_start(*s) ? parse_arg_name(s) : parse_arg_index(s);
4757 start = s = format(s, arg);
4759 write(writer_, start, s);
4762 template<
typename Char,
typename It>
4777 template<
typename It>
4783 template<
typename It>
4789 #if FMT_HAS_GXX_CXX11 4790 template<
typename Range>
4793 return join(std::begin(range), std::end(range), sep);
4796 template<
typename Range>
4799 return join(std::begin(range), std::end(range), sep);
4803 template<
typename ArgFormatter,
typename Char,
typename It>
4806 const Char *end = format_str;
4809 while (*end && *end !=
'}')
4812 FMT_THROW(
FormatError(
"missing '}' in format string"));
4817 const Char *save = format_str;
4819 while (it != e.last)
4826 format_str = end + 1;
4830 #if FMT_USE_USER_DEFINED_LITERALS 4832 namespace internal {
4834 template<
typename Char>
4839 template<
typename... Args>
4840 auto operator()(Args &&... args)
const -> decltype(format(str, std::forward<Args>(args)...))
4842 return format(str, std::forward<Args>(args)...);
4846 template<
typename Char>
4851 template<
typename T>
4854 return {str, std::forward<T>(value)};
4860 inline namespace literals {
4872 inline internal::UdlFormat<char>
operator"" _format(
const char *s, std::size_t)
4876 inline internal::UdlFormat<wchar_t>
operator"" _format(
const wchar_t *s, std::size_t)
4891 inline internal::UdlArg<char>
operator"" _a(
const char *s, std::size_t)
4895 inline internal::UdlArg<wchar_t>
operator"" _a(
const wchar_t *s, std::size_t)
4902 #endif // FMT_USE_USER_DEFINED_LITERALS 4905 #if FMT_GCC_VERSION >= 406 4906 #pragma GCC diagnostic pop 4909 #if defined(__clang__) && !defined(FMT_ICC_VERSION) 4910 #pragma clang diagnostic pop 4913 #ifdef FMT_HEADER_ONLY 4914 #define FMT_FUNC inline 4915 #include "format.cc" 4920 #endif // FMT_FORMAT_H_ Definition: format.h:1349
Result visit_custom(Arg::CustomValue)
Definition: format.h:2095
Definition: format.h:1450
BasicCStringRef(const Char *s)
Definition: format.h:712
Result visit_string(Arg::StringValue< char >)
Definition: format.h:2077
Definition: format.h:1468
Result visit_pointer(const void *)
Definition: format.h:2089
Definition: format.h:1426
BasicWriter & operator<<(long double value)
Definition: format.h:3384
Definition: format.h:1876
Definition: format.h:2887
Result visit_uint(unsigned value)
Definition: format.h:2021
const Char * c_str() const
Definition: format.h:3289
Result visit_bool(bool value)
Definition: format.h:2033
Definition: format.h:1136
Definition: format.h:1819
Definition: format.h:1095
const Char * data() const FMT_NOEXCEPT
Definition: format.h:3280
Result visit_ulong_long(ULongLong value)
Definition: format.h:2027
Result visit_any_int(T)
Definition: format.h:2046
SystemError(int error_code, CStringRef message)
Definition: format.h:3084
const Char * data() const
Definition: format.h:629
Result visit_long_long(LongLong value)
Definition: format.h:2015
Definition: format.h:1360
Definition: format.h:1408
Result visit_any_double(T)
Definition: format.h:2065
Definition: format.h:2253
Definition: format.h:1557
Definition: format.h:1994
Definition: format.h:1433
Definition: format.h:3986
Definition: format.h:1205
BasicStringRef(const Char *s)
Definition: format.h:577
std::size_t size() const
Definition: format.h:3271
BasicCStringRef(const std::basic_string< Char, std::char_traits< Char >, Allocator > &s)
Definition: format.h:723
BasicStringRef(const Char *s, std::size_t size)
Definition: format.h:565
Result visit_wstring(Arg::StringValue< wchar_t >)
Definition: format.h:2083
Result visit_double(double value)
Definition: format.h:2052
Result visit_long_double(long double value)
Definition: format.h:2058
void write(BasicCStringRef< Char > format, ArgList args)
Definition: format.h:3332
Result visit_char(int value)
Definition: format.h:2039
BasicStringRef(const std::basic_string< Char, std::char_traits< Char >, Allocator > &s)
Definition: format.h:589
Definition: format.h:1352
BasicArrayWriter(Char(&array)[SIZE])
Definition: format.h:4011
const Char * c_str() const
Definition: format.h:729
std::basic_string< Char > str() const
Definition: format.h:3302
void reserve(std::size_t capacity)
Definition: format.h:868
Definition: format.h:1459
Definition: format.h:1506
Definition: format.h:1416
std::size_t size() const
Definition: format.h:842
std::size_t capacity() const
Definition: format.h:848
Definition: format.h:1014
Definition: format.h:1857
Definition: format.h:1027
Definition: format.h:2230
BasicWriter & operator<<(char value)
Definition: format.h:3393
Definition: format.h:2173
Definition: format.h:1214
Definition: format.h:1414
Result visit_int(int value)
Definition: format.h:2009
Definition: format.h:3924
Definition: format.h:2167
Definition: format.h:1872
Definition: format.h:1042
Result visit_cstring(const char *)
Definition: format.h:2071
void resize(std::size_t new_size)
Definition: format.h:856
BasicWriter & operator<<(ULongLong value)
Definition: format.h:3367
Definition: format.h:1148
void grow(std::size_t size) FMT_OVERRIDE
Definition: format.h:989
void append(const U *begin, const U *end)
Definition: format.h:902
Result visit(const Arg &arg)
Definition: format.h:2108
Definition: format.h:1530
Definition: format.h:1124
BasicWriter(Buffer< Char > &b)
Definition: format.h:3255
std::size_t size() const
Definition: format.h:635
BasicArrayWriter(Char *array, std::size_t size)
Definition: format.h:3998
Definition: format.h:2931
Definition: format.h:3053
Definition: format.h:1517
std::basic_string< Char > to_string() const
Definition: format.h:623
Definition: format.h:1419
virtual ~BasicWriter()
Definition: format.h:3266
Definition: format.h:1478
Definition: format.h:1548
Definition: format.h:4763
Definition: format.h:1605
internal::Arg operator[](unsigned index) const
Definition: format.h:1930
Definition: format.h:2206