diff --git a/include/spdlog/fmt/bundled/colors.h b/include/spdlog/fmt/bundled/colors.h new file mode 100644 index 00000000..003a6679 --- /dev/null +++ b/include/spdlog/fmt/bundled/colors.h @@ -0,0 +1,257 @@ +// Formatting library for C++ - the core API +// +// Copyright (c) 2012 - present, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. +// +// Copyright (c) 2018 - present, Remotion (Igor Schulz) +// All Rights Reserved +// {fmt} support for rgb color output. + +#ifndef FMT_COLORS_H_ +#define FMT_COLORS_H_ + +#include "format.h" + +FMT_BEGIN_NAMESPACE + +// rgb is a struct for red, green and blue colors. +// We use rgb as name because some editors will show it as color direct in the +// editor. +struct rgb +{ + FMT_CONSTEXPR_DECL rgb() + : r(0) + , g(0) + , b(0) + { + } + FMT_CONSTEXPR_DECL rgb(uint8_t r_, uint8_t g_, uint8_t b_) + : r(r_) + , g(g_) + , b(b_) + { + } + FMT_CONSTEXPR_DECL rgb(uint32_t hex) + : r((hex >> 16) & 0xFF) + , g((hex >> 8) & 0xFF) + , b((hex)&0xFF) + { + } + uint8_t r; + uint8_t g; + uint8_t b; +}; + +namespace internal { + +FMT_CONSTEXPR inline void to_esc(uint8_t c, char out[], int offset) +{ + out[offset + 0] = static_cast('0' + c / 100); + out[offset + 1] = static_cast('0' + c / 10 % 10); + out[offset + 2] = static_cast('0' + c % 10); +} + +} // namespace internal + +FMT_FUNC void vprint_rgb(rgb fd, string_view format, format_args args) +{ + char escape_fd[] = "\x1b[38;2;000;000;000m"; + static FMT_CONSTEXPR_DECL const char RESET_COLOR[] = "\x1b[0m"; + internal::to_esc(fd.r, escape_fd, 7); + internal::to_esc(fd.g, escape_fd, 11); + internal::to_esc(fd.b, escape_fd, 15); + + std::fputs(escape_fd, stdout); + vprint(format, args); + std::fputs(RESET_COLOR, stdout); +} + +FMT_FUNC void vprint_rgb(rgb fd, rgb bg, string_view format, format_args args) +{ + char escape_fd[] = "\x1b[38;2;000;000;000m"; // foreground color + char escape_bg[] = "\x1b[48;2;000;000;000m"; // background color + static FMT_CONSTEXPR_DECL const char RESET_COLOR[] = "\x1b[0m"; + internal::to_esc(fd.r, escape_fd, 7); + internal::to_esc(fd.g, escape_fd, 11); + internal::to_esc(fd.b, escape_fd, 15); + + internal::to_esc(bg.r, escape_bg, 7); + internal::to_esc(bg.g, escape_bg, 11); + internal::to_esc(bg.b, escape_bg, 15); + + std::fputs(escape_fd, stdout); + std::fputs(escape_bg, stdout); + vprint(format, args); + std::fputs(RESET_COLOR, stdout); +} + +template +inline void print_rgb(rgb fd, string_view format_str, const Args &... args) +{ + vprint_rgb(fd, format_str, make_format_args(args...)); +} + +// rgb foreground color +template +inline void print(rgb fd, string_view format_str, const Args &... args) +{ + vprint_rgb(fd, format_str, make_format_args(args...)); +} + +// rgb foreground color and background color +template +inline void print(rgb fd, rgb bg, string_view format_str, const Args &... args) +{ + vprint_rgb(fd, bg, format_str, make_format_args(args...)); +} + +enum class color : uint32_t +{ + alice_blue = 0xF0F8FF, // rgb(240,248,255) + antique_white = 0xFAEBD7, // rgb(250,235,215) + aqua = 0x00FFFF, // rgb(0,255,255) + aquamarine = 0x7FFFD4, // rgb(127,255,212) + azure = 0xF0FFFF, // rgb(240,255,255) + beige = 0xF5F5DC, // rgb(245,245,220) + bisque = 0xFFE4C4, // rgb(255,228,196) + black = 0x000000, // rgb(0,0,0) + blanched_almond = 0xFFEBCD, // rgb(255,235,205) + blue = 0x0000FF, // rgb(0,0,255) + blue_violet = 0x8A2BE2, // rgb(138,43,226) + brown = 0xA52A2A, // rgb(165,42,42) + burly_wood = 0xDEB887, // rgb(222,184,135) + cadet_blue = 0x5F9EA0, // rgb(95,158,160) + chartreuse = 0x7FFF00, // rgb(127,255,0) + chocolate = 0xD2691E, // rgb(210,105,30) + coral = 0xFF7F50, // rgb(255,127,80) + cornflower_blue = 0x6495ED, // rgb(100,149,237) + cornsilk = 0xFFF8DC, // rgb(255,248,220) + crimson = 0xDC143C, // rgb(220,20,60) + cyan = 0x00FFFF, // rgb(0,255,255) + dark_blue = 0x00008B, // rgb(0,0,139) + dark_cyan = 0x008B8B, // rgb(0,139,139) + dark_golden_rod = 0xB8860B, // rgb(184,134,11) + dark_gray = 0xA9A9A9, // rgb(169,169,169) + dark_green = 0x006400, // rgb(0,100,0) + dark_khaki = 0xBDB76B, // rgb(189,183,107) + dark_magenta = 0x8B008B, // rgb(139,0,139) + dark_olive_green = 0x556B2F, // rgb(85,107,47) + dark_orange = 0xFF8C00, // rgb(255,140,0) + dark_orchid = 0x9932CC, // rgb(153,50,204) + dark_red = 0x8B0000, // rgb(139,0,0) + dark_salmon = 0xE9967A, // rgb(233,150,122) + dark_sea_green = 0x8FBC8F, // rgb(143,188,143) + dark_slate_blue = 0x483D8B, // rgb(72,61,139) + dark_slate_gray = 0x2F4F4F, // rgb(47,79,79) + dark_turquoise = 0x00CED1, // rgb(0,206,209) + dark_violet = 0x9400D3, // rgb(148,0,211) + deep_pink = 0xFF1493, // rgb(255,20,147) + deep_sky_blue = 0x00BFFF, // rgb(0,191,255) + dim_gray = 0x696969, // rgb(105,105,105) + dodger_blue = 0x1E90FF, // rgb(30,144,255) + fire_brick = 0xB22222, // rgb(178,34,34) + floral_white = 0xFFFAF0, // rgb(255,250,240) + forest_green = 0x228B22, // rgb(34,139,34) + fuchsia = 0xFF00FF, // rgb(255,0,255) + gainsboro = 0xDCDCDC, // rgb(220,220,220) + ghost_white = 0xF8F8FF, // rgb(248,248,255) + gold = 0xFFD700, // rgb(255,215,0) + golden_rod = 0xDAA520, // rgb(218,165,32) + gray = 0x808080, // rgb(128,128,128) + green = 0x008000, // rgb(0,128,0) + green_yellow = 0xADFF2F, // rgb(173,255,47) + honey_dew = 0xF0FFF0, // rgb(240,255,240) + hot_pink = 0xFF69B4, // rgb(255,105,180) + indian_red = 0xCD5C5C, // rgb(205,92,92) + indigo = 0x4B0082, // rgb(75,0,130) + ivory = 0xFFFFF0, // rgb(255,255,240) + khaki = 0xF0E68C, // rgb(240,230,140) + lavender = 0xE6E6FA, // rgb(230,230,250) + lavender_blush = 0xFFF0F5, // rgb(255,240,245) + lawn_green = 0x7CFC00, // rgb(124,252,0) + lemon_chiffon = 0xFFFACD, // rgb(255,250,205) + light_blue = 0xADD8E6, // rgb(173,216,230) + light_coral = 0xF08080, // rgb(240,128,128) + light_cyan = 0xE0FFFF, // rgb(224,255,255) + light_golden_rod_yellow = 0xFAFAD2, // rgb(250,250,210) + light_gray = 0xD3D3D3, // rgb(211,211,211) + light_green = 0x90EE90, // rgb(144,238,144) + light_pink = 0xFFB6C1, // rgb(255,182,193) + light_salmon = 0xFFA07A, // rgb(255,160,122) + light_sea_green = 0x20B2AA, // rgb(32,178,170) + light_sky_blue = 0x87CEFA, // rgb(135,206,250) + light_slate_gray = 0x778899, // rgb(119,136,153) + light_steel_blue = 0xB0C4DE, // rgb(176,196,222) + light_yellow = 0xFFFFE0, // rgb(255,255,224) + lime = 0x00FF00, // rgb(0,255,0) + lime_green = 0x32CD32, // rgb(50,205,50) + linen = 0xFAF0E6, // rgb(250,240,230) + magenta = 0xFF00FF, // rgb(255,0,255) + maroon = 0x800000, // rgb(128,0,0) + medium_aqua_marine = 0x66CDAA, // rgb(102,205,170) + medium_blue = 0x0000CD, // rgb(0,0,205) + medium_orchid = 0xBA55D3, // rgb(186,85,211) + medium_purple = 0x9370DB, // rgb(147,112,219) + medium_sea_green = 0x3CB371, // rgb(60,179,113) + medium_slate_blue = 0x7B68EE, // rgb(123,104,238) + medium_spring_green = 0x00FA9A, // rgb(0,250,154) + medium_turquoise = 0x48D1CC, // rgb(72,209,204) + medium_violet_red = 0xC71585, // rgb(199,21,133) + midnight_blue = 0x191970, // rgb(25,25,112) + mint_cream = 0xF5FFFA, // rgb(245,255,250) + misty_rose = 0xFFE4E1, // rgb(255,228,225) + moccasin = 0xFFE4B5, // rgb(255,228,181) + navajo_white = 0xFFDEAD, // rgb(255,222,173) + navy = 0x000080, // rgb(0,0,128) + old_lace = 0xFDF5E6, // rgb(253,245,230) + olive = 0x808000, // rgb(128,128,0) + olive_drab = 0x6B8E23, // rgb(107,142,35) + orange = 0xFFA500, // rgb(255,165,0) + orange_red = 0xFF4500, // rgb(255,69,0) + orchid = 0xDA70D6, // rgb(218,112,214) + pale_golden_rod = 0xEEE8AA, // rgb(238,232,170) + pale_green = 0x98FB98, // rgb(152,251,152) + pale_turquoise = 0xAFEEEE, // rgb(175,238,238) + pale_violet_red = 0xDB7093, // rgb(219,112,147) + papaya_whip = 0xFFEFD5, // rgb(255,239,213) + peach_puff = 0xFFDAB9, // rgb(255,218,185) + peru = 0xCD853F, // rgb(205,133,63) + pink = 0xFFC0CB, // rgb(255,192,203) + plum = 0xDDA0DD, // rgb(221,160,221) + powder_blue = 0xB0E0E6, // rgb(176,224,230) + purple = 0x800080, // rgb(128,0,128) + rebecca_purple = 0x663399, // rgb(102,51,153) + red = 0xFF0000, // rgb(255,0,0) + rosy_brown = 0xBC8F8F, // rgb(188,143,143) + royal_blue = 0x4169E1, // rgb(65,105,225) + saddle_brown = 0x8B4513, // rgb(139,69,19) + salmon = 0xFA8072, // rgb(250,128,114) + sandy_brown = 0xF4A460, // rgb(244,164,96) + sea_green = 0x2E8B57, // rgb(46,139,87) + sea_shell = 0xFFF5EE, // rgb(255,245,238) + sienna = 0xA0522D, // rgb(160,82,45) + silver = 0xC0C0C0, // rgb(192,192,192) + sky_blue = 0x87CEEB, // rgb(135,206,235) + slate_blue = 0x6A5ACD, // rgb(106,90,205) + slate_gray = 0x708090, // rgb(112,128,144) + snow = 0xFFFAFA, // rgb(255,250,250) + spring_green = 0x00FF7F, // rgb(0,255,127) + steel_blue = 0x4682B4, // rgb(70,130,180) + tan = 0xD2B48C, // rgb(210,180,140) + teal = 0x008080, // rgb(0,128,128) + thistle = 0xD8BFD8, // rgb(216,191,216) + tomato = 0xFF6347, // rgb(255,99,71) + turquoise = 0x40E0D0, // rgb(64,224,208) + violet = 0xEE82EE, // rgb(238,130,238) + wheat = 0xF5DEB3, // rgb(245,222,179) + white = 0xFFFFFF, // rgb(255,255,255) + white_smoke = 0xF5F5F5, // rgb(245,245,245) + yellow = 0xFFFF00, // rgb(255,255,0) + yellow_green = 0x9ACD32, // rgb(154,205,50) +}; // enum class colors + +FMT_END_NAMESPACE + +#endif // FMT_COLORS_H_ diff --git a/include/spdlog/fmt/bundled/core.h b/include/spdlog/fmt/bundled/core.h new file mode 100644 index 00000000..60135a0f --- /dev/null +++ b/include/spdlog/fmt/bundled/core.h @@ -0,0 +1,1574 @@ +// Formatting library for C++ - the core API +// +// Copyright (c) 2012 - present, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. + +#ifndef FMT_CORE_H_ +#define FMT_CORE_H_ + +#include +#include +#include +#include +#include +#include + +// The fmt library version in the form major * 10000 + minor * 100 + patch. +#define FMT_VERSION 50100 + +#ifdef __has_feature +#define FMT_HAS_FEATURE(x) __has_feature(x) +#else +#define FMT_HAS_FEATURE(x) 0 +#endif + +#ifdef __has_include +#define FMT_HAS_INCLUDE(x) __has_include(x) +#else +#define FMT_HAS_INCLUDE(x) 0 +#endif + +#ifdef __has_cpp_attribute +#define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x) +#else +#define FMT_HAS_CPP_ATTRIBUTE(x) 0 +#endif + +#if defined(__GNUC__) && !defined(__clang__) +#define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) +#else +#define FMT_GCC_VERSION 0 +#endif + +#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__) +#define FMT_HAS_GXX_CXX11 FMT_GCC_VERSION +#else +#define FMT_HAS_GXX_CXX11 0 +#endif + +#ifdef _MSC_VER +#define FMT_MSC_VER _MSC_VER +#else +#define FMT_MSC_VER 0 +#endif + +// Check if relaxed c++14 constexpr is supported. +// GCC doesn't allow throw in constexpr until version 6 (bug 67371). +#ifndef FMT_USE_CONSTEXPR +#define FMT_USE_CONSTEXPR \ + (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1910 || (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L)) +#endif +#if FMT_USE_CONSTEXPR +#define FMT_CONSTEXPR constexpr +#define FMT_CONSTEXPR_DECL constexpr +#else +#define FMT_CONSTEXPR inline +#define FMT_CONSTEXPR_DECL +#endif + +#ifndef FMT_OVERRIDE +#if FMT_HAS_FEATURE(cxx_override) || (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900 +#define FMT_OVERRIDE override +#else +#define FMT_OVERRIDE +#endif +#endif + +#if FMT_HAS_FEATURE(cxx_explicit_conversions) || FMT_MSC_VER >= 1800 +#define FMT_EXPLICIT explicit +#else +#define FMT_EXPLICIT +#endif + +#ifndef FMT_NULL +#if FMT_HAS_FEATURE(cxx_nullptr) || (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1600 +#define FMT_NULL nullptr +#define FMT_USE_NULLPTR 1 +#else +#define FMT_NULL NULL +#endif +#endif + +#ifndef FMT_USE_NULLPTR +#define FMT_USE_NULLPTR 0 +#endif + +#if FMT_HAS_CPP_ATTRIBUTE(noreturn) +#define FMT_NORETURN [[noreturn]] +#else +#define FMT_NORETURN +#endif + +// Check if exceptions are disabled. +#if defined(__GNUC__) && !defined(__EXCEPTIONS) +#define FMT_EXCEPTIONS 0 +#elif FMT_MSC_VER && !_HAS_EXCEPTIONS +#define FMT_EXCEPTIONS 0 +#endif +#ifndef FMT_EXCEPTIONS +#define FMT_EXCEPTIONS 1 +#endif + +// Define FMT_USE_NOEXCEPT to make fmt use noexcept (C++11 feature). +#ifndef FMT_USE_NOEXCEPT +#define FMT_USE_NOEXCEPT 0 +#endif + +#if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900 +#define FMT_DETECTED_NOEXCEPT noexcept +#else +#define FMT_DETECTED_NOEXCEPT throw() +#endif + +#ifndef FMT_NOEXCEPT +#if FMT_EXCEPTIONS +#define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT +#else +#define FMT_NOEXCEPT +#endif +#endif + +// This is needed because GCC still uses throw() in its headers when exceptions +// are disabled. +#if FMT_GCC_VERSION +#define FMT_DTOR_NOEXCEPT FMT_DETECTED_NOEXCEPT +#else +#define FMT_DTOR_NOEXCEPT FMT_NOEXCEPT +#endif + +#ifndef FMT_BEGIN_NAMESPACE +#if FMT_HAS_FEATURE(cxx_inline_namespaces) || FMT_GCC_VERSION >= 404 || FMT_MSC_VER >= 1900 +#define FMT_INLINE_NAMESPACE inline namespace +#define FMT_END_NAMESPACE \ + } \ + } +#else +#define FMT_INLINE_NAMESPACE namespace +#define FMT_END_NAMESPACE \ + } \ + using namespace v5; \ + } +#endif +#define FMT_BEGIN_NAMESPACE \ + namespace fmt { \ + FMT_INLINE_NAMESPACE v5 \ + { +#endif + +#if !defined(FMT_HEADER_ONLY) && defined(_WIN32) +#ifdef FMT_EXPORT +#define FMT_API __declspec(dllexport) +#elif defined(FMT_SHARED) +#define FMT_API __declspec(dllimport) +#endif +#endif +#ifndef FMT_API +#define FMT_API +#endif + +#ifndef FMT_ASSERT +#define FMT_ASSERT(condition, message) assert((condition) && message) +#endif + +#define FMT_DELETED = delete + +// A macro to disallow the copy construction and assignment. +#define FMT_DISALLOW_COPY_AND_ASSIGN(Type) \ + Type(const Type &) FMT_DELETED; \ + void operator=(const Type &) FMT_DELETED + +// libc++ supports string_view in pre-c++17. +#if (FMT_HAS_INCLUDE() && (__cplusplus > 201402L || defined(_LIBCPP_VERSION))) || \ + (defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910) +#include +#define FMT_USE_STD_STRING_VIEW +#elif (FMT_HAS_INCLUDE() && __cplusplus >= 201402L) +#include +#define FMT_USE_EXPERIMENTAL_STRING_VIEW +#endif + +// std::result_of is defined in in gcc 4.4. +#if FMT_GCC_VERSION && FMT_GCC_VERSION <= 404 +#include +#endif + +FMT_BEGIN_NAMESPACE + +// An implementation of declval for pre-C++11 compilers such as gcc 4. +namespace internal { +template +typename std::add_rvalue_reference::type declval() FMT_NOEXCEPT; +} + +/** + An implementation of ``std::basic_string_view`` for pre-C++17. It provides a + subset of the API. ``fmt::basic_string_view`` is used for format strings even + if ``std::string_view`` is available to prevent issues when a library is + compiled with a different ``-std`` option than the client code (which is not + recommended). + */ +template +class basic_string_view +{ +private: + const Char *data_; + size_t size_; + +public: + typedef Char char_type; + typedef const Char *iterator; + + // Standard basic_string_view type. +#if defined(FMT_USE_STD_STRING_VIEW) + typedef std::basic_string_view type; +#elif defined(FMT_USE_EXPERIMENTAL_STRING_VIEW) + typedef std::experimental::basic_string_view type; +#else + struct type + { + const char *data() const + { + return FMT_NULL; + } + size_t size() const + { + return 0; + } + }; +#endif + + FMT_CONSTEXPR basic_string_view() FMT_NOEXCEPT : data_(FMT_NULL), size_(0) {} + + /** Constructs a string reference object from a C string and a size. */ + FMT_CONSTEXPR basic_string_view(const Char *s, size_t str_size) FMT_NOEXCEPT : data_(s), size_(str_size) {} + + /** + \rst + Constructs a string reference object from a C string computing + the size with ``std::char_traits::length``. + \endrst + */ + basic_string_view(const Char *s) + : data_(s) + , size_(std::char_traits::length(s)) + { + } + + /** Constructs a string reference from a ``std::basic_string`` object. */ + template + FMT_CONSTEXPR basic_string_view(const std::basic_string &s) FMT_NOEXCEPT : data_(s.c_str()), size_(s.size()) + { + } + + FMT_CONSTEXPR basic_string_view(type s) FMT_NOEXCEPT : data_(s.data()), size_(s.size()) {} + + /** Returns a pointer to the string data. */ + const Char *data() const + { + return data_; + } + + /** Returns the string size. */ + FMT_CONSTEXPR size_t size() const + { + return size_; + } + + FMT_CONSTEXPR iterator begin() const + { + return data_; + } + FMT_CONSTEXPR iterator end() const + { + return data_ + size_; + } + + FMT_CONSTEXPR void remove_prefix(size_t n) + { + data_ += n; + size_ -= n; + } + + // Lexicographically compare this string reference to other. + int compare(basic_string_view other) const + { + size_t str_size = size_ < other.size_ ? size_ : other.size_; + int result = std::char_traits::compare(data_, other.data_, str_size); + if (result == 0) + result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1); + return result; + } + + friend bool operator==(basic_string_view lhs, basic_string_view rhs) + { + return lhs.compare(rhs) == 0; + } + friend bool operator!=(basic_string_view lhs, basic_string_view rhs) + { + return lhs.compare(rhs) != 0; + } + friend bool operator<(basic_string_view lhs, basic_string_view rhs) + { + return lhs.compare(rhs) < 0; + } + friend bool operator<=(basic_string_view lhs, basic_string_view rhs) + { + return lhs.compare(rhs) <= 0; + } + friend bool operator>(basic_string_view lhs, basic_string_view rhs) + { + return lhs.compare(rhs) > 0; + } + friend bool operator>=(basic_string_view lhs, basic_string_view rhs) + { + return lhs.compare(rhs) >= 0; + } +}; + +typedef basic_string_view string_view; +typedef basic_string_view wstring_view; + +template +class basic_format_arg; + +template +class basic_format_args; + +// A formatter for objects of type T. +template +struct formatter; + +namespace internal { + +/** A contiguous memory buffer with an optional growing ability. */ +template +class basic_buffer +{ +private: + FMT_DISALLOW_COPY_AND_ASSIGN(basic_buffer); + + T *ptr_; + std::size_t size_; + std::size_t capacity_; + +protected: + basic_buffer(T *p = FMT_NULL, std::size_t buf_size = 0, std::size_t buf_capacity = 0) FMT_NOEXCEPT : ptr_(p), + size_(buf_size), + capacity_(buf_capacity) + { + } + + /** Sets the buffer data and capacity. */ + void set(T *buf_data, std::size_t buf_capacity) FMT_NOEXCEPT + { + ptr_ = buf_data; + capacity_ = buf_capacity; + } + + /** Increases the buffer capacity to hold at least *capacity* elements. */ + virtual void grow(std::size_t capacity) = 0; + +public: + typedef T value_type; + typedef const T &const_reference; + + virtual ~basic_buffer() {} + + T *begin() FMT_NOEXCEPT + { + return ptr_; + } + T *end() FMT_NOEXCEPT + { + return ptr_ + size_; + } + + /** Returns the size of this buffer. */ + std::size_t size() const FMT_NOEXCEPT + { + return size_; + } + + /** Returns the capacity of this buffer. */ + std::size_t capacity() const FMT_NOEXCEPT + { + return capacity_; + } + + /** Returns a pointer to the buffer data. */ + T *data() FMT_NOEXCEPT + { + return ptr_; + } + + /** Returns a pointer to the buffer data. */ + const T *data() const FMT_NOEXCEPT + { + return ptr_; + } + + /** + Resizes the buffer. If T is a POD type new elements may not be initialized. + */ + void resize(std::size_t new_size) + { + reserve(new_size); + size_ = new_size; + } + + /** Reserves space to store at least *buf_capacity* elements. */ + void reserve(std::size_t buf_capacity) + { + if (buf_capacity > capacity_) + grow(buf_capacity); + } + + void push_back(const T &value) + { + reserve(size_ + 1); + ptr_[size_++] = value; + } + + /** Appends data to the end of the buffer. */ + template + void append(const U *begin, const U *end); + + T &operator[](std::size_t index) + { + return ptr_[index]; + } + const T &operator[](std::size_t index) const + { + return ptr_[index]; + } +}; + +typedef basic_buffer buffer; +typedef basic_buffer wbuffer; + +// A container-backed buffer. +template +class container_buffer : public basic_buffer +{ +private: + Container &container_; + +protected: + void grow(std::size_t capacity) FMT_OVERRIDE + { + container_.resize(capacity); + this->set(&container_[0], capacity); + } + +public: + explicit container_buffer(Container &c) + : basic_buffer(&c[0], c.size(), c.size()) + , container_(c) + { + } +}; + +struct error_handler +{ + FMT_CONSTEXPR error_handler() {} + FMT_CONSTEXPR error_handler(const error_handler &) {} + + // This function is intentionally not constexpr to give a compile-time error. + FMT_API void on_error(const char *message); +}; + +// Formatting of wide characters and strings into a narrow output is disallowed: +// fmt::format("{}", L"test"); // error +// To fix this, use a wide format string: +// fmt::format(L"{}", L"test"); +template +inline void require_wchar() +{ + static_assert(std::is_same::value, "formatting of wide characters into a narrow output is disallowed"); +} + +template +struct named_arg_base; + +template +struct named_arg; + +template +struct is_named_arg : std::false_type +{ +}; + +template +struct is_named_arg> : std::true_type +{ +}; + +enum type +{ + none_type, + named_arg_type, + // Integer types should go first, + int_type, + uint_type, + long_long_type, + ulong_long_type, + bool_type, + char_type, + last_integer_type = char_type, + // followed by floating-point types. + double_type, + long_double_type, + last_numeric_type = long_double_type, + cstring_type, + string_type, + pointer_type, + custom_type +}; + +FMT_CONSTEXPR bool is_integral(type t) +{ + FMT_ASSERT(t != internal::named_arg_type, "invalid argument type"); + return t > internal::none_type && t <= internal::last_integer_type; +} + +FMT_CONSTEXPR bool is_arithmetic(type t) +{ + FMT_ASSERT(t != internal::named_arg_type, "invalid argument type"); + return t > internal::none_type && t <= internal::last_numeric_type; +} + +template +struct convert_to_int +{ + enum + { + value = !std::is_arithmetic::value && std::is_convertible::value + }; +}; + +template +struct string_value +{ + const Char *value; + std::size_t size; +}; + +template +struct custom_value +{ + const void *value; + void (*format)(const void *arg, Context &ctx); +}; + +// A formatting argument value. +template +class value +{ +public: + typedef typename Context::char_type char_type; + + union + { + int int_value; + unsigned uint_value; + long long long_long_value; + unsigned long long ulong_long_value; + double double_value; + long double long_double_value; + const void *pointer; + string_value string; + string_value sstring; + string_value ustring; + custom_value custom; + }; + + FMT_CONSTEXPR value(int val = 0) + : int_value(val) + { + } + value(unsigned val) + { + uint_value = val; + } + value(long long val) + { + long_long_value = val; + } + value(unsigned long long val) + { + ulong_long_value = val; + } + value(double val) + { + double_value = val; + } + value(long double val) + { + long_double_value = val; + } + value(const char_type *val) + { + string.value = val; + } + value(const signed char *val) + { + static_assert(std::is_same::value, "incompatible string types"); + sstring.value = val; + } + value(const unsigned char *val) + { + static_assert(std::is_same::value, "incompatible string types"); + ustring.value = val; + } + value(basic_string_view val) + { + string.value = val.data(); + string.size = val.size(); + } + value(const void *val) + { + pointer = val; + } + + template + explicit value(const T &val) + { + custom.value = &val; + custom.format = &format_custom_arg; + } + + const named_arg_base &as_named_arg() + { + return *static_cast *>(pointer); + } + +private: + // Formats an argument of a custom type, such as a user-defined class. + template + static void format_custom_arg(const void *arg, Context &ctx) + { + // Get the formatter type through the context to allow different contexts + // have different extension points, e.g. `formatter` for `format` and + // `printf_formatter` for `printf`. + typename Context::template formatter_type::type f; + auto &&parse_ctx = ctx.parse_context(); + parse_ctx.advance_to(f.parse(parse_ctx)); + ctx.advance_to(f.format(*static_cast(arg), ctx)); + } +}; + +template +struct typed_value : value +{ + static const type type_tag = TYPE; + + template + FMT_CONSTEXPR typed_value(const T &val) + : value(val) + { + } +}; + +template +FMT_CONSTEXPR basic_format_arg make_arg(const T &value); + +#define FMT_MAKE_VALUE(TAG, ArgType, ValueType) \ + template \ + FMT_CONSTEXPR typed_value make_value(ArgType val) \ + { \ + return static_cast(val); \ + } + +#define FMT_MAKE_VALUE_SAME(TAG, Type) \ + template \ + FMT_CONSTEXPR typed_value make_value(Type val) \ + { \ + return val; \ + } + +FMT_MAKE_VALUE(bool_type, bool, int) +FMT_MAKE_VALUE(int_type, short, int) +FMT_MAKE_VALUE(uint_type, unsigned short, unsigned) +FMT_MAKE_VALUE_SAME(int_type, int) +FMT_MAKE_VALUE_SAME(uint_type, unsigned) + +// To minimize the number of types we need to deal with, long is translated +// either to int or to long long depending on its size. +typedef std::conditional::type long_type; +FMT_MAKE_VALUE((sizeof(long) == sizeof(int) ? int_type : long_long_type), long, long_type) +typedef std::conditional::type ulong_type; +FMT_MAKE_VALUE((sizeof(unsigned long) == sizeof(unsigned) ? uint_type : ulong_long_type), unsigned long, ulong_type) + +FMT_MAKE_VALUE_SAME(long_long_type, long long) +FMT_MAKE_VALUE_SAME(ulong_long_type, unsigned long long) +FMT_MAKE_VALUE(int_type, signed char, int) +FMT_MAKE_VALUE(uint_type, unsigned char, unsigned) +FMT_MAKE_VALUE(char_type, char, int) + +#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) +template +inline typed_value make_value(wchar_t val) +{ + require_wchar(); + return static_cast(val); +} +#endif + +FMT_MAKE_VALUE(double_type, float, double) +FMT_MAKE_VALUE_SAME(double_type, double) +FMT_MAKE_VALUE_SAME(long_double_type, long double) + +// Formatting of wide strings into a narrow buffer and multibyte strings +// into a wide buffer is disallowed (https://github.com/fmtlib/fmt/pull/606). +FMT_MAKE_VALUE(cstring_type, typename C::char_type *, const typename C::char_type *) +FMT_MAKE_VALUE(cstring_type, const typename C::char_type *, const typename C::char_type *) + +FMT_MAKE_VALUE(cstring_type, signed char *, const signed char *) +FMT_MAKE_VALUE_SAME(cstring_type, const signed char *) +FMT_MAKE_VALUE(cstring_type, unsigned char *, const unsigned char *) +FMT_MAKE_VALUE_SAME(cstring_type, const unsigned char *) +FMT_MAKE_VALUE_SAME(string_type, basic_string_view) +FMT_MAKE_VALUE(string_type, typename basic_string_view::type, basic_string_view) +FMT_MAKE_VALUE(string_type, const std::basic_string &, basic_string_view) +FMT_MAKE_VALUE(pointer_type, void *, const void *) +FMT_MAKE_VALUE_SAME(pointer_type, const void *) + +#if FMT_USE_NULLPTR +FMT_MAKE_VALUE(pointer_type, std::nullptr_t, const void *) +#endif + +// Formatting of arbitrary pointers is disallowed. If you want to output a +// pointer cast it to "void *" or "const void *". In particular, this forbids +// formatting of "[const] volatile char *" which is printed as bool by +// iostreams. +template +typename std::enable_if::value>::type make_value(const T *) +{ + static_assert(!sizeof(T), "formatting of non-void pointers is disallowed"); +} + +template +inline typename std::enable_if::value && convert_to_int::value, typed_value>::type +make_value(const T &val) +{ + return static_cast(val); +} + +template +inline typename std::enable_if::value && !std::is_convertible>::value, + // Implicit conversion to std::string is not handled here because it's + // unsafe: https://github.com/fmtlib/fmt/issues/729 + typed_value>::type +make_value(const T &val) +{ + return val; +} + +template +typed_value make_value(const named_arg &val) +{ + basic_format_arg arg = make_arg(val.value); + std::memcpy(val.data, &arg, sizeof(arg)); + return static_cast(&val); +} + +// Maximum number of arguments with packed types. +enum +{ + max_packed_args = 15 +}; + +template +class arg_map; + +template +struct result_of; + +template +struct result_of +{ + // A workaround for gcc 4.4 that doesn't allow F to be a reference. + typedef typename std::result_of::type(Args...)>::type type; +}; +} // namespace internal + +// A formatting argument. It is a trivially copyable/constructible type to +// allow storage in basic_memory_buffer. +template +class basic_format_arg +{ +private: + internal::value value_; + internal::type type_; + + template + friend FMT_CONSTEXPR basic_format_arg internal::make_arg(const T &value); + + template + friend FMT_CONSTEXPR typename internal::result_of::type visit(Visitor &&vis, basic_format_arg arg); + + friend class basic_format_args; + friend class internal::arg_map; + + typedef typename Context::char_type char_type; + +public: + class handle + { + public: + explicit handle(internal::custom_value custom) + : custom_(custom) + { + } + + void format(Context &ctx) const + { + custom_.format(custom_.value, ctx); + } + + private: + internal::custom_value custom_; + }; + + FMT_CONSTEXPR basic_format_arg() + : type_(internal::none_type) + { + } + + FMT_EXPLICIT operator bool() const FMT_NOEXCEPT + { + return type_ != internal::none_type; + } + + internal::type type() const + { + return type_; + } + + bool is_integral() const + { + return internal::is_integral(type_); + } + bool is_arithmetic() const + { + return internal::is_arithmetic(type_); + } +}; + +// Parsing context consisting of a format string range being parsed and an +// argument counter for automatic indexing. +template +class basic_parse_context : private ErrorHandler +{ +private: + basic_string_view format_str_; + int next_arg_id_; + +public: + typedef Char char_type; + typedef typename basic_string_view::iterator iterator; + + explicit FMT_CONSTEXPR basic_parse_context(basic_string_view format_str, ErrorHandler eh = ErrorHandler()) + : ErrorHandler(eh) + , format_str_(format_str) + , next_arg_id_(0) + { + } + + // Returns an iterator to the beginning of the format string range being + // parsed. + FMT_CONSTEXPR iterator begin() const FMT_NOEXCEPT + { + return format_str_.begin(); + } + + // Returns an iterator past the end of the format string range being parsed. + FMT_CONSTEXPR iterator end() const FMT_NOEXCEPT + { + return format_str_.end(); + } + + // Advances the begin iterator to ``it``. + FMT_CONSTEXPR void advance_to(iterator it) + { + format_str_.remove_prefix(it - begin()); + } + + // Returns the next argument index. + FMT_CONSTEXPR unsigned next_arg_id(); + + FMT_CONSTEXPR bool check_arg_id(unsigned) + { + if (next_arg_id_ > 0) + { + on_error("cannot switch from automatic to manual argument indexing"); + return false; + } + next_arg_id_ = -1; + return true; + } + void check_arg_id(basic_string_view) {} + + FMT_CONSTEXPR void on_error(const char *message) + { + ErrorHandler::on_error(message); + } + + FMT_CONSTEXPR ErrorHandler error_handler() const + { + return *this; + } +}; + +typedef basic_parse_context parse_context; +typedef basic_parse_context wparse_context; + +namespace internal { +// A map from argument names to their values for named arguments. +template +class arg_map +{ +private: + FMT_DISALLOW_COPY_AND_ASSIGN(arg_map); + + typedef typename Context::char_type char_type; + + struct entry + { + basic_string_view name; + basic_format_arg arg; + }; + + entry *map_; + unsigned size_; + + void push_back(value val) + { + const internal::named_arg_base &named = val.as_named_arg(); + map_[size_] = entry{named.name, named.template deserialize()}; + ++size_; + } + +public: + arg_map() + : map_(FMT_NULL) + , size_(0) + { + } + void init(const basic_format_args &args); + ~arg_map() + { + delete[] map_; + } + + basic_format_arg find(basic_string_view name) const + { + // The list is unsorted, so just return the first matching name. + for (entry *it = map_, *end = map_ + size_; it != end; ++it) + { + if (it->name == name) + return it->arg; + } + return basic_format_arg(); + } +}; + +template +class context_base +{ +public: + typedef OutputIt iterator; + +private: + basic_parse_context parse_context_; + iterator out_; + basic_format_args args_; + +protected: + typedef Char char_type; + typedef basic_format_arg format_arg; + + context_base(OutputIt out, basic_string_view format_str, basic_format_args ctx_args) + : parse_context_(format_str) + , out_(out) + , args_(ctx_args) + { + } + + // Returns the argument with specified index. + format_arg do_get_arg(unsigned arg_id) + { + format_arg arg = args_.get(arg_id); + if (!arg) + parse_context_.on_error("argument index out of range"); + return arg; + } + + // Checks if manual indexing is used and returns the argument with + // specified index. + format_arg get_arg(unsigned arg_id) + { + return this->parse_context().check_arg_id(arg_id) ? this->do_get_arg(arg_id) : format_arg(); + } + +public: + basic_parse_context &parse_context() + { + return parse_context_; + } + + internal::error_handler error_handler() + { + return parse_context_.error_handler(); + } + + void on_error(const char *message) + { + parse_context_.on_error(message); + } + + // Returns an iterator to the beginning of the output range. + iterator out() + { + return out_; + } + iterator begin() + { + return out_; + } // deprecated + + // Advances the begin iterator to ``it``. + void advance_to(iterator it) + { + out_ = it; + } + + basic_format_args args() const + { + return args_; + } +}; + +// Extracts a reference to the container from back_insert_iterator. +template +inline Container &get_container(std::back_insert_iterator it) +{ + typedef std::back_insert_iterator bi_iterator; + struct accessor : bi_iterator + { + accessor(bi_iterator iter) + : bi_iterator(iter) + { + } + using bi_iterator::container; + }; + return *accessor(it).container; +} +} // namespace internal + +// Formatting context. +template +class basic_format_context : public internal::context_base, Char> +{ +public: + /** The character type for the output. */ + typedef Char char_type; + + // using formatter_type = formatter; + template + struct formatter_type + { + typedef formatter type; + }; + +private: + internal::arg_map map_; + + FMT_DISALLOW_COPY_AND_ASSIGN(basic_format_context); + + typedef internal::context_base base; + typedef typename base::format_arg format_arg; + using base::get_arg; + +public: + using typename base::iterator; + + /** + Constructs a ``basic_format_context`` object. References to the arguments are + stored in the object so make sure they have appropriate lifetimes. + */ + basic_format_context(OutputIt out, basic_string_view format_str, basic_format_args ctx_args) + : base(out, format_str, ctx_args) + { + } + + format_arg next_arg() + { + return this->do_get_arg(this->parse_context().next_arg_id()); + } + format_arg get_arg(unsigned arg_id) + { + return this->do_get_arg(arg_id); + } + + // Checks if manual indexing is used and returns the argument with the + // specified name. + format_arg get_arg(basic_string_view name); +}; + +template +struct buffer_context +{ + typedef basic_format_context>, Char> type; +}; +typedef buffer_context::type format_context; +typedef buffer_context::type wformat_context; + +namespace internal { +template +struct get_type +{ + typedef decltype(make_value(declval::type &>())) value_type; + static const type value = value_type::type_tag; +}; + +template +FMT_CONSTEXPR uint64_t get_types() +{ + return 0; +} + +template +FMT_CONSTEXPR uint64_t get_types() +{ + return get_type::value | (get_types() << 4); +} + +template +FMT_CONSTEXPR basic_format_arg make_arg(const T &value) +{ + basic_format_arg arg; + arg.type_ = get_type::value; + arg.value_ = make_value(value); + return arg; +} + +template +inline typename std::enable_if>::type make_arg(const T &value) +{ + return make_value(value); +} + +template +inline typename std::enable_if>::type make_arg(const T &value) +{ + return make_arg(value); +} +} // namespace internal + +/** + \rst + An array of references to arguments. It can be implicitly converted into + `~fmt::basic_format_args` for passing into type-erased formatting functions + such as `~fmt::vformat`. + \endrst + */ +template +class format_arg_store +{ +private: + static const size_t NUM_ARGS = sizeof...(Args); + + // Packed is a macro on MinGW so use IS_PACKED instead. + static const bool IS_PACKED = NUM_ARGS < internal::max_packed_args; + + typedef typename std::conditional, basic_format_arg>::type value_type; + + // If the arguments are not packed, add one more element to mark the end. + value_type data_[NUM_ARGS + (IS_PACKED && NUM_ARGS != 0 ? 0 : 1)]; + + friend class basic_format_args; + + static FMT_CONSTEXPR int64_t get_types() + { + return IS_PACKED ? static_cast(internal::get_types()) : -static_cast(NUM_ARGS); + } + +public: +#if FMT_USE_CONSTEXPR + static constexpr int64_t TYPES = get_types(); +#else + static const int64_t TYPES; +#endif + +#if FMT_GCC_VERSION && FMT_GCC_VERSION <= 405 + // Workaround an array initialization bug in gcc 4.5 and earlier. + format_arg_store(const Args &... args) + { + data_ = {internal::make_arg(args)...}; + } +#else + format_arg_store(const Args &... args) + : data_{internal::make_arg(args)...} + { + } +#endif +}; + +#if !FMT_USE_CONSTEXPR +template +const int64_t format_arg_store::TYPES = get_types(); +#endif + +/** + \rst + Constructs an `~fmt::format_arg_store` object that contains references to + arguments and can be implicitly converted to `~fmt::format_args`. `Context` can + be omitted in which case it defaults to `~fmt::context`. + \endrst + */ +template +inline format_arg_store make_format_args(const Args &... args) +{ + return format_arg_store(args...); +} + +template +inline format_arg_store make_format_args(const Args &... args) +{ + return format_arg_store(args...); +} + +/** Formatting arguments. */ +template +class basic_format_args +{ +public: + typedef unsigned size_type; + typedef basic_format_arg format_arg; + +private: + // To reduce compiled code size per formatting function call, types of first + // max_packed_args arguments are passed in the types_ field. + uint64_t types_; + union + { + // If the number of arguments is less than max_packed_args, the argument + // values are stored in values_, otherwise they are stored in args_. + // This is done to reduce compiled code size as storing larger objects + // may require more code (at least on x86-64) even if the same amount of + // data is actually copied to stack. It saves ~10% on the bloat test. + const internal::value *values_; + const format_arg *args_; + }; + + typename internal::type type(unsigned index) const + { + unsigned shift = index * 4; + uint64_t mask = 0xf; + return static_cast((types_ & (mask << shift)) >> shift); + } + + friend class internal::arg_map; + + void set_data(const internal::value *values) + { + values_ = values; + } + void set_data(const format_arg *args) + { + args_ = args; + } + + format_arg do_get(size_type index) const + { + int64_t signed_types = static_cast(types_); + if (signed_types < 0) + { + uint64_t num_args = -signed_types; + return index < num_args ? args_[index] : format_arg(); + } + format_arg arg; + if (index > internal::max_packed_args) + return arg; + arg.type_ = type(index); + if (arg.type_ == internal::none_type) + return arg; + internal::value &val = arg.value_; + val = values_[index]; + return arg; + } + +public: + basic_format_args() + : types_(0) + { + } + + /** + \rst + Constructs a `basic_format_args` object from `~fmt::format_arg_store`. + \endrst + */ + template + basic_format_args(const format_arg_store &store) + : types_(store.TYPES) + { + set_data(store.data_); + } + + /** Returns the argument at specified index. */ + format_arg get(size_type index) const + { + format_arg arg = do_get(index); + return arg.type_ == internal::named_arg_type ? arg.value_.as_named_arg().template deserialize() : arg; + } + + unsigned max_size() const + { + int64_t signed_types = static_cast(types_); + return static_cast(signed_types < 0 ? -signed_types : static_cast(internal::max_packed_args)); + } +}; + +/** An alias to ``basic_format_args``. */ +// It is a separate type rather than a typedef to make symbols readable. +struct format_args : basic_format_args +{ + template + format_args(Args &&... arg) + : basic_format_args(std::forward(arg)...) + { + } +}; +struct wformat_args : basic_format_args +{ + template + wformat_args(Args &&... arg) + : basic_format_args(std::forward(arg)...) + { + } +}; + +namespace internal { +template +struct named_arg_base +{ + basic_string_view name; + + // Serialized value. + mutable char data[sizeof(basic_format_arg)]; + + named_arg_base(basic_string_view nm) + : name(nm) + { + } + + template + basic_format_arg deserialize() const + { + basic_format_arg arg; + std::memcpy(&arg, data, sizeof(basic_format_arg)); + return arg; + } +}; + +template +struct named_arg : named_arg_base +{ + const T &value; + + named_arg(basic_string_view name, const T &val) + : named_arg_base(name) + , value(val) + { + } +}; +} // namespace internal + +/** + \rst + Returns a named argument to be used in a formatting function. + + **Example**:: + + fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23)); + \endrst + */ +template +inline internal::named_arg arg(string_view name, const T &arg) +{ + return internal::named_arg(name, arg); +} + +template +inline internal::named_arg arg(wstring_view name, const T &arg) +{ + return internal::named_arg(name, arg); +} + +// This function template is deleted intentionally to disable nested named +// arguments as in ``format("{}", arg("a", arg("b", 42)))``. +template +void arg(S, internal::named_arg) FMT_DELETED; + +enum color +{ + black, + red, + green, + yellow, + blue, + magenta, + cyan, + white +}; + +FMT_API void vprint_colored(color c, string_view format, format_args args); +FMT_API void vprint_colored(color c, wstring_view format, wformat_args args); + +/** + Formats a string and prints it to stdout using ANSI escape sequences to + specify color (experimental). + Example: + fmt::print_colored(fmt::RED, "Elapsed time: {0:.2f} seconds", 1.23); + */ +template +inline void print_colored(color c, string_view format_str, const Args &... args) +{ + vprint_colored(c, format_str, make_format_args(args...)); +} + +template +inline void print_colored(color c, wstring_view format_str, const Args &... args) +{ + vprint_colored(c, format_str, make_format_args(args...)); +} + +format_context::iterator vformat_to(internal::buffer &buf, string_view format_str, format_args args); +wformat_context::iterator vformat_to(internal::wbuffer &buf, wstring_view format_str, wformat_args args); + +template +struct is_contiguous : std::false_type +{ +}; + +template +struct is_contiguous> : std::true_type +{ +}; + +template +struct is_contiguous> : std::true_type +{ +}; + +/** Formats a string and writes the output to ``out``. */ +template +typename std::enable_if::value, std::back_insert_iterator>::type vformat_to( + std::back_insert_iterator out, string_view format_str, format_args args) +{ + auto &container = internal::get_container(out); + internal::container_buffer buf(container); + vformat_to(buf, format_str, args); + return std::back_inserter(container); +} + +template +typename std::enable_if::value, std::back_insert_iterator>::type vformat_to( + std::back_insert_iterator out, wstring_view format_str, wformat_args args) +{ + auto &container = internal::get_container(out); + internal::container_buffer buf(container); + vformat_to(buf, format_str, args); + return std::back_inserter(container); +} + +std::string vformat(string_view format_str, format_args args); +std::wstring vformat(wstring_view format_str, wformat_args args); + +/** + \rst + Formats arguments and returns the result as a string. + + **Example**:: + + #include + std::string message = fmt::format("The answer is {}", 42); + \endrst +*/ +template +inline std::string format(string_view format_str, const Args &... args) +{ + // This should be just + // return vformat(format_str, make_format_args(args...)); + // but gcc has trouble optimizing the latter, so break it down. + format_arg_store as{args...}; + return vformat(format_str, as); +} +template +inline std::wstring format(wstring_view format_str, const Args &... args) +{ + format_arg_store as{args...}; + return vformat(format_str, as); +} + +FMT_API void vprint(std::FILE *f, string_view format_str, format_args args); +FMT_API void vprint(std::FILE *f, wstring_view format_str, wformat_args args); + +/** + \rst + Prints formatted data to the file *f*. + + **Example**:: + + fmt::print(stderr, "Don't {}!", "panic"); + \endrst + */ +template +inline void print(std::FILE *f, string_view format_str, const Args &... args) +{ + format_arg_store as(args...); + vprint(f, format_str, as); +} +/** + Prints formatted data to the file *f* which should be in wide-oriented mode set + via ``fwide(f, 1)`` or ``_setmode(_fileno(f), _O_U8TEXT)`` on Windows. + */ +template +inline void print(std::FILE *f, wstring_view format_str, const Args &... args) +{ + format_arg_store as(args...); + vprint(f, format_str, as); +} + +FMT_API void vprint(string_view format_str, format_args args); +FMT_API void vprint(wstring_view format_str, wformat_args args); + +/** + \rst + Prints formatted data to ``stdout``. + + **Example**:: + + fmt::print("Elapsed time: {0:.2f} seconds", 1.23); + \endrst + */ +template +inline void print(string_view format_str, const Args &... args) +{ + format_arg_store as{args...}; + vprint(format_str, as); +} + +template +inline void print(wstring_view format_str, const Args &... args) +{ + format_arg_store as(args...); + vprint(format_str, as); +} +FMT_END_NAMESPACE + +#endif // FMT_CORE_H_ diff --git a/include/spdlog/fmt/bundled/format-inl.h b/include/spdlog/fmt/bundled/format-inl.h new file mode 100644 index 00000000..267d2449 --- /dev/null +++ b/include/spdlog/fmt/bundled/format-inl.h @@ -0,0 +1,534 @@ +// Formatting library for C++ +// +// Copyright (c) 2012 - 2016, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. + +#ifndef FMT_FORMAT_INL_H_ +#define FMT_FORMAT_INL_H_ + +#include "format.h" + +#include + +#include +#include +#include +#include +#include +#include // for std::ptrdiff_t +#include + +#if defined(_WIN32) && defined(__MINGW32__) +#include +#endif + +#if FMT_USE_WINDOWS_H +#if !defined(FMT_HEADER_ONLY) && !defined(WIN32_LEAN_AND_MEAN) +#define WIN32_LEAN_AND_MEAN +#endif +#if defined(NOMINMAX) || defined(FMT_WIN_MINMAX) +#include +#else +#define NOMINMAX +#include +#undef NOMINMAX +#endif +#endif + +#if FMT_EXCEPTIONS +#define FMT_TRY try +#define FMT_CATCH(x) catch (x) +#else +#define FMT_TRY if (true) +#define FMT_CATCH(x) if (false) +#endif + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4127) // conditional expression is constant +#pragma warning(disable : 4702) // unreachable code +// Disable deprecation warning for strerror. The latter is not called but +// MSVC fails to detect it. +#pragma warning(disable : 4996) +#endif + +// Dummy implementations of strerror_r and strerror_s called if corresponding +// system functions are not available. +inline fmt::internal::null<> strerror_r(int, char *, ...) +{ + return fmt::internal::null<>(); +} +inline fmt::internal::null<> strerror_s(char *, std::size_t, ...) +{ + return fmt::internal::null<>(); +} + +FMT_BEGIN_NAMESPACE + +namespace { + +#ifndef _MSC_VER +#define FMT_SNPRINTF snprintf +#else // _MSC_VER +inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) +{ + va_list args; + va_start(args, format); + int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args); + va_end(args); + return result; +} +#define FMT_SNPRINTF fmt_snprintf +#endif // _MSC_VER + +#if defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT) +#define FMT_SWPRINTF snwprintf +#else +#define FMT_SWPRINTF swprintf +#endif // defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT) + +const char RESET_COLOR[] = "\x1b[0m"; +const wchar_t WRESET_COLOR[] = L"\x1b[0m"; + +typedef void (*FormatFunc)(internal::buffer &, int, string_view); + +// Portable thread-safe version of strerror. +// Sets buffer to point to a string describing the error code. +// This can be either a pointer to a string stored in buffer, +// or a pointer to some static immutable string. +// Returns one of the following values: +// 0 - success +// ERANGE - buffer is not large enough to store the error message +// other - failure +// Buffer should be at least of size 1. +int safe_strerror(int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT +{ + FMT_ASSERT(buffer != FMT_NULL && buffer_size != 0, "invalid buffer"); + + class dispatcher + { + private: + int error_code_; + char *&buffer_; + std::size_t buffer_size_; + + // A noop assignment operator to avoid bogus warnings. + void operator=(const dispatcher &) {} + + // Handle the result of XSI-compliant version of strerror_r. + int handle(int result) + { + // glibc versions before 2.13 return result in errno. + return result == -1 ? errno : result; + } + + // Handle the result of GNU-specific version of strerror_r. + int handle(char *message) + { + // If the buffer is full then the message is probably truncated. + if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1) + return ERANGE; + buffer_ = message; + return 0; + } + + // Handle the case when strerror_r is not available. + int handle(internal::null<>) + { + return fallback(strerror_s(buffer_, buffer_size_, error_code_)); + } + + // Fallback to strerror_s when strerror_r is not available. + int fallback(int result) + { + // If the buffer is full then the message is probably truncated. + return result == 0 && strlen(buffer_) == buffer_size_ - 1 ? ERANGE : result; + } + + // Fallback to strerror if strerror_r and strerror_s are not available. + int fallback(internal::null<>) + { + errno = 0; + buffer_ = strerror(error_code_); + return errno; + } + + public: + dispatcher(int err_code, char *&buf, std::size_t buf_size) + : error_code_(err_code) + , buffer_(buf) + , buffer_size_(buf_size) + { + } + + int run() + { + return handle(strerror_r(error_code_, buffer_, buffer_size_)); + } + }; + return dispatcher(error_code, buffer, buffer_size).run(); +} + +void format_error_code(internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT +{ + // Report error code making sure that the output fits into + // inline_buffer_size to avoid dynamic memory allocation and potential + // bad_alloc. + out.resize(0); + static const char SEP[] = ": "; + static const char ERROR_STR[] = "error "; + // Subtract 2 to account for terminating null characters in SEP and ERROR_STR. + std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2; + typedef internal::int_traits::main_type main_type; + main_type abs_value = static_cast(error_code); + if (internal::is_negative(error_code)) + { + abs_value = 0 - abs_value; + ++error_code_size; + } + error_code_size += internal::count_digits(abs_value); + writer w(out); + if (message.size() <= inline_buffer_size - error_code_size) + { + w.write(message); + w.write(SEP); + } + w.write(ERROR_STR); + w.write(error_code); + assert(out.size() <= inline_buffer_size); +} + +void report_error(FormatFunc func, int error_code, string_view message) FMT_NOEXCEPT +{ + memory_buffer full_message; + func(full_message, error_code, message); + // Use Writer::data instead of Writer::c_str to avoid potential memory + // allocation. + std::fwrite(full_message.data(), full_message.size(), 1, stderr); + std::fputc('\n', stderr); +} +} // namespace + +class locale +{ +private: + std::locale locale_; + +public: + explicit locale(std::locale loc = std::locale()) + : locale_(loc) + { + } + std::locale get() + { + return locale_; + } +}; + +template +FMT_FUNC Char internal::thousands_sep(locale_provider *lp) +{ + std::locale loc = lp ? lp->locale().get() : std::locale(); + return std::use_facet>(loc).thousands_sep(); +} + +FMT_FUNC void system_error::init(int err_code, string_view format_str, format_args args) +{ + error_code_ = err_code; + memory_buffer buffer; + format_system_error(buffer, err_code, vformat(format_str, args)); + std::runtime_error &base = *this; + base = std::runtime_error(to_string(buffer)); +} + +namespace internal { +template +int char_traits::format_float(char *buffer, std::size_t size, const char *format, int precision, T value) +{ + return precision < 0 ? FMT_SNPRINTF(buffer, size, format, value) : FMT_SNPRINTF(buffer, size, format, precision, value); +} + +template +int char_traits::format_float(wchar_t *buffer, std::size_t size, const wchar_t *format, int precision, T value) +{ + return precision < 0 ? FMT_SWPRINTF(buffer, size, format, value) : FMT_SWPRINTF(buffer, size, format, precision, value); +} + +template +const char basic_data::DIGITS[] = "0001020304050607080910111213141516171819" + "2021222324252627282930313233343536373839" + "4041424344454647484950515253545556575859" + "6061626364656667686970717273747576777879" + "8081828384858687888990919293949596979899"; + +#define FMT_POWERS_OF_10(factor) \ + factor * 10, factor * 100, factor * 1000, factor * 10000, factor * 100000, factor * 1000000, factor * 10000000, factor * 100000000, \ + factor * 1000000000 + +template +const uint32_t basic_data::POWERS_OF_10_32[] = {0, FMT_POWERS_OF_10(1)}; + +template +const uint64_t basic_data::POWERS_OF_10_64[] = {0, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ull), 10000000000000000000ull}; + +// Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340. +// These are generated by support/compute-powers.py. +template +const uint64_t basic_data::POW10_SIGNIFICANDS[] = {0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76, 0xcf42894a5dce35ea, + 0x9a6bb0aa55653b2d, 0xe61acf033d1a45df, 0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c, 0x8dd01fad907ffc3c, + 0xd3515c2831559a83, 0x9d71ac8fada6c9b5, 0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57, 0xc21094364dfb5637, + 0x9096ea6f3848984f, 0xd77485cb25823ac7, 0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e, 0x84c8d4dfd2c63f3b, + 0xc5dd44271ad3cdba, 0x936b9fcebb25c996, 0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126, 0xb5b5ada8aaff80b8, + 0x87625f056c7c4a8b, 0xc9bcff6034c13053, 0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f, 0xf8a95fcf88747d94, + 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b, 0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06, 0xaa242499697392d3, + 0xfd87b5f28300ca0e, 0xbce5086492111aeb, 0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000, 0xe8d4a51000000000, + 0xad78ebc5ac620000, 0x813f3978f8940984, 0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068, 0x9f4f2726179a2245, + 0xed63a231d4c4fb27, 0xb0de65388cc8ada8, 0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758, 0xda01ee641a708dea, + 0xa26da3999aef774a, 0xf209787bb47d6b85, 0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d, 0x952ab45cfa97a0b3, + 0xde469fbd99a05fe3, 0xa59bc234db398c25, 0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2, 0xcc20ce9bd35c78a5, + 0x98165af37b2153df, 0xe2a0b5dc971f303a, 0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410, 0x8bab8eefb6409c1a, + 0xd01fef10a657842c, 0x9b10a4e5e9913129, 0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85, 0xbf21e44003acdd2d, + 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841, 0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b}; + +// Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding +// to significands above. +template +const int16_t basic_data::POW10_EXPONENTS[] = {-1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954, -927, -901, + -874, -847, -821, -794, -768, -741, -715, -688, -661, -635, -608, -582, -555, -529, -502, -475, -449, -422, -396, -369, -343, -316, + -289, -263, -236, -210, -183, -157, -130, -103, -77, -50, -24, 3, 30, 56, 83, 109, 136, 162, 189, 216, 242, 269, 295, 322, 348, 375, + 402, 428, 455, 481, 508, 534, 561, 588, 614, 641, 667, 694, 720, 747, 774, 800, 827, 853, 880, 907, 933, 960, 986, 1013, 1039, 1066}; + +FMT_FUNC fp operator*(fp x, fp y) +{ + // Multiply 32-bit parts of significands. + uint64_t mask = (1ULL << 32) - 1; + uint64_t a = x.f >> 32, b = x.f & mask; + uint64_t c = y.f >> 32, d = y.f & mask; + uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d; + // Compute mid 64-bit of result and round. + uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31); + return fp(ac + (ad >> 32) + (bc >> 32) + (mid >> 32), x.e + y.e + 64); +} + +FMT_FUNC fp get_cached_power(int min_exponent, int &pow10_exponent) +{ + const double one_over_log2_10 = 0.30102999566398114; // 1 / log2(10) + int index = static_cast(std::ceil((min_exponent + fp::significand_size - 1) * one_over_log2_10)); + // Decimal exponent of the first (smallest) cached power of 10. + const int first_dec_exp = -348; + // Difference between two consecutive decimal exponents in cached powers of 10. + const int dec_exp_step = 8; + index = (index - first_dec_exp - 1) / dec_exp_step + 1; + pow10_exponent = first_dec_exp + index * dec_exp_step; + return fp(data::POW10_SIGNIFICANDS[index], data::POW10_EXPONENTS[index]); +} +} // namespace internal + +#if FMT_USE_WINDOWS_H + +FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s) +{ + static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16"; + if (s.size() > INT_MAX) + FMT_THROW(windows_error(ERROR_INVALID_PARAMETER, ERROR_MSG)); + int s_size = static_cast(s.size()); + if (s_size == 0) + { + // MultiByteToWideChar does not support zero length, handle separately. + buffer_.resize(1); + buffer_[0] = 0; + return; + } + + int length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, FMT_NULL, 0); + if (length == 0) + FMT_THROW(windows_error(GetLastError(), ERROR_MSG)); + buffer_.resize(length + 1); + length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length); + if (length == 0) + FMT_THROW(windows_error(GetLastError(), ERROR_MSG)); + buffer_[length] = 0; +} + +FMT_FUNC internal::utf16_to_utf8::utf16_to_utf8(wstring_view s) +{ + if (int error_code = convert(s)) + { + FMT_THROW(windows_error(error_code, "cannot convert string from UTF-16 to UTF-8")); + } +} + +FMT_FUNC int internal::utf16_to_utf8::convert(wstring_view s) +{ + if (s.size() > INT_MAX) + return ERROR_INVALID_PARAMETER; + int s_size = static_cast(s.size()); + if (s_size == 0) + { + // WideCharToMultiByte does not support zero length, handle separately. + buffer_.resize(1); + buffer_[0] = 0; + return 0; + } + + int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, FMT_NULL, 0, FMT_NULL, FMT_NULL); + if (length == 0) + return GetLastError(); + buffer_.resize(length + 1); + length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, FMT_NULL, FMT_NULL); + if (length == 0) + return GetLastError(); + buffer_[length] = 0; + return 0; +} + +FMT_FUNC void windows_error::init(int err_code, string_view format_str, format_args args) +{ + error_code_ = err_code; + memory_buffer buffer; + internal::format_windows_error(buffer, err_code, vformat(format_str, args)); + std::runtime_error &base = *this; + base = std::runtime_error(to_string(buffer)); +} + +FMT_FUNC void internal::format_windows_error(internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT +{ + FMT_TRY + { + wmemory_buffer buf; + buf.resize(inline_buffer_size); + for (;;) + { + wchar_t *system_message = &buf[0]; + int result = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, FMT_NULL, error_code, + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), system_message, static_cast(buf.size()), FMT_NULL); + if (result != 0) + { + utf16_to_utf8 utf8_message; + if (utf8_message.convert(system_message) == ERROR_SUCCESS) + { + writer w(out); + w.write(message); + w.write(": "); + w.write(utf8_message); + return; + } + break; + } + if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) + break; // Can't get error message, report error code instead. + buf.resize(buf.size() * 2); + } + } + FMT_CATCH(...) {} + format_error_code(out, error_code, message); +} + +#endif // FMT_USE_WINDOWS_H + +FMT_FUNC void format_system_error(internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT +{ + FMT_TRY + { + memory_buffer buf; + buf.resize(inline_buffer_size); + for (;;) + { + char *system_message = &buf[0]; + int result = safe_strerror(error_code, system_message, buf.size()); + if (result == 0) + { + writer w(out); + w.write(message); + w.write(": "); + w.write(system_message); + return; + } + if (result != ERANGE) + break; // Can't get error message, report error code instead. + buf.resize(buf.size() * 2); + } + } + FMT_CATCH(...) {} + format_error_code(out, error_code, message); +} + +template +void basic_fixed_buffer::grow(std::size_t) +{ + FMT_THROW(std::runtime_error("buffer overflow")); +} + +FMT_FUNC void internal::error_handler::on_error(const char *message) +{ + FMT_THROW(format_error(message)); +} + +FMT_FUNC void report_system_error(int error_code, fmt::string_view message) FMT_NOEXCEPT +{ + report_error(format_system_error, error_code, message); +} + +#if FMT_USE_WINDOWS_H +FMT_FUNC void report_windows_error(int error_code, fmt::string_view message) FMT_NOEXCEPT +{ + report_error(internal::format_windows_error, error_code, message); +} +#endif + +FMT_FUNC void vprint(std::FILE *f, string_view format_str, format_args args) +{ + memory_buffer buffer; + vformat_to(buffer, format_str, args); + std::fwrite(buffer.data(), 1, buffer.size(), f); +} + +FMT_FUNC void vprint(std::FILE *f, wstring_view format_str, wformat_args args) +{ + wmemory_buffer buffer; + vformat_to(buffer, format_str, args); + std::fwrite(buffer.data(), sizeof(wchar_t), buffer.size(), f); +} + +FMT_FUNC void vprint(string_view format_str, format_args args) +{ + vprint(stdout, format_str, args); +} + +FMT_FUNC void vprint(wstring_view format_str, wformat_args args) +{ + vprint(stdout, format_str, args); +} + +FMT_FUNC void vprint_colored(color c, string_view format, format_args args) +{ + char escape[] = "\x1b[30m"; + escape[3] = static_cast('0' + c); + std::fputs(escape, stdout); + vprint(format, args); + std::fputs(RESET_COLOR, stdout); +} + +FMT_FUNC void vprint_colored(color c, wstring_view format, wformat_args args) +{ + wchar_t escape[] = L"\x1b[30m"; + escape[3] = static_cast('0' + c); + std::fputws(escape, stdout); + vprint(format, args); + std::fputws(WRESET_COLOR, stdout); +} + +FMT_FUNC locale locale_provider::locale() +{ + return fmt::locale(); +} + +FMT_END_NAMESPACE + +#ifdef _MSC_VER +#pragma warning(pop) +#endif + +#endif // FMT_FORMAT_INL_H_ diff --git a/include/spdlog/fmt/bundled/format.cc b/include/spdlog/fmt/bundled/format.cc new file mode 100644 index 00000000..41746612 --- /dev/null +++ b/include/spdlog/fmt/bundled/format.cc @@ -0,0 +1,46 @@ +// Formatting library for C++ +// +// Copyright (c) 2012 - 2016, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. + +#include "fmt/format-inl.h" + +namespace fmt { + +template struct internal::basic_data; + +// Explicit instantiations for char. + +template FMT_API char internal::thousands_sep(locale_provider *lp); + +template void basic_fixed_buffer::grow(std::size_t); + +template void internal::arg_map::init( + const basic_format_args &args); + +template FMT_API int internal::char_traits::format_float( + char *buffer, std::size_t size, const char *format, + unsigned width, int precision, double value); + +template FMT_API int internal::char_traits::format_float( + char *buffer, std::size_t size, const char *format, + unsigned width, int precision, long double value); + +// Explicit instantiations for wchar_t. + +template FMT_API wchar_t internal::thousands_sep(locale_provider *lp); + +template void basic_fixed_buffer::grow(std::size_t); + +template void internal::arg_map::init(const wformat_args &args); + +template FMT_API int internal::char_traits::format_float( + wchar_t *buffer, std::size_t size, const wchar_t *format, + unsigned width, int precision, double value); + +template FMT_API int internal::char_traits::format_float( + wchar_t *buffer, std::size_t size, const wchar_t *format, + unsigned width, int precision, long double value); +} // namespace fmt diff --git a/include/spdlog/fmt/bundled/format.h b/include/spdlog/fmt/bundled/format.h new file mode 100644 index 00000000..05a0430f --- /dev/null +++ b/include/spdlog/fmt/bundled/format.h @@ -0,0 +1,4514 @@ +/* + Formatting library for C++ + + Copyright (c) 2012 - present, Victor Zverovich + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef FMT_FORMAT_H_ +#define FMT_FORMAT_H_ + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __clang__ +#define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) +#else +#define FMT_CLANG_VERSION 0 +#endif + +#ifdef __INTEL_COMPILER +#define FMT_ICC_VERSION __INTEL_COMPILER +#elif defined(__ICL) +#define FMT_ICC_VERSION __ICL +#else +#define FMT_ICC_VERSION 0 +#endif + +#include "core.h" + +#if FMT_GCC_VERSION >= 406 || FMT_CLANG_VERSION +#pragma GCC diagnostic push + +// Disable the warning about declaration shadowing because it affects too +// many valid cases. +#pragma GCC diagnostic ignored "-Wshadow" + +// Disable the warning about implicit conversions that may change the sign of +// an integer; silencing it otherwise would require many explicit casts. +#pragma GCC diagnostic ignored "-Wsign-conversion" +#endif + +#ifdef _SECURE_SCL +#define FMT_SECURE_SCL _SECURE_SCL +#else +#define FMT_SECURE_SCL 0 +#endif + +#if FMT_SECURE_SCL +#include +#endif + +#ifdef __has_builtin +#define FMT_HAS_BUILTIN(x) __has_builtin(x) +#else +#define FMT_HAS_BUILTIN(x) 0 +#endif + +#ifdef __GNUC_LIBSTD__ +#define FMT_GNUC_LIBSTD_VERSION (__GNUC_LIBSTD__ * 100 + __GNUC_LIBSTD_MINOR__) +#endif + +#ifndef FMT_THROW +#if FMT_EXCEPTIONS +#if FMT_MSC_VER +FMT_BEGIN_NAMESPACE +namespace internal { +template +inline void do_throw(const Exception &x) +{ + // Silence unreachable code warnings in MSVC because these are nearly + // impossible to fix in a generic code. + volatile bool b = true; + if (b) + throw x; +} +} // namespace internal +FMT_END_NAMESPACE +#define FMT_THROW(x) fmt::internal::do_throw(x) +#else +#define FMT_THROW(x) throw x +#endif +#else +#define FMT_THROW(x) \ + do \ + { \ + static_cast(sizeof(x)); \ + assert(false); \ + } while (false); +#endif +#endif + +#ifndef FMT_USE_USER_DEFINED_LITERALS +// For Intel's compiler both it and the system gcc/msc must support UDLs. +#if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 || FMT_MSC_VER >= 1900) && (!FMT_ICC_VERSION || FMT_ICC_VERSION >= 1500) +#define FMT_USE_USER_DEFINED_LITERALS 1 +#else +#define FMT_USE_USER_DEFINED_LITERALS 0 +#endif +#endif + +#if FMT_USE_USER_DEFINED_LITERALS && !defined(FMT_ICC_VERSION) && \ + ((FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L) || (defined(FMT_CLANG_VERSION) && FMT_CLANG_VERSION >= 304)) +#define FMT_UDL_TEMPLATE 1 +#else +#define FMT_UDL_TEMPLATE 0 +#endif + +#ifndef FMT_USE_EXTERN_TEMPLATES +#ifndef FMT_HEADER_ONLY +#define FMT_USE_EXTERN_TEMPLATES ((FMT_CLANG_VERSION >= 209 && __cplusplus >= 201103L) || (FMT_GCC_VERSION >= 303 && FMT_HAS_GXX_CXX11)) +#else +#define FMT_USE_EXTERN_TEMPLATES 0 +#endif +#endif + +#if FMT_HAS_GXX_CXX11 || FMT_HAS_FEATURE(cxx_trailing_return) || FMT_MSC_VER >= 1600 +#define FMT_USE_TRAILING_RETURN 1 +#else +#define FMT_USE_TRAILING_RETURN 0 +#endif + +#if FMT_HAS_GXX_CXX11 || FMT_HAS_FEATURE(cxx_rvalue_references) || FMT_MSC_VER >= 1600 +#define FMT_USE_RVALUE_REFERENCES 1 +#else +#define FMT_USE_RVALUE_REFERENCES 0 +#endif + +#ifndef FMT_USE_GRISU +#define FMT_USE_GRISU 0 +#endif + +// __builtin_clz is broken in clang with Microsoft CodeGen: +// https://github.com/fmtlib/fmt/issues/519 +#ifndef _MSC_VER +#if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clz) +#define FMT_BUILTIN_CLZ(n) __builtin_clz(n) +#endif + +#if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clzll) +#define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n) +#endif +#endif + +// A workaround for gcc 4.4 that doesn't support union members with ctors. +#if FMT_GCC_VERSION && FMT_GCC_VERSION <= 404 +#define FMT_UNION struct +#else +#define FMT_UNION union +#endif + +// Some compilers masquerade as both MSVC and GCC-likes or otherwise support +// __builtin_clz and __builtin_clzll, so only define FMT_BUILTIN_CLZ using the +// MSVC intrinsics if the clz and clzll builtins are not available. +#if FMT_MSC_VER && !defined(FMT_BUILTIN_CLZLL) && !defined(_MANAGED) +#include // _BitScanReverse, _BitScanReverse64 + +FMT_BEGIN_NAMESPACE +namespace internal { +// Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning. +#ifndef __clang__ +#pragma intrinsic(_BitScanReverse) +#endif +inline uint32_t clz(uint32_t x) +{ + unsigned long r = 0; + _BitScanReverse(&r, x); + + assert(x != 0); + // Static analysis complains about using uninitialized data + // "r", but the only way that can happen is if "x" is 0, + // which the callers guarantee to not happen. +#pragma warning(suppress : 6102) + return 31 - r; +} +#define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n) + +#if defined(_WIN64) && !defined(__clang__) +#pragma intrinsic(_BitScanReverse64) +#endif + +inline uint32_t clzll(uint64_t x) +{ + unsigned long r = 0; +#ifdef _WIN64 + _BitScanReverse64(&r, x); +#else + // Scan the high 32 bits. + if (_BitScanReverse(&r, static_cast(x >> 32))) + return 63 - (r + 32); + + // Scan the low 32 bits. + _BitScanReverse(&r, static_cast(x)); +#endif + + assert(x != 0); + // Static analysis complains about using uninitialized data + // "r", but the only way that can happen is if "x" is 0, + // which the callers guarantee to not happen. +#pragma warning(suppress : 6102) + return 63 - r; +} +#define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n) +} // namespace internal +FMT_END_NAMESPACE +#endif + +FMT_BEGIN_NAMESPACE +namespace internal { + +// An equivalent of `*reinterpret_cast(&source)` that doesn't produce +// undefined behavior (e.g. due to type aliasing). +// Example: uint64_t d = bit_cast(2.718); +template +inline Dest bit_cast(const Source &source) +{ + static_assert(sizeof(Dest) == sizeof(Source), "size mismatch"); + Dest dest; + std::memcpy(&dest, &source, sizeof(dest)); + return dest; +} + +// An implementation of begin and end for pre-C++11 compilers such as gcc 4. +template +FMT_CONSTEXPR auto begin(const C &c) -> decltype(c.begin()) +{ + return c.begin(); +} +template +FMT_CONSTEXPR T *begin(T (&array)[N]) FMT_NOEXCEPT +{ + return array; +} +template +FMT_CONSTEXPR auto end(const C &c) -> decltype(c.end()) +{ + return c.end(); +} +template +FMT_CONSTEXPR T *end(T (&array)[N]) FMT_NOEXCEPT +{ + return array + N; +} + +// For std::result_of in gcc 4.4. +template +struct function +{ + template + struct result + { + typedef Result type; + }; +}; + +struct dummy_int +{ + int data[2]; + operator int() const + { + return 0; + } +}; +typedef std::numeric_limits fputil; + +// Dummy implementations of system functions such as signbit and ecvt called +// if the latter are not available. +inline dummy_int signbit(...) +{ + return dummy_int(); +} +inline dummy_int _ecvt_s(...) +{ + return dummy_int(); +} +inline dummy_int isinf(...) +{ + return dummy_int(); +} +inline dummy_int _finite(...) +{ + return dummy_int(); +} +inline dummy_int isnan(...) +{ + return dummy_int(); +} +inline dummy_int _isnan(...) +{ + return dummy_int(); +} + +// A handmade floating-point number f * pow(2, e). +class fp +{ +private: + typedef uint64_t significand_type; + + // All sizes are in bits. + static FMT_CONSTEXPR_DECL const int char_size = std::numeric_limits::digits; + // Subtract 1 to account for an implicit most significant bit in the + // normalized form. + static FMT_CONSTEXPR_DECL const int double_significand_size = std::numeric_limits::digits - 1; + static FMT_CONSTEXPR_DECL const uint64_t implicit_bit = 1ull << double_significand_size; + +public: + significand_type f; + int e; + + static FMT_CONSTEXPR_DECL const int significand_size = sizeof(significand_type) * char_size; + + fp(uint64_t f, int e) + : f(f) + , e(e) + { + } + + // Constructs fp from an IEEE754 double. It is a template to prevent compile + // errors on platforms where double is not IEEE754. + template + explicit fp(Double d) + { + // Assume double is in the format [sign][exponent][significand]. + typedef std::numeric_limits limits; + const int double_size = sizeof(Double) * char_size; + const int exponent_size = double_size - double_significand_size - 1; // -1 for sign + const uint64_t significand_mask = implicit_bit - 1; + const uint64_t exponent_mask = (~0ull >> 1) & ~significand_mask; + const int exponent_bias = (1 << exponent_size) - limits::max_exponent - 1; + auto u = bit_cast(d); + auto biased_e = (u & exponent_mask) >> double_significand_size; + f = u & significand_mask; + if (biased_e != 0) + f += implicit_bit; + else + biased_e = 1; // Subnormals use biased exponent 1 (min exponent). + e = static_cast(biased_e - exponent_bias - double_significand_size); + } + + // Normalizes the value converted from double and multiplied by (1 << SHIFT). + template + void normalize() + { + // Handle subnormals. + auto shifted_implicit_bit = implicit_bit << SHIFT; + while ((f & shifted_implicit_bit) == 0) + { + f <<= 1; + --e; + } + // Subtract 1 to account for hidden bit. + auto offset = significand_size - double_significand_size - SHIFT - 1; + f <<= offset; + e -= offset; + } +}; + +// Returns an fp number representing x - y. Result may not be normalized. +inline fp operator-(fp x, fp y) +{ + FMT_ASSERT(x.f >= y.f && x.e == y.e, "invalid operands"); + return fp(x.f - y.f, x.e); +} + +// Computes an fp number r with r.f = x.f * y.f / pow(2, 64) rounded to nearest +// with half-up tie breaking, r.e = x.e + y.e + 64. Result may not be normalized. +fp operator*(fp x, fp y); + +// Returns cached power (of 10) c_k = c_k.f * pow(2, c_k.e) such that its +// (binary) exponent satisfies min_exponent <= c_k.e <= min_exponent + 3. +fp get_cached_power(int min_exponent, int &pow10_exponent); + +template +typename Allocator::value_type *allocate(Allocator &alloc, std::size_t n) +{ +#if __cplusplus >= 201103L || FMT_MSC_VER >= 1700 + return std::allocator_traits::allocate(alloc, n); +#else + return alloc.allocate(n); +#endif +} + +// A helper function to suppress bogus "conditional expression is constant" +// warnings. +template +inline T const_check(T value) +{ + return value; +} +} // namespace internal +FMT_END_NAMESPACE + +namespace std { +// Standard permits specialization of std::numeric_limits. This specialization +// is used to resolve ambiguity between isinf and std::isinf in glibc: +// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=48891 +// and the same for isnan and signbit. +template<> +class numeric_limits : public std::numeric_limits +{ +public: + // Portable version of isinf. + template + static bool isinfinity(T x) + { + using namespace fmt::internal; + // The resolution "priority" is: + // isinf macro > std::isinf > ::isinf > fmt::internal::isinf + if (const_check(sizeof(isinf(x)) != sizeof(dummy_int))) + return isinf(x) != 0; + return !_finite(static_cast(x)); + } + + // Portable version of isnan. + template + static bool isnotanumber(T x) + { + using namespace fmt::internal; + if (const_check(sizeof(isnan(x)) != sizeof(fmt::internal::dummy_int))) + return isnan(x) != 0; + return _isnan(static_cast(x)) != 0; + } + + // Portable version of signbit. + static bool isnegative(double x) + { + using namespace fmt::internal; + if (const_check(sizeof(signbit(x)) != sizeof(fmt::internal::dummy_int))) + return signbit(x) != 0; + if (x < 0) + return true; + if (!isnotanumber(x)) + return false; + int dec = 0, sign = 0; + char buffer[2]; // The buffer size must be >= 2 or _ecvt_s will fail. + _ecvt_s(buffer, sizeof(buffer), x, 0, &dec, &sign); + return sign != 0; + } +}; +} // namespace std + +FMT_BEGIN_NAMESPACE +template +class basic_writer; + +template +class output_range +{ +private: + OutputIt it_; + + // Unused yet. + typedef void sentinel; + sentinel end() const; + +public: + typedef OutputIt iterator; + typedef T value_type; + + explicit output_range(OutputIt it) + : it_(it) + { + } + OutputIt begin() const + { + return it_; + } +}; + +// A range where begin() returns back_insert_iterator. +template +class back_insert_range : public output_range> +{ + typedef output_range> base; + +public: + typedef typename Container::value_type value_type; + + back_insert_range(Container &c) + : base(std::back_inserter(c)) + { + } + back_insert_range(typename base::iterator it) + : base(it) + { + } +}; + +typedef basic_writer> writer; +typedef basic_writer> wwriter; + +/** A formatting error such as invalid format string. */ +class format_error : public std::runtime_error +{ +public: + explicit format_error(const char *message) + : std::runtime_error(message) + { + } + + explicit format_error(const std::string &message) + : std::runtime_error(message) + { + } +}; + +namespace internal { + +// Casts nonnegative integer to unsigned. +template +FMT_CONSTEXPR typename std::make_unsigned::type to_unsigned(Int value) +{ + FMT_ASSERT(value >= 0, "negative value"); + return static_cast::type>(value); +} + +#if FMT_SECURE_SCL +template +struct checked +{ + typedef stdext::checked_array_iterator type; +}; + +// Make a checked iterator to avoid warnings on MSVC. +template +inline stdext::checked_array_iterator make_checked(T *p, std::size_t size) +{ + return {p, size}; +} +#else +template +struct checked +{ + typedef T *type; +}; +template +inline T *make_checked(T *p, std::size_t) +{ + return p; +} +#endif + +template +template +void basic_buffer::append(const U *begin, const U *end) +{ + std::size_t new_size = size_ + internal::to_unsigned(end - begin); + reserve(new_size); + std::uninitialized_copy(begin, end, internal::make_checked(ptr_, capacity_) + size_); + size_ = new_size; +} +} // namespace internal + +// A wrapper around std::locale used to reduce compile times since +// is very heavy. +class locale; + +class locale_provider +{ +public: + virtual ~locale_provider() {} + virtual fmt::locale locale(); +}; + +// The number of characters to store in the basic_memory_buffer object itself +// to avoid dynamic memory allocation. +enum +{ + inline_buffer_size = 500 +}; + +/** + \rst + A dynamically growing memory buffer for trivially copyable/constructible types + with the first ``SIZE`` elements stored in the object itself. + + You can use one of the following typedefs for common character types: + + +----------------+------------------------------+ + | Type | Definition | + +================+==============================+ + | memory_buffer | basic_memory_buffer | + +----------------+------------------------------+ + | wmemory_buffer | basic_memory_buffer | + +----------------+------------------------------+ + + **Example**:: + + fmt::memory_buffer out; + format_to(out, "The answer is {}.", 42); + + This will write the following output to the ``out`` object: + + .. code-block:: none + + The answer is 42. + + The output can be converted to an ``std::string`` with ``to_string(out)``. + \endrst + */ +template> +class basic_memory_buffer : private Allocator, public internal::basic_buffer +{ +private: + T store_[SIZE]; + + // Deallocate memory allocated by the buffer. + void deallocate() + { + T *data = this->data(); + if (data != store_) + Allocator::deallocate(data, this->capacity()); + } + +protected: + void grow(std::size_t size) FMT_OVERRIDE; + +public: + explicit basic_memory_buffer(const Allocator &alloc = Allocator()) + : Allocator(alloc) + { + this->set(store_, SIZE); + } + ~basic_memory_buffer() + { + deallocate(); + } + +private: + // Move data from other to this buffer. + void move(basic_memory_buffer &other) + { + Allocator &this_alloc = *this, &other_alloc = other; + this_alloc = std::move(other_alloc); + T *data = other.data(); + std::size_t size = other.size(), capacity = other.capacity(); + if (data == other.store_) + { + this->set(store_, capacity); + std::uninitialized_copy(other.store_, other.store_ + size, internal::make_checked(store_, capacity)); + } + else + { + this->set(data, capacity); + // Set pointer to the inline array so that delete is not called + // when deallocating. + other.set(other.store_, 0); + } + this->resize(size); + } + +public: + /** + \rst + Constructs a :class:`fmt::basic_memory_buffer` object moving the content + of the other object to it. + \endrst + */ + basic_memory_buffer(basic_memory_buffer &&other) + { + move(other); + } + + /** + \rst + Moves the content of the other ``basic_memory_buffer`` object to this one. + \endrst + */ + basic_memory_buffer &operator=(basic_memory_buffer &&other) + { + assert(this != &other); + deallocate(); + move(other); + return *this; + } + + // Returns a copy of the allocator associated with this buffer. + Allocator get_allocator() const + { + return *this; + } +}; + +template +void basic_memory_buffer::grow(std::size_t size) +{ + std::size_t old_capacity = this->capacity(); + std::size_t new_capacity = old_capacity + old_capacity / 2; + if (size > new_capacity) + new_capacity = size; + T *old_data = this->data(); + T *new_data = internal::allocate(*this, new_capacity); + // The following code doesn't throw, so the raw pointer above doesn't leak. + std::uninitialized_copy(old_data, old_data + this->size(), internal::make_checked(new_data, new_capacity)); + this->set(new_data, new_capacity); + // deallocate must not throw according to the standard, but even if it does, + // the buffer already uses the new storage and will deallocate it in + // destructor. + if (old_data != store_) + Allocator::deallocate(old_data, old_capacity); +} + +typedef basic_memory_buffer memory_buffer; +typedef basic_memory_buffer wmemory_buffer; + +/** + \rst + A fixed-size memory buffer. For a dynamically growing buffer use + :class:`fmt::basic_memory_buffer`. + + Trying to increase the buffer size past the initial capacity will throw + ``std::runtime_error``. + \endrst + */ +template +class basic_fixed_buffer : public internal::basic_buffer +{ +public: + /** + \rst + Constructs a :class:`fmt::basic_fixed_buffer` object for *array* of the + given size. + \endrst + */ + basic_fixed_buffer(Char *array, std::size_t size) + { + this->set(array, size); + } + + /** + \rst + Constructs a :class:`fmt::basic_fixed_buffer` object for *array* of the + size known at compile time. + \endrst + */ + template + explicit basic_fixed_buffer(Char (&array)[SIZE]) + { + this->set(array, SIZE); + } + +protected: + FMT_API void grow(std::size_t size) FMT_OVERRIDE; +}; + +namespace internal { + +template +struct char_traits; + +template<> +struct char_traits +{ + // Formats a floating-point number. + template + FMT_API static int format_float(char *buffer, std::size_t size, const char *format, int precision, T value); +}; + +template<> +struct char_traits +{ + template + FMT_API static int format_float(wchar_t *buffer, std::size_t size, const wchar_t *format, int precision, T value); +}; + +#if FMT_USE_EXTERN_TEMPLATES +extern template int char_traits::format_float( + char *buffer, std::size_t size, const char *format, int precision, double value); +extern template int char_traits::format_float( + char *buffer, std::size_t size, const char *format, int precision, long double value); + +extern template int char_traits::format_float( + wchar_t *buffer, std::size_t size, const wchar_t *format, int precision, double value); +extern template int char_traits::format_float( + wchar_t *buffer, std::size_t size, const wchar_t *format, int precision, long double value); +#endif + +template +inline typename std::enable_if::value, typename checked::type>::type reserve( + std::back_insert_iterator &it, std::size_t n) +{ + Container &c = internal::get_container(it); + std::size_t size = c.size(); + c.resize(size + n); + return make_checked(&c[size], n); +} + +template +inline Iterator &reserve(Iterator &it, std::size_t) +{ + return it; +} + +template +class null_terminating_iterator; + +template +FMT_CONSTEXPR_DECL const Char *pointer_from(null_terminating_iterator it); + +// An iterator that produces a null terminator on *end. This simplifies parsing +// and allows comparing the performance of processing a null-terminated string +// vs string_view. +template +class null_terminating_iterator +{ +public: + typedef std::ptrdiff_t difference_type; + typedef Char value_type; + typedef const Char *pointer; + typedef const Char &reference; + typedef std::random_access_iterator_tag iterator_category; + + null_terminating_iterator() + : ptr_(0) + , end_(0) + { + } + + FMT_CONSTEXPR null_terminating_iterator(const Char *ptr, const Char *end) + : ptr_(ptr) + , end_(end) + { + } + + template + FMT_CONSTEXPR explicit null_terminating_iterator(const Range &r) + : ptr_(r.begin()) + , end_(r.end()) + { + } + + null_terminating_iterator &operator=(const Char *ptr) + { + assert(ptr <= end_); + ptr_ = ptr; + return *this; + } + + FMT_CONSTEXPR Char operator*() const + { + return ptr_ != end_ ? *ptr_ : 0; + } + + FMT_CONSTEXPR null_terminating_iterator operator++() + { + ++ptr_; + return *this; + } + + FMT_CONSTEXPR null_terminating_iterator operator++(int) + { + null_terminating_iterator result(*this); + ++ptr_; + return result; + } + + FMT_CONSTEXPR null_terminating_iterator operator--() + { + --ptr_; + return *this; + } + + FMT_CONSTEXPR null_terminating_iterator operator+(difference_type n) + { + return null_terminating_iterator(ptr_ + n, end_); + } + + FMT_CONSTEXPR null_terminating_iterator operator-(difference_type n) + { + return null_terminating_iterator(ptr_ - n, end_); + } + + FMT_CONSTEXPR null_terminating_iterator operator+=(difference_type n) + { + ptr_ += n; + return *this; + } + + FMT_CONSTEXPR difference_type operator-(null_terminating_iterator other) const + { + return ptr_ - other.ptr_; + } + + FMT_CONSTEXPR bool operator!=(null_terminating_iterator other) const + { + return ptr_ != other.ptr_; + } + + bool operator>=(null_terminating_iterator other) const + { + return ptr_ >= other.ptr_; + } + + // This should be a friend specialization pointer_from but the latter + // doesn't compile by gcc 5.1 due to a compiler bug. + template + friend FMT_CONSTEXPR_DECL const CharT *pointer_from(null_terminating_iterator it); + +private: + const Char *ptr_; + const Char *end_; +}; + +template +FMT_CONSTEXPR const T *pointer_from(const T *p) +{ + return p; +} + +template +FMT_CONSTEXPR const Char *pointer_from(null_terminating_iterator it) +{ + return it.ptr_; +} + +// An output iterator that counts the number of objects written to it and +// discards them. +template +class counting_iterator +{ +private: + std::size_t count_; + mutable T blackhole_; + +public: + typedef std::output_iterator_tag iterator_category; + typedef T value_type; + typedef std::ptrdiff_t difference_type; + typedef T *pointer; + typedef T &reference; + typedef counting_iterator _Unchecked_type; // Mark iterator as checked. + + counting_iterator() + : count_(0) + { + } + + std::size_t count() const + { + return count_; + } + + counting_iterator &operator++() + { + ++count_; + return *this; + } + + counting_iterator operator++(int) + { + auto it = *this; + ++*this; + return it; + } + + T &operator*() const + { + return blackhole_; + } +}; + +// An output iterator that truncates the output and counts the number of objects +// written to it. +template +class truncating_iterator +{ +private: + typedef std::iterator_traits traits; + + OutputIt out_; + std::size_t limit_; + std::size_t count_; + mutable typename traits::value_type blackhole_; + +public: + typedef std::output_iterator_tag iterator_category; + typedef typename traits::value_type value_type; + typedef typename traits::difference_type difference_type; + typedef typename traits::pointer pointer; + typedef typename traits::reference reference; + typedef truncating_iterator _Unchecked_type; // Mark iterator as checked. + + truncating_iterator(OutputIt out, std::size_t limit) + : out_(out) + , limit_(limit) + , count_(0) + { + } + + OutputIt base() const + { + return out_; + } + std::size_t count() const + { + return count_; + } + + truncating_iterator &operator++() + { + if (count_++ < limit_) + ++out_; + return *this; + } + + truncating_iterator operator++(int) + { + auto it = *this; + ++*this; + return it; + } + + reference operator*() const + { + return count_ < limit_ ? *out_ : blackhole_; + } +}; + +// Returns true if value is negative, false otherwise. +// Same as (value < 0) but doesn't produce warnings if T is an unsigned type. +template +FMT_CONSTEXPR typename std::enable_if::is_signed, bool>::type is_negative(T value) +{ + return value < 0; +} +template +FMT_CONSTEXPR typename std::enable_if::is_signed, bool>::type is_negative(T) +{ + return false; +} + +template +struct int_traits +{ + // Smallest of uint32_t and uint64_t that is large enough to represent + // all values of T. + typedef typename std::conditional::digits <= 32, uint32_t, uint64_t>::type main_type; +}; + +// Static data is placed in this class template to allow header-only +// configuration. +template +struct FMT_API basic_data +{ + static const uint32_t POWERS_OF_10_32[]; + static const uint64_t POWERS_OF_10_64[]; + static const uint64_t POW10_SIGNIFICANDS[]; + static const int16_t POW10_EXPONENTS[]; + static const char DIGITS[]; +}; + +#if FMT_USE_EXTERN_TEMPLATES +extern template struct basic_data; +#endif + +typedef basic_data<> data; + +#ifdef FMT_BUILTIN_CLZLL +// Returns the number of decimal digits in n. Leading zeros are not counted +// except for n == 0 in which case count_digits returns 1. +inline unsigned count_digits(uint64_t n) +{ + // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10 + // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits. + int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12; + return to_unsigned(t) - (n < data::POWERS_OF_10_64[t]) + 1; +} +#else +// Fallback version of count_digits used when __builtin_clz is not available. +inline unsigned count_digits(uint64_t n) +{ + unsigned count = 1; + for (;;) + { + // Integer division is slow so do it for a group of four digits instead + // of for every digit. The idea comes from the talk by Alexandrescu + // "Three Optimization Tips for C++". See speed-test for a comparison. + if (n < 10) + return count; + if (n < 100) + return count + 1; + if (n < 1000) + return count + 2; + if (n < 10000) + return count + 3; + n /= 10000u; + count += 4; + } +} +#endif + +#if FMT_HAS_CPP_ATTRIBUTE(always_inline) +#define FMT_ALWAYS_INLINE __attribute__((always_inline)) +#else +#define FMT_ALWAYS_INLINE +#endif + +template +inline char *lg(uint32_t n, Handler h) FMT_ALWAYS_INLINE; + +// Computes g = floor(log10(n)) and calls h.on(n); +template +inline char *lg(uint32_t n, Handler h) +{ + return n < 100 ? n < 10 ? h.template on<0>(n) : h.template on<1>(n) + : n < 1000000 ? n < 10000 ? n < 1000 ? h.template on<2>(n) : h.template on<3>(n) + : n < 100000 ? h.template on<4>(n) : h.template on<5>(n) + : n < 100000000 ? n < 10000000 ? h.template on<6>(n) : h.template on<7>(n) + : n < 1000000000 ? h.template on<8>(n) : h.template on<9>(n); +} + +// An lg handler that formats a decimal number. +// Usage: lg(n, decimal_formatter(buffer)); +class decimal_formatter +{ +private: + char *buffer_; + + void write_pair(unsigned N, uint32_t index) + { + std::memcpy(buffer_ + N, data::DIGITS + index * 2, 2); + } + +public: + explicit decimal_formatter(char *buf) + : buffer_(buf) + { + } + + template + char *on(uint32_t u) + { + if (N == 0) + { + *buffer_ = static_cast(u) + '0'; + } + else if (N == 1) + { + write_pair(0, u); + } + else + { + // The idea of using 4.32 fixed-point numbers is based on + // https://github.com/jeaiii/itoa + unsigned n = N - 1; + unsigned a = n / 5 * n * 53 / 16; + uint64_t t = ((1ULL << (32 + a)) / data::POWERS_OF_10_32[n] + 1 - n / 9); + t = ((t * u) >> a) + n / 5 * 4; + write_pair(0, t >> 32); + for (int i = 2; i < N; i += 2) + { + t = 100ULL * static_cast(t); + write_pair(i, t >> 32); + } + if (N % 2 == 0) + { + buffer_[N] = static_cast((10ULL * static_cast(t)) >> 32) + '0'; + } + } + return buffer_ += N + 1; + } +}; + +// An lg handler that formats a decimal number with a terminating null. +class decimal_formatter_null : public decimal_formatter +{ +public: + explicit decimal_formatter_null(char *buf) + : decimal_formatter(buf) + { + } + + template + char *on(uint32_t u) + { + char *buf = decimal_formatter::on(u); + *buf = '\0'; + return buf; + } +}; + +#ifdef FMT_BUILTIN_CLZ +// Optional version of count_digits for better performance on 32-bit platforms. +inline unsigned count_digits(uint32_t n) +{ + int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12; + return to_unsigned(t) - (n < data::POWERS_OF_10_32[t]) + 1; +} +#endif + +// A functor that doesn't add a thousands separator. +struct no_thousands_sep +{ + typedef char char_type; + + template + void operator()(Char *) + { + } +}; + +// A functor that adds a thousands separator. +template +class add_thousands_sep +{ +private: + basic_string_view sep_; + + // Index of a decimal digit with the least significant digit having index 0. + unsigned digit_index_; + +public: + typedef Char char_type; + + explicit add_thousands_sep(basic_string_view sep) + : sep_(sep) + , digit_index_(0) + { + } + + void operator()(Char *&buffer) + { + if (++digit_index_ % 3 != 0) + return; + buffer -= sep_.size(); + std::uninitialized_copy(sep_.data(), sep_.data() + sep_.size(), internal::make_checked(buffer, sep_.size())); + } +}; + +template +FMT_API Char thousands_sep(locale_provider *lp); + +// Formats a decimal unsigned integer value writing into buffer. +// thousands_sep is a functor that is called after writing each char to +// add a thousands separator if necessary. +template +inline Char *format_decimal(Char *buffer, UInt value, unsigned num_digits, ThousandsSep thousands_sep) +{ + buffer += num_digits; + Char *end = buffer; + while (value >= 100) + { + // Integer division is slow so do it for a group of two digits instead + // of for every digit. The idea comes from the talk by Alexandrescu + // "Three Optimization Tips for C++". See speed-test for a comparison. + unsigned index = static_cast((value % 100) * 2); + value /= 100; + *--buffer = data::DIGITS[index + 1]; + thousands_sep(buffer); + *--buffer = data::DIGITS[index]; + thousands_sep(buffer); + } + if (value < 10) + { + *--buffer = static_cast('0' + value); + return end; + } + unsigned index = static_cast(value * 2); + *--buffer = data::DIGITS[index + 1]; + thousands_sep(buffer); + *--buffer = data::DIGITS[index]; + return end; +} + +template +inline Iterator format_decimal(Iterator out, UInt value, unsigned num_digits, ThousandsSep sep) +{ + typedef typename ThousandsSep::char_type char_type; + // Buffer should be large enough to hold all digits (digits10 + 1) and null. + char_type buffer[std::numeric_limits::digits10 + 2]; + format_decimal(buffer, value, num_digits, sep); + return std::copy_n(buffer, num_digits, out); +} + +template +inline It format_decimal(It out, UInt value, unsigned num_digits) +{ + return format_decimal(out, value, num_digits, no_thousands_sep()); +} + +template +inline Char *format_uint(Char *buffer, UInt value, unsigned num_digits, bool upper = false) +{ + buffer += num_digits; + Char *end = buffer; + do + { + const char *digits = upper ? "0123456789ABCDEF" : "0123456789abcdef"; + unsigned digit = (value & ((1 << BASE_BITS) - 1)); + *--buffer = BASE_BITS < 4 ? static_cast('0' + digit) : digits[digit]; + } while ((value >>= BASE_BITS) != 0); + return end; +} + +template +inline It format_uint(It out, UInt value, unsigned num_digits, bool upper = false) +{ + // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1) + // and null. + char buffer[std::numeric_limits::digits / BASE_BITS + 2]; + format_uint(buffer, value, num_digits, upper); + return std::copy_n(buffer, num_digits, out); +} + +#ifndef _WIN32 +#define FMT_USE_WINDOWS_H 0 +#elif !defined(FMT_USE_WINDOWS_H) +#define FMT_USE_WINDOWS_H 1 +#endif + +// Define FMT_USE_WINDOWS_H to 0 to disable use of windows.h. +// All the functionality that relies on it will be disabled too. +#if FMT_USE_WINDOWS_H +// A converter from UTF-8 to UTF-16. +// It is only provided for Windows since other systems support UTF-8 natively. +class utf8_to_utf16 +{ +private: + wmemory_buffer buffer_; + +public: + FMT_API explicit utf8_to_utf16(string_view s); + operator wstring_view() const + { + return wstring_view(&buffer_[0], size()); + } + size_t size() const + { + return buffer_.size() - 1; + } + const wchar_t *c_str() const + { + return &buffer_[0]; + } + std::wstring str() const + { + return std::wstring(&buffer_[0], size()); + } +}; + +// A converter from UTF-16 to UTF-8. +// It is only provided for Windows since other systems support UTF-8 natively. +class utf16_to_utf8 +{ +private: + memory_buffer buffer_; + +public: + utf16_to_utf8() {} + FMT_API explicit utf16_to_utf8(wstring_view s); + operator string_view() const + { + return string_view(&buffer_[0], size()); + } + size_t size() const + { + return buffer_.size() - 1; + } + const char *c_str() const + { + return &buffer_[0]; + } + std::string str() const + { + return std::string(&buffer_[0], size()); + } + + // Performs conversion returning a system error code instead of + // throwing exception on conversion error. This method may still throw + // in case of memory allocation error. + FMT_API int convert(wstring_view s); +}; + +FMT_API void format_windows_error(fmt::internal::buffer &out, int error_code, fmt::string_view message) FMT_NOEXCEPT; +#endif + +template +struct null +{ +}; +} // namespace internal + +struct monostate +{ +}; + +/** + \rst + Visits an argument dispatching to the appropriate visit method based on + the argument type. For example, if the argument type is ``double`` then + ``vis(value)`` will be called with the value of type ``double``. + \endrst + */ +template +FMT_CONSTEXPR typename internal::result_of::type visit(Visitor &&vis, basic_format_arg arg) +{ + typedef typename Context::char_type char_type; + switch (arg.type_) + { + case internal::none_type: + break; + case internal::named_arg_type: + FMT_ASSERT(false, "invalid argument type"); + break; + case internal::int_type: + return vis(arg.value_.int_value); + case internal::uint_type: + return vis(arg.value_.uint_value); + case internal::long_long_type: + return vis(arg.value_.long_long_value); + case internal::ulong_long_type: + return vis(arg.value_.ulong_long_value); + case internal::bool_type: + return vis(arg.value_.int_value != 0); + case internal::char_type: + return vis(static_cast(arg.value_.int_value)); + case internal::double_type: + return vis(arg.value_.double_value); + case internal::long_double_type: + return vis(arg.value_.long_double_value); + case internal::cstring_type: + return vis(arg.value_.string.value); + case internal::string_type: + return vis(basic_string_view(arg.value_.string.value, arg.value_.string.size)); + case internal::pointer_type: + return vis(arg.value_.pointer); + case internal::custom_type: + return vis(typename basic_format_arg::handle(arg.value_.custom)); + } + return vis(monostate()); +} + +enum alignment +{ + ALIGN_DEFAULT, + ALIGN_LEFT, + ALIGN_RIGHT, + ALIGN_CENTER, + ALIGN_NUMERIC +}; + +// Flags. +enum +{ + SIGN_FLAG = 1, + PLUS_FLAG = 2, + MINUS_FLAG = 4, + HASH_FLAG = 8 +}; + +enum format_spec_tag +{ + fill_tag, + align_tag, + width_tag, + type_tag +}; + +// Format specifier. +template +class format_spec +{ +private: + T value_; + +public: + typedef T value_type; + + explicit format_spec(T value) + : value_(value) + { + } + + T value() const + { + return value_; + } +}; + +// template +// typedef format_spec fill_spec; +template +class fill_spec : public format_spec +{ +public: + explicit fill_spec(Char value) + : format_spec(value) + { + } +}; + +typedef format_spec width_spec; +typedef format_spec type_spec; + +// An empty format specifier. +struct empty_spec +{ +}; + +// An alignment specifier. +struct align_spec : empty_spec +{ + unsigned width_; + // Fill is always wchar_t and cast to char if necessary to avoid having + // two specialization of AlignSpec and its subclasses. + wchar_t fill_; + alignment align_; + + FMT_CONSTEXPR align_spec(unsigned width, wchar_t fill, alignment align = ALIGN_DEFAULT) + : width_(width) + , fill_(fill) + , align_(align) + { + } + + FMT_CONSTEXPR unsigned width() const + { + return width_; + } + FMT_CONSTEXPR wchar_t fill() const + { + return fill_; + } + FMT_CONSTEXPR alignment align() const + { + return align_; + } + + int precision() const + { + return -1; + } +}; + +// Format specifiers. +template +class basic_format_specs : public align_spec +{ +private: + template + typename std::enable_if::value || std::is_same::value, void>::type set( + fill_spec fill) + { + fill_ = fill.value(); + } + + void set(width_spec width) + { + width_ = width.value(); + } + + void set(type_spec type) + { + type_ = type.value(); + } + + template + void set(Spec spec, Specs... tail) + { + set(spec); + set(tail...); + } + +public: + unsigned flags_; + int precision_; + Char type_; + + FMT_CONSTEXPR basic_format_specs(unsigned width = 0, char type = 0, wchar_t fill = ' ') + : align_spec(width, fill) + , flags_(0) + , precision_(-1) + , type_(type) + { + } + + template + explicit basic_format_specs(FormatSpecs... specs) + : align_spec(0, ' ') + , flags_(0) + , precision_(-1) + , type_(0) + { + set(specs...); + } + + FMT_CONSTEXPR bool flag(unsigned f) const + { + return (flags_ & f) != 0; + } + FMT_CONSTEXPR int precision() const + { + return precision_; + } + FMT_CONSTEXPR Char type() const + { + return type_; + } +}; + +typedef basic_format_specs format_specs; + +template +FMT_CONSTEXPR unsigned basic_parse_context::next_arg_id() +{ + if (next_arg_id_ >= 0) + return internal::to_unsigned(next_arg_id_++); + on_error("cannot switch from manual to automatic argument indexing"); + return 0; +} + +struct format_string +{ +}; + +namespace internal { + +template +FMT_CONSTEXPR void handle_int_type_spec(Char spec, Handler &&handler) +{ + switch (spec) + { + case 0: + case 'd': + handler.on_dec(); + break; + case 'x': + case 'X': + handler.on_hex(); + break; + case 'b': + case 'B': + handler.on_bin(); + break; + case 'o': + handler.on_oct(); + break; + case 'n': + handler.on_num(); + break; + default: + handler.on_error(); + } +} + +template +FMT_CONSTEXPR void handle_float_type_spec(Char spec, Handler &&handler) +{ + switch (spec) + { + case 0: + case 'g': + case 'G': + handler.on_general(); + break; + case 'e': + case 'E': + handler.on_exp(); + break; + case 'f': + case 'F': + handler.on_fixed(); + break; + case 'a': + case 'A': + handler.on_hex(); + break; + default: + handler.on_error(); + break; + } +} + +template +FMT_CONSTEXPR void handle_char_specs(const basic_format_specs &specs, Handler &&handler) +{ + if (specs.type() && specs.type() != 'c') + { + handler.on_int(); + return; + } + if (specs.align() == ALIGN_NUMERIC || specs.flag(~0u) != 0) + handler.on_error("invalid format specifier for char"); + handler.on_char(); +} + +template +FMT_CONSTEXPR void handle_cstring_type_spec(Char spec, Handler &&handler) +{ + if (spec == 0 || spec == 's') + handler.on_string(); + else if (spec == 'p') + handler.on_pointer(); + else + handler.on_error("invalid type specifier"); +} + +template +FMT_CONSTEXPR void check_string_type_spec(Char spec, ErrorHandler &&eh) +{ + if (spec != 0 && spec != 's') + eh.on_error("invalid type specifier"); +} + +template +FMT_CONSTEXPR void check_pointer_type_spec(Char spec, ErrorHandler &&eh) +{ + if (spec != 0 && spec != 'p') + eh.on_error("invalid type specifier"); +} + +template +class int_type_checker : private ErrorHandler +{ +public: + FMT_CONSTEXPR explicit int_type_checker(ErrorHandler eh) + : ErrorHandler(eh) + { + } + + FMT_CONSTEXPR void on_dec() {} + FMT_CONSTEXPR void on_hex() {} + FMT_CONSTEXPR void on_bin() {} + FMT_CONSTEXPR void on_oct() {} + FMT_CONSTEXPR void on_num() {} + + FMT_CONSTEXPR void on_error() + { + ErrorHandler::on_error("invalid type specifier"); + } +}; + +template +class float_type_checker : private ErrorHandler +{ +public: + FMT_CONSTEXPR explicit float_type_checker(ErrorHandler eh) + : ErrorHandler(eh) + { + } + + FMT_CONSTEXPR void on_general() {} + FMT_CONSTEXPR void on_exp() {} + FMT_CONSTEXPR void on_fixed() {} + FMT_CONSTEXPR void on_hex() {} + + FMT_CONSTEXPR void on_error() + { + ErrorHandler::on_error("invalid type specifier"); + } +}; + +template +class char_specs_checker : public ErrorHandler +{ +private: + CharType type_; + +public: + FMT_CONSTEXPR char_specs_checker(CharType type, ErrorHandler eh) + : ErrorHandler(eh) + , type_(type) + { + } + + FMT_CONSTEXPR void on_int() + { + handle_int_type_spec(type_, int_type_checker(*this)); + } + FMT_CONSTEXPR void on_char() {} +}; + +template +class cstring_type_checker : public ErrorHandler +{ +public: + FMT_CONSTEXPR explicit cstring_type_checker(ErrorHandler eh) + : ErrorHandler(eh) + { + } + + FMT_CONSTEXPR void on_string() {} + FMT_CONSTEXPR void on_pointer() {} +}; + +template +void arg_map::init(const basic_format_args &args) +{ + if (map_) + return; + map_ = new entry[args.max_size()]; + bool use_values = args.type(max_packed_args - 1) == internal::none_type; + if (use_values) + { + for (unsigned i = 0; /*nothing*/; ++i) + { + internal::type arg_type = args.type(i); + switch (arg_type) + { + case internal::none_type: + return; + case internal::named_arg_type: + push_back(args.values_[i]); + break; + default: + break; // Do nothing. + } + } + return; + } + for (unsigned i = 0;; ++i) + { + switch (args.args_[i].type_) + { + case internal::none_type: + return; + case internal::named_arg_type: + push_back(args.args_[i].value_); + break; + default: + break; // Do nothing. + } + } +} + +template +class arg_formatter_base +{ +public: + typedef typename Range::value_type char_type; + typedef decltype(internal::declval().begin()) iterator; + typedef basic_format_specs format_specs; + +private: + typedef basic_writer writer_type; + writer_type writer_; + format_specs &specs_; + + FMT_DISALLOW_COPY_AND_ASSIGN(arg_formatter_base); + + struct char_writer + { + char_type value; + template + void operator()(It &&it) const + { + *it++ = value; + } + }; + + void write_char(char_type value) + { + writer_.write_padded(1, specs_, char_writer{value}); + } + + void write_pointer(const void *p) + { + format_specs specs = specs_; + specs.flags_ = HASH_FLAG; + specs.type_ = 'x'; + writer_.write_int(reinterpret_cast(p), specs); + } + +protected: + writer_type &writer() + { + return writer_; + } + format_specs &spec() + { + return specs_; + } + iterator out() + { + return writer_.out(); + } + + void write(bool value) + { + writer_.write_str(string_view(value ? "true" : "false"), specs_); + } + + void write(const char_type *value) + { + if (!value) + FMT_THROW(format_error("string pointer is null")); + auto length = std::char_traits::length(value); + writer_.write_str(basic_string_view(value, length), specs_); + } + +public: + arg_formatter_base(Range r, format_specs &s) + : writer_(r) + , specs_(s) + { + } + + iterator operator()(monostate) + { + FMT_ASSERT(false, "invalid argument type"); + return out(); + } + + template + typename std::enable_if::value, iterator>::type operator()(T value) + { + writer_.write_int(value, specs_); + return out(); + } + + template + typename std::enable_if::value, iterator>::type operator()(T value) + { + writer_.write_double(value, specs_); + return out(); + } + + iterator operator()(bool value) + { + if (specs_.type_) + return (*this)(value ? 1 : 0); + write(value); + return out(); + } + + struct char_spec_handler : internal::error_handler + { + arg_formatter_base &formatter; + char_type value; + + char_spec_handler(arg_formatter_base &f, char_type val) + : formatter(f) + , value(val) + { + } + + void on_int() + { + formatter.writer_.write_int(value, formatter.specs_); + } + void on_char() + { + formatter.write_char(value); + } + }; + + iterator operator()(char_type value) + { + internal::handle_char_specs(specs_, char_spec_handler(*this, value)); + return out(); + } + + struct cstring_spec_handler : internal::error_handler + { + arg_formatter_base &formatter; + const char_type *value; + + cstring_spec_handler(arg_formatter_base &f, const char_type *val) + : formatter(f) + , value(val) + { + } + + void on_string() + { + formatter.write(value); + } + void on_pointer() + { + formatter.write_pointer(value); + } + }; + + iterator operator()(const char_type *value) + { + internal::handle_cstring_type_spec(specs_.type_, cstring_spec_handler(*this, value)); + return out(); + } + + iterator operator()(basic_string_view value) + { + internal::check_string_type_spec(specs_.type_, internal::error_handler()); + writer_.write_str(value, specs_); + return out(); + } + + iterator operator()(const void *value) + { + check_pointer_type_spec(specs_.type_, internal::error_handler()); + write_pointer(value); + return out(); + } +}; + +template +struct is_format_string : std::integral_constant::value> +{ +}; + +template +FMT_CONSTEXPR bool is_name_start(Char c) +{ + return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c; +} + +// Parses the input as an unsigned integer. This function assumes that the +// first character is a digit and presence of a non-digit character at the end. +// it: an iterator pointing to the beginning of the input range. +template +FMT_CONSTEXPR unsigned parse_nonnegative_int(Iterator &it, ErrorHandler &&eh) +{ + assert('0' <= *it && *it <= '9'); + unsigned value = 0; + // Convert to unsigned to prevent a warning. + unsigned max_int = (std::numeric_limits::max)(); + unsigned big = max_int / 10; + do + { + // Check for overflow. + if (value > big) + { + value = max_int + 1; + break; + } + value = value * 10 + (*it - '0'); + // Workaround for MSVC "setup_exception stack overflow" error: + auto next = it; + ++next; + it = next; + } while ('0' <= *it && *it <= '9'); + if (value > max_int) + eh.on_error("number is too big"); + return value; +} + +template +class custom_formatter : public function +{ +private: + Context &ctx_; + +public: + explicit custom_formatter(Context &ctx) + : ctx_(ctx) + { + } + + bool operator()(typename basic_format_arg::handle h) const + { + h.format(ctx_); + return true; + } + + template + bool operator()(T) const + { + return false; + } +}; + +template +struct is_integer +{ + enum + { + value = + std::is_integral::value && !std::is_same::value && !std::is_same::value && !std::is_same::value + }; +}; + +template +class width_checker : public function +{ +public: + explicit FMT_CONSTEXPR width_checker(ErrorHandler &eh) + : handler_(eh) + { + } + + template + FMT_CONSTEXPR typename std::enable_if::value, unsigned long long>::type operator()(T value) + { + if (is_negative(value)) + handler_.on_error("negative width"); + return value; + } + + template + FMT_CONSTEXPR typename std::enable_if::value, unsigned long long>::type operator()(T) + { + handler_.on_error("width is not integer"); + return 0; + } + +private: + ErrorHandler &handler_; +}; + +template +class precision_checker : public function +{ +public: + explicit FMT_CONSTEXPR precision_checker(ErrorHandler &eh) + : handler_(eh) + { + } + + template + FMT_CONSTEXPR typename std::enable_if::value, unsigned long long>::type operator()(T value) + { + if (is_negative(value)) + handler_.on_error("negative precision"); + return value; + } + + template + FMT_CONSTEXPR typename std::enable_if::value, unsigned long long>::type operator()(T) + { + handler_.on_error("precision is not integer"); + return 0; + } + +private: + ErrorHandler &handler_; +}; + +// A format specifier handler that sets fields in basic_format_specs. +template +class specs_setter +{ +public: + explicit FMT_CONSTEXPR specs_setter(basic_format_specs &specs) + : specs_(specs) + { + } + + FMT_CONSTEXPR specs_setter(const specs_setter &other) + : specs_(other.specs_) + { + } + + FMT_CONSTEXPR void on_align(alignment align) + { + specs_.align_ = align; + } + FMT_CONSTEXPR void on_fill(Char fill) + { + specs_.fill_ = fill; + } + FMT_CONSTEXPR void on_plus() + { + specs_.flags_ |= SIGN_FLAG | PLUS_FLAG; + } + FMT_CONSTEXPR void on_minus() + { + specs_.flags_ |= MINUS_FLAG; + } + FMT_CONSTEXPR void on_space() + { + specs_.flags_ |= SIGN_FLAG; + } + FMT_CONSTEXPR void on_hash() + { + specs_.flags_ |= HASH_FLAG; + } + + FMT_CONSTEXPR void on_zero() + { + specs_.align_ = ALIGN_NUMERIC; + specs_.fill_ = '0'; + } + + FMT_CONSTEXPR void on_width(unsigned width) + { + specs_.width_ = width; + } + FMT_CONSTEXPR void on_precision(unsigned precision) + { + specs_.precision_ = precision; + } + FMT_CONSTEXPR void end_precision() {} + + FMT_CONSTEXPR void on_type(Char type) + { + specs_.type_ = type; + } + +protected: + basic_format_specs &specs_; +}; + +// A format specifier handler that checks if specifiers are consistent with the +// argument type. +template +class specs_checker : public Handler +{ +public: + FMT_CONSTEXPR specs_checker(const Handler &handler, internal::type arg_type) + : Handler(handler) + , arg_type_(arg_type) + { + } + + FMT_CONSTEXPR specs_checker(const specs_checker &other) + : Handler(other) + , arg_type_(other.arg_type_) + { + } + + FMT_CONSTEXPR void on_align(alignment align) + { + if (align == ALIGN_NUMERIC) + require_numeric_argument(); + Handler::on_align(align); + } + + FMT_CONSTEXPR void on_plus() + { + check_sign(); + Handler::on_plus(); + } + + FMT_CONSTEXPR void on_minus() + { + check_sign(); + Handler::on_minus(); + } + + FMT_CONSTEXPR void on_space() + { + check_sign(); + Handler::on_space(); + } + + FMT_CONSTEXPR void on_hash() + { + require_numeric_argument(); + Handler::on_hash(); + } + + FMT_CONSTEXPR void on_zero() + { + require_numeric_argument(); + Handler::on_zero(); + } + + FMT_CONSTEXPR void end_precision() + { + if (is_integral(arg_type_) || arg_type_ == pointer_type) + this->on_error("precision not allowed for this argument type"); + } + +private: + FMT_CONSTEXPR void require_numeric_argument() + { + if (!is_arithmetic(arg_type_)) + this->on_error("format specifier requires numeric argument"); + } + + FMT_CONSTEXPR void check_sign() + { + require_numeric_argument(); + if (is_integral(arg_type_) && arg_type_ != int_type && arg_type_ != long_long_type && arg_type_ != internal::char_type) + { + this->on_error("format specifier requires signed argument"); + } + } + + internal::type arg_type_; +}; + +template class Handler, typename T, typename Context, typename ErrorHandler> +FMT_CONSTEXPR void set_dynamic_spec(T &value, basic_format_arg arg, ErrorHandler eh) +{ + unsigned long long big_value = visit(Handler(eh), arg); + if (big_value > (std::numeric_limits::max)()) + eh.on_error("number is too big"); + value = static_cast(big_value); +} + +struct auto_id +{ +}; + +// The standard format specifier handler with checking. +template +class specs_handler : public specs_setter +{ +public: + typedef typename Context::char_type char_type; + + FMT_CONSTEXPR specs_handler(basic_format_specs &specs, Context &ctx) + : specs_setter(specs) + , context_(ctx) + { + } + + template + FMT_CONSTEXPR void on_dynamic_width(Id arg_id) + { + set_dynamic_spec(this->specs_.width_, get_arg(arg_id), context_.error_handler()); + } + + template + FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) + { + set_dynamic_spec(this->specs_.precision_, get_arg(arg_id), context_.error_handler()); + } + + void on_error(const char *message) + { + context_.on_error(message); + } + +private: + FMT_CONSTEXPR basic_format_arg get_arg(auto_id) + { + return context_.next_arg(); + } + + template + FMT_CONSTEXPR basic_format_arg get_arg(Id arg_id) + { + context_.parse_context().check_arg_id(arg_id); + return context_.get_arg(arg_id); + } + + Context &context_; +}; + +// An argument reference. +template +struct arg_ref +{ + enum Kind + { + NONE, + INDEX, + NAME + }; + + FMT_CONSTEXPR arg_ref() + : kind(NONE) + , index(0) + { + } + FMT_CONSTEXPR explicit arg_ref(unsigned index) + : kind(INDEX) + , index(index) + { + } + explicit arg_ref(basic_string_view name) + : kind(NAME) + , name(name) + { + } + + FMT_CONSTEXPR arg_ref &operator=(unsigned idx) + { + kind = INDEX; + index = idx; + return *this; + } + + Kind kind; + FMT_UNION + { + unsigned index; + basic_string_view name; + }; +}; + +// Format specifiers with width and precision resolved at formatting rather +// than parsing time to allow re-using the same parsed specifiers with +// differents sets of arguments (precompilation of format strings). +template +struct dynamic_format_specs : basic_format_specs +{ + arg_ref width_ref; + arg_ref precision_ref; +}; + +// Format spec handler that saves references to arguments representing dynamic +// width and precision to be resolved at formatting time. +template +class dynamic_specs_handler : public specs_setter +{ +public: + typedef typename ParseContext::char_type char_type; + + FMT_CONSTEXPR dynamic_specs_handler(dynamic_format_specs &specs, ParseContext &ctx) + : specs_setter(specs) + , specs_(specs) + , context_(ctx) + { + } + + FMT_CONSTEXPR dynamic_specs_handler(const dynamic_specs_handler &other) + : specs_setter(other) + , specs_(other.specs_) + , context_(other.context_) + { + } + + template + FMT_CONSTEXPR void on_dynamic_width(Id arg_id) + { + specs_.width_ref = make_arg_ref(arg_id); + } + + template + FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) + { + specs_.precision_ref = make_arg_ref(arg_id); + } + + FMT_CONSTEXPR void on_error(const char *message) + { + context_.on_error(message); + } + +private: + typedef arg_ref arg_ref_type; + + template + FMT_CONSTEXPR arg_ref_type make_arg_ref(Id arg_id) + { + context_.check_arg_id(arg_id); + return arg_ref_type(arg_id); + } + + FMT_CONSTEXPR arg_ref_type make_arg_ref(auto_id) + { + return arg_ref_type(context_.next_arg_id()); + } + + dynamic_format_specs &specs_; + ParseContext &context_; +}; + +template +FMT_CONSTEXPR Iterator parse_arg_id(Iterator it, IDHandler &&handler) +{ + typedef typename std::iterator_traits::value_type char_type; + char_type c = *it; + if (c == '}' || c == ':') + { + handler(); + return it; + } + if (c >= '0' && c <= '9') + { + unsigned index = parse_nonnegative_int(it, handler); + if (*it != '}' && *it != ':') + { + handler.on_error("invalid format string"); + return it; + } + handler(index); + return it; + } + if (!is_name_start(c)) + { + handler.on_error("invalid format string"); + return it; + } + auto start = it; + do + { + c = *++it; + } while (is_name_start(c) || ('0' <= c && c <= '9')); + handler(basic_string_view(pointer_from(start), it - start)); + return it; +} + +// Adapts SpecHandler to IDHandler API for dynamic width. +template +struct width_adapter +{ + explicit FMT_CONSTEXPR width_adapter(SpecHandler &h) + : handler(h) + { + } + + FMT_CONSTEXPR void operator()() + { + handler.on_dynamic_width(auto_id()); + } + FMT_CONSTEXPR void operator()(unsigned id) + { + handler.on_dynamic_width(id); + } + FMT_CONSTEXPR void operator()(basic_string_view id) + { + handler.on_dynamic_width(id); + } + + FMT_CONSTEXPR void on_error(const char *message) + { + handler.on_error(message); + } + + SpecHandler &handler; +}; + +// Adapts SpecHandler to IDHandler API for dynamic precision. +template +struct precision_adapter +{ + explicit FMT_CONSTEXPR precision_adapter(SpecHandler &h) + : handler(h) + { + } + + FMT_CONSTEXPR void operator()() + { + handler.on_dynamic_precision(auto_id()); + } + FMT_CONSTEXPR void operator()(unsigned id) + { + handler.on_dynamic_precision(id); + } + FMT_CONSTEXPR void operator()(basic_string_view id) + { + handler.on_dynamic_precision(id); + } + + FMT_CONSTEXPR void on_error(const char *message) + { + handler.on_error(message); + } + + SpecHandler &handler; +}; + +// Parses standard format specifiers and sends notifications about parsed +// components to handler. +// it: an iterator pointing to the beginning of a null-terminated range of +// characters, possibly emulated via null_terminating_iterator, representing +// format specifiers. +template +FMT_CONSTEXPR Iterator parse_format_specs(Iterator it, SpecHandler &&handler) +{ + typedef typename std::iterator_traits::value_type char_type; + char_type c = *it; + if (c == '}' || !c) + return it; + + // Parse fill and alignment. + alignment align = ALIGN_DEFAULT; + int i = 1; + do + { + auto p = it + i; + switch (*p) + { + case '<': + align = ALIGN_LEFT; + break; + case '>': + align = ALIGN_RIGHT; + break; + case '=': + align = ALIGN_NUMERIC; + break; + case '^': + align = ALIGN_CENTER; + break; + } + if (align != ALIGN_DEFAULT) + { + if (p != it) + { + if (c == '{') + { + handler.on_error("invalid fill character '{'"); + return it; + } + it += 2; + handler.on_fill(c); + } + else + ++it; + handler.on_align(align); + break; + } + } while (--i >= 0); + + // Parse sign. + switch (*it) + { + case '+': + handler.on_plus(); + ++it; + break; + case '-': + handler.on_minus(); + ++it; + break; + case ' ': + handler.on_space(); + ++it; + break; + } + + if (*it == '#') + { + handler.on_hash(); + ++it; + } + + // Parse zero flag. + if (*it == '0') + { + handler.on_zero(); + ++it; + } + + // Parse width. + if ('0' <= *it && *it <= '9') + { + handler.on_width(parse_nonnegative_int(it, handler)); + } + else if (*it == '{') + { + it = parse_arg_id(it + 1, width_adapter(handler)); + if (*it++ != '}') + { + handler.on_error("invalid format string"); + return it; + } + } + + // Parse precision. + if (*it == '.') + { + ++it; + if ('0' <= *it && *it <= '9') + { + handler.on_precision(parse_nonnegative_int(it, handler)); + } + else if (*it == '{') + { + it = parse_arg_id(it + 1, precision_adapter(handler)); + if (*it++ != '}') + { + handler.on_error("invalid format string"); + return it; + } + } + else + { + handler.on_error("missing precision specifier"); + return it; + } + handler.end_precision(); + } + + // Parse type. + if (*it != '}' && *it) + handler.on_type(*it++); + return it; +} + +template +struct id_adapter +{ + FMT_CONSTEXPR explicit id_adapter(Handler &h) + : handler(h) + { + } + + FMT_CONSTEXPR void operator()() + { + handler.on_arg_id(); + } + FMT_CONSTEXPR void operator()(unsigned id) + { + handler.on_arg_id(id); + } + FMT_CONSTEXPR void operator()(basic_string_view id) + { + handler.on_arg_id(id); + } + + FMT_CONSTEXPR void on_error(const char *message) + { + handler.on_error(message); + } + + Handler &handler; +}; + +template +FMT_CONSTEXPR void parse_format_string(Iterator it, Handler &&handler) +{ + typedef typename std::iterator_traits::value_type char_type; + auto start = it; + while (*it) + { + char_type ch = *it++; + if (ch != '{' && ch != '}') + continue; + if (*it == ch) + { + handler.on_text(start, it); + start = ++it; + continue; + } + if (ch == '}') + { + handler.on_error("unmatched '}' in format string"); + return; + } + handler.on_text(start, it - 1); + + it = parse_arg_id(it, id_adapter(handler)); + if (*it == '}') + { + handler.on_replacement_field(it); + } + else if (*it == ':') + { + ++it; + it = handler.on_format_specs(it); + if (*it != '}') + { + handler.on_error("unknown format specifier"); + return; + } + } + else + { + handler.on_error("missing '}' in format string"); + return; + } + + start = ++it; + } + handler.on_text(start, it); +} + +template +FMT_CONSTEXPR const typename ParseContext::char_type *parse_format_specs(ParseContext &ctx) +{ + // GCC 7.2 requires initializer. + formatter f{}; + return f.parse(ctx); +} + +template +class format_string_checker +{ +public: + explicit FMT_CONSTEXPR format_string_checker(basic_string_view format_str, ErrorHandler eh) + : arg_id_(-1) + , context_(format_str, eh) + , parse_funcs_{&parse_format_specs...} + { + } + + FMT_CONSTEXPR void on_text(const Char *, const Char *) {} + + FMT_CONSTEXPR void on_arg_id() + { + arg_id_ = context_.next_arg_id(); + check_arg_id(); + } + FMT_CONSTEXPR void on_arg_id(unsigned id) + { + arg_id_ = id; + context_.check_arg_id(id); + check_arg_id(); + } + FMT_CONSTEXPR void on_arg_id(basic_string_view) {} + + FMT_CONSTEXPR void on_replacement_field(const Char *) {} + + FMT_CONSTEXPR const Char *on_format_specs(const Char *s) + { + context_.advance_to(s); + return to_unsigned(arg_id_) < NUM_ARGS ? parse_funcs_[arg_id_](context_) : s; + } + + FMT_CONSTEXPR void on_error(const char *message) + { + context_.on_error(message); + } + +private: + typedef basic_parse_context parse_context_type; + enum + { + NUM_ARGS = sizeof...(Args) + }; + + FMT_CONSTEXPR void check_arg_id() + { + if (internal::to_unsigned(arg_id_) >= NUM_ARGS) + context_.on_error("argument index out of range"); + } + + // Format specifier parsing function. + typedef const Char *(*parse_func)(parse_context_type &); + + int arg_id_; + parse_context_type context_; + parse_func parse_funcs_[NUM_ARGS > 0 ? NUM_ARGS : 1]; +}; + +template +FMT_CONSTEXPR bool check_format_string(basic_string_view s, ErrorHandler eh = ErrorHandler()) +{ + format_string_checker checker(s, eh); + parse_format_string(s.begin(), checker); + return true; +} + +template +void check_format_string(String format_str) +{ + FMT_CONSTEXPR_DECL bool invalid_format = + internal::check_format_string(string_view(format_str.data(), format_str.size())); + (void)invalid_format; +} + +// Specifies whether to format T using the standard formatter. +// It is not possible to use get_type in formatter specialization directly +// because of a bug in MSVC. +template +struct format_type : std::integral_constant::value != custom_type> +{ +}; + +// Specifies whether to format enums. +template +struct format_enum : std::integral_constant::value> +{ +}; + +template class Handler, typename Spec, typename Context> +void handle_dynamic_spec(Spec &value, arg_ref ref, Context &ctx) +{ + typedef typename Context::char_type char_type; + switch (ref.kind) + { + case arg_ref::NONE: + break; + case arg_ref::INDEX: + internal::set_dynamic_spec(value, ctx.get_arg(ref.index), ctx.error_handler()); + break; + case arg_ref::NAME: + internal::set_dynamic_spec(value, ctx.get_arg(ref.name), ctx.error_handler()); + break; + } +} +} // namespace internal + +/** The default argument formatter. */ +template +class arg_formatter : public internal::function::iterator>, + public internal::arg_formatter_base +{ +private: + typedef typename Range::value_type char_type; + typedef internal::arg_formatter_base base; + typedef basic_format_context context_type; + + context_type &ctx_; + +public: + typedef Range range; + typedef typename base::iterator iterator; + typedef typename base::format_specs format_specs; + + /** + \rst + Constructs an argument formatter object. + *ctx* is a reference to the formatting context, + *spec* contains format specifier information for standard argument types. + \endrst + */ + arg_formatter(context_type &ctx, format_specs &spec) + : base(Range(ctx.out()), spec) + , ctx_(ctx) + { + } + + using base::operator(); + + /** Formats an argument of a user-defined type. */ + iterator operator()(typename basic_format_arg::handle handle) + { + handle.format(ctx_); + return this->out(); + } +}; + +/** + An error returned by an operating system or a language runtime, + for example a file opening error. +*/ +class system_error : public std::runtime_error +{ +private: + FMT_API void init(int err_code, string_view format_str, format_args args); + +protected: + int error_code_; + + system_error() + : std::runtime_error("") + { + } + +public: + /** + \rst + Constructs a :class:`fmt::system_error` object with a description + formatted with `fmt::format_system_error`. *message* and additional + arguments passed into the constructor are formatted similarly to + `fmt::format`. + + **Example**:: + + // This throws a system_error with the description + // cannot open file 'madeup': No such file or directory + // or similar (system message may vary). + const char *filename = "madeup"; + std::FILE *file = std::fopen(filename, "r"); + if (!file) + throw fmt::system_error(errno, "cannot open file '{}'", filename); + \endrst + */ + template + system_error(int error_code, string_view message, const Args &... args) + : std::runtime_error("") + { + init(error_code, message, make_format_args(args...)); + } + + int error_code() const + { + return error_code_; + } +}; + +/** + \rst + Formats an error returned by an operating system or a language runtime, + for example a file opening error, and writes it to *out* in the following + form: + + .. parsed-literal:: + **: ** + + where ** is the passed message and ** is + the system message corresponding to the error code. + *error_code* is a system error code as given by ``errno``. + If *error_code* is not a valid error code such as -1, the system message + may look like "Unknown error -1" and is platform-dependent. + \endrst + */ +FMT_API void format_system_error(internal::buffer &out, int error_code, fmt::string_view message) FMT_NOEXCEPT; + +/** + This template provides operations for formatting and writing data into a + character range. + */ +template +class basic_writer +{ +public: + typedef typename Range::value_type char_type; + typedef decltype(internal::declval().begin()) iterator; + typedef basic_format_specs format_specs; + +private: + // Output iterator. + iterator out_; + + std::unique_ptr locale_; + + FMT_DISALLOW_COPY_AND_ASSIGN(basic_writer); + + iterator out() const + { + return out_; + } + + // Attempts to reserve space for n extra characters in the output range. + // Returns a pointer to the reserved range or a reference to out_. + auto reserve(std::size_t n) -> decltype(internal::reserve(out_, n)) + { + return internal::reserve(out_, n); + } + + // Writes a value in the format + // + // where is written by f(it). + template + void write_padded(std::size_t size, const align_spec &spec, F f); + + template + struct padded_int_writer + { + string_view prefix; + char_type fill; + std::size_t padding; + F f; + + template + void operator()(It &&it) const + { + if (prefix.size() != 0) + it = std::copy_n(prefix.data(), prefix.size(), it); + it = std::fill_n(it, padding, fill); + f(it); + } + }; + + // Writes an integer in the format + // + // where are written by f(it). + template + void write_int(unsigned num_digits, string_view prefix, const Spec &spec, F f) + { + std::size_t size = prefix.size() + num_digits; + char_type fill = static_cast(spec.fill()); + std::size_t padding = 0; + if (spec.align() == ALIGN_NUMERIC) + { + if (spec.width() > size) + { + padding = spec.width() - size; + size = spec.width(); + } + } + else if (spec.precision() > static_cast(num_digits)) + { + size = prefix.size() + spec.precision(); + padding = spec.precision() - num_digits; + fill = '0'; + } + align_spec as = spec; + if (spec.align() == ALIGN_DEFAULT) + as.align_ = ALIGN_RIGHT; + write_padded(size, as, padded_int_writer{prefix, fill, padding, f}); + } + + // Writes a decimal integer. + template + void write_decimal(Int value) + { + typedef typename internal::int_traits::main_type main_type; + main_type abs_value = static_cast(value); + bool is_negative = internal::is_negative(value); + if (is_negative) + abs_value = 0 - abs_value; + unsigned num_digits = internal::count_digits(abs_value); + auto &&it = reserve((is_negative ? 1 : 0) + num_digits); + if (is_negative) + *it++ = '-'; + internal::format_decimal(it, abs_value, num_digits); + } + + // The handle_int_type_spec handler that writes an integer. + template + struct int_writer + { + typedef typename internal::int_traits::main_type unsigned_type; + + basic_writer &writer; + const Spec &spec; + unsigned_type abs_value; + char prefix[4]; + unsigned prefix_size; + + string_view get_prefix() const + { + return string_view(prefix, prefix_size); + } + + // Counts the number of digits in abs_value. BITS = log2(radix). + template + unsigned count_digits() const + { + unsigned_type n = abs_value; + unsigned num_digits = 0; + do + { + ++num_digits; + } while ((n >>= BITS) != 0); + return num_digits; + } + + int_writer(basic_writer &w, Int value, const Spec &s) + : writer(w) + , spec(s) + , abs_value(static_cast(value)) + , prefix_size(0) + { + if (internal::is_negative(value)) + { + prefix[0] = '-'; + ++prefix_size; + abs_value = 0 - abs_value; + } + else if (spec.flag(SIGN_FLAG)) + { + prefix[0] = spec.flag(PLUS_FLAG) ? '+' : ' '; + ++prefix_size; + } + } + + struct dec_writer + { + unsigned_type abs_value; + unsigned num_digits; + + template + void operator()(It &&it) const + { + it = internal::format_decimal(it, abs_value, num_digits); + } + }; + + void on_dec() + { + unsigned num_digits = internal::count_digits(abs_value); + writer.write_int(num_digits, get_prefix(), spec, dec_writer{abs_value, num_digits}); + } + + struct hex_writer + { + int_writer &self; + unsigned num_digits; + + template + void operator()(It &&it) const + { + it = internal::format_uint<4>(it, self.abs_value, num_digits, self.spec.type() != 'x'); + } + }; + + void on_hex() + { + if (spec.flag(HASH_FLAG)) + { + prefix[prefix_size++] = '0'; + prefix[prefix_size++] = static_cast(spec.type()); + } + unsigned num_digits = count_digits<4>(); + writer.write_int(num_digits, get_prefix(), spec, hex_writer{*this, num_digits}); + } + + template + struct bin_writer + { + unsigned_type abs_value; + unsigned num_digits; + + template + void operator()(It &&it) const + { + it = internal::format_uint(it, abs_value, num_digits); + } + }; + + void on_bin() + { + if (spec.flag(HASH_FLAG)) + { + prefix[prefix_size++] = '0'; + prefix[prefix_size++] = static_cast(spec.type()); + } + unsigned num_digits = count_digits<1>(); + writer.write_int(num_digits, get_prefix(), spec, bin_writer<1>{abs_value, num_digits}); + } + + void on_oct() + { + unsigned num_digits = count_digits<3>(); + if (spec.flag(HASH_FLAG) && spec.precision() <= static_cast(num_digits)) + { + // Octal prefix '0' is counted as a digit, so only add it if precision + // is not greater than the number of digits. + prefix[prefix_size++] = '0'; + } + writer.write_int(num_digits, get_prefix(), spec, bin_writer<3>{abs_value, num_digits}); + } + + enum + { + SEP_SIZE = 1 + }; + + struct num_writer + { + unsigned_type abs_value; + unsigned size; + char_type sep; + + template + void operator()(It &&it) const + { + basic_string_view s(&sep, SEP_SIZE); + it = format_decimal(it, abs_value, size, internal::add_thousands_sep(s)); + } + }; + + void on_num() + { + unsigned num_digits = internal::count_digits(abs_value); + char_type sep = internal::thousands_sep(writer.locale_.get()); + unsigned size = num_digits + SEP_SIZE * ((num_digits - 1) / 3); + writer.write_int(size, get_prefix(), spec, num_writer{abs_value, size, sep}); + } + + void on_error() + { + FMT_THROW(format_error("invalid type specifier")); + } + }; + + // Writes a formatted integer. + template + void write_int(T value, const Spec &spec) + { + internal::handle_int_type_spec(spec.type(), int_writer(*this, value, spec)); + } + + enum + { + INF_SIZE = 3 + }; // This is an enum to workaround a bug in MSVC. + + struct inf_or_nan_writer + { + char sign; + const char *str; + + template + void operator()(It &&it) const + { + if (sign) + *it++ = sign; + it = std::copy_n(str, static_cast(INF_SIZE), it); + } + }; + + struct double_writer + { + size_t n; + char sign; + basic_memory_buffer &buffer; + + template + void operator()(It &&it) + { + if (sign) + { + *it++ = sign; + --n; + } + it = std::copy_n(buffer.begin(), n, it); + } + }; + + // Formats a floating-point number (double or long double). + template + void write_double(T value, const format_specs &spec); + template + void write_double_sprintf(T value, const format_specs &spec, internal::basic_buffer &buffer); + + template + struct str_writer + { + const Char *s; + std::size_t size; + + template + void operator()(It &&it) const + { + it = std::copy_n(s, size, it); + } + }; + + // Writes a formatted string. + template + void write_str(const Char *s, std::size_t size, const align_spec &spec) + { + write_padded(size, spec, str_writer{s, size}); + } + + template + void write_str(basic_string_view str, const format_specs &spec); + + // Appends floating-point length specifier to the format string. + // The second argument is only used for overload resolution. + void append_float_length(char_type *&format_ptr, long double) + { + *format_ptr++ = 'L'; + } + + template + void append_float_length(char_type *&, T) + { + } + + template + friend class internal::arg_formatter_base; + +public: + /** Constructs a ``basic_writer`` object. */ + explicit basic_writer(Range out) + : out_(out.begin()) + { + } + + void write(int value) + { + write_decimal(value); + } + void write(long value) + { + write_decimal(value); + } + void write(long long value) + { + write_decimal(value); + } + + void write(unsigned value) + { + write_decimal(value); + } + void write(unsigned long value) + { + write_decimal(value); + } + void write(unsigned long long value) + { + write_decimal(value); + } + + /** + \rst + Formats *value* and writes it to the buffer. + \endrst + */ + template + typename std::enable_if::value, void>::type write(T value, FormatSpec spec, FormatSpecs... specs) + { + format_specs s(spec, specs...); + s.align_ = ALIGN_RIGHT; + write_int(value, s); + } + + void write(double value) + { + write_double(value, format_specs()); + } + + /** + \rst + Formats *value* using the general format for floating-point numbers + (``'g'``) and writes it to the buffer. + \endrst + */ + void write(long double value) + { + write_double(value, format_specs()); + } + + /** Writes a character to the buffer. */ + void write(char value) + { + *reserve(1) = value; + } + + void write(wchar_t value) + { + internal::require_wchar(); + *reserve(1) = value; + } + + /** + \rst + Writes *value* to the buffer. + \endrst + */ + void write(string_view value) + { + auto &&it = reserve(value.size()); + it = std::copy(value.begin(), value.end(), it); + } + + void write(wstring_view value) + { + internal::require_wchar(); + auto &&it = reserve(value.size()); + it = std::uninitialized_copy(value.begin(), value.end(), it); + } + + template + void write(basic_string_view str, FormatSpecs... specs) + { + write_str(str, format_specs(specs...)); + } + + template + typename std::enable_if::value>::type write(const T *p) + { + format_specs specs; + specs.flags_ = HASH_FLAG; + specs.type_ = 'x'; + write_int(reinterpret_cast(p), specs); + } +}; + +template +template +void basic_writer::write_padded(std::size_t size, const align_spec &spec, F f) +{ + unsigned width = spec.width(); + if (width <= size) + return f(reserve(size)); + auto &&it = reserve(width); + char_type fill = static_cast(spec.fill()); + std::size_t padding = width - size; + if (spec.align() == ALIGN_RIGHT) + { + it = std::fill_n(it, padding, fill); + f(it); + } + else if (spec.align() == ALIGN_CENTER) + { + std::size_t left_padding = padding / 2; + it = std::fill_n(it, left_padding, fill); + f(it); + it = std::fill_n(it, padding - left_padding, fill); + } + else + { + f(it); + it = std::fill_n(it, padding, fill); + } +} + +template +template +void basic_writer::write_str(basic_string_view s, const format_specs &spec) +{ + const Char *data = s.data(); + std::size_t size = s.size(); + std::size_t precision = static_cast(spec.precision_); + if (spec.precision_ >= 0 && precision < size) + size = precision; + write_str(data, size, spec); +} + +template +struct float_spec_handler +{ + Char type; + bool upper; + + explicit float_spec_handler(Char t) + : type(t) + , upper(false) + { + } + + void on_general() + { + if (type == 'G') + upper = true; + else + type = 'g'; + } + + void on_exp() + { + if (type == 'E') + upper = true; + } + + void on_fixed() + { + if (type == 'F') + { + upper = true; +#if FMT_MSC_VER + // MSVC's printf doesn't support 'F'. + type = 'f'; +#endif + } + } + + void on_hex() + { + if (type == 'A') + upper = true; + } + + void on_error() + { + FMT_THROW(format_error("invalid type specifier")); + } +}; + +template +template +void basic_writer::write_double(T value, const format_specs &spec) +{ + // Check type. + float_spec_handler handler(spec.type()); + internal::handle_float_type_spec(spec.type(), handler); + + char sign = 0; + // Use isnegative instead of value < 0 because the latter is always + // false for NaN. + if (internal::fputil::isnegative(static_cast(value))) + { + sign = '-'; + value = -value; + } + else if (spec.flag(SIGN_FLAG)) + { + sign = spec.flag(PLUS_FLAG) ? '+' : ' '; + } + + struct write_inf_or_nan_t + { + basic_writer &writer; + format_specs spec; + char sign; + void operator()(const char *str) const + { + writer.write_padded(INF_SIZE + (sign ? 1 : 0), spec, inf_or_nan_writer{sign, str}); + } + } write_inf_or_nan = {*this, spec, sign}; + + // Format NaN and ininity ourselves because sprintf's output is not consistent + // across platforms. + if (internal::fputil::isnotanumber(value)) + return write_inf_or_nan(handler.upper ? "NAN" : "nan"); + if (internal::fputil::isinfinity(value)) + return write_inf_or_nan(handler.upper ? "INF" : "inf"); + + basic_memory_buffer buffer; + if (FMT_USE_GRISU && sizeof(T) <= sizeof(double) && std::numeric_limits::is_iec559) + { + internal::fp fp_value(static_cast(value)); + fp_value.normalize(); + // Find a cached power of 10 close to 1 / fp_value. + int dec_exp = 0; + const int min_exp = -60; + auto dec_pow = internal::get_cached_power(min_exp - (fp_value.e + internal::fp::significand_size), dec_exp); + internal::fp product = fp_value * dec_pow; + // Generate output. + internal::fp one(1ull << -product.e, product.e); + uint64_t hi = product.f >> -one.e; + uint64_t f = product.f & (one.f - 1); + typedef back_insert_range> range; + basic_writer w{range(buffer)}; + w.write(hi); + size_t digits = buffer.size(); + w.write('.'); + const unsigned max_digits = 18; + while (digits++ < max_digits) + { + f *= 10; + w.write(static_cast('0' + (f >> -one.e))); + f &= one.f - 1; + } + w.write('e'); + w.write(-dec_exp); + } + else + { + format_specs normalized_spec(spec); + normalized_spec.type_ = handler.type; + write_double_sprintf(value, normalized_spec, buffer); + } + size_t n = buffer.size(); + align_spec as = spec; + if (spec.align() == ALIGN_NUMERIC) + { + if (sign) + { + auto &&it = reserve(1); + *it++ = sign; + sign = 0; + if (as.width_) + --as.width_; + } + as.align_ = ALIGN_RIGHT; + } + else + { + if (spec.align() == ALIGN_DEFAULT) + as.align_ = ALIGN_RIGHT; + if (sign) + ++n; + } + write_padded(n, as, double_writer{n, sign, buffer}); +} + +template +template +void basic_writer::write_double_sprintf(T value, const format_specs &spec, internal::basic_buffer &buffer) +{ + // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail. + FMT_ASSERT(buffer.capacity() != 0, "empty buffer"); + + // Build format string. + enum + { + MAX_FORMAT_SIZE = 10 + }; // longest format: %#-*.*Lg + char_type format[MAX_FORMAT_SIZE]; + char_type *format_ptr = format; + *format_ptr++ = '%'; + if (spec.flag(HASH_FLAG)) + *format_ptr++ = '#'; + if (spec.precision() >= 0) + { + *format_ptr++ = '.'; + *format_ptr++ = '*'; + } + + append_float_length(format_ptr, value); + *format_ptr++ = spec.type(); + *format_ptr = '\0'; + + // Format using snprintf. + char_type *start = FMT_NULL; + for (;;) + { + std::size_t buffer_size = buffer.capacity(); + start = &buffer[0]; + int result = internal::char_traits::format_float(start, buffer_size, format, spec.precision(), value); + if (result >= 0) + { + unsigned n = internal::to_unsigned(result); + if (n < buffer.capacity()) + { + buffer.resize(n); + break; // The buffer is large enough - continue with formatting. + } + buffer.reserve(n + 1); + } + else + { + // If result is negative we ask to increase the capacity by at least 1, + // but as std::vector, the buffer grows exponentially. + buffer.reserve(buffer.capacity() + 1); + } + } +} + +// Reports a system error without throwing an exception. +// Can be used to report errors from destructors. +FMT_API void report_system_error(int error_code, string_view message) FMT_NOEXCEPT; + +#if FMT_USE_WINDOWS_H + +/** A Windows error. */ +class windows_error : public system_error +{ +private: + FMT_API void init(int error_code, string_view format_str, format_args args); + +public: + /** + \rst + Constructs a :class:`fmt::windows_error` object with the description + of the form + + .. parsed-literal:: + **: ** + + where ** is the formatted message and ** is the + system message corresponding to the error code. + *error_code* is a Windows error code as given by ``GetLastError``. + If *error_code* is not a valid error code such as -1, the system message + will look like "error -1". + + **Example**:: + + // This throws a windows_error with the description + // cannot open file 'madeup': The system cannot find the file specified. + // or similar (system message may vary). + const char *filename = "madeup"; + LPOFSTRUCT of = LPOFSTRUCT(); + HFILE file = OpenFile(filename, &of, OF_READ); + if (file == HFILE_ERROR) { + throw fmt::windows_error(GetLastError(), + "cannot open file '{}'", filename); + } + \endrst + */ + template + windows_error(int error_code, string_view message, const Args &... args) + { + init(error_code, message, make_format_args(args...)); + } +}; + +// Reports a Windows error without throwing an exception. +// Can be used to report errors from destructors. +FMT_API void report_windows_error(int error_code, string_view message) FMT_NOEXCEPT; + +#endif + +/** Fast integer formatter. */ +class format_int +{ +private: + // Buffer should be large enough to hold all digits (digits10 + 1), + // a sign and a null character. + enum + { + BUFFER_SIZE = std::numeric_limits::digits10 + 3 + }; + mutable char buffer_[BUFFER_SIZE]; + char *str_; + + // Formats value in reverse and returns a pointer to the beginning. + char *format_decimal(unsigned long long value) + { + char *ptr = buffer_ + BUFFER_SIZE - 1; + while (value >= 100) + { + // Integer division is slow so do it for a group of two digits instead + // of for every digit. The idea comes from the talk by Alexandrescu + // "Three Optimization Tips for C++". See speed-test for a comparison. + unsigned index = static_cast((value % 100) * 2); + value /= 100; + *--ptr = internal::data::DIGITS[index + 1]; + *--ptr = internal::data::DIGITS[index]; + } + if (value < 10) + { + *--ptr = static_cast('0' + value); + return ptr; + } + unsigned index = static_cast(value * 2); + *--ptr = internal::data::DIGITS[index + 1]; + *--ptr = internal::data::DIGITS[index]; + return ptr; + } + + void format_signed(long long value) + { + unsigned long long abs_value = static_cast(value); + bool negative = value < 0; + if (negative) + abs_value = 0 - abs_value; + str_ = format_decimal(abs_value); + if (negative) + *--str_ = '-'; + } + +public: + explicit format_int(int value) + { + format_signed(value); + } + explicit format_int(long value) + { + format_signed(value); + } + explicit format_int(long long value) + { + format_signed(value); + } + explicit format_int(unsigned value) + : str_(format_decimal(value)) + { + } + explicit format_int(unsigned long value) + : str_(format_decimal(value)) + { + } + explicit format_int(unsigned long long value) + : str_(format_decimal(value)) + { + } + + /** Returns the number of characters written to the output buffer. */ + std::size_t size() const + { + return internal::to_unsigned(buffer_ - str_ + BUFFER_SIZE - 1); + } + + /** + Returns a pointer to the output buffer content. No terminating null + character is appended. + */ + const char *data() const + { + return str_; + } + + /** + Returns a pointer to the output buffer content with terminating null + character appended. + */ + const char *c_str() const + { + buffer_[BUFFER_SIZE - 1] = '\0'; + return str_; + } + + /** + \rst + Returns the content of the output buffer as an ``std::string``. + \endrst + */ + std::string str() const + { + return std::string(str_, size()); + } +}; + +// Formats a decimal integer value writing into buffer and returns +// a pointer to the end of the formatted string. This function doesn't +// write a terminating null character. +template +inline void format_decimal(char *&buffer, T value) +{ + typedef typename internal::int_traits::main_type main_type; + main_type abs_value = static_cast(value); + if (internal::is_negative(value)) + { + *buffer++ = '-'; + abs_value = 0 - abs_value; + } + if (abs_value < 100) + { + if (abs_value < 10) + { + *buffer++ = static_cast('0' + abs_value); + return; + } + unsigned index = static_cast(abs_value * 2); + *buffer++ = internal::data::DIGITS[index]; + *buffer++ = internal::data::DIGITS[index + 1]; + return; + } + unsigned num_digits = internal::count_digits(abs_value); + internal::format_decimal(buffer, abs_value, num_digits); + buffer += num_digits; +} + +// Formatter of objects of type T. +template +struct formatter::type, T>::value>::type> +{ + + // Parses format specifiers stopping either at the end of the range or at the + // terminating '}'. + template + FMT_CONSTEXPR typename ParseContext::iterator parse(ParseContext &ctx) + { + auto it = internal::null_terminating_iterator(ctx); + typedef internal::dynamic_specs_handler handler_type; + auto type = internal::get_type::type, T>::value; + internal::specs_checker handler(handler_type(specs_, ctx), type); + it = parse_format_specs(it, handler); + auto type_spec = specs_.type(); + auto eh = ctx.error_handler(); + switch (type) + { + case internal::none_type: + case internal::named_arg_type: + FMT_ASSERT(false, "invalid argument type"); + break; + case internal::int_type: + case internal::uint_type: + case internal::long_long_type: + case internal::ulong_long_type: + case internal::bool_type: + handle_int_type_spec(type_spec, internal::int_type_checker(eh)); + break; + case internal::char_type: + handle_char_specs(specs_, internal::char_specs_checker(type_spec, eh)); + break; + case internal::double_type: + case internal::long_double_type: + handle_float_type_spec(type_spec, internal::float_type_checker(eh)); + break; + case internal::cstring_type: + internal::handle_cstring_type_spec(type_spec, internal::cstring_type_checker(eh)); + break; + case internal::string_type: + internal::check_string_type_spec(type_spec, eh); + break; + case internal::pointer_type: + internal::check_pointer_type_spec(type_spec, eh); + break; + case internal::custom_type: + // Custom format specifiers should be checked in parse functions of + // formatter specializations. + break; + } + return pointer_from(it); + } + + template + auto format(const T &val, FormatContext &ctx) -> decltype(ctx.out()) + { + internal::handle_dynamic_spec(specs_.width_, specs_.width_ref, ctx); + internal::handle_dynamic_spec(specs_.precision_, specs_.precision_ref, ctx); + typedef output_range range_type; + visit(arg_formatter(ctx, specs_), internal::make_arg(val)); + return ctx.out(); + } + +private: + internal::dynamic_format_specs specs_; +}; + +template +struct formatter::value>::type> : public formatter +{ + template + auto parse(ParseContext &ctx) -> decltype(ctx.begin()) + { + return ctx.begin(); + } +}; + +// A formatter for types known only at run time such as variant alternatives. +// +// Usage: +// typedef std::variant variant; +// template <> +// struct formatter: dynamic_formatter<> { +// void format(buffer &buf, const variant &v, context &ctx) { +// visit([&](const auto &val) { format(buf, val, ctx); }, v); +// } +// }; +template +class dynamic_formatter +{ +private: + struct null_handler : internal::error_handler + { + void on_align(alignment) {} + void on_plus() {} + void on_minus() {} + void on_space() {} + void on_hash() {} + }; + +public: + template + auto parse(ParseContext &ctx) -> decltype(ctx.begin()) + { + auto it = internal::null_terminating_iterator(ctx); + // Checks are deferred to formatting time when the argument type is known. + internal::dynamic_specs_handler handler(specs_, ctx); + it = parse_format_specs(it, handler); + return pointer_from(it); + } + + template + auto format(const T &val, FormatContext &ctx) -> decltype(ctx.out()) + { + handle_specs(ctx); + internal::specs_checker checker(null_handler(), internal::get_type::value); + checker.on_align(specs_.align()); + if (specs_.flags_ == 0) + { + // Do nothing. + } + else if (specs_.flag(SIGN_FLAG)) + { + if (specs_.flag(PLUS_FLAG)) + checker.on_plus(); + else + checker.on_space(); + } + else if (specs_.flag(MINUS_FLAG)) + { + checker.on_minus(); + } + else if (specs_.flag(HASH_FLAG)) + { + checker.on_hash(); + } + if (specs_.precision_ != -1) + checker.end_precision(); + typedef output_range range; + visit(arg_formatter(ctx, specs_), internal::make_arg(val)); + return ctx.out(); + } + +private: + template + void handle_specs(Context &ctx) + { + internal::handle_dynamic_spec(specs_.width_, specs_.width_ref, ctx); + internal::handle_dynamic_spec(specs_.precision_, specs_.precision_ref, ctx); + } + + internal::dynamic_format_specs specs_; +}; + +template +typename basic_format_context::format_arg basic_format_context::get_arg(basic_string_view name) +{ + map_.init(this->args()); + format_arg arg = map_.find(name); + if (arg.type() == internal::none_type) + this->on_error("argument not found"); + return arg; +} + +template +struct format_handler : internal::error_handler +{ + typedef internal::null_terminating_iterator iterator; + typedef typename ArgFormatter::range range; + + format_handler(range r, basic_string_view str, basic_format_args format_args) + : context(r.begin(), str, format_args) + { + } + + void on_text(iterator begin, iterator end) + { + size_t size = end - begin; + auto out = context.out(); + auto &&it = internal::reserve(out, size); + it = std::copy_n(begin, size, it); + context.advance_to(out); + } + + void on_arg_id() + { + arg = context.next_arg(); + } + void on_arg_id(unsigned id) + { + context.parse_context().check_arg_id(id); + arg = context.get_arg(id); + } + void on_arg_id(basic_string_view id) + { + arg = context.get_arg(id); + } + + void on_replacement_field(iterator it) + { + context.parse_context().advance_to(pointer_from(it)); + if (visit(internal::custom_formatter(context), arg)) + return; + basic_format_specs specs; + context.advance_to(visit(ArgFormatter(context, specs), arg)); + } + + iterator on_format_specs(iterator it) + { + auto &parse_ctx = context.parse_context(); + parse_ctx.advance_to(pointer_from(it)); + if (visit(internal::custom_formatter(context), arg)) + return iterator(parse_ctx); + basic_format_specs specs; + using internal::specs_handler; + internal::specs_checker> handler(specs_handler(specs, context), arg.type()); + it = parse_format_specs(it, handler); + if (*it != '}') + on_error("missing '}' in format string"); + parse_ctx.advance_to(pointer_from(it)); + context.advance_to(visit(ArgFormatter(context, specs), arg)); + return it; + } + + Context context; + basic_format_arg arg; +}; + +/** Formats arguments and writes the output to the range. */ +template +typename Context::iterator vformat_to(typename ArgFormatter::range out, basic_string_view format_str, basic_format_args args) +{ + typedef internal::null_terminating_iterator iterator; + format_handler h(out, format_str, args); + parse_format_string(iterator(format_str.begin(), format_str.end()), h); + return h.context.out(); +} + +// Casts ``p`` to ``const void*`` for pointer formatting. +// Example: +// auto s = format("{}", ptr(p)); +template +inline const void *ptr(const T *p) +{ + return p; +} + +template +struct arg_join +{ + It begin; + It end; + basic_string_view sep; + + arg_join(It begin, It end, basic_string_view sep) + : begin(begin) + , end(end) + , sep(sep) + { + } +}; + +template +struct formatter, Char> : formatter::value_type, Char> +{ + template + auto format(const arg_join &value, FormatContext &ctx) -> decltype(ctx.out()) + { + typedef formatter::value_type, Char> base; + auto it = value.begin; + auto out = ctx.out(); + if (it != value.end) + { + out = base::format(*it++, ctx); + while (it != value.end) + { + out = std::copy(value.sep.begin(), value.sep.end(), out); + ctx.advance_to(out); + out = base::format(*it++, ctx); + } + } + return out; + } +}; + +template +arg_join join(It begin, It end, string_view sep) +{ + return arg_join(begin, end, sep); +} + +template +arg_join join(It begin, It end, wstring_view sep) +{ + return arg_join(begin, end, sep); +} + +// The following causes ICE in gcc 4.4. +#if FMT_USE_TRAILING_RETURN && (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 405) +template +auto join(const Range &range, string_view sep) -> arg_join +{ + return join(internal::begin(range), internal::end(range), sep); +} + +template +auto join(const Range &range, wstring_view sep) -> arg_join +{ + return join(internal::begin(range), internal::end(range), sep); +} +#endif + +/** + \rst + Converts *value* to ``std::string`` using the default format for type *T*. + + **Example**:: + + #include + + std::string answer = fmt::to_string(42); + \endrst + */ +template +std::string to_string(const T &value) +{ + std::string str; + internal::container_buffer buf(str); + writer(buf).write(value); + return str; +} + +/** + Converts *value* to ``std::wstring`` using the default format for type *T*. + */ +template +std::wstring to_wstring(const T &value) +{ + std::wstring str; + internal::container_buffer buf(str); + wwriter(buf).write(value); + return str; +} + +template +std::basic_string to_string(const basic_memory_buffer &buffer) +{ + return std::basic_string(buffer.data(), buffer.size()); +} + +inline format_context::iterator vformat_to(internal::buffer &buf, string_view format_str, format_args args) +{ + typedef back_insert_range range; + return vformat_to>(buf, format_str, args); +} + +inline wformat_context::iterator vformat_to(internal::wbuffer &buf, wstring_view format_str, wformat_args args) +{ + typedef back_insert_range range; + return vformat_to>(buf, format_str, args); +} + +template +inline format_context::iterator format_to(memory_buffer &buf, string_view format_str, const Args &... args) +{ + return vformat_to(buf, format_str, make_format_args(args...)); +} + +template +inline wformat_context::iterator format_to(wmemory_buffer &buf, wstring_view format_str, const Args &... args) +{ + return vformat_to(buf, format_str, make_format_args(args...)); +} + +template +// using format_context_t = basic_format_context; +struct format_context_t +{ + typedef basic_format_context type; +}; + +template +// using format_args_t = basic_format_args>; +struct format_args_t +{ + typedef basic_format_args::type> type; +}; + +template +inline OutputIt vformat_to(OutputIt out, string_view format_str, typename format_args_t::type args) +{ + typedef output_range range; + return vformat_to>(range(out), format_str, args); +} + +/** + \rst + Formats arguments, writes the result to the output iterator ``out`` and returns + the iterator past the end of the output range. + + **Example**:: + + std::vector out; + fmt::format_to(std::back_inserter(out), "{}", 42); + \endrst + */ +template +inline OutputIt format_to(OutputIt out, string_view format_str, const Args &... args) +{ + return vformat_to(out, format_str, make_format_args::type>(args...)); +} + +template +inline typename std::enable_if::value, std::back_insert_iterator>::type format_to( + std::back_insert_iterator out, string_view format_str, const Args &... args) +{ + return vformat_to(out, format_str, make_format_args(args...)); +} + +template +inline typename std::enable_if::value, std::back_insert_iterator>::type format_to( + std::back_insert_iterator out, wstring_view format_str, const Args &... args) +{ + return vformat_to(out, format_str, make_format_args(args...)); +} + +template +struct format_to_n_result +{ + /** Iterator past the end of the output range. */ + OutputIt out; + /** Total (not truncated) output size. */ + std::size_t size; +}; + +/** + \rst + Formats arguments, writes up to ``n`` characters of the result to the output + iterator ``out`` and returns the total output size and the iterator past the end + of the output range. + \endrst + */ +template +inline format_to_n_result format_to_n(OutputIt out, std::size_t n, string_view format_str, const Args &... args) +{ + typedef internal::truncating_iterator It; + auto it = vformat_to(It(out, n), format_str, make_format_args::type>(args...)); + return {it.base(), it.count()}; +} + +inline std::string vformat(string_view format_str, format_args args) +{ + memory_buffer buffer; + vformat_to(buffer, format_str, args); + return fmt::to_string(buffer); +} + +inline std::wstring vformat(wstring_view format_str, wformat_args args) +{ + wmemory_buffer buffer; + vformat_to(buffer, format_str, args); + return to_string(buffer); +} + +template +inline typename std::enable_if::value, std::string>::type format(String format_str, const Args &... args) +{ + internal::check_format_string(format_str); + return vformat(format_str.data(), make_format_args(args...)); +} + +template +inline typename std::enable_if::value>::type print(String format_str, const Args &... args) +{ + internal::check_format_string(format_str); + return vprint(format_str.data(), make_format_args(args...)); +} + +/** + Returns the number of characters in the output of + ``format(format_str, args...)``. + */ +template +inline std::size_t formatted_size(string_view format_str, const Args &... args) +{ + auto it = format_to(internal::counting_iterator(), format_str, args...); + return it.count(); +} + +#if FMT_USE_USER_DEFINED_LITERALS +namespace internal { + +#if FMT_UDL_TEMPLATE +template +class udl_formatter +{ +public: + template + std::basic_string operator()(const Args &... args) const + { + FMT_CONSTEXPR_DECL Char s[] = {CHARS..., '\0'}; + FMT_CONSTEXPR_DECL bool invalid_format = + check_format_string(basic_string_view(s, sizeof...(CHARS))); + (void)invalid_format; + return format(s, args...); + } +}; +#else +template +struct udl_formatter +{ + const Char *str; + + template + auto operator()(Args &&... args) const -> decltype(format(str, std::forward(args)...)) + { + return format(str, std::forward(args)...); + } +}; +#endif // FMT_UDL_TEMPLATE + +template +struct udl_arg +{ + const Char *str; + + template + named_arg operator=(T &&value) const + { + return {str, std::forward(value)}; + } +}; + +} // namespace internal + +inline namespace literals { + +#if FMT_UDL_TEMPLATE +template +FMT_CONSTEXPR internal::udl_formatter operator""_format() +{ + return {}; +} +#else +/** + \rst + User-defined literal equivalent of :func:`fmt::format`. + + **Example**:: + + using namespace fmt::literals; + std::string message = "The answer is {}"_format(42); + \endrst + */ +inline internal::udl_formatter operator"" _format(const char *s, std::size_t) +{ + return {s}; +} +inline internal::udl_formatter operator"" _format(const wchar_t *s, std::size_t) +{ + return {s}; +} +#endif // FMT_UDL_TEMPLATE + +/** + \rst + User-defined literal equivalent of :func:`fmt::arg`. + + **Example**:: + + using namespace fmt::literals; + fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23); + \endrst + */ +inline internal::udl_arg operator"" _a(const char *s, std::size_t) +{ + return {s}; +} +inline internal::udl_arg operator"" _a(const wchar_t *s, std::size_t) +{ + return {s}; +} +} // namespace literals +#endif // FMT_USE_USER_DEFINED_LITERALS +FMT_END_NAMESPACE + +#define FMT_STRING(s) \ + [] { \ + struct S : fmt::format_string \ + { \ + static FMT_CONSTEXPR decltype(s) data() \ + { \ + return s; \ + } \ + static FMT_CONSTEXPR size_t size() \ + { \ + return sizeof(s); \ + } \ + }; \ + return S{}; \ + }() + +#ifndef FMT_NO_FMT_STRING_ALIAS +/** + \rst + Constructs a compile-time format string. + + **Example**:: + + #include + // A compile-time error because 'd' is an invalid specifier for strings. + std::string s = format(fmt("{:d}"), "foo"); + \endrst + */ +#define fmt(s) FMT_STRING(s) +#endif + +#ifdef FMT_HEADER_ONLY +#define FMT_FUNC inline +#include "format-inl.h" +#else +#define FMT_FUNC +#endif + +// Restore warnings. +#if FMT_GCC_VERSION >= 406 || FMT_CLANG_VERSION +#pragma GCC diagnostic pop +#endif + +#endif // FMT_FORMAT_H_ diff --git a/include/spdlog/fmt/bundled/locale.h b/include/spdlog/fmt/bundled/locale.h new file mode 100644 index 00000000..0fa78c85 --- /dev/null +++ b/include/spdlog/fmt/bundled/locale.h @@ -0,0 +1,27 @@ +// Formatting library for C++ - locale support +// +// Copyright (c) 2012 - 2016, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. + +#include "format.h" +#include + +namespace fmt { +class locale +{ +private: + std::locale locale_; + +public: + explicit locale(std::locale loc = std::locale()) + : locale_(loc) + { + } + std::locale get() + { + return locale_; + } +}; +} // namespace fmt diff --git a/include/spdlog/fmt/bundled/ostream.h b/include/spdlog/fmt/bundled/ostream.h new file mode 100644 index 00000000..df7b03d5 --- /dev/null +++ b/include/spdlog/fmt/bundled/ostream.h @@ -0,0 +1,171 @@ +// Formatting library for C++ - std::ostream support +// +// Copyright (c) 2012 - 2016, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. + +#ifndef FMT_OSTREAM_H_ +#define FMT_OSTREAM_H_ + +#include "format.h" +#include + +FMT_BEGIN_NAMESPACE +namespace internal { + +template +class formatbuf : public std::basic_streambuf +{ +private: + typedef typename std::basic_streambuf::int_type int_type; + typedef typename std::basic_streambuf::traits_type traits_type; + + basic_buffer &buffer_; + +public: + formatbuf(basic_buffer &buffer) + : buffer_(buffer) + { + } + +protected: + // The put-area is actually always empty. This makes the implementation + // simpler and has the advantage that the streambuf and the buffer are always + // in sync and sputc never writes into uninitialized memory. The obvious + // disadvantage is that each call to sputc always results in a (virtual) call + // to overflow. There is no disadvantage here for sputn since this always + // results in a call to xsputn. + + int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE + { + if (!traits_type::eq_int_type(ch, traits_type::eof())) + buffer_.push_back(static_cast(ch)); + return ch; + } + + std::streamsize xsputn(const Char *s, std::streamsize count) FMT_OVERRIDE + { + buffer_.append(s, s + count); + return count; + } +}; + +template +struct test_stream : std::basic_ostream +{ +private: + struct null; + // Hide all operator<< from std::basic_ostream. + void operator<<(null); +}; + +// Checks if T has a user-defined operator<< (e.g. not a member of std::ostream). +template +class is_streamable +{ +private: + template + static decltype(internal::declval &>() << internal::declval(), std::true_type()) test(int); + + template + static std::false_type test(...); + + typedef decltype(test(0)) result; + +public: + // std::string operator<< is not considered user-defined because we handle strings + // specially. + static const bool value = result::value && !std::is_same::value; +}; + +// Disable conversion to int if T has an overloaded operator<< which is a free +// function (not a member of std::ostream). +template +class convert_to_int +{ +public: + static const bool value = convert_to_int::value && !is_streamable::value; +}; + +// Write the content of buf to os. +template +void write(std::basic_ostream &os, basic_buffer &buf) +{ + const Char *data = buf.data(); + typedef std::make_unsigned::type UnsignedStreamSize; + UnsignedStreamSize size = buf.size(); + UnsignedStreamSize max_size = internal::to_unsigned((std::numeric_limits::max)()); + do + { + UnsignedStreamSize n = size <= max_size ? size : max_size; + os.write(data, static_cast(n)); + data += n; + size -= n; + } while (size != 0); +} + +template +void format_value(basic_buffer &buffer, const T &value) +{ + internal::formatbuf format_buf(buffer); + std::basic_ostream output(&format_buf); + output.exceptions(std::ios_base::failbit | std::ios_base::badbit); + output << value; + buffer.resize(buffer.size()); +} + +// Disable builtin formatting of enums and use operator<< instead. +template +struct format_enum::value>::type> : std::false_type +{ +}; +} // namespace internal + +// Formats an object of type T that has an overloaded ostream operator<<. +template +struct formatter::value>::type> : formatter, Char> +{ + + template + auto format(const T &value, Context &ctx) -> decltype(ctx.out()) + { + basic_memory_buffer buffer; + internal::format_value(buffer, value); + basic_string_view str(buffer.data(), buffer.size()); + formatter, Char>::format(str, ctx); + return ctx.out(); + } +}; + +template +inline void vprint( + std::basic_ostream &os, basic_string_view format_str, basic_format_args::type> args) +{ + basic_memory_buffer buffer; + vformat_to(buffer, format_str, args); + internal::write(os, buffer); +} +/** + \rst + Prints formatted data to the stream *os*. + + **Example**:: + + fmt::print(cerr, "Don't {}!", "panic"); + \endrst + */ +template +inline void print(std::ostream &os, string_view format_str, const Args &... args) +{ + vprint(os, format_str, make_format_args(args...)); +} + +template +inline void print(std::wostream &os, wstring_view format_str, const Args &... args) +{ + vprint(os, format_str, make_format_args(args...)); +} +FMT_END_NAMESPACE + +#endif // FMT_OSTREAM_H_ diff --git a/include/spdlog/fmt/bundled/posix.h b/include/spdlog/fmt/bundled/posix.h new file mode 100644 index 00000000..20c75899 --- /dev/null +++ b/include/spdlog/fmt/bundled/posix.h @@ -0,0 +1,484 @@ +// A C++ interface to POSIX functions. +// +// Copyright (c) 2012 - 2016, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. + +#ifndef FMT_POSIX_H_ +#define FMT_POSIX_H_ + +#if defined(__MINGW32__) || defined(__CYGWIN__) +// Workaround MinGW bug https://sourceforge.net/p/mingw/bugs/2024/. +#undef __STRICT_ANSI__ +#endif + +#include +#include // for O_RDONLY +#include // for locale_t +#include +#include // for strtod_l + +#include + +#if defined __APPLE__ || defined(__FreeBSD__) +#include // for LC_NUMERIC_MASK on OS X +#endif + +#include "format.h" + +#ifndef FMT_POSIX +#if defined(_WIN32) && !defined(__MINGW32__) +// Fix warnings about deprecated symbols. +#define FMT_POSIX(call) _##call +#else +#define FMT_POSIX(call) call +#endif +#endif + +// Calls to system functions are wrapped in FMT_SYSTEM for testability. +#ifdef FMT_SYSTEM +#define FMT_POSIX_CALL(call) FMT_SYSTEM(call) +#else +#define FMT_SYSTEM(call) call +#ifdef _WIN32 +// Fix warnings about deprecated symbols. +#define FMT_POSIX_CALL(call) ::_##call +#else +#define FMT_POSIX_CALL(call) ::call +#endif +#endif + +// Retries the expression while it evaluates to error_result and errno +// equals to EINTR. +#ifndef _WIN32 +#define FMT_RETRY_VAL(result, expression, error_result) \ + do \ + { \ + result = (expression); \ + } while (result == error_result && errno == EINTR) +#else +#define FMT_RETRY_VAL(result, expression, error_result) result = (expression) +#endif + +#define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1) + +FMT_BEGIN_NAMESPACE + +/** + \rst + A reference to a null-terminated string. It can be constructed from a C + string or ``std::string``. + + You can use one of the following typedefs for common character types: + + +---------------+-----------------------------+ + | Type | Definition | + +===============+=============================+ + | cstring_view | basic_cstring_view | + +---------------+-----------------------------+ + | wcstring_view | basic_cstring_view | + +---------------+-----------------------------+ + + This class is most useful as a parameter type to allow passing + different types of strings to a function, for example:: + + template + std::string format(cstring_view format_str, const Args & ... args); + + format("{}", 42); + format(std::string("{}"), 42); + \endrst + */ +template +class basic_cstring_view +{ +private: + const Char *data_; + +public: + /** Constructs a string reference object from a C string. */ + basic_cstring_view(const Char *s) + : data_(s) + { + } + + /** + \rst + Constructs a string reference from an ``std::string`` object. + \endrst + */ + basic_cstring_view(const std::basic_string &s) + : data_(s.c_str()) + { + } + + /** Returns the pointer to a C string. */ + const Char *c_str() const + { + return data_; + } +}; + +typedef basic_cstring_view cstring_view; +typedef basic_cstring_view wcstring_view; + +// An error code. +class error_code +{ +private: + int value_; + +public: + explicit error_code(int value = 0) FMT_NOEXCEPT : value_(value) {} + + int get() const FMT_NOEXCEPT + { + return value_; + } +}; + +// A buffered file. +class buffered_file +{ +private: + FILE *file_; + + friend class file; + + explicit buffered_file(FILE *f) + : file_(f) + { + } + +public: + // Constructs a buffered_file object which doesn't represent any file. + buffered_file() FMT_NOEXCEPT : file_(FMT_NULL) {} + + // Destroys the object closing the file it represents if any. + FMT_API ~buffered_file() FMT_DTOR_NOEXCEPT; + +#if !FMT_USE_RVALUE_REFERENCES + // Emulate a move constructor and a move assignment operator if rvalue + // references are not supported. + +private: + // A proxy object to emulate a move constructor. + // It is private to make it impossible call operator Proxy directly. + struct Proxy + { + FILE *file; + }; + +public: + // A "move constructor" for moving from a temporary. + buffered_file(Proxy p) FMT_NOEXCEPT : file_(p.file) {} + + // A "move constructor" for moving from an lvalue. + buffered_file(buffered_file &f) FMT_NOEXCEPT : file_(f.file_) + { + f.file_ = FMT_NULL; + } + + // A "move assignment operator" for moving from a temporary. + buffered_file &operator=(Proxy p) + { + close(); + file_ = p.file; + return *this; + } + + // A "move assignment operator" for moving from an lvalue. + buffered_file &operator=(buffered_file &other) + { + close(); + file_ = other.file_; + other.file_ = FMT_NULL; + return *this; + } + + // Returns a proxy object for moving from a temporary: + // buffered_file file = buffered_file(...); + operator Proxy() FMT_NOEXCEPT + { + Proxy p = {file_}; + file_ = FMT_NULL; + return p; + } + +#else +private: + FMT_DISALLOW_COPY_AND_ASSIGN(buffered_file); + +public: + buffered_file(buffered_file &&other) FMT_NOEXCEPT : file_(other.file_) + { + other.file_ = FMT_NULL; + } + + buffered_file &operator=(buffered_file &&other) + { + close(); + file_ = other.file_; + other.file_ = FMT_NULL; + return *this; + } +#endif + + // Opens a file. + FMT_API buffered_file(cstring_view filename, cstring_view mode); + + // Closes the file. + FMT_API void close(); + + // Returns the pointer to a FILE object representing this file. + FILE *get() const FMT_NOEXCEPT + { + return file_; + } + + // We place parentheses around fileno to workaround a bug in some versions + // of MinGW that define fileno as a macro. + FMT_API int(fileno)() const; + + void vprint(string_view format_str, format_args args) + { + fmt::vprint(file_, format_str, args); + } + + template + inline void print(string_view format_str, const Args &... args) + { + vprint(format_str, make_format_args(args...)); + } +}; + +// A file. Closed file is represented by a file object with descriptor -1. +// Methods that are not declared with FMT_NOEXCEPT may throw +// fmt::system_error in case of failure. Note that some errors such as +// closing the file multiple times will cause a crash on Windows rather +// than an exception. You can get standard behavior by overriding the +// invalid parameter handler with _set_invalid_parameter_handler. +class file +{ +private: + int fd_; // File descriptor. + + // Constructs a file object with a given descriptor. + explicit file(int fd) + : fd_(fd) + { + } + +public: + // Possible values for the oflag argument to the constructor. + enum + { + RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only. + WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only. + RDWR = FMT_POSIX(O_RDWR) // Open for reading and writing. + }; + + // Constructs a file object which doesn't represent any file. + file() FMT_NOEXCEPT : fd_(-1) {} + + // Opens a file and constructs a file object representing this file. + FMT_API file(cstring_view path, int oflag); + +#if !FMT_USE_RVALUE_REFERENCES + // Emulate a move constructor and a move assignment operator if rvalue + // references are not supported. + +private: + // A proxy object to emulate a move constructor. + // It is private to make it impossible call operator Proxy directly. + struct Proxy + { + int fd; + }; + +public: + // A "move constructor" for moving from a temporary. + file(Proxy p) FMT_NOEXCEPT : fd_(p.fd) {} + + // A "move constructor" for moving from an lvalue. + file(file &other) FMT_NOEXCEPT : fd_(other.fd_) + { + other.fd_ = -1; + } + + // A "move assignment operator" for moving from a temporary. + file &operator=(Proxy p) + { + close(); + fd_ = p.fd; + return *this; + } + + // A "move assignment operator" for moving from an lvalue. + file &operator=(file &other) + { + close(); + fd_ = other.fd_; + other.fd_ = -1; + return *this; + } + + // Returns a proxy object for moving from a temporary: + // file f = file(...); + operator Proxy() FMT_NOEXCEPT + { + Proxy p = {fd_}; + fd_ = -1; + return p; + } + +#else +private: + FMT_DISALLOW_COPY_AND_ASSIGN(file); + +public: + file(file &&other) FMT_NOEXCEPT : fd_(other.fd_) + { + other.fd_ = -1; + } + + file &operator=(file &&other) + { + close(); + fd_ = other.fd_; + other.fd_ = -1; + return *this; + } +#endif + + // Destroys the object closing the file it represents if any. + FMT_API ~file() FMT_DTOR_NOEXCEPT; + + // Returns the file descriptor. + int descriptor() const FMT_NOEXCEPT + { + return fd_; + } + + // Closes the file. + FMT_API void close(); + + // Returns the file size. The size has signed type for consistency with + // stat::st_size. + FMT_API long long size() const; + + // Attempts to read count bytes from the file into the specified buffer. + FMT_API std::size_t read(void *buffer, std::size_t count); + + // Attempts to write count bytes from the specified buffer to the file. + FMT_API std::size_t write(const void *buffer, std::size_t count); + + // Duplicates a file descriptor with the dup function and returns + // the duplicate as a file object. + FMT_API static file dup(int fd); + + // Makes fd be the copy of this file descriptor, closing fd first if + // necessary. + FMT_API void dup2(int fd); + + // Makes fd be the copy of this file descriptor, closing fd first if + // necessary. + FMT_API void dup2(int fd, error_code &ec) FMT_NOEXCEPT; + + // Creates a pipe setting up read_end and write_end file objects for reading + // and writing respectively. + FMT_API static void pipe(file &read_end, file &write_end); + + // Creates a buffered_file object associated with this file and detaches + // this file object from the file. + FMT_API buffered_file fdopen(const char *mode); +}; + +// Returns the memory page size. +long getpagesize(); + +#if (defined(LC_NUMERIC_MASK) || defined(_MSC_VER)) && !defined(__ANDROID__) && !defined(__CYGWIN__) && !defined(__OpenBSD__) +#define FMT_LOCALE +#endif + +#ifdef FMT_LOCALE +// A "C" numeric locale. +class Locale +{ +private: +#ifdef _MSC_VER + typedef _locale_t locale_t; + + enum + { + LC_NUMERIC_MASK = LC_NUMERIC + }; + + static locale_t newlocale(int category_mask, const char *locale, locale_t) + { + return _create_locale(category_mask, locale); + } + + static void freelocale(locale_t locale) + { + _free_locale(locale); + } + + static double strtod_l(const char *nptr, char **endptr, _locale_t locale) + { + return _strtod_l(nptr, endptr, locale); + } +#endif + + locale_t locale_; + + FMT_DISALLOW_COPY_AND_ASSIGN(Locale); + +public: + typedef locale_t Type; + + Locale() + : locale_(newlocale(LC_NUMERIC_MASK, "C", FMT_NULL)) + { + if (!locale_) + FMT_THROW(system_error(errno, "cannot create locale")); + } + ~Locale() + { + freelocale(locale_); + } + + Type get() const + { + return locale_; + } + + // Converts string to floating-point number and advances str past the end + // of the parsed input. + double strtod(const char *&str) const + { + char *end = FMT_NULL; + double result = strtod_l(str, &end, locale_); + str = end; + return result; + } +}; +#endif // FMT_LOCALE +FMT_END_NAMESPACE + +#if !FMT_USE_RVALUE_REFERENCES +namespace std { +// For compatibility with C++98. +inline fmt::buffered_file &move(fmt::buffered_file &f) +{ + return f; +} +inline fmt::file &move(fmt::file &f) +{ + return f; +} +} // namespace std +#endif + +#endif // FMT_POSIX_H_ diff --git a/include/spdlog/fmt/bundled/printf.h b/include/spdlog/fmt/bundled/printf.h new file mode 100644 index 00000000..073439e6 --- /dev/null +++ b/include/spdlog/fmt/bundled/printf.h @@ -0,0 +1,786 @@ +// Formatting library for C++ +// +// Copyright (c) 2012 - 2016, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. + +#ifndef FMT_PRINTF_H_ +#define FMT_PRINTF_H_ + +#include // std::fill_n +#include // std::numeric_limits + +#include "ostream.h" + +FMT_BEGIN_NAMESPACE +namespace internal { + +// Checks if a value fits in int - used to avoid warnings about comparing +// signed and unsigned integers. +template +struct int_checker +{ + template + static bool fits_in_int(T value) + { + unsigned max = std::numeric_limits::max(); + return value <= max; + } + static bool fits_in_int(bool) + { + return true; + } +}; + +template<> +struct int_checker +{ + template + static bool fits_in_int(T value) + { + return value >= std::numeric_limits::min() && value <= std::numeric_limits::max(); + } + static bool fits_in_int(int) + { + return true; + } +}; + +class printf_precision_handler : public function +{ +public: + template + typename std::enable_if::value, int>::type operator()(T value) + { + if (!int_checker::is_signed>::fits_in_int(value)) + FMT_THROW(format_error("number is too big")); + return static_cast(value); + } + + template + typename std::enable_if::value, int>::type operator()(T) + { + FMT_THROW(format_error("precision is not integer")); + return 0; + } +}; + +// An argument visitor that returns true iff arg is a zero integer. +class is_zero_int : public function +{ +public: + template + typename std::enable_if::value, bool>::type operator()(T value) + { + return value == 0; + } + + template + typename std::enable_if::value, bool>::type operator()(T) + { + return false; + } +}; + +template +struct make_unsigned_or_bool : std::make_unsigned +{ +}; + +template<> +struct make_unsigned_or_bool +{ + typedef bool type; +}; + +template +class arg_converter : public function +{ +private: + typedef typename Context::char_type Char; + + basic_format_arg &arg_; + typename Context::char_type type_; + +public: + arg_converter(basic_format_arg &arg, Char type) + : arg_(arg) + , type_(type) + { + } + + void operator()(bool value) + { + if (type_ != 's') + operator()(value); + } + + template + typename std::enable_if::value>::type operator()(U value) + { + bool is_signed = type_ == 'd' || type_ == 'i'; + typedef typename std::conditional::value, U, T>::type TargetType; + if (const_check(sizeof(TargetType) <= sizeof(int))) + { + // Extra casts are used to silence warnings. + if (is_signed) + { + arg_ = internal::make_arg(static_cast(static_cast(value))); + } + else + { + typedef typename make_unsigned_or_bool::type Unsigned; + arg_ = internal::make_arg(static_cast(static_cast(value))); + } + } + else + { + if (is_signed) + { + // glibc's printf doesn't sign extend arguments of smaller types: + // std::printf("%lld", -42); // prints "4294967254" + // but we don't have to do the same because it's a UB. + arg_ = internal::make_arg(static_cast(value)); + } + else + { + arg_ = internal::make_arg(static_cast::type>(value)); + } + } + } + + template + typename std::enable_if::value>::type operator()(U) + { + // No coversion needed for non-integral types. + } +}; + +// Converts an integer argument to T for printf, if T is an integral type. +// If T is void, the argument is converted to corresponding signed or unsigned +// type depending on the type specifier: 'd' and 'i' - signed, other - +// unsigned). +template +void convert_arg(basic_format_arg &arg, Char type) +{ + visit(arg_converter(arg, type), arg); +} + +// Converts an integer argument to char for printf. +template +class char_converter : public function +{ +private: + basic_format_arg &arg_; + + FMT_DISALLOW_COPY_AND_ASSIGN(char_converter); + +public: + explicit char_converter(basic_format_arg &arg) + : arg_(arg) + { + } + + template + typename std::enable_if::value>::type operator()(T value) + { + typedef typename Context::char_type Char; + arg_ = internal::make_arg(static_cast(value)); + } + + template + typename std::enable_if::value>::type operator()(T) + { + // No coversion needed for non-integral types. + } +}; + +// Checks if an argument is a valid printf width specifier and sets +// left alignment if it is negative. +template +class printf_width_handler : public function +{ +private: + typedef basic_format_specs format_specs; + + format_specs &spec_; + + FMT_DISALLOW_COPY_AND_ASSIGN(printf_width_handler); + +public: + explicit printf_width_handler(format_specs &spec) + : spec_(spec) + { + } + + template + typename std::enable_if::value, unsigned>::type operator()(T value) + { + typedef typename internal::int_traits::main_type UnsignedType; + UnsignedType width = static_cast(value); + if (internal::is_negative(value)) + { + spec_.align_ = ALIGN_LEFT; + width = 0 - width; + } + unsigned int_max = std::numeric_limits::max(); + if (width > int_max) + FMT_THROW(format_error("number is too big")); + return static_cast(width); + } + + template + typename std::enable_if::value, unsigned>::type operator()(T) + { + FMT_THROW(format_error("width is not integer")); + return 0; + } +}; +} // namespace internal + +template +class printf_arg_formatter; + +template>>> +class basic_printf_context; + +/** + \rst + The ``printf`` argument formatter. + \endrst + */ +template +class printf_arg_formatter : public internal::function::iterator>, + public internal::arg_formatter_base +{ +private: + typedef typename Range::value_type char_type; + typedef decltype(internal::declval().begin()) iterator; + typedef internal::arg_formatter_base base; + typedef basic_printf_context context_type; + + context_type &context_; + + void write_null_pointer(char) + { + this->spec().type_ = 0; + this->write("(nil)"); + } + + void write_null_pointer(wchar_t) + { + this->spec().type_ = 0; + this->write(L"(nil)"); + } + +public: + typedef typename base::format_specs format_specs; + + /** + \rst + Constructs an argument formatter object. + *buffer* is a reference to the output buffer and *spec* contains format + specifier information for standard argument types. + \endrst + */ + printf_arg_formatter(internal::basic_buffer &buffer, format_specs &spec, context_type &ctx) + : base(back_insert_range>(buffer), spec) + , context_(ctx) + { + } + + using base::operator(); + + /** Formats an argument of type ``bool``. */ + iterator operator()(bool value) + { + format_specs &fmt_spec = this->spec(); + if (fmt_spec.type_ != 's') + return (*this)(value ? 1 : 0); + fmt_spec.type_ = 0; + this->write(value); + return this->out(); + } + + /** Formats a character. */ + iterator operator()(char_type value) + { + format_specs &fmt_spec = this->spec(); + if (fmt_spec.type_ && fmt_spec.type_ != 'c') + return (*this)(static_cast(value)); + fmt_spec.flags_ = 0; + fmt_spec.align_ = ALIGN_RIGHT; + return base::operator()(value); + } + + /** Formats a null-terminated C string. */ + iterator operator()(const char *value) + { + if (value) + base::operator()(value); + else if (this->spec().type_ == 'p') + write_null_pointer(char_type()); + else + this->write("(null)"); + return this->out(); + } + + /** Formats a null-terminated wide C string. */ + iterator operator()(const wchar_t *value) + { + if (value) + base::operator()(value); + else if (this->spec().type_ == 'p') + write_null_pointer(char_type()); + else + this->write(L"(null)"); + return this->out(); + } + + /** Formats a pointer. */ + iterator operator()(const void *value) + { + if (value) + return base::operator()(value); + this->spec().type_ = 0; + write_null_pointer(char_type()); + return this->out(); + } + + /** Formats an argument of a custom (user-defined) type. */ + iterator operator()(typename basic_format_arg::handle handle) + { + handle.format(context_); + return this->out(); + } +}; + +template +struct printf_formatter +{ + template + auto parse(ParseContext &ctx) -> decltype(ctx.begin()) + { + return ctx.begin(); + } + + template + auto format(const T &value, FormatContext &ctx) -> decltype(ctx.out()) + { + internal::format_value(internal::get_container(ctx.out()), value); + return ctx.out(); + } +}; + +/** This template formats data and writes the output to a writer. */ +template +class basic_printf_context : private internal::context_base, Char> +{ +public: + /** The character type for the output. */ + typedef Char char_type; + + template + struct formatter_type + { + typedef printf_formatter type; + }; + +private: + typedef internal::context_base base; + typedef typename base::format_arg format_arg; + typedef basic_format_specs format_specs; + typedef internal::null_terminating_iterator iterator; + + void parse_flags(format_specs &spec, iterator &it); + + // Returns the argument with specified index or, if arg_index is equal + // to the maximum unsigned value, the next argument. + format_arg get_arg(iterator it, unsigned arg_index = (std::numeric_limits::max)()); + + // Parses argument index, flags and width and returns the argument index. + unsigned parse_header(iterator &it, format_specs &spec); + +public: + /** + \rst + Constructs a ``printf_context`` object. References to the arguments and + the writer are stored in the context object so make sure they have + appropriate lifetimes. + \endrst + */ + basic_printf_context(OutputIt out, basic_string_view format_str, basic_format_args args) + : base(out, format_str, args) + { + } + + using base::advance_to; + using base::out; + using base::parse_context; + + /** Formats stored arguments and writes the output to the range. */ + void format(); +}; + +template +void basic_printf_context::parse_flags(format_specs &spec, iterator &it) +{ + for (;;) + { + switch (*it++) + { + case '-': + spec.align_ = ALIGN_LEFT; + break; + case '+': + spec.flags_ |= SIGN_FLAG | PLUS_FLAG; + break; + case '0': + spec.fill_ = '0'; + break; + case ' ': + spec.flags_ |= SIGN_FLAG; + break; + case '#': + spec.flags_ |= HASH_FLAG; + break; + default: + --it; + return; + } + } +} + +template +typename basic_printf_context::format_arg basic_printf_context::get_arg( + iterator it, unsigned arg_index) +{ + (void)it; + if (arg_index == std::numeric_limits::max()) + return this->do_get_arg(this->parse_context().next_arg_id()); + return base::get_arg(arg_index - 1); +} + +template +unsigned basic_printf_context::parse_header(iterator &it, format_specs &spec) +{ + unsigned arg_index = std::numeric_limits::max(); + char_type c = *it; + if (c >= '0' && c <= '9') + { + // Parse an argument index (if followed by '$') or a width possibly + // preceded with '0' flag(s). + internal::error_handler eh; + unsigned value = parse_nonnegative_int(it, eh); + if (*it == '$') + { // value is an argument index + ++it; + arg_index = value; + } + else + { + if (c == '0') + spec.fill_ = '0'; + if (value != 0) + { + // Nonzero value means that we parsed width and don't need to + // parse it or flags again, so return now. + spec.width_ = value; + return arg_index; + } + } + } + parse_flags(spec, it); + // Parse width. + if (*it >= '0' && *it <= '9') + { + internal::error_handler eh; + spec.width_ = parse_nonnegative_int(it, eh); + } + else if (*it == '*') + { + ++it; + spec.width_ = visit(internal::printf_width_handler(spec), get_arg(it)); + } + return arg_index; +} + +template +void basic_printf_context::format() +{ + auto &buffer = internal::get_container(this->out()); + auto start = iterator(this->parse_context()); + auto it = start; + using internal::pointer_from; + while (*it) + { + char_type c = *it++; + if (c != '%') + continue; + if (*it == c) + { + buffer.append(pointer_from(start), pointer_from(it)); + start = ++it; + continue; + } + buffer.append(pointer_from(start), pointer_from(it) - 1); + + format_specs spec; + spec.align_ = ALIGN_RIGHT; + + // Parse argument index, flags and width. + unsigned arg_index = parse_header(it, spec); + + // Parse precision. + if (*it == '.') + { + ++it; + if ('0' <= *it && *it <= '9') + { + internal::error_handler eh; + spec.precision_ = static_cast(parse_nonnegative_int(it, eh)); + } + else if (*it == '*') + { + ++it; + spec.precision_ = visit(internal::printf_precision_handler(), get_arg(it)); + } + else + { + spec.precision_ = 0; + } + } + + format_arg arg = get_arg(it, arg_index); + if (spec.flag(HASH_FLAG) && visit(internal::is_zero_int(), arg)) + spec.flags_ &= ~internal::to_unsigned(HASH_FLAG); + if (spec.fill_ == '0') + { + if (arg.is_arithmetic()) + spec.align_ = ALIGN_NUMERIC; + else + spec.fill_ = ' '; // Ignore '0' flag for non-numeric types. + } + + // Parse length and convert the argument to the required type. + using internal::convert_arg; + switch (*it++) + { + case 'h': + if (*it == 'h') + convert_arg(arg, *++it); + else + convert_arg(arg, *it); + break; + case 'l': + if (*it == 'l') + convert_arg(arg, *++it); + else + convert_arg(arg, *it); + break; + case 'j': + convert_arg(arg, *it); + break; + case 'z': + convert_arg(arg, *it); + break; + case 't': + convert_arg(arg, *it); + break; + case 'L': + // printf produces garbage when 'L' is omitted for long double, no + // need to do the same. + break; + default: + --it; + convert_arg(arg, *it); + } + + // Parse type. + if (!*it) + FMT_THROW(format_error("invalid format string")); + spec.type_ = static_cast(*it++); + if (arg.is_integral()) + { + // Normalize type. + switch (spec.type_) + { + case 'i': + case 'u': + spec.type_ = 'd'; + break; + case 'c': + // TODO: handle wchar_t better? + visit(internal::char_converter(arg), arg); + break; + } + } + + start = it; + + // Format argument. + visit(AF(buffer, spec, *this), arg); + } + buffer.append(pointer_from(start), pointer_from(it)); +} + +template +void printf(internal::basic_buffer &buf, basic_string_view format, basic_format_args args) +{ + Context(std::back_inserter(buf), format, args).format(); +} + +template +struct printf_context +{ + typedef basic_printf_context, typename Buffer::value_type> type; +}; + +template +inline format_arg_store::type, Args...> make_printf_args(const Args &... args) +{ + return format_arg_store::type, Args...>(args...); +} +typedef basic_format_args::type> printf_args; +typedef basic_format_args::type> wprintf_args; + +inline std::string vsprintf(string_view format, printf_args args) +{ + memory_buffer buffer; + printf(buffer, format, args); + return to_string(buffer); +} + +/** + \rst + Formats arguments and returns the result as a string. + + **Example**:: + + std::string message = fmt::sprintf("The answer is %d", 42); + \endrst +*/ +template +inline std::string sprintf(string_view format_str, const Args &... args) +{ + return vsprintf(format_str, make_format_args::type>(args...)); +} + +inline std::wstring vsprintf(wstring_view format, wprintf_args args) +{ + wmemory_buffer buffer; + printf(buffer, format, args); + return to_string(buffer); +} + +template +inline std::wstring sprintf(wstring_view format_str, const Args &... args) +{ + return vsprintf(format_str, make_format_args::type>(args...)); +} + +template +inline int vfprintf( + std::FILE *f, basic_string_view format, basic_format_args>::type> args) +{ + basic_memory_buffer buffer; + printf(buffer, format, args); + std::size_t size = buffer.size(); + return std::fwrite(buffer.data(), sizeof(Char), size, f) < size ? -1 : static_cast(size); +} + +/** + \rst + Prints formatted data to the file *f*. + + **Example**:: + + fmt::fprintf(stderr, "Don't %s!", "panic"); + \endrst + */ +template +inline int fprintf(std::FILE *f, string_view format_str, const Args &... args) +{ + auto vargs = make_format_args::type>(args...); + return vfprintf(f, format_str, vargs); +} + +template +inline int fprintf(std::FILE *f, wstring_view format_str, const Args &... args) +{ + return vfprintf(f, format_str, make_format_args::type>(args...)); +} + +inline int vprintf(string_view format, printf_args args) +{ + return vfprintf(stdout, format, args); +} + +inline int vprintf(wstring_view format, wprintf_args args) +{ + return vfprintf(stdout, format, args); +} + +/** + \rst + Prints formatted data to ``stdout``. + + **Example**:: + + fmt::printf("Elapsed time: %.2f seconds", 1.23); + \endrst + */ +template +inline int printf(string_view format_str, const Args &... args) +{ + return vprintf(format_str, make_format_args::type>(args...)); +} + +template +inline int printf(wstring_view format_str, const Args &... args) +{ + return vprintf(format_str, make_format_args::type>(args...)); +} + +inline int vfprintf(std::ostream &os, string_view format_str, printf_args args) +{ + memory_buffer buffer; + printf(buffer, format_str, args); + internal::write(os, buffer); + return static_cast(buffer.size()); +} + +inline int vfprintf(std::wostream &os, wstring_view format_str, wprintf_args args) +{ + wmemory_buffer buffer; + printf(buffer, format_str, args); + internal::write(os, buffer); + return static_cast(buffer.size()); +} + +/** + \rst + Prints formatted data to the stream *os*. + + **Example**:: + + fmt::fprintf(cerr, "Don't %s!", "panic"); + \endrst + */ +template +inline int fprintf(std::ostream &os, string_view format_str, const Args &... args) +{ + auto vargs = make_format_args::type>(args...); + return vfprintf(os, format_str, vargs); +} + +template +inline int fprintf(std::wostream &os, wstring_view format_str, const Args &... args) +{ + auto vargs = make_format_args::type>(args...); + return vfprintf(os, format_str, vargs); +} +FMT_END_NAMESPACE + +#endif // FMT_PRINTF_H_ diff --git a/include/spdlog/fmt/bundled/ranges.h b/include/spdlog/fmt/bundled/ranges.h new file mode 100644 index 00000000..0c871cc6 --- /dev/null +++ b/include/spdlog/fmt/bundled/ranges.h @@ -0,0 +1,342 @@ +// Formatting library for C++ - the core API +// +// Copyright (c) 2012 - present, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. +// +// Copyright (c) 2018 - present, Remotion (Igor Schulz) +// All Rights Reserved +// {fmt} support for ranges, containers and types tuple interface. + +#ifndef FMT_RANGES_H_ +#define FMT_RANGES_H_ + +#include "format.h" +#include + +// output only up to N items from the range. +#ifndef FMT_RANGE_OUTPUT_LENGTH_LIMIT +#define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256 +#endif + +FMT_BEGIN_NAMESPACE + +template +struct formatting_base +{ + template + FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) + { + return ctx.begin(); + } +}; + +template +struct formatting_range : formatting_base +{ + static FMT_CONSTEXPR_DECL const std::size_t range_length_limit = + FMT_RANGE_OUTPUT_LENGTH_LIMIT; // output only up to N items from the range. + Char prefix; + Char delimiter; + Char postfix; + formatting_range() + : prefix('{') + , delimiter(',') + , postfix('}') + { + } + static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true; + static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false; +}; + +template +struct formatting_tuple : formatting_base +{ + Char prefix; + Char delimiter; + Char postfix; + formatting_tuple() + : prefix('(') + , delimiter(',') + , postfix(')') + { + } + static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true; + static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false; +}; + +namespace internal { + +template +void copy(const RangeT &range, OutputIterator out) +{ + for (auto it = range.begin(), end = range.end(); it != end; ++it) + *out++ = *it; +} + +template +void copy(const char *str, OutputIterator out) +{ + const char *p_curr = str; + while (*p_curr) + { + *out++ = *p_curr++; + } +} + +template +void copy(char ch, OutputIterator out) +{ + *out++ = ch; +} + +/// Return true value if T has std::string interface, like std::string_view. +template +class is_like_std_string +{ + template + static auto check(U *p) -> decltype(p->find('a'), p->length(), p->data(), int()); + template + static void check(...); + +public: + static FMT_CONSTEXPR_DECL const bool value = !std::is_void(FMT_NULL))>::value; +}; + +template +struct conditional_helper +{ +}; + +template +struct is_range_ : std::false_type +{ +}; + +template +struct is_range_().begin()), decltype(internal::declval().end())>, void>::type> + : std::true_type +{ +}; + +/// tuple_size and tuple_element check. +template +class is_tuple_like_ +{ + template + static auto check(U *p) -> decltype(std::tuple_size::value, internal::declval::type>(), int()); + template + static void check(...); + +public: + static FMT_CONSTEXPR_DECL const bool value = !std::is_void(FMT_NULL))>::value; +}; + +// Check for integer_sequence +#if defined(__cpp_lib_integer_sequence) || FMT_MSC_VER >= 1900 +template +using integer_sequence = std::integer_sequence; +template +using index_sequence = std::index_sequence; +template +using make_index_sequence = std::make_index_sequence; +#else +template +struct integer_sequence +{ + typedef T value_type; + + static FMT_CONSTEXPR std::size_t size() + { + return sizeof...(N); + } +}; + +template +using index_sequence = integer_sequence; + +template +struct make_integer_sequence : make_integer_sequence +{ +}; +template +struct make_integer_sequence : integer_sequence +{ +}; + +template +using make_index_sequence = make_integer_sequence; +#endif + +template +void for_each(index_sequence, Tuple &&tup, F &&f) noexcept +{ + using std::get; + // using free function get(T) now. + const int _[] = {0, ((void)f(get(tup)), 0)...}; + (void)_; // blocks warnings +} + +template +FMT_CONSTEXPR make_index_sequence::value> get_indexes(T const &) +{ + return {}; +} + +template +void for_each(Tuple &&tup, F &&f) +{ + const auto indexes = get_indexes(tup); + for_each(indexes, std::forward(tup), std::forward(f)); +} + +template +FMT_CONSTEXPR const char *format_str_quoted( + bool add_space, const Arg &, typename std::enable_if::type>::value>::type * = nullptr) +{ + return add_space ? " {}" : "{}"; +} + +template +FMT_CONSTEXPR const char *format_str_quoted( + bool add_space, const Arg &, typename std::enable_if::type>::value>::type * = nullptr) +{ + return add_space ? " \"{}\"" : "\"{}\""; +} + +FMT_CONSTEXPR const char *format_str_quoted(bool add_space, const char *) +{ + return add_space ? " \"{}\"" : "\"{}\""; +} +FMT_CONSTEXPR const wchar_t *format_str_quoted(bool add_space, const wchar_t *) +{ + return add_space ? L" \"{}\"" : L"\"{}\""; +} + +FMT_CONSTEXPR const char *format_str_quoted(bool add_space, const char) +{ + return add_space ? " '{}'" : "'{}'"; +} +FMT_CONSTEXPR const wchar_t *format_str_quoted(bool add_space, const wchar_t) +{ + return add_space ? L" '{}'" : L"'{}'"; +} + +} // namespace internal + +template +struct is_tuple_like +{ + static FMT_CONSTEXPR_DECL const bool value = internal::is_tuple_like_::value && !internal::is_range_::value; +}; + +template +struct formatter::value>::type> +{ +private: + // C++11 generic lambda for format() + template + struct format_each + { + template + void operator()(const T &v) + { + if (i > 0) + { + if (formatting.add_prepostfix_space) + { + *out++ = ' '; + } + internal::copy(formatting.delimiter, out); + } + format_to(out, internal::format_str_quoted((formatting.add_delimiter_spaces && i > 0), v), v); + ++i; + } + + formatting_tuple &formatting; + std::size_t &i; + typename std::add_lvalue_reference().out())>::type out; + }; + +public: + formatting_tuple formatting; + + template + FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) + { + return formatting.parse(ctx); + } + + template + auto format(const TupleT &values, FormatContext &ctx) -> decltype(ctx.out()) + { + auto out = ctx.out(); + std::size_t i = 0; + internal::copy(formatting.prefix, out); + + internal::for_each(values, format_each{formatting, i, out}); + if (formatting.add_prepostfix_space) + { + *out++ = ' '; + } + internal::copy(formatting.postfix, out); + + return ctx.out(); + } +}; + +template +struct is_range +{ + static FMT_CONSTEXPR_DECL const bool value = internal::is_range_::value && !internal::is_like_std_string::value; +}; + +template +struct formatter::value>::type> +{ + + formatting_range formatting; + + template + FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) + { + return formatting.parse(ctx); + } + + template + typename FormatContext::iterator format(const RangeT &values, FormatContext &ctx) + { + auto out = ctx.out(); + internal::copy(formatting.prefix, out); + std::size_t i = 0; + for (auto it = values.begin(), end = values.end(); it != end; ++it) + { + if (i > 0) + { + if (formatting.add_prepostfix_space) + { + *out++ = ' '; + } + internal::copy(formatting.delimiter, out); + } + format_to(out, internal::format_str_quoted((formatting.add_delimiter_spaces && i > 0), *it), *it); + if (++i > formatting.range_length_limit) + { + format_to(out, " ... "); + break; + } + } + if (formatting.add_prepostfix_space) + { + *out++ = ' '; + } + internal::copy(formatting.postfix, out); + return ctx.out(); + } +}; + +FMT_END_NAMESPACE + +#endif // FMT_RANGES_H_ diff --git a/include/spdlog/fmt/bundled/time.h b/include/spdlog/fmt/bundled/time.h new file mode 100644 index 00000000..3e1443b8 --- /dev/null +++ b/include/spdlog/fmt/bundled/time.h @@ -0,0 +1,199 @@ +// Formatting library for C++ - time formatting +// +// Copyright (c) 2012 - 2016, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. + +#ifndef FMT_TIME_H_ +#define FMT_TIME_H_ + +#include "format.h" +#include + +FMT_BEGIN_NAMESPACE + +namespace internal { +inline null<> localtime_r(...) +{ + return null<>(); +} +inline null<> localtime_s(...) +{ + return null<>(); +} +inline null<> gmtime_r(...) +{ + return null<>(); +} +inline null<> gmtime_s(...) +{ + return null<>(); +} +} // namespace internal + +// Thread-safe replacement for std::localtime +inline std::tm localtime(std::time_t time) +{ + struct dispatcher + { + std::time_t time_; + std::tm tm_; + + dispatcher(std::time_t t) + : time_(t) + { + } + + bool run() + { + using namespace fmt::internal; + return handle(localtime_r(&time_, &tm_)); + } + + bool handle(std::tm *tm) + { + return tm != FMT_NULL; + } + + bool handle(internal::null<>) + { + using namespace fmt::internal; + return fallback(localtime_s(&tm_, &time_)); + } + + bool fallback(int res) + { + return res == 0; + } + + bool fallback(internal::null<>) + { + using namespace fmt::internal; + std::tm *tm = std::localtime(&time_); + if (tm) + tm_ = *tm; + return tm != FMT_NULL; + } + }; + dispatcher lt(time); + if (lt.run()) + return lt.tm_; + // Too big time values may be unsupported. + FMT_THROW(format_error("time_t value out of range")); +} + +// Thread-safe replacement for std::gmtime +inline std::tm gmtime(std::time_t time) +{ + struct dispatcher + { + std::time_t time_; + std::tm tm_; + + dispatcher(std::time_t t) + : time_(t) + { + } + + bool run() + { + using namespace fmt::internal; + return handle(gmtime_r(&time_, &tm_)); + } + + bool handle(std::tm *tm) + { + return tm != FMT_NULL; + } + + bool handle(internal::null<>) + { + using namespace fmt::internal; + return fallback(gmtime_s(&tm_, &time_)); + } + + bool fallback(int res) + { + return res == 0; + } + + bool fallback(internal::null<>) + { + std::tm *tm = std::gmtime(&time_); + if (tm) + tm_ = *tm; + return tm != FMT_NULL; + } + }; + dispatcher gt(time); + if (gt.run()) + return gt.tm_; + // Too big time values may be unsupported. + FMT_THROW(format_error("time_t value out of range")); +} + +namespace internal { +inline std::size_t strftime(char *str, std::size_t count, const char *format, const std::tm *time) +{ + return std::strftime(str, count, format, time); +} + +inline std::size_t strftime(wchar_t *str, std::size_t count, const wchar_t *format, const std::tm *time) +{ + return std::wcsftime(str, count, format, time); +} +} // namespace internal + +template +struct formatter +{ + template + auto parse(ParseContext &ctx) -> decltype(ctx.begin()) + { + auto it = internal::null_terminating_iterator(ctx); + if (*it == ':') + ++it; + auto end = it; + while (*end && *end != '}') + ++end; + tm_format.reserve(end - it + 1); + using internal::pointer_from; + tm_format.append(pointer_from(it), pointer_from(end)); + tm_format.push_back('\0'); + return pointer_from(end); + } + + template + auto format(const std::tm &tm, FormatContext &ctx) -> decltype(ctx.out()) + { + internal::basic_buffer &buf = internal::get_container(ctx.out()); + std::size_t start = buf.size(); + for (;;) + { + std::size_t size = buf.capacity() - start; + std::size_t count = internal::strftime(&buf[start], size, &tm_format[0], &tm); + if (count != 0) + { + buf.resize(start + count); + break; + } + if (size >= tm_format.size() * 256) + { + // If the buffer is 256 times larger than the format string, assume + // that `strftime` gives an empty result. There doesn't seem to be a + // better way to distinguish the two cases: + // https://github.com/fmtlib/fmt/issues/367 + break; + } + const std::size_t MIN_GROWTH = 10; + buf.reserve(buf.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH)); + } + return ctx.out(); + } + + basic_memory_buffer tm_format; +}; +FMT_END_NAMESPACE + +#endif // FMT_TIME_H_