1 // Formatting library for C++ - the core API
2 //
3 // Copyright (c) 2012 - present, Victor Zverovich
4 // All rights reserved.
5 //
6 // For the license information refer to format.h.
7
8 #ifndef FMT_CORE_H_
9 #define FMT_CORE_H_
10
11 #include <cstdio> // std::FILE
12 #include <cstring>
13 #include <functional>
14 #include <iterator>
15 #include <memory>
16 #include <string>
17 #include <type_traits>
18 #include <vector>
19
20 // The fmt library version in the form major * 10000 + minor * 100 + patch.
21 #define FMT_VERSION 70003
22
23 #ifdef __clang__
24 # define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
25 #else
26 # define FMT_CLANG_VERSION 0
27 #endif
28
29 #if defined(__GNUC__) && !defined(__clang__)
30 # define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
31 #else
32 # define FMT_GCC_VERSION 0
33 #endif
34
35 #if defined(__INTEL_COMPILER)
36 # define FMT_ICC_VERSION __INTEL_COMPILER
37 #else
38 # define FMT_ICC_VERSION 0
39 #endif
40
41 #if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
42 # define FMT_HAS_GXX_CXX11 FMT_GCC_VERSION
43 #else
44 # define FMT_HAS_GXX_CXX11 0
45 #endif
46
47 #ifdef __NVCC__
48 # define FMT_NVCC __NVCC__
49 #else
50 # define FMT_NVCC 0
51 #endif
52
53 #ifdef _MSC_VER
54 # define FMT_MSC_VER _MSC_VER
55 # define FMT_SUPPRESS_MSC_WARNING(n) __pragma(warning(suppress : n))
56 #else
57 # define FMT_MSC_VER 0
58 # define FMT_SUPPRESS_MSC_WARNING(n)
59 #endif
60 #ifdef __has_feature
61 # define FMT_HAS_FEATURE(x) __has_feature(x)
62 #else
63 # define FMT_HAS_FEATURE(x) 0
64 #endif
65
66 #if defined(__has_include) && !defined(__INTELLISENSE__) && \
67 !(FMT_ICC_VERSION && FMT_ICC_VERSION < 1600)
68 # define FMT_HAS_INCLUDE(x) __has_include(x)
69 #else
70 # define FMT_HAS_INCLUDE(x) 0
71 #endif
72
73 #ifdef __has_cpp_attribute
74 # define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
75 #else
76 # define FMT_HAS_CPP_ATTRIBUTE(x) 0
77 #endif
78
79 #define FMT_HAS_CPP14_ATTRIBUTE(attribute) \
80 (__cplusplus >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute))
81
82 #define FMT_HAS_CPP17_ATTRIBUTE(attribute) \
83 (__cplusplus >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute))
84
85 // Check if relaxed C++14 constexpr is supported.
86 // GCC doesn't allow throw in constexpr until version 6 (bug 67371).
87 #ifndef FMT_USE_CONSTEXPR
88 # define FMT_USE_CONSTEXPR \
89 (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1910 || \
90 (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L)) && \
91 !FMT_NVCC && !FMT_ICC_VERSION
92 #endif
93 #if FMT_USE_CONSTEXPR
94 # define FMT_CONSTEXPR constexpr
95 # define FMT_CONSTEXPR_DECL constexpr
96 #else
97 # define FMT_CONSTEXPR inline
98 # define FMT_CONSTEXPR_DECL
99 #endif
100
101 #ifndef FMT_OVERRIDE
102 # if FMT_HAS_FEATURE(cxx_override) || \
103 (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900
104 # define FMT_OVERRIDE override
105 # else
106 # define FMT_OVERRIDE
107 # endif
108 #endif
109
110 // Check if exceptions are disabled.
111 #ifndef FMT_EXCEPTIONS
112 # if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || \
113 FMT_MSC_VER && !_HAS_EXCEPTIONS
114 # define FMT_EXCEPTIONS 0
115 # else
116 # define FMT_EXCEPTIONS 1
117 # endif
118 #endif
119
120 // Define FMT_USE_NOEXCEPT to make fmt use noexcept (C++11 feature).
121 #ifndef FMT_USE_NOEXCEPT
122 # define FMT_USE_NOEXCEPT 0
123 #endif
124
125 #if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \
126 (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900
127 # define FMT_DETECTED_NOEXCEPT noexcept
128 # define FMT_HAS_CXX11_NOEXCEPT 1
129 #else
130 # define FMT_DETECTED_NOEXCEPT throw()
131 # define FMT_HAS_CXX11_NOEXCEPT 0
132 #endif
133
134 #ifndef FMT_NOEXCEPT
135 # if FMT_EXCEPTIONS || FMT_HAS_CXX11_NOEXCEPT
136 # define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT
137 # else
138 # define FMT_NOEXCEPT
139 # endif
140 #endif
141
142 // [[noreturn]] is disabled on MSVC and NVCC because of bogus unreachable code
143 // warnings.
144 #if FMT_EXCEPTIONS && FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VER && \
145 !FMT_NVCC
146 # define FMT_NORETURN [[noreturn]]
147 #else
148 # define FMT_NORETURN
149 #endif
150
151 #ifndef FMT_DEPRECATED
152 # if FMT_HAS_CPP14_ATTRIBUTE(deprecated) || FMT_MSC_VER >= 1900
153 # define FMT_DEPRECATED [[deprecated]]
154 # else
155 # if defined(__GNUC__) || defined(__clang__)
156 # define FMT_DEPRECATED __attribute__((deprecated))
157 # elif FMT_MSC_VER
158 # define FMT_DEPRECATED __declspec(deprecated)
159 # else
160 # define FMT_DEPRECATED /* deprecated */
161 # endif
162 # endif
163 #endif
164
165 // Workaround broken [[deprecated]] in the Intel, PGI and NVCC compilers.
166 #if FMT_ICC_VERSION || defined(__PGI) || FMT_NVCC
167 # define FMT_DEPRECATED_ALIAS
168 #else
169 # define FMT_DEPRECATED_ALIAS FMT_DEPRECATED
170 #endif
171
172 #ifndef FMT_INLINE
173 # if FMT_GCC_VERSION || FMT_CLANG_VERSION
174 # define FMT_INLINE inline __attribute__((always_inline))
175 # else
176 # define FMT_INLINE inline
177 # endif
178 #endif
179
180 #ifndef FMT_BEGIN_NAMESPACE
181 # if FMT_HAS_FEATURE(cxx_inline_namespaces) || FMT_GCC_VERSION >= 404 || \
182 FMT_MSC_VER >= 1900
183 # define FMT_INLINE_NAMESPACE inline namespace
184 # define FMT_END_NAMESPACE \
185 } \
186 }
187 # else
188 # define FMT_INLINE_NAMESPACE namespace
189 # define FMT_END_NAMESPACE \
190 } \
191 using namespace v7; \
192 }
193 # endif
194 # define FMT_BEGIN_NAMESPACE \
195 namespace fmt { \
196 FMT_INLINE_NAMESPACE v7 {
197 #endif
198
199 #if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
200 # define FMT_CLASS_API FMT_SUPPRESS_MSC_WARNING(4275)
201 # ifdef FMT_EXPORT
202 # define FMT_API __declspec(dllexport)
203 # define FMT_EXTERN_TEMPLATE_API FMT_API
204 # define FMT_EXPORTED
205 # elif defined(FMT_SHARED)
206 # define FMT_API __declspec(dllimport)
207 # define FMT_EXTERN_TEMPLATE_API FMT_API
208 # endif
209 #else
210 # define FMT_CLASS_API
211 #endif
212 #ifndef FMT_API
213 # define FMT_API
214 #endif
215 #ifndef FMT_EXTERN_TEMPLATE_API
216 # define FMT_EXTERN_TEMPLATE_API
217 #endif
218 #ifndef FMT_INSTANTIATION_DEF_API
219 # define FMT_INSTANTIATION_DEF_API FMT_API
220 #endif
221
222 #ifndef FMT_HEADER_ONLY
223 # define FMT_EXTERN extern
224 #else
225 # define FMT_EXTERN
226 #endif
227
228 // libc++ supports string_view in pre-c++17.
229 #if (FMT_HAS_INCLUDE(<string_view>) && \
230 (__cplusplus > 201402L || defined(_LIBCPP_VERSION))) || \
231 (defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910)
232 # include <string_view>
233 # define FMT_USE_STRING_VIEW
234 #elif FMT_HAS_INCLUDE("experimental/string_view") && __cplusplus >= 201402L
235 # include <experimental/string_view>
236 # define FMT_USE_EXPERIMENTAL_STRING_VIEW
237 #endif
238
239 #ifndef FMT_UNICODE
240 # define FMT_UNICODE !FMT_MSC_VER
241 #endif
242 #if FMT_UNICODE && FMT_MSC_VER
243 # pragma execution_character_set("utf-8")
244 #endif
245
246 FMT_BEGIN_NAMESPACE
247
248 // Implementations of enable_if_t and other metafunctions for older systems.
249 template <bool B, class T = void>
250 using enable_if_t = typename std::enable_if<B, T>::type;
251 template <bool B, class T, class F>
252 using conditional_t = typename std::conditional<B, T, F>::type;
253 template <bool B> using bool_constant = std::integral_constant<bool, B>;
254 template <typename T>
255 using remove_reference_t = typename std::remove_reference<T>::type;
256 template <typename T>
257 using remove_const_t = typename std::remove_const<T>::type;
258 template <typename T>
259 using remove_cvref_t = typename std::remove_cv<remove_reference_t<T>>::type;
260 template <typename T> struct type_identity { using type = T; };
261 template <typename T> using type_identity_t = typename type_identity<T>::type;
262
263 struct monostate {};
264
265 // An enable_if helper to be used in template parameters which results in much
266 // shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed
267 // to workaround a bug in MSVC 2019 (see #1140 and #1186).
268 #define FMT_ENABLE_IF(...) enable_if_t<(__VA_ARGS__), int> = 0
269
270 namespace detail {
271
272 // A helper function to suppress bogus "conditional expression is constant"
273 // warnings.
const_check(T value)274 template <typename T> constexpr T const_check(T value) { return value; }
275
276 FMT_NORETURN FMT_API void assert_fail(const char* file, int line,
277 const char* message);
278
279 #ifndef FMT_ASSERT
280 # ifdef NDEBUG
281 // FMT_ASSERT is not empty to avoid -Werror=empty-body.
282 # define FMT_ASSERT(condition, message) ((void)0)
283 # else
284 # define FMT_ASSERT(condition, message) \
285 ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
286 ? (void)0 \
287 : ::fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
288 # endif
289 #endif
290
291 #if defined(FMT_USE_STRING_VIEW)
292 template <typename Char> using std_string_view = std::basic_string_view<Char>;
293 #elif defined(FMT_USE_EXPERIMENTAL_STRING_VIEW)
294 template <typename Char>
295 using std_string_view = std::experimental::basic_string_view<Char>;
296 #else
297 template <typename T> struct std_string_view {};
298 #endif
299
300 #ifdef FMT_USE_INT128
301 // Do nothing.
302 #elif defined(__SIZEOF_INT128__) && !FMT_NVCC && !(FMT_CLANG_VERSION && FMT_MSC_VER)
303 # define FMT_USE_INT128 1
304 using int128_t = __int128_t;
305 using uint128_t = __uint128_t;
306 #else
307 # define FMT_USE_INT128 0
308 #endif
309 #if !FMT_USE_INT128
310 struct int128_t {};
311 struct uint128_t {};
312 #endif
313
314 // Casts a nonnegative integer to unsigned.
315 template <typename Int>
to_unsigned(Int value)316 FMT_CONSTEXPR typename std::make_unsigned<Int>::type to_unsigned(Int value) {
317 FMT_ASSERT(value >= 0, "negative value");
318 return static_cast<typename std::make_unsigned<Int>::type>(value);
319 }
320
321 FMT_SUPPRESS_MSC_WARNING(4566) constexpr unsigned char micro[] = "\u00B5";
322
is_unicode()323 template <typename Char> constexpr bool is_unicode() {
324 return FMT_UNICODE || sizeof(Char) != 1 ||
325 (sizeof(micro) == 3 && micro[0] == 0xC2 && micro[1] == 0xB5);
326 }
327
328 #ifdef __cpp_char8_t
329 using char8_type = char8_t;
330 #else
331 enum char8_type : unsigned char {};
332 #endif
333 } // namespace detail
334
335 #ifdef FMT_USE_INTERNAL
336 namespace internal = detail; // DEPRECATED
337 #endif
338
339 /**
340 An implementation of ``std::basic_string_view`` for pre-C++17. It provides a
341 subset of the API. ``fmt::basic_string_view`` is used for format strings even
342 if ``std::string_view`` is available to prevent issues when a library is
343 compiled with a different ``-std`` option than the client code (which is not
344 recommended).
345 */
346 template <typename Char> class basic_string_view {
347 private:
348 const Char* data_;
349 size_t size_;
350
351 public:
352 using value_type = Char;
353 using iterator = const Char*;
354
basic_string_view()355 constexpr basic_string_view() FMT_NOEXCEPT : data_(nullptr), size_(0) {}
356
357 /** Constructs a string reference object from a C string and a size. */
basic_string_view(const Char * s,size_t count)358 constexpr basic_string_view(const Char* s, size_t count) FMT_NOEXCEPT
359 : data_(s),
360 size_(count) {}
361
362 /**
363 \rst
364 Constructs a string reference object from a C string computing
365 the size with ``std::char_traits<Char>::length``.
366 \endrst
367 */
368 #if __cplusplus >= 201703L // C++17's char_traits::length() is constexpr.
369 FMT_CONSTEXPR
370 #endif
basic_string_view(const Char * s)371 basic_string_view(const Char* s)
372 : data_(s), size_(std::char_traits<Char>::length(s)) {}
373
374 /** Constructs a string reference from a ``std::basic_string`` object. */
375 template <typename Traits, typename Alloc>
basic_string_view(const std::basic_string<Char,Traits,Alloc> & s)376 FMT_CONSTEXPR basic_string_view(
377 const std::basic_string<Char, Traits, Alloc>& s) FMT_NOEXCEPT
378 : data_(s.data()),
379 size_(s.size()) {}
380
381 template <typename S, FMT_ENABLE_IF(std::is_same<
382 S, detail::std_string_view<Char>>::value)>
basic_string_view(S s)383 FMT_CONSTEXPR basic_string_view(S s) FMT_NOEXCEPT : data_(s.data()),
384 size_(s.size()) {}
385
386 /** Returns a pointer to the string data. */
data()387 constexpr const Char* data() const { return data_; }
388
389 /** Returns the string size. */
size()390 constexpr size_t size() const { return size_; }
391
begin()392 constexpr iterator begin() const { return data_; }
end()393 constexpr iterator end() const { return data_ + size_; }
394
395 constexpr const Char& operator[](size_t pos) const { return data_[pos]; }
396
remove_prefix(size_t n)397 FMT_CONSTEXPR void remove_prefix(size_t n) {
398 data_ += n;
399 size_ -= n;
400 }
401
402 // Lexicographically compare this string reference to other.
compare(basic_string_view other)403 int compare(basic_string_view other) const {
404 size_t str_size = size_ < other.size_ ? size_ : other.size_;
405 int result = std::char_traits<Char>::compare(data_, other.data_, str_size);
406 if (result == 0)
407 result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
408 return result;
409 }
410
411 friend bool operator==(basic_string_view lhs, basic_string_view rhs) {
412 return lhs.compare(rhs) == 0;
413 }
414 friend bool operator!=(basic_string_view lhs, basic_string_view rhs) {
415 return lhs.compare(rhs) != 0;
416 }
417 friend bool operator<(basic_string_view lhs, basic_string_view rhs) {
418 return lhs.compare(rhs) < 0;
419 }
420 friend bool operator<=(basic_string_view lhs, basic_string_view rhs) {
421 return lhs.compare(rhs) <= 0;
422 }
423 friend bool operator>(basic_string_view lhs, basic_string_view rhs) {
424 return lhs.compare(rhs) > 0;
425 }
426 friend bool operator>=(basic_string_view lhs, basic_string_view rhs) {
427 return lhs.compare(rhs) >= 0;
428 }
429 };
430
431 using string_view = basic_string_view<char>;
432 using wstring_view = basic_string_view<wchar_t>;
433
434 /** Specifies if ``T`` is a character type. Can be specialized by users. */
435 template <typename T> struct is_char : std::false_type {};
436 template <> struct is_char<char> : std::true_type {};
437 template <> struct is_char<wchar_t> : std::true_type {};
438 template <> struct is_char<detail::char8_type> : std::true_type {};
439 template <> struct is_char<char16_t> : std::true_type {};
440 template <> struct is_char<char32_t> : std::true_type {};
441
442 /**
443 \rst
444 Returns a string view of `s`. In order to add custom string type support to
445 {fmt} provide an overload of `to_string_view` for it in the same namespace as
446 the type for the argument-dependent lookup to work.
447
448 **Example**::
449
450 namespace my_ns {
451 inline string_view to_string_view(const my_string& s) {
452 return {s.data(), s.length()};
453 }
454 }
455 std::string message = fmt::format(my_string("The answer is {}"), 42);
456 \endrst
457 */
458 template <typename Char, FMT_ENABLE_IF(is_char<Char>::value)>
459 inline basic_string_view<Char> to_string_view(const Char* s) {
460 return s;
461 }
462
463 template <typename Char, typename Traits, typename Alloc>
464 inline basic_string_view<Char> to_string_view(
465 const std::basic_string<Char, Traits, Alloc>& s) {
466 return s;
467 }
468
469 template <typename Char>
470 inline basic_string_view<Char> to_string_view(basic_string_view<Char> s) {
471 return s;
472 }
473
474 template <typename Char,
475 FMT_ENABLE_IF(!std::is_empty<detail::std_string_view<Char>>::value)>
476 inline basic_string_view<Char> to_string_view(detail::std_string_view<Char> s) {
477 return s;
478 }
479
480 // A base class for compile-time strings. It is defined in the fmt namespace to
481 // make formatting functions visible via ADL, e.g. format(FMT_STRING("{}"), 42).
482 struct compile_string {};
483
484 template <typename S>
485 struct is_compile_string : std::is_base_of<compile_string, S> {};
486
487 template <typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
488 constexpr basic_string_view<typename S::char_type> to_string_view(const S& s) {
489 return s;
490 }
491
492 namespace detail {
493 void to_string_view(...);
494 using fmt::v7::to_string_view;
495
496 // Specifies whether S is a string type convertible to fmt::basic_string_view.
497 // It should be a constexpr function but MSVC 2017 fails to compile it in
498 // enable_if and MSVC 2015 fails to compile it as an alias template.
499 template <typename S>
500 struct is_string : std::is_class<decltype(to_string_view(std::declval<S>()))> {
501 };
502
503 template <typename S, typename = void> struct char_t_impl {};
504 template <typename S> struct char_t_impl<S, enable_if_t<is_string<S>::value>> {
505 using result = decltype(to_string_view(std::declval<S>()));
506 using type = typename result::value_type;
507 };
508
509 struct error_handler {
510 constexpr error_handler() = default;
511 constexpr error_handler(const error_handler&) = default;
512
513 // This function is intentionally not constexpr to give a compile-time error.
514 FMT_NORETURN FMT_API void on_error(const char* message);
515 };
516 } // namespace detail
517
518 /** String's character type. */
519 template <typename S> using char_t = typename detail::char_t_impl<S>::type;
520
521 /**
522 \rst
523 Parsing context consisting of a format string range being parsed and an
524 argument counter for automatic indexing.
525
526 You can use one of the following type aliases for common character types:
527
528 +-----------------------+-------------------------------------+
529 | Type | Definition |
530 +=======================+=====================================+
531 | format_parse_context | basic_format_parse_context<char> |
532 +-----------------------+-------------------------------------+
533 | wformat_parse_context | basic_format_parse_context<wchar_t> |
534 +-----------------------+-------------------------------------+
535 \endrst
536 */
537 template <typename Char, typename ErrorHandler = detail::error_handler>
538 class basic_format_parse_context : private ErrorHandler {
539 private:
540 basic_string_view<Char> format_str_;
541 int next_arg_id_;
542
543 public:
544 using char_type = Char;
545 using iterator = typename basic_string_view<Char>::iterator;
546
547 explicit constexpr basic_format_parse_context(
548 basic_string_view<Char> format_str, ErrorHandler eh = {})
549 : ErrorHandler(eh), format_str_(format_str), next_arg_id_(0) {}
550
551 /**
552 Returns an iterator to the beginning of the format string range being
553 parsed.
554 */
555 constexpr iterator begin() const FMT_NOEXCEPT { return format_str_.begin(); }
556
557 /**
558 Returns an iterator past the end of the format string range being parsed.
559 */
560 constexpr iterator end() const FMT_NOEXCEPT { return format_str_.end(); }
561
562 /** Advances the begin iterator to ``it``. */
563 FMT_CONSTEXPR void advance_to(iterator it) {
564 format_str_.remove_prefix(detail::to_unsigned(it - begin()));
565 }
566
567 /**
568 Reports an error if using the manual argument indexing; otherwise returns
569 the next argument index and switches to the automatic indexing.
570 */
571 FMT_CONSTEXPR int next_arg_id() {
572 // Don't check if the argument id is valid to avoid overhead and because it
573 // will be checked during formatting anyway.
574 if (next_arg_id_ >= 0) return next_arg_id_++;
575 on_error("cannot switch from manual to automatic argument indexing");
576 return 0;
577 }
578
579 /**
580 Reports an error if using the automatic argument indexing; otherwise
581 switches to the manual indexing.
582 */
583 FMT_CONSTEXPR void check_arg_id(int) {
584 if (next_arg_id_ > 0)
585 on_error("cannot switch from automatic to manual argument indexing");
586 else
587 next_arg_id_ = -1;
588 }
589
590 FMT_CONSTEXPR void check_arg_id(basic_string_view<Char>) {}
591
592 FMT_CONSTEXPR void on_error(const char* message) {
593 ErrorHandler::on_error(message);
594 }
595
596 constexpr ErrorHandler error_handler() const { return *this; }
597 };
598
599 using format_parse_context = basic_format_parse_context<char>;
600 using wformat_parse_context = basic_format_parse_context<wchar_t>;
601
602 template <typename Context> class basic_format_arg;
603 template <typename Context> class basic_format_args;
604 template <typename Context> class dynamic_format_arg_store;
605
606 // A formatter for objects of type T.
607 template <typename T, typename Char = char, typename Enable = void>
608 struct formatter {
609 // A deleted default constructor indicates a disabled formatter.
610 formatter() = delete;
611 };
612
613 // Specifies if T has an enabled formatter specialization. A type can be
614 // formattable even if it doesn't have a formatter e.g. via a conversion.
615 template <typename T, typename Context>
616 using has_formatter =
617 std::is_constructible<typename Context::template formatter_type<T>>;
618
619 namespace detail {
620
621 /**
622 \rst
623 A contiguous memory buffer with an optional growing ability. It is an internal
624 class and shouldn't be used directly, only via `~fmt::basic_memory_buffer`.
625 \endrst
626 */
627 template <typename T> class buffer {
628 private:
629 T* ptr_;
630 size_t size_;
631 size_t capacity_;
632
633 protected:
634 // Don't initialize ptr_ since it is not accessed to save a few cycles.
635 FMT_SUPPRESS_MSC_WARNING(26495)
636 buffer(size_t sz) FMT_NOEXCEPT : size_(sz), capacity_(sz) {}
637
638 buffer(T* p = nullptr, size_t sz = 0, size_t cap = 0) FMT_NOEXCEPT
639 : ptr_(p),
640 size_(sz),
641 capacity_(cap) {}
642
643 /** Sets the buffer data and capacity. */
644 void set(T* buf_data, size_t buf_capacity) FMT_NOEXCEPT {
645 ptr_ = buf_data;
646 capacity_ = buf_capacity;
647 }
648
649 /** Increases the buffer capacity to hold at least *capacity* elements. */
650 virtual void grow(size_t capacity) = 0;
651
652 public:
653 using value_type = T;
654 using const_reference = const T&;
655
656 buffer(const buffer&) = delete;
657 void operator=(const buffer&) = delete;
658 virtual ~buffer() = default;
659
660 T* begin() FMT_NOEXCEPT { return ptr_; }
661 T* end() FMT_NOEXCEPT { return ptr_ + size_; }
662
663 const T* begin() const FMT_NOEXCEPT { return ptr_; }
664 const T* end() const FMT_NOEXCEPT { return ptr_ + size_; }
665
666 /** Returns the size of this buffer. */
667 size_t size() const FMT_NOEXCEPT { return size_; }
668
669 /** Returns the capacity of this buffer. */
670 size_t capacity() const FMT_NOEXCEPT { return capacity_; }
671
672 /** Returns a pointer to the buffer data. */
673 T* data() FMT_NOEXCEPT { return ptr_; }
674
675 /** Returns a pointer to the buffer data. */
676 const T* data() const FMT_NOEXCEPT { return ptr_; }
677
678 /**
679 Resizes the buffer. If T is a POD type new elements may not be initialized.
680 */
681 void resize(size_t new_size) {
682 reserve(new_size);
683 size_ = new_size;
684 }
685
686 /** Clears this buffer. */
687 void clear() { size_ = 0; }
688
689 /** Reserves space to store at least *capacity* elements. */
690 void reserve(size_t new_capacity) {
691 if (new_capacity > capacity_) grow(new_capacity);
692 }
693
694 void push_back(const T& value) {
695 reserve(size_ + 1);
696 ptr_[size_++] = value;
697 }
698
699 /** Appends data to the end of the buffer. */
700 template <typename U> void append(const U* begin, const U* end);
701
702 template <typename I> T& operator[](I index) { return ptr_[index]; }
703 template <typename I> const T& operator[](I index) const {
704 return ptr_[index];
705 }
706 };
707
708 // A container-backed buffer.
709 template <typename Container>
710 class container_buffer : public buffer<typename Container::value_type> {
711 private:
712 Container& container_;
713
714 protected:
715 void grow(size_t capacity) FMT_OVERRIDE {
716 container_.resize(capacity);
717 this->set(&container_[0], capacity);
718 }
719
720 public:
721 explicit container_buffer(Container& c)
722 : buffer<typename Container::value_type>(c.size()), container_(c) {}
723 };
724
725 // Extracts a reference to the container from back_insert_iterator.
726 template <typename Container>
727 inline Container& get_container(std::back_insert_iterator<Container> it) {
728 using bi_iterator = std::back_insert_iterator<Container>;
729 struct accessor : bi_iterator {
730 accessor(bi_iterator iter) : bi_iterator(iter) {}
731 using bi_iterator::container;
732 };
733 return *accessor(it).container;
734 }
735
736 template <typename T, typename Char = char, typename Enable = void>
737 struct fallback_formatter {
738 fallback_formatter() = delete;
739 };
740
741 // Specifies if T has an enabled fallback_formatter specialization.
742 template <typename T, typename Context>
743 using has_fallback_formatter =
744 std::is_constructible<fallback_formatter<T, typename Context::char_type>>;
745
746 struct view {};
747
748 template <typename Char, typename T> struct named_arg : view {
749 const Char* name;
750 const T& value;
751 named_arg(const Char* n, const T& v) : name(n), value(v) {}
752 };
753
754 template <typename Char> struct named_arg_info {
755 const Char* name;
756 int id;
757 };
758
759 template <typename T, typename Char, size_t NUM_ARGS, size_t NUM_NAMED_ARGS>
760 struct arg_data {
761 // args_[0].named_args points to named_args_ to avoid bloating format_args.
762 T args_[1 + (NUM_ARGS != 0 ? NUM_ARGS : 1)];
763 named_arg_info<Char> named_args_[NUM_NAMED_ARGS];
764
765 template <typename... U>
766 arg_data(const U&... init) : args_{T(named_args_, NUM_NAMED_ARGS), init...} {}
767 arg_data(const arg_data& other) = delete;
768 const T* args() const { return args_ + 1; }
769 named_arg_info<Char>* named_args() { return named_args_; }
770 };
771
772 template <typename T, typename Char, size_t NUM_ARGS>
773 struct arg_data<T, Char, NUM_ARGS, 0> {
774 T args_[NUM_ARGS != 0 ? NUM_ARGS : 1];
775
776 template <typename... U>
777 FMT_INLINE arg_data(const U&... init) : args_{init...} {}
778 FMT_INLINE const T* args() const { return args_; }
779 FMT_INLINE std::nullptr_t named_args() { return nullptr; }
780 };
781
782 template <typename Char>
783 inline void init_named_args(named_arg_info<Char>*, int, int) {}
784
785 template <typename Char, typename T, typename... Tail>
786 void init_named_args(named_arg_info<Char>* named_args, int arg_count,
787 int named_arg_count, const T&, const Tail&... args) {
788 init_named_args(named_args, arg_count + 1, named_arg_count, args...);
789 }
790
791 template <typename Char, typename T, typename... Tail>
792 void init_named_args(named_arg_info<Char>* named_args, int arg_count,
793 int named_arg_count, const named_arg<Char, T>& arg,
794 const Tail&... args) {
795 named_args[named_arg_count++] = {arg.name, arg_count};
796 init_named_args(named_args, arg_count + 1, named_arg_count, args...);
797 }
798
799 template <typename... Args>
800 FMT_INLINE void init_named_args(std::nullptr_t, int, int, const Args&...) {}
801
802 template <typename T> struct is_named_arg : std::false_type {};
803
804 template <typename T, typename Char>
805 struct is_named_arg<named_arg<Char, T>> : std::true_type {};
806
807 template <bool B = false> constexpr size_t count() { return B ? 1 : 0; }
808 template <bool B1, bool B2, bool... Tail> constexpr size_t count() {
809 return (B1 ? 1 : 0) + count<B2, Tail...>();
810 }
811
812 template <typename... Args> constexpr size_t count_named_args() {
813 return count<is_named_arg<Args>::value...>();
814 }
815
816 enum class type {
817 none_type,
818 // Integer types should go first,
819 int_type,
820 uint_type,
821 long_long_type,
822 ulong_long_type,
823 int128_type,
824 uint128_type,
825 bool_type,
826 char_type,
827 last_integer_type = char_type,
828 // followed by floating-point types.
829 float_type,
830 double_type,
831 long_double_type,
832 last_numeric_type = long_double_type,
833 cstring_type,
834 string_type,
835 pointer_type,
836 custom_type
837 };
838
839 // Maps core type T to the corresponding type enum constant.
840 template <typename T, typename Char>
841 struct type_constant : std::integral_constant<type, type::custom_type> {};
842
843 #define FMT_TYPE_CONSTANT(Type, constant) \
844 template <typename Char> \
845 struct type_constant<Type, Char> \
846 : std::integral_constant<type, type::constant> {}
847
848 FMT_TYPE_CONSTANT(int, int_type);
849 FMT_TYPE_CONSTANT(unsigned, uint_type);
850 FMT_TYPE_CONSTANT(long long, long_long_type);
851 FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type);
852 FMT_TYPE_CONSTANT(int128_t, int128_type);
853 FMT_TYPE_CONSTANT(uint128_t, uint128_type);
854 FMT_TYPE_CONSTANT(bool, bool_type);
855 FMT_TYPE_CONSTANT(Char, char_type);
856 FMT_TYPE_CONSTANT(float, float_type);
857 FMT_TYPE_CONSTANT(double, double_type);
858 FMT_TYPE_CONSTANT(long double, long_double_type);
859 FMT_TYPE_CONSTANT(const Char*, cstring_type);
860 FMT_TYPE_CONSTANT(basic_string_view<Char>, string_type);
861 FMT_TYPE_CONSTANT(const void*, pointer_type);
862
863 constexpr bool is_integral_type(type t) {
864 return t > type::none_type && t <= type::last_integer_type;
865 }
866
867 constexpr bool is_arithmetic_type(type t) {
868 return t > type::none_type && t <= type::last_numeric_type;
869 }
870
871 template <typename Char> struct string_value {
872 const Char* data;
873 size_t size;
874 };
875
876 template <typename Char> struct named_arg_value {
877 const named_arg_info<Char>* data;
878 size_t size;
879 };
880
881 template <typename Context> struct custom_value {
882 using parse_context = typename Context::parse_context_type;
883 const void* value;
884 void (*format)(const void* arg, parse_context& parse_ctx, Context& ctx);
885 };
886
887 // A formatting argument value.
888 template <typename Context> class value {
889 public:
890 using char_type = typename Context::char_type;
891
892 union {
893 int int_value;
894 unsigned uint_value;
895 long long long_long_value;
896 unsigned long long ulong_long_value;
897 int128_t int128_value;
898 uint128_t uint128_value;
899 bool bool_value;
900 char_type char_value;
901 float float_value;
902 double double_value;
903 long double long_double_value;
904 const void* pointer;
905 string_value<char_type> string;
906 custom_value<Context> custom;
907 named_arg_value<char_type> named_args;
908 };
909
910 constexpr FMT_INLINE value(int val = 0) : int_value(val) {}
911 constexpr FMT_INLINE value(unsigned val) : uint_value(val) {}
912 FMT_INLINE value(long long val) : long_long_value(val) {}
913 FMT_INLINE value(unsigned long long val) : ulong_long_value(val) {}
914 FMT_INLINE value(int128_t val) : int128_value(val) {}
915 FMT_INLINE value(uint128_t val) : uint128_value(val) {}
916 FMT_INLINE value(float val) : float_value(val) {}
917 FMT_INLINE value(double val) : double_value(val) {}
918 FMT_INLINE value(long double val) : long_double_value(val) {}
919 FMT_INLINE value(bool val) : bool_value(val) {}
920 FMT_INLINE value(char_type val) : char_value(val) {}
921 FMT_INLINE value(const char_type* val) { string.data = val; }
922 FMT_INLINE value(basic_string_view<char_type> val) {
923 string.data = val.data();
924 string.size = val.size();
925 }
926 FMT_INLINE value(const void* val) : pointer(val) {}
927 FMT_INLINE value(const named_arg_info<char_type>* args, size_t size)
928 : named_args{args, size} {}
929
930 template <typename T> FMT_INLINE value(const T& val) {
931 custom.value = &val;
932 // Get the formatter type through the context to allow different contexts
933 // have different extension points, e.g. `formatter<T>` for `format` and
934 // `printf_formatter<T>` for `printf`.
935 custom.format = format_custom_arg<
936 T, conditional_t<has_formatter<T, Context>::value,
937 typename Context::template formatter_type<T>,
938 fallback_formatter<T, char_type>>>;
939 }
940
941 private:
942 // Formats an argument of a custom type, such as a user-defined class.
943 template <typename T, typename Formatter>
944 static void format_custom_arg(const void* arg,
945 typename Context::parse_context_type& parse_ctx,
946 Context& ctx) {
947 Formatter f;
948 parse_ctx.advance_to(f.parse(parse_ctx));
949 ctx.advance_to(f.format(*static_cast<const T*>(arg), ctx));
950 }
951 };
952
953 template <typename Context, typename T>
954 FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T& value);
955
956 // To minimize the number of types we need to deal with, long is translated
957 // either to int or to long long depending on its size.
958 enum { long_short = sizeof(long) == sizeof(int) };
959 using long_type = conditional_t<long_short, int, long long>;
960 using ulong_type = conditional_t<long_short, unsigned, unsigned long long>;
961
962 // Maps formatting arguments to core types.
963 template <typename Context> struct arg_mapper {
964 using char_type = typename Context::char_type;
965
966 FMT_CONSTEXPR int map(signed char val) { return val; }
967 FMT_CONSTEXPR unsigned map(unsigned char val) { return val; }
968 FMT_CONSTEXPR int map(short val) { return val; }
969 FMT_CONSTEXPR unsigned map(unsigned short val) { return val; }
970 FMT_CONSTEXPR int map(int val) { return val; }
971 FMT_CONSTEXPR unsigned map(unsigned val) { return val; }
972 FMT_CONSTEXPR long_type map(long val) { return val; }
973 FMT_CONSTEXPR ulong_type map(unsigned long val) { return val; }
974 FMT_CONSTEXPR long long map(long long val) { return val; }
975 FMT_CONSTEXPR unsigned long long map(unsigned long long val) { return val; }
976 FMT_CONSTEXPR int128_t map(int128_t val) { return val; }
977 FMT_CONSTEXPR uint128_t map(uint128_t val) { return val; }
978 FMT_CONSTEXPR bool map(bool val) { return val; }
979
980 template <typename T, FMT_ENABLE_IF(is_char<T>::value)>
981 FMT_CONSTEXPR char_type map(T val) {
982 static_assert(
983 std::is_same<T, char>::value || std::is_same<T, char_type>::value,
984 "mixing character types is disallowed");
985 return val;
986 }
987
988 FMT_CONSTEXPR float map(float val) { return val; }
989 FMT_CONSTEXPR double map(double val) { return val; }
990 FMT_CONSTEXPR long double map(long double val) { return val; }
991
992 FMT_CONSTEXPR const char_type* map(char_type* val) { return val; }
993 FMT_CONSTEXPR const char_type* map(const char_type* val) { return val; }
994 template <typename T, FMT_ENABLE_IF(is_string<T>::value)>
995 FMT_CONSTEXPR basic_string_view<char_type> map(const T& val) {
996 static_assert(std::is_same<char_type, char_t<T>>::value,
997 "mixing character types is disallowed");
998 return to_string_view(val);
999 }
1000 template <typename T,
1001 FMT_ENABLE_IF(
1002 std::is_constructible<basic_string_view<char_type>, T>::value &&
1003 !is_string<T>::value && !has_formatter<T, Context>::value &&
1004 !has_fallback_formatter<T, Context>::value)>
1005 FMT_CONSTEXPR basic_string_view<char_type> map(const T& val) {
1006 return basic_string_view<char_type>(val);
1007 }
1008 template <
1009 typename T,
1010 FMT_ENABLE_IF(
1011 std::is_constructible<std_string_view<char_type>, T>::value &&
1012 !std::is_constructible<basic_string_view<char_type>, T>::value &&
1013 !is_string<T>::value && !has_formatter<T, Context>::value &&
1014 !has_fallback_formatter<T, Context>::value)>
1015 FMT_CONSTEXPR basic_string_view<char_type> map(const T& val) {
1016 return std_string_view<char_type>(val);
1017 }
1018 FMT_CONSTEXPR const char* map(const signed char* val) {
1019 static_assert(std::is_same<char_type, char>::value, "invalid string type");
1020 return reinterpret_cast<const char*>(val);
1021 }
1022 FMT_CONSTEXPR const char* map(const unsigned char* val) {
1023 static_assert(std::is_same<char_type, char>::value, "invalid string type");
1024 return reinterpret_cast<const char*>(val);
1025 }
1026 FMT_CONSTEXPR const char* map(signed char* val) {
1027 const auto* const_val = val;
1028 return map(const_val);
1029 }
1030 FMT_CONSTEXPR const char* map(unsigned char* val) {
1031 const auto* const_val = val;
1032 return map(const_val);
1033 }
1034
1035 FMT_CONSTEXPR const void* map(void* val) { return val; }
1036 FMT_CONSTEXPR const void* map(const void* val) { return val; }
1037 FMT_CONSTEXPR const void* map(std::nullptr_t val) { return val; }
1038 template <typename T> FMT_CONSTEXPR int map(const T*) {
1039 // Formatting of arbitrary pointers is disallowed. If you want to output
1040 // a pointer cast it to "void *" or "const void *". In particular, this
1041 // forbids formatting of "[const] volatile char *" which is printed as bool
1042 // by iostreams.
1043 static_assert(!sizeof(T), "formatting of non-void pointers is disallowed");
1044 return 0;
1045 }
1046
1047 template <typename T,
1048 FMT_ENABLE_IF(std::is_enum<T>::value &&
1049 !has_formatter<T, Context>::value &&
1050 !has_fallback_formatter<T, Context>::value)>
1051 FMT_CONSTEXPR auto map(const T& val)
1052 -> decltype(std::declval<arg_mapper>().map(
1053 static_cast<typename std::underlying_type<T>::type>(val))) {
1054 return map(static_cast<typename std::underlying_type<T>::type>(val));
1055 }
1056 template <typename T,
1057 FMT_ENABLE_IF(!is_string<T>::value && !is_char<T>::value &&
1058 (has_formatter<T, Context>::value ||
1059 has_fallback_formatter<T, Context>::value))>
1060 FMT_CONSTEXPR const T& map(const T& val) {
1061 return val;
1062 }
1063
1064 template <typename T>
1065 FMT_CONSTEXPR auto map(const named_arg<char_type, T>& val)
1066 -> decltype(std::declval<arg_mapper>().map(val.value)) {
1067 return map(val.value);
1068 }
1069
1070 int map(...) {
1071 constexpr bool formattable = sizeof(Context) == 0;
1072 static_assert(
1073 formattable,
1074 "Cannot format argument. To make type T formattable provide a "
1075 "formatter<T> specialization: "
1076 "https://fmt.dev/latest/api.html#formatting-user-defined-types");
1077 return 0;
1078 }
1079 };
1080
1081 // A type constant after applying arg_mapper<Context>.
1082 template <typename T, typename Context>
1083 using mapped_type_constant =
1084 type_constant<decltype(arg_mapper<Context>().map(std::declval<const T&>())),
1085 typename Context::char_type>;
1086
1087 enum { packed_arg_bits = 4 };
1088 // Maximum number of arguments with packed types.
1089 enum { max_packed_args = 62 / packed_arg_bits };
1090 enum : unsigned long long { is_unpacked_bit = 1ULL << 63 };
1091 enum : unsigned long long { has_named_args_bit = 1ULL << 62 };
1092 } // namespace detail
1093
1094 // A formatting argument. It is a trivially copyable/constructible type to
1095 // allow storage in basic_memory_buffer.
1096 template <typename Context> class basic_format_arg {
1097 private:
1098 detail::value<Context> value_;
1099 detail::type type_;
1100
1101 template <typename ContextType, typename T>
1102 friend FMT_CONSTEXPR basic_format_arg<ContextType> detail::make_arg(
1103 const T& value);
1104
1105 template <typename Visitor, typename Ctx>
1106 friend FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis,
1107 const basic_format_arg<Ctx>& arg)
1108 -> decltype(vis(0));
1109
1110 friend class basic_format_args<Context>;
1111 friend class dynamic_format_arg_store<Context>;
1112
1113 using char_type = typename Context::char_type;
1114
1115 template <typename T, typename Char, size_t NUM_ARGS, size_t NUM_NAMED_ARGS>
1116 friend struct detail::arg_data;
1117
1118 basic_format_arg(const detail::named_arg_info<char_type>* args, size_t size)
1119 : value_(args, size) {}
1120
1121 public:
1122 class handle {
1123 public:
1124 explicit handle(detail::custom_value<Context> custom) : custom_(custom) {}
1125
1126 void format(typename Context::parse_context_type& parse_ctx,
1127 Context& ctx) const {
1128 custom_.format(custom_.value, parse_ctx, ctx);
1129 }
1130
1131 private:
1132 detail::custom_value<Context> custom_;
1133 };
1134
1135 constexpr basic_format_arg() : type_(detail::type::none_type) {}
1136
1137 constexpr explicit operator bool() const FMT_NOEXCEPT {
1138 return type_ != detail::type::none_type;
1139 }
1140
1141 detail::type type() const { return type_; }
1142
1143 bool is_integral() const { return detail::is_integral_type(type_); }
1144 bool is_arithmetic() const { return detail::is_arithmetic_type(type_); }
1145 };
1146
1147 /**
1148 \rst
1149 Visits an argument dispatching to the appropriate visit method based on
1150 the argument type. For example, if the argument type is ``double`` then
1151 ``vis(value)`` will be called with the value of type ``double``.
1152 \endrst
1153 */
1154 template <typename Visitor, typename Context>
1155 FMT_CONSTEXPR_DECL FMT_INLINE auto visit_format_arg(
1156 Visitor&& vis, const basic_format_arg<Context>& arg) -> decltype(vis(0)) {
1157 using char_type = typename Context::char_type;
1158 switch (arg.type_) {
1159 case detail::type::none_type:
1160 break;
1161 case detail::type::int_type:
1162 return vis(arg.value_.int_value);
1163 case detail::type::uint_type:
1164 return vis(arg.value_.uint_value);
1165 case detail::type::long_long_type:
1166 return vis(arg.value_.long_long_value);
1167 case detail::type::ulong_long_type:
1168 return vis(arg.value_.ulong_long_value);
1169 #if FMT_USE_INT128
1170 case detail::type::int128_type:
1171 return vis(arg.value_.int128_value);
1172 case detail::type::uint128_type:
1173 return vis(arg.value_.uint128_value);
1174 #else
1175 case detail::type::int128_type:
1176 case detail::type::uint128_type:
1177 break;
1178 #endif
1179 case detail::type::bool_type:
1180 return vis(arg.value_.bool_value);
1181 case detail::type::char_type:
1182 return vis(arg.value_.char_value);
1183 case detail::type::float_type:
1184 return vis(arg.value_.float_value);
1185 case detail::type::double_type:
1186 return vis(arg.value_.double_value);
1187 case detail::type::long_double_type:
1188 return vis(arg.value_.long_double_value);
1189 case detail::type::cstring_type:
1190 return vis(arg.value_.string.data);
1191 case detail::type::string_type:
1192 return vis(basic_string_view<char_type>(arg.value_.string.data,
1193 arg.value_.string.size));
1194 case detail::type::pointer_type:
1195 return vis(arg.value_.pointer);
1196 case detail::type::custom_type:
1197 return vis(typename basic_format_arg<Context>::handle(arg.value_.custom));
1198 }
1199 return vis(monostate());
1200 }
1201
1202 // Checks whether T is a container with contiguous storage.
1203 template <typename T> struct is_contiguous : std::false_type {};
1204 template <typename Char>
1205 struct is_contiguous<std::basic_string<Char>> : std::true_type {};
1206 template <typename Char>
1207 struct is_contiguous<detail::buffer<Char>> : std::true_type {};
1208
1209 namespace detail {
1210
1211 template <typename OutputIt>
1212 struct is_back_insert_iterator : std::false_type {};
1213 template <typename Container>
1214 struct is_back_insert_iterator<std::back_insert_iterator<Container>>
1215 : std::true_type {};
1216
1217 template <typename OutputIt>
1218 struct is_contiguous_back_insert_iterator : std::false_type {};
1219 template <typename Container>
1220 struct is_contiguous_back_insert_iterator<std::back_insert_iterator<Container>>
1221 : is_contiguous<Container> {};
1222
1223 // A type-erased reference to an std::locale to avoid heavy <locale> include.
1224 class locale_ref {
1225 private:
1226 const void* locale_; // A type-erased pointer to std::locale.
1227
1228 public:
1229 locale_ref() : locale_(nullptr) {}
1230 template <typename Locale> explicit locale_ref(const Locale& loc);
1231
1232 explicit operator bool() const FMT_NOEXCEPT { return locale_ != nullptr; }
1233
1234 template <typename Locale> Locale get() const;
1235 };
1236
1237 template <typename> constexpr unsigned long long encode_types() { return 0; }
1238
1239 template <typename Context, typename Arg, typename... Args>
1240 constexpr unsigned long long encode_types() {
1241 return static_cast<unsigned>(mapped_type_constant<Arg, Context>::value) |
1242 (encode_types<Context, Args...>() << packed_arg_bits);
1243 }
1244
1245 template <typename Context, typename T>
1246 FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T& value) {
1247 basic_format_arg<Context> arg;
1248 arg.type_ = mapped_type_constant<T, Context>::value;
1249 arg.value_ = arg_mapper<Context>().map(value);
1250 return arg;
1251 }
1252
1253 // The type template parameter is there to avoid an ODR violation when using
1254 // a fallback formatter in one translation unit and an implicit conversion in
1255 // another (not recommended).
1256 template <bool IS_PACKED, typename Context, type, typename T,
1257 FMT_ENABLE_IF(IS_PACKED)>
1258 inline value<Context> make_arg(const T& val) {
1259 return arg_mapper<Context>().map(val);
1260 }
1261
1262 template <bool IS_PACKED, typename Context, type, typename T,
1263 FMT_ENABLE_IF(!IS_PACKED)>
1264 inline basic_format_arg<Context> make_arg(const T& value) {
1265 return make_arg<Context>(value);
1266 }
1267
1268 template <typename T> struct is_reference_wrapper : std::false_type {};
1269 template <typename T>
1270 struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
1271
1272 template <typename T> const T& unwrap(const T& v) { return v; }
1273 template <typename T> const T& unwrap(const std::reference_wrapper<T>& v) {
1274 return static_cast<const T&>(v);
1275 }
1276
1277 class dynamic_arg_list {
1278 // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
1279 // templates it doesn't complain about inability to deduce single translation
1280 // unit for placing vtable. So storage_node_base is made a fake template.
1281 template <typename = void> struct node {
1282 virtual ~node() = default;
1283 std::unique_ptr<node<>> next;
1284 };
1285
1286 template <typename T> struct typed_node : node<> {
1287 T value;
1288
1289 template <typename Arg>
1290 FMT_CONSTEXPR typed_node(const Arg& arg) : value(arg) {}
1291
1292 template <typename Char>
1293 FMT_CONSTEXPR typed_node(const basic_string_view<Char>& arg)
1294 : value(arg.data(), arg.size()) {}
1295 };
1296
1297 std::unique_ptr<node<>> head_;
1298
1299 public:
1300 template <typename T, typename Arg> const T& push(const Arg& arg) {
1301 auto new_node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg));
1302 auto& value = new_node->value;
1303 new_node->next = std::move(head_);
1304 head_ = std::move(new_node);
1305 return value;
1306 }
1307 };
1308 } // namespace detail
1309
1310 // Formatting context.
1311 template <typename OutputIt, typename Char> class basic_format_context {
1312 public:
1313 /** The character type for the output. */
1314 using char_type = Char;
1315
1316 private:
1317 OutputIt out_;
1318 basic_format_args<basic_format_context> args_;
1319 detail::locale_ref loc_;
1320
1321 public:
1322 using iterator = OutputIt;
1323 using format_arg = basic_format_arg<basic_format_context>;
1324 using parse_context_type = basic_format_parse_context<Char>;
1325 template <typename T> using formatter_type = formatter<T, char_type>;
1326
1327 basic_format_context(const basic_format_context&) = delete;
1328 void operator=(const basic_format_context&) = delete;
1329 /**
1330 Constructs a ``basic_format_context`` object. References to the arguments are
1331 stored in the object so make sure they have appropriate lifetimes.
1332 */
1333 basic_format_context(OutputIt out,
1334 basic_format_args<basic_format_context> ctx_args,
1335 detail::locale_ref loc = detail::locale_ref())
1336 : out_(out), args_(ctx_args), loc_(loc) {}
1337
1338 format_arg arg(int id) const { return args_.get(id); }
1339 format_arg arg(basic_string_view<char_type> name) { return args_.get(name); }
1340 int arg_id(basic_string_view<char_type> name) { return args_.get_id(name); }
1341 const basic_format_args<basic_format_context>& args() const { return args_; }
1342
1343 detail::error_handler error_handler() { return {}; }
1344 void on_error(const char* message) { error_handler().on_error(message); }
1345
1346 // Returns an iterator to the beginning of the output range.
1347 iterator out() { return out_; }
1348
1349 // Advances the begin iterator to ``it``.
1350 void advance_to(iterator it) {
1351 if (!detail::is_back_insert_iterator<iterator>()) out_ = it;
1352 }
1353
1354 detail::locale_ref locale() { return loc_; }
1355 };
1356
1357 template <typename Char>
1358 using buffer_context =
1359 basic_format_context<std::back_insert_iterator<detail::buffer<Char>>, Char>;
1360 using format_context = buffer_context<char>;
1361 using wformat_context = buffer_context<wchar_t>;
1362
1363 // Workaround a bug in gcc: https://stackoverflow.com/q/62767544/471164.
1364 #define FMT_BUFFER_CONTEXT(Char) \
1365 basic_format_context<std::back_insert_iterator<detail::buffer<Char>>, Char>
1366
1367 /**
1368 \rst
1369 An array of references to arguments. It can be implicitly converted into
1370 `~fmt::basic_format_args` for passing into type-erased formatting functions
1371 such as `~fmt::vformat`.
1372 \endrst
1373 */
1374 template <typename Context, typename... Args>
1375 class format_arg_store
1376 #if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
1377 // Workaround a GCC template argument substitution bug.
1378 : public basic_format_args<Context>
1379 #endif
1380 {
1381 private:
1382 static const size_t num_args = sizeof...(Args);
1383 static const size_t num_named_args = detail::count_named_args<Args...>();
1384 static const bool is_packed = num_args <= detail::max_packed_args;
1385
1386 using value_type = conditional_t<is_packed, detail::value<Context>,
1387 basic_format_arg<Context>>;
1388
1389 detail::arg_data<value_type, typename Context::char_type, num_args,
1390 num_named_args>
1391 data_;
1392
1393 friend class basic_format_args<Context>;
1394
1395 static constexpr unsigned long long desc =
1396 (is_packed ? detail::encode_types<Context, Args...>()
1397 : detail::is_unpacked_bit | num_args) |
1398 (num_named_args != 0
1399 ? static_cast<unsigned long long>(detail::has_named_args_bit)
1400 : 0);
1401
1402 public:
1403 format_arg_store(const Args&... args)
1404 :
1405 #if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
1406 basic_format_args<Context>(*this),
1407 #endif
1408 data_{detail::make_arg<
1409 is_packed, Context,
1410 detail::mapped_type_constant<Args, Context>::value>(args)...} {
1411 detail::init_named_args(data_.named_args(), 0, 0, args...);
1412 }
1413 };
1414
1415 /**
1416 \rst
1417 Constructs an `~fmt::format_arg_store` object that contains references to
1418 arguments and can be implicitly converted to `~fmt::format_args`. `Context`
1419 can be omitted in which case it defaults to `~fmt::context`.
1420 See `~fmt::arg` for lifetime considerations.
1421 \endrst
1422 */
1423 template <typename Context = format_context, typename... Args>
1424 inline format_arg_store<Context, Args...> make_format_args(
1425 const Args&... args) {
1426 return {args...};
1427 }
1428
1429 /**
1430 \rst
1431 Returns a named argument to be used in a formatting function. It should only
1432 be used in a call to a formatting function.
1433
1434 **Example**::
1435
1436 fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23));
1437 \endrst
1438 */
1439 template <typename Char, typename T>
1440 inline detail::named_arg<Char, T> arg(const Char* name, const T& arg) {
1441 static_assert(!detail::is_named_arg<T>(), "nested named arguments");
1442 return {name, arg};
1443 }
1444
1445 /**
1446 \rst
1447 A dynamic version of `fmt::format_arg_store`.
1448 It's equipped with a storage to potentially temporary objects which lifetimes
1449 could be shorter than the format arguments object.
1450
1451 It can be implicitly converted into `~fmt::basic_format_args` for passing
1452 into type-erased formatting functions such as `~fmt::vformat`.
1453 \endrst
1454 */
1455 template <typename Context>
1456 class dynamic_format_arg_store
1457 #if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
1458 // Workaround a GCC template argument substitution bug.
1459 : public basic_format_args<Context>
1460 #endif
1461 {
1462 private:
1463 using char_type = typename Context::char_type;
1464
1465 template <typename T> struct need_copy {
1466 static constexpr detail::type mapped_type =
1467 detail::mapped_type_constant<T, Context>::value;
1468
1469 enum {
1470 value = !(detail::is_reference_wrapper<T>::value ||
1471 std::is_same<T, basic_string_view<char_type>>::value ||
1472 std::is_same<T, detail::std_string_view<char_type>>::value ||
1473 (mapped_type != detail::type::cstring_type &&
1474 mapped_type != detail::type::string_type &&
1475 mapped_type != detail::type::custom_type))
1476 };
1477 };
1478
1479 template <typename T>
1480 using stored_type = conditional_t<detail::is_string<T>::value,
1481 std::basic_string<char_type>, T>;
1482
1483 // Storage of basic_format_arg must be contiguous.
1484 std::vector<basic_format_arg<Context>> data_;
1485 std::vector<detail::named_arg_info<char_type>> named_info_;
1486
1487 // Storage of arguments not fitting into basic_format_arg must grow
1488 // without relocation because items in data_ refer to it.
1489 detail::dynamic_arg_list dynamic_args_;
1490
1491 friend class basic_format_args<Context>;
1492
1493 unsigned long long get_types() const {
1494 return detail::is_unpacked_bit | data_.size() |
1495 (named_info_.empty()
1496 ? 0ULL
1497 : static_cast<unsigned long long>(detail::has_named_args_bit));
1498 }
1499
1500 const basic_format_arg<Context>* data() const {
1501 return named_info_.empty() ? data_.data() : data_.data() + 1;
1502 }
1503
1504 template <typename T> void emplace_arg(const T& arg) {
1505 data_.emplace_back(detail::make_arg<Context>(arg));
1506 }
1507
1508 template <typename T>
1509 void emplace_arg(const detail::named_arg<char_type, T>& arg) {
1510 if (named_info_.empty()) {
1511 constexpr const detail::named_arg_info<char_type>* zero_ptr{nullptr};
1512 data_.insert(data_.begin(), {zero_ptr, 0});
1513 }
1514 data_.emplace_back(detail::make_arg<Context>(detail::unwrap(arg.value)));
1515 auto pop_one = [](std::vector<basic_format_arg<Context>>* data) {
1516 data->pop_back();
1517 };
1518 std::unique_ptr<std::vector<basic_format_arg<Context>>, decltype(pop_one)>
1519 guard{&data_, pop_one};
1520 named_info_.push_back({arg.name, static_cast<int>(data_.size() - 2u)});
1521 data_[0].value_.named_args = {named_info_.data(), named_info_.size()};
1522 guard.release();
1523 }
1524
1525 public:
1526 /**
1527 \rst
1528 Adds an argument into the dynamic store for later passing to a formatting
1529 function.
1530
1531 Note that custom types and string types (but not string views) are copied
1532 into the store dynamically allocating memory if necessary.
1533
1534 **Example**::
1535
1536 fmt::dynamic_format_arg_store<fmt::format_context> store;
1537 store.push_back(42);
1538 store.push_back("abc");
1539 store.push_back(1.5f);
1540 std::string result = fmt::vformat("{} and {} and {}", store);
1541 \endrst
1542 */
1543 template <typename T> void push_back(const T& arg) {
1544 if (detail::const_check(need_copy<T>::value))
1545 emplace_arg(dynamic_args_.push<stored_type<T>>(arg));
1546 else
1547 emplace_arg(detail::unwrap(arg));
1548 }
1549
1550 /**
1551 \rst
1552 Adds a reference to the argument into the dynamic store for later passing to
1553 a formatting function. Supports named arguments wrapped in
1554 ``std::reference_wrapper`` via ``std::ref()``/``std::cref()``.
1555
1556 **Example**::
1557
1558 fmt::dynamic_format_arg_store<fmt::format_context> store;
1559 char str[] = "1234567890";
1560 store.push_back(std::cref(str));
1561 int a1_val{42};
1562 auto a1 = fmt::arg("a1_", a1_val);
1563 store.push_back(std::cref(a1));
1564
1565 // Changing str affects the output but only for string and custom types.
1566 str[0] = 'X';
1567
1568 std::string result = fmt::vformat("{} and {a1_}");
1569 assert(result == "X234567890 and 42");
1570 \endrst
1571 */
1572 template <typename T> void push_back(std::reference_wrapper<T> arg) {
1573 static_assert(
1574 detail::is_named_arg<typename std::remove_cv<T>::type>::value ||
1575 need_copy<T>::value,
1576 "objects of built-in types and string views are always copied");
1577 emplace_arg(arg.get());
1578 }
1579
1580 /**
1581 Adds named argument into the dynamic store for later passing to a formatting
1582 function. ``std::reference_wrapper`` is supported to avoid copying of the
1583 argument.
1584 */
1585 template <typename T>
1586 void push_back(const detail::named_arg<char_type, T>& arg) {
1587 const char_type* arg_name =
1588 dynamic_args_.push<std::basic_string<char_type>>(arg.name).c_str();
1589 if (detail::const_check(need_copy<T>::value)) {
1590 emplace_arg(
1591 fmt::arg(arg_name, dynamic_args_.push<stored_type<T>>(arg.value)));
1592 } else {
1593 emplace_arg(fmt::arg(arg_name, arg.value));
1594 }
1595 }
1596
1597 /** Erase all elements from the store */
1598 void clear() {
1599 data_.clear();
1600 named_info_.clear();
1601 dynamic_args_ = detail::dynamic_arg_list();
1602 }
1603
1604 /**
1605 \rst
1606 Reserves space to store at least *new_cap* arguments including
1607 *new_cap_named* named arguments.
1608 \endrst
1609 */
1610 void reserve(size_t new_cap, size_t new_cap_named) {
1611 FMT_ASSERT(new_cap >= new_cap_named,
1612 "Set of arguments includes set of named arguments");
1613 data_.reserve(new_cap);
1614 named_info_.reserve(new_cap_named);
1615 }
1616 };
1617
1618 /**
1619 \rst
1620 A view of a collection of formatting arguments. To avoid lifetime issues it
1621 should only be used as a parameter type in type-erased functions such as
1622 ``vformat``::
1623
1624 void vlog(string_view format_str, format_args args); // OK
1625 format_args args = make_format_args(42); // Error: dangling reference
1626 \endrst
1627 */
1628 template <typename Context> class basic_format_args {
1629 public:
1630 using size_type = int;
1631 using format_arg = basic_format_arg<Context>;
1632
1633 private:
1634 // A descriptor that contains information about formatting arguments.
1635 // If the number of arguments is less or equal to max_packed_args then
1636 // argument types are passed in the descriptor. This reduces binary code size
1637 // per formatting function call.
1638 unsigned long long desc_;
1639 union {
1640 // If is_packed() returns true then argument values are stored in values_;
1641 // otherwise they are stored in args_. This is done to improve cache
1642 // locality and reduce compiled code size since storing larger objects
1643 // may require more code (at least on x86-64) even if the same amount of
1644 // data is actually copied to stack. It saves ~10% on the bloat test.
1645 const detail::value<Context>* values_;
1646 const format_arg* args_;
1647 };
1648
1649 bool is_packed() const { return (desc_ & detail::is_unpacked_bit) == 0; }
1650 bool has_named_args() const {
1651 return (desc_ & detail::has_named_args_bit) != 0;
1652 }
1653
1654 detail::type type(int index) const {
1655 int shift = index * detail::packed_arg_bits;
1656 unsigned int mask = (1 << detail::packed_arg_bits) - 1;
1657 return static_cast<detail::type>((desc_ >> shift) & mask);
1658 }
1659
1660 basic_format_args(unsigned long long desc,
1661 const detail::value<Context>* values)
1662 : desc_(desc), values_(values) {}
1663 basic_format_args(unsigned long long desc, const format_arg* args)
1664 : desc_(desc), args_(args) {}
1665
1666 public:
1667 basic_format_args() : desc_(0) {}
1668
1669 /**
1670 \rst
1671 Constructs a `basic_format_args` object from `~fmt::format_arg_store`.
1672 \endrst
1673 */
1674 template <typename... Args>
1675 FMT_INLINE basic_format_args(const format_arg_store<Context, Args...>& store)
1676 : basic_format_args(store.desc, store.data_.args()) {}
1677
1678 /**
1679 \rst
1680 Constructs a `basic_format_args` object from
1681 `~fmt::dynamic_format_arg_store`.
1682 \endrst
1683 */
1684 FMT_INLINE basic_format_args(const dynamic_format_arg_store<Context>& store)
1685 : basic_format_args(store.get_types(), store.data()) {}
1686
1687 /**
1688 \rst
1689 Constructs a `basic_format_args` object from a dynamic set of arguments.
1690 \endrst
1691 */
1692 basic_format_args(const format_arg* args, int count)
1693 : basic_format_args(detail::is_unpacked_bit | detail::to_unsigned(count),
1694 args) {}
1695
1696 /** Returns the argument with the specified id. */
1697 format_arg get(int id) const {
1698 format_arg arg;
1699 if (!is_packed()) {
1700 if (id < max_size()) arg = args_[id];
1701 return arg;
1702 }
1703 if (id >= detail::max_packed_args) return arg;
1704 arg.type_ = type(id);
1705 if (arg.type_ == detail::type::none_type) return arg;
1706 arg.value_ = values_[id];
1707 return arg;
1708 }
1709
1710 template <typename Char> format_arg get(basic_string_view<Char> name) const {
1711 int id = get_id(name);
1712 return id >= 0 ? get(id) : format_arg();
1713 }
1714
1715 template <typename Char> int get_id(basic_string_view<Char> name) const {
1716 if (!has_named_args()) return -1;
1717 const auto& named_args =
1718 (is_packed() ? values_[-1] : args_[-1].value_).named_args;
1719 for (size_t i = 0; i < named_args.size; ++i) {
1720 if (named_args.data[i].name == name) return named_args.data[i].id;
1721 }
1722 return -1;
1723 }
1724
1725 int max_size() const {
1726 unsigned long long max_packed = detail::max_packed_args;
1727 return static_cast<int>(is_packed() ? max_packed
1728 : desc_ & ~detail::is_unpacked_bit);
1729 }
1730 };
1731
1732 /** An alias to ``basic_format_args<context>``. */
1733 // It is a separate type rather than an alias to make symbols readable.
1734 struct format_args : basic_format_args<format_context> {
1735 template <typename... Args>
1736 FMT_INLINE format_args(const Args&... args) : basic_format_args(args...) {}
1737 };
1738 struct wformat_args : basic_format_args<wformat_context> {
1739 using basic_format_args::basic_format_args;
1740 };
1741
1742 namespace detail {
1743
1744 // Reports a compile-time error if S is not a valid format string.
1745 template <typename..., typename S, FMT_ENABLE_IF(!is_compile_string<S>::value)>
1746 FMT_INLINE void check_format_string(const S&) {
1747 #ifdef FMT_ENFORCE_COMPILE_STRING
1748 static_assert(is_compile_string<S>::value,
1749 "FMT_ENFORCE_COMPILE_STRING requires all format strings to use "
1750 "FMT_STRING.");
1751 #endif
1752 }
1753 template <typename..., typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
1754 void check_format_string(S);
1755
1756 template <typename... Args, typename S, typename Char = char_t<S>>
1757 inline format_arg_store<buffer_context<Char>, remove_reference_t<Args>...>
1758 make_args_checked(const S& format_str,
1759 const remove_reference_t<Args>&... args) {
1760 static_assert(count<(std::is_base_of<view, remove_reference_t<Args>>::value &&
1761 std::is_reference<Args>::value)...>() == 0,
1762 "passing views as lvalues is disallowed");
1763 check_format_string<Args...>(format_str);
1764 return {args...};
1765 }
1766
1767 template <typename Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
1768 std::basic_string<Char> vformat(
1769 basic_string_view<Char> format_str,
1770 basic_format_args<buffer_context<type_identity_t<Char>>> args);
1771
1772 FMT_API std::string vformat(string_view format_str, format_args args);
1773
1774 template <typename Char>
1775 typename FMT_BUFFER_CONTEXT(Char)::iterator vformat_to(
1776 buffer<Char>& buf, basic_string_view<Char> format_str,
1777 basic_format_args<FMT_BUFFER_CONTEXT(type_identity_t<Char>)> args);
1778
1779 template <typename Char, typename Args,
1780 FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
1781 inline void vprint_mojibake(std::FILE*, basic_string_view<Char>, const Args&) {}
1782
1783 FMT_API void vprint_mojibake(std::FILE*, string_view, format_args);
1784 #ifndef _WIN32
1785 inline void vprint_mojibake(std::FILE*, string_view, format_args) {}
1786 #endif
1787 } // namespace detail
1788
1789 /** Formats a string and writes the output to ``out``. */
1790 // GCC 8 and earlier cannot handle std::back_insert_iterator<Container> with
1791 // vformat_to<ArgFormatter>(...) overload, so SFINAE on iterator type instead.
1792 template <
1793 typename OutputIt, typename S, typename Char = char_t<S>,
1794 FMT_ENABLE_IF(detail::is_contiguous_back_insert_iterator<OutputIt>::value)>
1795 OutputIt vformat_to(
1796 OutputIt out, const S& format_str,
1797 basic_format_args<buffer_context<type_identity_t<Char>>> args) {
1798 auto& c = detail::get_container(out);
1799 detail::container_buffer<remove_reference_t<decltype(c)>> buf(c);
1800 detail::vformat_to(buf, to_string_view(format_str), args);
1801 return out;
1802 }
1803
1804 template <typename Container, typename S, typename... Args,
1805 FMT_ENABLE_IF(
1806 is_contiguous<Container>::value&& detail::is_string<S>::value)>
1807 inline std::back_insert_iterator<Container> format_to(
1808 std::back_insert_iterator<Container> out, const S& format_str,
1809 Args&&... args) {
1810 return vformat_to(out, to_string_view(format_str),
1811 detail::make_args_checked<Args...>(format_str, args...));
1812 }
1813
1814 template <typename S, typename Char = char_t<S>>
1815 FMT_INLINE std::basic_string<Char> vformat(
1816 const S& format_str,
1817 basic_format_args<buffer_context<type_identity_t<Char>>> args) {
1818 return detail::vformat(to_string_view(format_str), args);
1819 }
1820
1821 /**
1822 \rst
1823 Formats arguments and returns the result as a string.
1824
1825 **Example**::
1826
1827 #include <fmt/core.h>
1828 std::string message = fmt::format("The answer is {}", 42);
1829 \endrst
1830 */
1831 // Pass char_t as a default template parameter instead of using
1832 // std::basic_string<char_t<S>> to reduce the symbol size.
1833 template <typename S, typename... Args, typename Char = char_t<S>>
1834 FMT_INLINE std::basic_string<Char> format(const S& format_str, Args&&... args) {
1835 const auto& vargs = detail::make_args_checked<Args...>(format_str, args...);
1836 return detail::vformat(to_string_view(format_str), vargs);
1837 }
1838
1839 FMT_API void vprint(string_view, format_args);
1840 FMT_API void vprint(std::FILE*, string_view, format_args);
1841
1842 /**
1843 \rst
1844 Formats ``args`` according to specifications in ``format_str`` and writes the
1845 output to the file ``f``. Strings are assumed to be Unicode-encoded unless the
1846 ``FMT_UNICODE`` macro is set to 0.
1847
1848 **Example**::
1849
1850 fmt::print(stderr, "Don't {}!", "panic");
1851 \endrst
1852 */
1853 template <typename S, typename... Args, typename Char = char_t<S>>
1854 inline void print(std::FILE* f, const S& format_str, Args&&... args) {
1855 const auto& vargs = detail::make_args_checked<Args...>(format_str, args...);
1856 return detail::is_unicode<Char>()
1857 ? vprint(f, to_string_view(format_str), vargs)
1858 : detail::vprint_mojibake(f, to_string_view(format_str), vargs);
1859 }
1860
1861 /**
1862 \rst
1863 Formats ``args`` according to specifications in ``format_str`` and writes
1864 the output to ``stdout``. Strings are assumed to be Unicode-encoded unless
1865 the ``FMT_UNICODE`` macro is set to 0.
1866
1867 **Example**::
1868
1869 fmt::print("Elapsed time: {0:.2f} seconds", 1.23);
1870 \endrst
1871 */
1872 template <typename S, typename... Args, typename Char = char_t<S>>
1873 inline void print(const S& format_str, Args&&... args) {
1874 const auto& vargs = detail::make_args_checked<Args...>(format_str, args...);
1875 return detail::is_unicode<Char>()
1876 ? vprint(to_string_view(format_str), vargs)
1877 : detail::vprint_mojibake(stdout, to_string_view(format_str),
1878 vargs);
1879 }
1880 FMT_END_NAMESPACE
1881
1882 #endif // FMT_CORE_H_
1883