// 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 // std::FILE #include #include #include #include // The fmt library version in the form major * 10000 + minor * 100 + patch. #define FMT_VERSION 60103 #ifdef __has_feature # define FMT_HAS_FEATURE(x) __has_feature(x) #else # define FMT_HAS_FEATURE(x) 0 #endif #if defined(__has_include) && !defined(__INTELLISENSE__) && \ !(defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1600) # 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 __NVCC__ # define FMT_NVCC __NVCC__ #else # define FMT_NVCC 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)) && \ !FMT_NVCC #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 // Check if exceptions are disabled. #ifndef FMT_EXCEPTIONS # if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || \ FMT_MSC_VER && !_HAS_EXCEPTIONS # define FMT_EXCEPTIONS 0 # else # define FMT_EXCEPTIONS 1 # endif #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 # define FMT_HAS_CXX11_NOEXCEPT 1 #else # define FMT_DETECTED_NOEXCEPT throw() # define FMT_HAS_CXX11_NOEXCEPT 0 #endif #ifndef FMT_NOEXCEPT # if FMT_EXCEPTIONS || FMT_HAS_CXX11_NOEXCEPT # define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT # else # define FMT_NOEXCEPT # endif #endif // [[noreturn]] is disabled on MSVC and NVCC because of bogus unreachable code // warnings. #if FMT_EXCEPTIONS && FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VER && \ !FMT_NVCC # define FMT_NORETURN [[noreturn]] #else # define FMT_NORETURN #endif #ifndef FMT_DEPRECATED # if (FMT_HAS_CPP_ATTRIBUTE(deprecated) && __cplusplus >= 201402L) || \ FMT_MSC_VER >= 1900 # define FMT_DEPRECATED [[deprecated]] # else # if defined(__GNUC__) || defined(__clang__) # define FMT_DEPRECATED __attribute__((deprecated)) # elif FMT_MSC_VER # define FMT_DEPRECATED __declspec(deprecated) # else # define FMT_DEPRECATED /* deprecated */ # endif # endif #endif // Workaround broken [[deprecated]] in the Intel compiler and NVCC. #if defined(__INTEL_COMPILER) || FMT_NVCC # define FMT_DEPRECATED_ALIAS #else # define FMT_DEPRECATED_ALIAS FMT_DEPRECATED #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 v6; \ } # endif # define FMT_BEGIN_NAMESPACE \ namespace fmt { \ FMT_INLINE_NAMESPACE v6 { #endif #if !defined(FMT_HEADER_ONLY) && defined(_WIN32) # if FMT_MSC_VER # define FMT_NO_W4275 __pragma(warning(suppress : 4275)) # else # define FMT_NO_W4275 # endif # define FMT_CLASS_API FMT_NO_W4275 # ifdef FMT_EXPORT # define FMT_API __declspec(dllexport) # elif defined(FMT_SHARED) # define FMT_API __declspec(dllimport) # define FMT_EXTERN_TEMPLATE_API FMT_API # endif #endif #ifndef FMT_CLASS_API # define FMT_CLASS_API #endif #ifndef FMT_API # if FMT_GCC_VERSION || FMT_CLANG_VERSION # define FMT_API __attribute__((visibility("default"))) # define FMT_EXTERN_TEMPLATE_API FMT_API # define FMT_INSTANTIATION_DEF_API # else # define FMT_API # endif #endif #ifndef FMT_EXTERN_TEMPLATE_API # define FMT_EXTERN_TEMPLATE_API #endif #ifndef FMT_INSTANTIATION_DEF_API # define FMT_INSTANTIATION_DEF_API FMT_API #endif #ifndef FMT_HEADER_ONLY # define FMT_EXTERN extern #else # define FMT_EXTERN #endif // 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_STRING_VIEW #elif FMT_HAS_INCLUDE("experimental/string_view") && __cplusplus >= 201402L # include # define FMT_USE_EXPERIMENTAL_STRING_VIEW #endif #ifndef FMT_UNICODE # define FMT_UNICODE 0 #endif #if FMT_UNICODE # pragma execution_character_set("utf-8") #endif FMT_BEGIN_NAMESPACE // Implementations of enable_if_t and other metafunctions for older systems. template using enable_if_t = typename std::enable_if::type; template using conditional_t = typename std::conditional::type; template using bool_constant = std::integral_constant; template using remove_reference_t = typename std::remove_reference::type; template using remove_const_t = typename std::remove_const::type; template using remove_cvref_t = typename std::remove_cv>::type; template struct type_identity { using type = T; }; template using type_identity_t = typename type_identity::type; struct monostate {}; // An enable_if helper to be used in template parameters which results in much // shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed // to workaround a bug in MSVC 2019 (see #1140 and #1186). #define FMT_ENABLE_IF(...) enable_if_t<(__VA_ARGS__), int> = 0 namespace internal { // A workaround for gcc 4.8 to make void_t work in a SFINAE context. template struct void_t_impl { using type = void; }; FMT_API void assert_fail(const char* file, int line, const char* message); #ifndef FMT_ASSERT # ifdef NDEBUG # define FMT_ASSERT(condition, message) # else # define FMT_ASSERT(condition, message) \ ((condition) \ ? void() \ : ::fmt::internal::assert_fail(__FILE__, __LINE__, (message))) # endif #endif #if defined(FMT_USE_STRING_VIEW) template using std_string_view = std::basic_string_view; #elif defined(FMT_USE_EXPERIMENTAL_STRING_VIEW) template using std_string_view = std::experimental::basic_string_view; #else template struct std_string_view {}; #endif #ifdef FMT_USE_INT128 // Do nothing. #elif defined(__SIZEOF_INT128__) && !FMT_NVCC # define FMT_USE_INT128 1 using int128_t = __int128_t; using uint128_t = __uint128_t; #else # define FMT_USE_INT128 0 #endif #if !FMT_USE_INT128 struct int128_t {}; struct uint128_t {}; #endif // Casts a 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); } } // namespace internal template using void_t = typename internal::void_t_impl::type; /** 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: using char_type FMT_DEPRECATED_ALIAS = Char; using value_type = Char; using iterator = const Char*; FMT_CONSTEXPR basic_string_view() FMT_NOEXCEPT : data_(nullptr), size_(0) {} /** Constructs a string reference object from a C string and a size. */ FMT_CONSTEXPR basic_string_view(const Char* s, size_t count) FMT_NOEXCEPT : data_(s), size_(count) {} /** \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.data()), size_(s.size()) {} template < typename S, FMT_ENABLE_IF(std::is_same>::value)> FMT_CONSTEXPR basic_string_view(S s) FMT_NOEXCEPT : data_(s.data()), size_(s.size()) {} /** Returns a pointer to the string data. */ FMT_CONSTEXPR 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 const Char& operator[](size_t pos) const { return data_[pos]; } 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; } }; using string_view = basic_string_view; using wstring_view = basic_string_view; #ifndef __cpp_char8_t // A UTF-8 code unit type. enum char8_t : unsigned char {}; #endif /** Specifies if ``T`` is a character type. Can be specialized by users. */ template struct is_char : std::false_type {}; template <> struct is_char : std::true_type {}; template <> struct is_char : std::true_type {}; template <> struct is_char : std::true_type {}; template <> struct is_char : std::true_type {}; template <> struct is_char : std::true_type {}; /** \rst Returns a string view of `s`. In order to add custom string type support to {fmt} provide an overload of `to_string_view` for it in the same namespace as the type for the argument-dependent lookup to work. **Example**:: namespace my_ns { inline string_view to_string_view(const my_string& s) { return {s.data(), s.length()}; } } std::string message = fmt::format(my_string("The answer is {}"), 42); \endrst */ template ::value)> inline basic_string_view to_string_view(const Char* s) { return s; } template inline basic_string_view to_string_view( const std::basic_string& s) { return s; } template inline basic_string_view to_string_view(basic_string_view s) { return s; } template >::value)> inline basic_string_view to_string_view( internal::std_string_view s) { return s; } // A base class for compile-time strings. It is defined in the fmt namespace to // make formatting functions visible via ADL, e.g. format(fmt("{}"), 42). struct compile_string {}; template struct is_compile_string : std::is_base_of {}; template ::value)> constexpr basic_string_view to_string_view(const S& s) { return s; } namespace internal { void to_string_view(...); using fmt::v6::to_string_view; // Specifies whether S is a string type convertible to fmt::basic_string_view. // It should be a constexpr function but MSVC 2017 fails to compile it in // enable_if and MSVC 2015 fails to compile it as an alias template. template struct is_string : std::is_class()))> { }; template struct char_t_impl {}; template struct char_t_impl::value>> { using result = decltype(to_string_view(std::declval())); using type = typename result::value_type; }; struct error_handler { FMT_CONSTEXPR error_handler() = default; FMT_CONSTEXPR error_handler(const error_handler&) = default; // This function is intentionally not constexpr to give a compile-time error. FMT_NORETURN FMT_API void on_error(const char* message); }; } // namespace internal /** String's character type. */ template using char_t = typename internal::char_t_impl::type; /** \rst Parsing context consisting of a format string range being parsed and an argument counter for automatic indexing. You can use one of the following type aliases for common character types: +-----------------------+-------------------------------------+ | Type | Definition | +=======================+=====================================+ | format_parse_context | basic_format_parse_context | +-----------------------+-------------------------------------+ | wformat_parse_context | basic_format_parse_context | +-----------------------+-------------------------------------+ \endrst */ template class basic_format_parse_context : private ErrorHandler { private: basic_string_view format_str_; int next_arg_id_; public: using char_type = Char; using iterator = typename basic_string_view::iterator; explicit FMT_CONSTEXPR basic_format_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(internal::to_unsigned(it - begin())); } /** Reports an error if using the manual argument indexing; otherwise returns the next argument index and switches to the automatic indexing. */ FMT_CONSTEXPR int next_arg_id() { if (next_arg_id_ >= 0) return next_arg_id_++; on_error("cannot switch from manual to automatic argument indexing"); return 0; } /** Reports an error if using the automatic argument indexing; otherwise switches to the manual indexing. */ FMT_CONSTEXPR void check_arg_id(int) { if (next_arg_id_ > 0) on_error("cannot switch from automatic to manual argument indexing"); else next_arg_id_ = -1; } FMT_CONSTEXPR 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; } }; using format_parse_context = basic_format_parse_context; using wformat_parse_context = basic_format_parse_context; template using basic_parse_context FMT_DEPRECATED_ALIAS = basic_format_parse_context; using parse_context FMT_DEPRECATED_ALIAS = basic_format_parse_context; using wparse_context FMT_DEPRECATED_ALIAS = basic_format_parse_context; template class basic_format_arg; template class basic_format_args; // A formatter for objects of type T. template struct formatter { // A deleted default constructor indicates a disabled formatter. formatter() = delete; }; template struct FMT_DEPRECATED convert_to_int : bool_constant::value && std::is_convertible::value> {}; // Specifies if T has an enabled formatter specialization. A type can be // formattable even if it doesn't have a formatter e.g. via a conversion. template using has_formatter = std::is_constructible>; namespace internal { /** A contiguous memory buffer with an optional growing ability. */ template class buffer { private: T* ptr_; std::size_t size_; std::size_t capacity_; protected: // Don't initialize ptr_ since it is not accessed to save a few cycles. buffer(std::size_t sz) FMT_NOEXCEPT : size_(sz), capacity_(sz) {} buffer(T* p = nullptr, std::size_t sz = 0, std::size_t cap = 0) FMT_NOEXCEPT : ptr_(p), size_(sz), capacity_(cap) {} /** 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: using value_type = T; using const_reference = const T&; buffer(const buffer&) = delete; void operator=(const buffer&) = delete; virtual ~buffer() = default; T* begin() FMT_NOEXCEPT { return ptr_; } T* end() FMT_NOEXCEPT { return ptr_ + size_; } const T* begin() const FMT_NOEXCEPT { return ptr_; } const T* end() const 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; } /** Clears this buffer. */ void clear() { size_ = 0; } /** Reserves space to store at least *capacity* elements. */ void reserve(std::size_t new_capacity) { if (new_capacity > capacity_) grow(new_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]; } }; // A container-backed buffer. template class container_buffer : public 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) : buffer(c.size()), container_(c) {} }; // Extracts a reference to the container from back_insert_iterator. template inline Container& get_container(std::back_insert_iterator it) { using bi_iterator = std::back_insert_iterator; struct accessor : bi_iterator { accessor(bi_iterator iter) : bi_iterator(iter) {} using bi_iterator::container; }; return *accessor(it).container; } template struct fallback_formatter { fallback_formatter() = delete; }; // Specifies if T has an enabled fallback_formatter specialization. template using has_fallback_formatter = std::is_constructible>; template struct named_arg_base; template struct named_arg; enum class type { none_type, named_arg_type, // Integer types should go first, int_type, uint_type, long_long_type, ulong_long_type, int128_type, uint128_type, bool_type, char_type, last_integer_type = char_type, // followed by floating-point types. float_type, double_type, long_double_type, last_numeric_type = long_double_type, cstring_type, string_type, pointer_type, custom_type }; // Maps core type T to the corresponding type enum constant. template struct type_constant : std::integral_constant {}; #define FMT_TYPE_CONSTANT(Type, constant) \ template \ struct type_constant \ : std::integral_constant {} FMT_TYPE_CONSTANT(const named_arg_base&, named_arg_type); FMT_TYPE_CONSTANT(int, int_type); FMT_TYPE_CONSTANT(unsigned, uint_type); FMT_TYPE_CONSTANT(long long, long_long_type); FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type); FMT_TYPE_CONSTANT(int128_t, int128_type); FMT_TYPE_CONSTANT(uint128_t, uint128_type); FMT_TYPE_CONSTANT(bool, bool_type); FMT_TYPE_CONSTANT(Char, char_type); FMT_TYPE_CONSTANT(float, float_type); FMT_TYPE_CONSTANT(double, double_type); FMT_TYPE_CONSTANT(long double, long_double_type); FMT_TYPE_CONSTANT(const Char*, cstring_type); FMT_TYPE_CONSTANT(basic_string_view, string_type); FMT_TYPE_CONSTANT(const void*, pointer_type); FMT_CONSTEXPR bool is_integral_type(type t) { FMT_ASSERT(t != type::named_arg_type, "invalid argument type"); return t > type::none_type && t <= type::last_integer_type; } FMT_CONSTEXPR bool is_arithmetic_type(type t) { FMT_ASSERT(t != type::named_arg_type, "invalid argument type"); return t > type::none_type && t <= type::last_numeric_type; } template struct string_value { const Char* data; std::size_t size; }; template struct custom_value { using parse_context = basic_format_parse_context; const void* value; void (*format)(const void* arg, parse_context& parse_ctx, Context& ctx); }; // A formatting argument value. template class value { public: using char_type = typename Context::char_type; union { int int_value; unsigned uint_value; long long long_long_value; unsigned long long ulong_long_value; int128_t int128_value; uint128_t uint128_value; bool bool_value; char_type char_value; float float_value; double double_value; long double long_double_value; const void* pointer; string_value string; custom_value custom; const named_arg_base* named_arg; }; FMT_CONSTEXPR value(int val = 0) : int_value(val) {} FMT_CONSTEXPR value(unsigned val) : uint_value(val) {} value(long long val) : long_long_value(val) {} value(unsigned long long val) : ulong_long_value(val) {} value(int128_t val) : int128_value(val) {} value(uint128_t val) : uint128_value(val) {} value(float val) : float_value(val) {} value(double val) : double_value(val) {} value(long double val) : long_double_value(val) {} value(bool val) : bool_value(val) {} value(char_type val) : char_value(val) {} value(const char_type* val) { string.data = val; } value(basic_string_view val) { string.data = val.data(); string.size = val.size(); } value(const void* val) : pointer(val) {} template value(const T& val) { custom.value = &val; // 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`. custom.format = format_custom_arg< T, conditional_t::value, typename Context::template formatter_type, fallback_formatter>>; } value(const named_arg_base& val) { named_arg = &val; } private: // Formats an argument of a custom type, such as a user-defined class. template static void format_custom_arg( const void* arg, basic_format_parse_context& parse_ctx, Context& ctx) { Formatter f; parse_ctx.advance_to(f.parse(parse_ctx)); ctx.advance_to(f.format(*static_cast(arg), ctx)); } }; template FMT_CONSTEXPR basic_format_arg make_arg(const T& value); // 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. enum { long_short = sizeof(long) == sizeof(int) }; using long_type = conditional_t; using ulong_type = conditional_t; // Maps formatting arguments to core types. template struct arg_mapper { using char_type = typename Context::char_type; FMT_CONSTEXPR int map(signed char val) { return val; } FMT_CONSTEXPR unsigned map(unsigned char val) { return val; } FMT_CONSTEXPR int map(short val) { return val; } FMT_CONSTEXPR unsigned map(unsigned short val) { return val; } FMT_CONSTEXPR int map(int val) { return val; } FMT_CONSTEXPR unsigned map(unsigned val) { return val; } FMT_CONSTEXPR long_type map(long val) { return val; } FMT_CONSTEXPR ulong_type map(unsigned long val) { return val; } FMT_CONSTEXPR long long map(long long val) { return val; } FMT_CONSTEXPR unsigned long long map(unsigned long long val) { return val; } FMT_CONSTEXPR int128_t map(int128_t val) { return val; } FMT_CONSTEXPR uint128_t map(uint128_t val) { return val; } FMT_CONSTEXPR bool map(bool val) { return val; } template ::value)> FMT_CONSTEXPR char_type map(T val) { static_assert( std::is_same::value || std::is_same::value, "mixing character types is disallowed"); return val; } FMT_CONSTEXPR float map(float val) { return val; } FMT_CONSTEXPR double map(double val) { return val; } FMT_CONSTEXPR long double map(long double val) { return val; } FMT_CONSTEXPR const char_type* map(char_type* val) { return val; } FMT_CONSTEXPR const char_type* map(const char_type* val) { return val; } template ::value)> FMT_CONSTEXPR basic_string_view map(const T& val) { static_assert(std::is_same>::value, "mixing character types is disallowed"); return to_string_view(val); } template , T>::value && !is_string::value && !has_formatter::value && !has_fallback_formatter::value)> FMT_CONSTEXPR basic_string_view map(const T& val) { return basic_string_view(val); } template < typename T, FMT_ENABLE_IF( std::is_constructible, T>::value && !std::is_constructible, T>::value && !is_string::value && !has_formatter::value && !has_fallback_formatter::value)> FMT_CONSTEXPR basic_string_view map(const T& val) { return std_string_view(val); } FMT_CONSTEXPR const char* map(const signed char* val) { static_assert(std::is_same::value, "invalid string type"); return reinterpret_cast(val); } FMT_CONSTEXPR const char* map(const unsigned char* val) { static_assert(std::is_same::value, "invalid string type"); return reinterpret_cast(val); } FMT_CONSTEXPR const void* map(void* val) { return val; } FMT_CONSTEXPR const void* map(const void* val) { return val; } FMT_CONSTEXPR const void* map(std::nullptr_t val) { return val; } template FMT_CONSTEXPR int map(const T*) { // 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. static_assert(!sizeof(T), "formatting of non-void pointers is disallowed"); return 0; } template ::value && !has_formatter::value && !has_fallback_formatter::value)> FMT_CONSTEXPR auto map(const T& val) -> decltype( map(static_cast::type>(val))) { return map(static_cast::type>(val)); } template < typename T, FMT_ENABLE_IF( !is_string::value && !is_char::value && (has_formatter::value || has_fallback_formatter::value))> FMT_CONSTEXPR const T& map(const T& val) { return val; } template FMT_CONSTEXPR const named_arg_base& map( const named_arg& val) { auto arg = make_arg(val.value); std::memcpy(val.data, &arg, sizeof(arg)); return val; } int map(...) { constexpr bool formattable = sizeof(Context) == 0; static_assert( formattable, "Cannot format argument. To make type T formattable provide a " "formatter specialization: " "https://fmt.dev/latest/api.html#formatting-user-defined-types"); return 0; } }; // A type constant after applying arg_mapper. template using mapped_type_constant = type_constant().map(std::declval())), typename Context::char_type>; enum { packed_arg_bits = 5 }; // Maximum number of arguments with packed types. enum { max_packed_args = 63 / packed_arg_bits }; enum : unsigned long long { is_unpacked_bit = 1ULL << 63 }; template class arg_map; } // 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 auto visit_format_arg(Visitor&& vis, const basic_format_arg& arg) -> decltype(vis(0)); friend class basic_format_args; friend class internal::arg_map; using char_type = typename Context::char_type; public: class handle { public: explicit handle(internal::custom_value custom) : custom_(custom) {} void format(basic_format_parse_context& parse_ctx, Context& ctx) const { custom_.format(custom_.value, parse_ctx, ctx); } private: internal::custom_value custom_; }; FMT_CONSTEXPR basic_format_arg() : type_(internal::type::none_type) {} FMT_CONSTEXPR explicit operator bool() const FMT_NOEXCEPT { return type_ != internal::type::none_type; } internal::type type() const { return type_; } bool is_integral() const { return internal::is_integral_type(type_); } bool is_arithmetic() const { return internal::is_arithmetic_type(type_); } }; /** \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 auto visit_format_arg(Visitor&& vis, const basic_format_arg& arg) -> decltype(vis(0)) { using char_type = typename Context::char_type; switch (arg.type_) { case internal::type::none_type: break; case internal::type::named_arg_type: FMT_ASSERT(false, "invalid argument type"); break; case internal::type::int_type: return vis(arg.value_.int_value); case internal::type::uint_type: return vis(arg.value_.uint_value); case internal::type::long_long_type: return vis(arg.value_.long_long_value); case internal::type::ulong_long_type: return vis(arg.value_.ulong_long_value); #if FMT_USE_INT128 case internal::type::int128_type: return vis(arg.value_.int128_value); case internal::type::uint128_type: return vis(arg.value_.uint128_value); #else case internal::type::int128_type: case internal::type::uint128_type: break; #endif case internal::type::bool_type: return vis(arg.value_.bool_value); case internal::type::char_type: return vis(arg.value_.char_value); case internal::type::float_type: return vis(arg.value_.float_value); case internal::type::double_type: return vis(arg.value_.double_value); case internal::type::long_double_type: return vis(arg.value_.long_double_value); case internal::type::cstring_type: return vis(arg.value_.string.data); case internal::type::string_type: return vis(basic_string_view(arg.value_.string.data, arg.value_.string.size)); case internal::type::pointer_type: return vis(arg.value_.pointer); case internal::type::custom_type: return vis(typename basic_format_arg::handle(arg.value_.custom)); } return vis(monostate()); } namespace internal { // A map from argument names to their values for named arguments. template class arg_map { private: using char_type = typename Context::char_type; struct entry { basic_string_view name; basic_format_arg arg; }; entry* map_; unsigned size_; void push_back(value val) { const auto& named = *val.named_arg; map_[size_] = {named.name, named.template deserialize()}; ++size_; } public: arg_map(const arg_map&) = delete; void operator=(const arg_map&) = delete; arg_map() : map_(nullptr), 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 {}; } }; // A type-erased reference to an std::locale to avoid heavy include. class locale_ref { private: const void* locale_; // A type-erased pointer to std::locale. public: locale_ref() : locale_(nullptr) {} template explicit locale_ref(const Locale& loc); explicit operator bool() const FMT_NOEXCEPT { return locale_ != nullptr; } template Locale get() const; }; template constexpr unsigned long long encode_types() { return 0; } template constexpr unsigned long long encode_types() { return static_cast(mapped_type_constant::value) | (encode_types() << packed_arg_bits); } template FMT_CONSTEXPR basic_format_arg make_arg(const T& value) { basic_format_arg arg; arg.type_ = mapped_type_constant::value; arg.value_ = arg_mapper().map(value); return arg; } template inline value make_arg(const T& val) { return arg_mapper().map(val); } template inline basic_format_arg make_arg(const T& value) { return make_arg(value); } } // namespace internal // Formatting context. template class basic_format_context { public: /** The character type for the output. */ using char_type = Char; private: OutputIt out_; basic_format_args args_; internal::arg_map map_; internal::locale_ref loc_; public: using iterator = OutputIt; using format_arg = basic_format_arg; template using formatter_type = formatter; basic_format_context(const basic_format_context&) = delete; void operator=(const basic_format_context&) = delete; /** 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_format_args ctx_args, internal::locale_ref loc = internal::locale_ref()) : out_(out), args_(ctx_args), loc_(loc) {} format_arg arg(int id) const { return args_.get(id); } // Checks if manual indexing is used and returns the argument with the // specified name. format_arg arg(basic_string_view name); internal::error_handler error_handler() { return {}; } void on_error(const char* message) { error_handler().on_error(message); } // Returns an iterator to the beginning of the output range. iterator out() { return out_; } // Advances the begin iterator to ``it``. void advance_to(iterator it) { out_ = it; } internal::locale_ref locale() { return loc_; } }; template using buffer_context = basic_format_context>, Char>; using format_context = buffer_context; using wformat_context = buffer_context; /** \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 #if FMT_GCC_VERSION < 409 // Workaround a GCC template argument substitution bug. : public basic_format_args #endif { private: static const size_t num_args = sizeof...(Args); static const bool is_packed = num_args < internal::max_packed_args; using value_type = conditional_t, basic_format_arg>; // If the arguments are not packed, add one more element to mark the end. value_type data_[num_args + (num_args == 0 ? 1 : 0)]; friend class basic_format_args; public: static constexpr unsigned long long types = is_packed ? internal::encode_types() : internal::is_unpacked_bit | num_args; format_arg_store(const Args&... args) : #if FMT_GCC_VERSION < 409 basic_format_args(*this), #endif data_{internal::make_arg(args)...} { } }; /** \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`. See `~fmt::arg` for lifetime considerations. \endrst */ template inline format_arg_store make_format_args( const Args&... args) { return {args...}; } /** \rst A view of a collection of formatting arguments. To avoid lifetime issues it should only be used as a parameter type in type-erased functions such as ``vformat``:: void vlog(string_view format_str, format_args args); // OK format_args args = make_format_args(42); // Error: dangling reference \endrst */ template class basic_format_args { public: using size_type = int; using format_arg = basic_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. unsigned long long 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_; }; bool is_packed() const { return (types_ & internal::is_unpacked_bit) == 0; } internal::type type(int index) const { int shift = index * internal::packed_arg_bits; unsigned int mask = (1 << internal::packed_arg_bits) - 1; return static_cast((types_ >> shift) & mask); } 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(int index) const { format_arg arg; if (!is_packed()) { auto num_args = max_size(); if (index < num_args) arg = args_[index]; return arg; } if (index > internal::max_packed_args) return arg; arg.type_ = type(index); if (arg.type_ == internal::type::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_); } /** \rst Constructs a `basic_format_args` object from a dynamic set of arguments. \endrst */ basic_format_args(const format_arg* args, int count) : types_(internal::is_unpacked_bit | internal::to_unsigned(count)) { set_data(args); } /** Returns the argument at specified index. */ format_arg get(int index) const { format_arg arg = do_get(index); if (arg.type_ == internal::type::named_arg_type) arg = arg.value_.named_arg->template deserialize(); return arg; } int max_size() const { unsigned long long max_packed = internal::max_packed_args; return static_cast(is_packed() ? max_packed : types_ & ~internal::is_unpacked_bit); } }; /** An alias to ``basic_format_args``. */ // It is a separate type rather than an alias to make symbols readable. struct format_args : basic_format_args { template format_args(Args&&... args) : basic_format_args(static_cast(args)...) {} }; struct wformat_args : basic_format_args { template wformat_args(Args&&... args) : basic_format_args(static_cast(args)...) {} }; template struct is_contiguous : std::false_type {}; template struct is_contiguous> : std::true_type {}; template struct is_contiguous> : std::true_type {}; namespace internal { template struct is_contiguous_back_insert_iterator : std::false_type {}; template struct is_contiguous_back_insert_iterator> : is_contiguous {}; 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; } }; struct view {}; template struct named_arg : view, named_arg_base { const T& value; named_arg(basic_string_view name, const T& val) : named_arg_base(name), value(val) {} }; template ::value)> inline void check_format_string(const S&) { #if defined(FMT_ENFORCE_COMPILE_STRING) static_assert(is_compile_string::value, "FMT_ENFORCE_COMPILE_STRING requires all format strings to " "utilize FMT_STRING() or fmt()."); #endif } template ::value)> void check_format_string(S); template struct bool_pack; template using all_true = std::is_same, bool_pack>; template > inline format_arg_store, remove_reference_t...> make_args_checked(const S& format_str, const remove_reference_t&... args) { static_assert( all_true<(!std::is_base_of>::value || !std::is_reference::value)...>::value, "passing views as lvalues is disallowed"); check_format_string>...>(format_str); return {args...}; } template std::basic_string vformat( basic_string_view format_str, basic_format_args>> args); template typename buffer_context::iterator vformat_to( buffer& buf, basic_string_view format_str, basic_format_args>> args); FMT_API void vprint_mojibake(std::FILE*, string_view, format_args); } // namespace internal /** \rst Returns a named argument to be used in a formatting function. It should only be used in a call to a formatting function. **Example**:: fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23)); \endrst */ template > inline internal::named_arg arg(const S& name, const T& arg) { static_assert(internal::is_string::value, ""); return {name, arg}; } // Disable nested named arguments, e.g. ``arg("a", arg("b", 42))``. template void arg(S, internal::named_arg) = delete; /** Formats a string and writes the output to ``out``. */ // GCC 8 and earlier cannot handle std::back_insert_iterator with // vformat_to(...) overload, so SFINAE on iterator type instead. template , FMT_ENABLE_IF( internal::is_contiguous_back_insert_iterator::value)> OutputIt vformat_to( OutputIt out, const S& format_str, basic_format_args>> args) { using container = remove_reference_t; internal::container_buffer buf((internal::get_container(out))); internal::vformat_to(buf, to_string_view(format_str), args); return out; } template ::value&& internal::is_string::value)> inline std::back_insert_iterator format_to( std::back_insert_iterator out, const S& format_str, Args&&... args) { return vformat_to(out, to_string_view(format_str), internal::make_args_checked(format_str, args...)); } template > inline std::basic_string vformat( const S& format_str, basic_format_args>> args) { return internal::vformat(to_string_view(format_str), args); } /** \rst Formats arguments and returns the result as a string. **Example**:: #include std::string message = fmt::format("The answer is {}", 42); \endrst */ // Pass char_t as a default template parameter instead of using // std::basic_string> to reduce the symbol size. template > inline std::basic_string format(const S& format_str, Args&&... args) { return internal::vformat( to_string_view(format_str), internal::make_args_checked(format_str, args...)); } FMT_API void vprint(string_view, format_args); FMT_API void vprint(std::FILE*, string_view, format_args); /** \rst Formats ``args`` according to specifications in ``format_str`` and writes the output to the file ``f``. Strings are assumed to be Unicode-encoded unless the ``FMT_UNICODE`` macro is set to 0. **Example**:: fmt::print(stderr, "Don't {}!", "panic"); \endrst */ template ::value)> inline void print(std::FILE* f, const S& format_str, Args&&... args) { #if !defined(_WIN32) || FMT_UNICODE vprint(f, to_string_view(format_str), internal::make_args_checked(format_str, args...)); #else internal::vprint_mojibake( f, to_string_view(format_str), internal::make_args_checked(format_str, args...)); #endif } /** \rst Formats ``args`` according to specifications in ``format_str`` and writes the output to ``stdout``. Strings are assumed to be Unicode-encoded unless the ``FMT_UNICODE`` macro is set to 0. **Example**:: fmt::print("Elapsed time: {0:.2f} seconds", 1.23); \endrst */ template ::value)> inline void print(const S& format_str, Args&&... args) { #if !defined(_WIN32) || FMT_UNICODE vprint(to_string_view(format_str), internal::make_args_checked(format_str, args...)); #else internal::vprint_mojibake( stdout, to_string_view(format_str), internal::make_args_checked(format_str, args...)); #endif } FMT_END_NAMESPACE #endif // FMT_CORE_H_