WPILibC++ 2025.3.1
Loading...
Searching...
No Matches
base.h
Go to the documentation of this file.
1// Formatting library for C++ - the base API for char/UTF-8
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_BASE_H_
9#define FMT_BASE_H_
10
11#if defined(FMT_IMPORT_STD) && !defined(FMT_MODULE)
12# define FMT_MODULE
13#endif
14
15#ifndef FMT_MODULE
16# include <limits.h> // CHAR_BIT
17# include <stdio.h> // FILE
18# include <string.h> // memcmp
19
20# include <type_traits> // std::enable_if
21#endif
22
23// The fmt library version in the form major * 10000 + minor * 100 + patch.
24#define FMT_VERSION 110100
25
26// Detect compiler versions.
27#if defined(__clang__) && !defined(__ibmxl__)
28# define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
29#else
30# define FMT_CLANG_VERSION 0
31#endif
32#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER)
33# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
34#else
35# define FMT_GCC_VERSION 0
36#endif
37#if defined(__ICL)
38# define FMT_ICC_VERSION __ICL
39#elif defined(__INTEL_COMPILER)
40# define FMT_ICC_VERSION __INTEL_COMPILER
41#else
42# define FMT_ICC_VERSION 0
43#endif
44#if defined(_MSC_VER)
45# define FMT_MSC_VERSION _MSC_VER
46#else
47# define FMT_MSC_VERSION 0
48#endif
49
50// Detect standard library versions.
51#ifdef _GLIBCXX_RELEASE
52# define FMT_GLIBCXX_RELEASE _GLIBCXX_RELEASE
53#else
54# define FMT_GLIBCXX_RELEASE 0
55#endif
56#ifdef _LIBCPP_VERSION
57# define FMT_LIBCPP_VERSION _LIBCPP_VERSION
58#else
59# define FMT_LIBCPP_VERSION 0
60#endif
61
62#ifdef _MSVC_LANG
63# define FMT_CPLUSPLUS _MSVC_LANG
64#else
65# define FMT_CPLUSPLUS __cplusplus
66#endif
67
68// Detect __has_*.
69#ifdef __has_feature
70# define FMT_HAS_FEATURE(x) __has_feature(x)
71#else
72# define FMT_HAS_FEATURE(x) 0
73#endif
74#ifdef __has_include
75# define FMT_HAS_INCLUDE(x) __has_include(x)
76#else
77# define FMT_HAS_INCLUDE(x) 0
78#endif
79#ifdef __has_builtin
80# define FMT_HAS_BUILTIN(x) __has_builtin(x)
81#else
82# define FMT_HAS_BUILTIN(x) 0
83#endif
84#ifdef __has_cpp_attribute
85# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
86#else
87# define FMT_HAS_CPP_ATTRIBUTE(x) 0
88#endif
89
90#define FMT_HAS_CPP14_ATTRIBUTE(attribute) \
91 (FMT_CPLUSPLUS >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute))
92
93#define FMT_HAS_CPP17_ATTRIBUTE(attribute) \
94 (FMT_CPLUSPLUS >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute))
95
96// Detect C++14 relaxed constexpr.
97#ifdef FMT_USE_CONSTEXPR
98// Use the provided definition.
99#elif FMT_GCC_VERSION >= 600 && FMT_CPLUSPLUS >= 201402L
100// GCC only allows throw in constexpr since version 6:
101// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67371.
102# define FMT_USE_CONSTEXPR 1
103#elif FMT_ICC_VERSION
104# define FMT_USE_CONSTEXPR 0 // https://github.com/fmtlib/fmt/issues/1628
105#elif FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VERSION >= 1912
106# define FMT_USE_CONSTEXPR 1
107#else
108# define FMT_USE_CONSTEXPR 0
109#endif
110#if FMT_USE_CONSTEXPR
111# define FMT_CONSTEXPR constexpr
112#else
113# define FMT_CONSTEXPR
114#endif
115
116// Detect consteval, C++20 constexpr extensions and std::is_constant_evaluated.
117#if !defined(__cpp_lib_is_constant_evaluated)
118# define FMT_USE_CONSTEVAL 0
119#elif FMT_CPLUSPLUS < 201709L
120# define FMT_USE_CONSTEVAL 0
121#elif FMT_GLIBCXX_RELEASE && FMT_GLIBCXX_RELEASE < 10
122# define FMT_USE_CONSTEVAL 0
123#elif FMT_LIBCPP_VERSION && FMT_LIBCPP_VERSION < 10000
124# define FMT_USE_CONSTEVAL 0
125#elif defined(__apple_build_version__) && __apple_build_version__ < 14000029L
126# define FMT_USE_CONSTEVAL 0 // consteval is broken in Apple clang < 14.
127#elif FMT_MSC_VERSION && FMT_MSC_VERSION < 1929
128# define FMT_USE_CONSTEVAL 0 // consteval is broken in MSVC VS2019 < 16.10.
129#elif defined(__cpp_consteval)
130# define FMT_USE_CONSTEVAL 1
131#elif FMT_GCC_VERSION >= 1002 || FMT_CLANG_VERSION >= 1101
132# define FMT_USE_CONSTEVAL 1
133#else
134# define FMT_USE_CONSTEVAL 0
135#endif
136#if FMT_USE_CONSTEVAL
137# define FMT_CONSTEVAL consteval
138# define FMT_CONSTEXPR20 constexpr
139#else
140# define FMT_CONSTEVAL
141# define FMT_CONSTEXPR20
142#endif
143
144// Check if exceptions are disabled.
145#ifdef FMT_USE_EXCEPTIONS
146// Use the provided definition.
147#elif defined(__GNUC__) && !defined(__EXCEPTIONS)
148# define FMT_USE_EXCEPTIONS 0
149#elif defined(__clang__) && !defined(__cpp_exceptions)
150# define FMT_USE_EXCEPTIONS 0
151#elif FMT_MSC_VERSION && !_HAS_EXCEPTIONS
152# define FMT_USE_EXCEPTIONS 0
153#else
154# define FMT_USE_EXCEPTIONS 1
155#endif
156#if FMT_USE_EXCEPTIONS
157# define FMT_TRY try
158# define FMT_CATCH(x) catch (x)
159#else
160# define FMT_TRY if (true)
161# define FMT_CATCH(x) if (false)
162#endif
163
164#if FMT_HAS_CPP17_ATTRIBUTE(fallthrough)
165# define FMT_FALLTHROUGH [[fallthrough]]
166#elif defined(__clang__)
167# define FMT_FALLTHROUGH [[clang::fallthrough]]
168#elif FMT_GCC_VERSION >= 700 && \
169 (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 520)
170# define FMT_FALLTHROUGH [[gnu::fallthrough]]
171#else
172# define FMT_FALLTHROUGH
173#endif
174
175// Disable [[noreturn]] on MSVC/NVCC because of bogus unreachable code warnings.
176#if FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VERSION && !defined(__NVCC__)
177# define FMT_NORETURN [[noreturn]]
178#else
179# define FMT_NORETURN
180#endif
181
182#ifdef FMT_NODISCARD
183// Use the provided definition.
184#elif FMT_HAS_CPP17_ATTRIBUTE(nodiscard)
185# define FMT_NODISCARD [[nodiscard]]
186#else
187# define FMT_NODISCARD
188#endif
189
190#ifdef FMT_DEPRECATED
191// Use the provided definition.
192#elif FMT_HAS_CPP14_ATTRIBUTE(deprecated)
193# define FMT_DEPRECATED [[deprecated]]
194#else
195# define FMT_DEPRECATED /* deprecated */
196#endif
197
198#ifdef FMT_ALWAYS_INLINE
199// Use the provided definition.
200#elif FMT_GCC_VERSION || FMT_CLANG_VERSION
201# define FMT_ALWAYS_INLINE inline __attribute__((always_inline))
202#else
203# define FMT_ALWAYS_INLINE inline
204#endif
205// A version of FMT_ALWAYS_INLINE to prevent code bloat in debug mode.
206#ifdef NDEBUG
207# define FMT_INLINE FMT_ALWAYS_INLINE
208#else
209# define FMT_INLINE inline
210#endif
211
212#if FMT_GCC_VERSION || FMT_CLANG_VERSION
213# define FMT_VISIBILITY(value) __attribute__((visibility(value)))
214#else
215# define FMT_VISIBILITY(value)
216#endif
217
218// Detect pragmas.
219#define FMT_PRAGMA_IMPL(x) _Pragma(#x)
220#if FMT_GCC_VERSION >= 504 && !defined(__NVCOMPILER)
221// Workaround a _Pragma bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59884
222// and an nvhpc warning: https://github.com/fmtlib/fmt/pull/2582.
223# define FMT_PRAGMA_GCC(x) FMT_PRAGMA_IMPL(GCC x)
224#else
225# define FMT_PRAGMA_GCC(x)
226#endif
227#if FMT_CLANG_VERSION
228# define FMT_PRAGMA_CLANG(x) FMT_PRAGMA_IMPL(clang x)
229#else
230# define FMT_PRAGMA_CLANG(x)
231#endif
232#if FMT_MSC_VERSION
233# define FMT_MSC_WARNING(...) __pragma(warning(__VA_ARGS__))
234#else
235# define FMT_MSC_WARNING(...)
236#endif
237
238#ifndef FMT_BEGIN_NAMESPACE
239# define FMT_BEGIN_NAMESPACE \
240 namespace fmt { \
241 inline namespace v11 {
242# define FMT_END_NAMESPACE \
243 } \
244 }
245#endif
246
247#ifndef FMT_EXPORT
248# define FMT_EXPORT
249# define FMT_BEGIN_EXPORT
250# define FMT_END_EXPORT
251#endif
252
253#ifdef _WIN32
254# define FMT_WIN32 1
255#else
256# define FMT_WIN32 0
257#endif
258
259#if !defined(FMT_HEADER_ONLY) && FMT_WIN32
260# if defined(FMT_LIB_EXPORT)
261# define FMT_API __declspec(dllexport)
262# elif defined(FMT_SHARED)
263# define FMT_API __declspec(dllimport)
264# endif
265#elif defined(FMT_LIB_EXPORT) || defined(FMT_SHARED)
266# define FMT_API FMT_VISIBILITY("default")
267#endif
268#ifndef FMT_API
269# define FMT_API
270#endif
271
272#ifndef FMT_OPTIMIZE_SIZE
273# define FMT_OPTIMIZE_SIZE 0
274#endif
275
276// FMT_BUILTIN_TYPE=0 may result in smaller library size at the cost of higher
277// per-call binary size by passing built-in types through the extension API.
278#ifndef FMT_BUILTIN_TYPES
279# define FMT_BUILTIN_TYPES 1
280#endif
281
282#define FMT_APPLY_VARIADIC(expr) \
283 using ignore = int[]; \
284 (void)ignore { 0, (expr, 0)... }
285
286// Enable minimal optimizations for more compact code in debug mode.
287FMT_PRAGMA_GCC(push_options)
288#if !defined(__OPTIMIZE__) && !defined(__CUDACC__)
289FMT_PRAGMA_GCC(optimize("Og"))
290#endif
291FMT_PRAGMA_CLANG(diagnostic push)
292
294
295// Implementations of enable_if_t and other metafunctions for older systems.
296template <bool B, typename T = void>
297using enable_if_t = typename std::enable_if<B, T>::type;
298template <bool B, typename T, typename F>
299using conditional_t = typename std::conditional<B, T, F>::type;
300template <bool B> using bool_constant = std::integral_constant<bool, B>;
301template <typename T>
302using remove_reference_t = typename std::remove_reference<T>::type;
303template <typename T>
304using remove_const_t = typename std::remove_const<T>::type;
305template <typename T>
306using remove_cvref_t = typename std::remove_cv<remove_reference_t<T>>::type;
307template <typename T>
308using make_unsigned_t = typename std::make_unsigned<T>::type;
309template <typename T>
310using underlying_t = typename std::underlying_type<T>::type;
311template <typename T> using decay_t = typename std::decay<T>::type;
312using nullptr_t = decltype(nullptr);
313
314#if FMT_GCC_VERSION && FMT_GCC_VERSION < 500
315// A workaround for gcc 4.9 to make void_t work in a SFINAE context.
316template <typename...> struct void_t_impl {
317 using type = void;
318};
319template <typename... T> using void_t = typename void_t_impl<T...>::type;
320#else
321template <typename...> using void_t = void;
322#endif
323
324struct monostate {
325 constexpr monostate() {}
326};
327
328// An enable_if helper to be used in template parameters which results in much
329// shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed
330// to workaround a bug in MSVC 2019 (see #1140 and #1186).
331#ifdef FMT_DOC
332# define FMT_ENABLE_IF(...)
333#else
334# define FMT_ENABLE_IF(...) fmt::enable_if_t<(__VA_ARGS__), int> = 0
335#endif
336
337template <typename T> constexpr auto min_of(T a, T b) -> T {
338 return a < b ? a : b;
339}
340template <typename T> constexpr auto max_of(T a, T b) -> T {
341 return a > b ? a : b;
342}
343
344namespace detail {
345// Suppresses "unused variable" warnings with the method described in
346// https://herbsutter.com/2009/10/18/mailbag-shutting-up-compiler-warnings/.
347// (void)var does not work on many Intel compilers.
348template <typename... T> FMT_CONSTEXPR void ignore_unused(const T&...) {}
349
350constexpr auto is_constant_evaluated(bool default_value = false) noexcept
351 -> bool {
352// Workaround for incompatibility between clang 14 and libstdc++ consteval-based
353// std::is_constant_evaluated: https://github.com/fmtlib/fmt/issues/3247.
354#if FMT_CPLUSPLUS >= 202002L && FMT_GLIBCXX_RELEASE >= 12 && \
355 (FMT_CLANG_VERSION >= 1400 && FMT_CLANG_VERSION < 1500)
356 ignore_unused(default_value);
357 return __builtin_is_constant_evaluated();
358#elif defined(__cpp_lib_is_constant_evaluated)
359 ignore_unused(default_value);
360 return std::is_constant_evaluated();
361#else
362 return default_value;
363#endif
364}
365
366// Suppresses "conditional expression is constant" warnings.
367template <typename T> FMT_ALWAYS_INLINE constexpr auto const_check(T val) -> T {
368 return val;
369}
370
371FMT_NORETURN FMT_API void assert_fail(const char* file, int line,
372 const char* message);
373
374#if defined(FMT_ASSERT)
375// Use the provided definition.
376#elif defined(NDEBUG)
377// FMT_ASSERT is not empty to avoid -Wempty-body.
378# define FMT_ASSERT(condition, message) \
379 fmt::detail::ignore_unused((condition), (message))
380#else
381# define FMT_ASSERT(condition, message) \
382 ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
383 ? (void)0 \
384 : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))
385#endif
386
387#ifdef FMT_USE_INT128
388// Use the provided definition.
389#elif defined(__SIZEOF_INT128__) && !defined(__NVCC__) && \
390 !(FMT_CLANG_VERSION && FMT_MSC_VERSION)
391# define FMT_USE_INT128 1
392using int128_opt = __int128_t; // An optional native 128-bit integer.
393using uint128_opt = __uint128_t;
394inline auto map(int128_opt x) -> int128_opt { return x; }
395inline auto map(uint128_opt x) -> uint128_opt { return x; }
396#else
397# define FMT_USE_INT128 0
398#endif
399#if !FMT_USE_INT128
400enum class int128_opt {};
401enum class uint128_opt {};
402// Reduce template instantiations.
403inline auto map(int128_opt) -> monostate { return {}; }
404inline auto map(uint128_opt) -> monostate { return {}; }
405#endif
406
407#ifndef FMT_USE_BITINT
408# define FMT_USE_BITINT (FMT_CLANG_VERSION >= 1500)
409#endif
410
411#if FMT_USE_BITINT
412FMT_PRAGMA_CLANG(diagnostic ignored "-Wbit-int-extension")
413template <int N> using bitint = _BitInt(N);
414template <int N> using ubitint = unsigned _BitInt(N);
415#else
416template <int N> struct bitint {};
417template <int N> struct ubitint {};
418#endif // FMT_USE_BITINT
419
420// Casts a nonnegative integer to unsigned.
421template <typename Int>
423 FMT_ASSERT(std::is_unsigned<Int>::value || value >= 0, "negative value");
424 return static_cast<make_unsigned_t<Int>>(value);
425}
426
427template <typename Char>
428using unsigned_char = conditional_t<sizeof(Char) == 1, unsigned char, unsigned>;
429
430// A heuristic to detect std::string and std::[experimental::]string_view.
431// It is mainly used to avoid dependency on <[experimental/]string_view>.
432template <typename T, typename Enable = void>
433struct is_std_string_like : std::false_type {};
434template <typename T>
435struct is_std_string_like<T, void_t<decltype(std::declval<T>().find_first_of(
436 typename T::value_type(), 0))>>
437 : std::is_convertible<decltype(std::declval<T>().data()),
438 const typename T::value_type*> {};
439
440// Check if the literal encoding is UTF-8.
441enum { is_utf8_enabled = "\u00A7"[1] == '\xA7' };
443
444#ifndef FMT_UNICODE
445# define FMT_UNICODE 1
446#endif
447
448static_assert(!FMT_UNICODE || use_utf8,
449 "Unicode support requires compiling with /utf-8");
450
451template <typename T> constexpr const char* narrow(const T*) { return nullptr; }
452constexpr FMT_ALWAYS_INLINE const char* narrow(const char* s) { return s; }
453
454template <typename Char>
455FMT_CONSTEXPR auto compare(const Char* s1, const Char* s2, std::size_t n)
456 -> int {
457 if (!is_constant_evaluated() && sizeof(Char) == 1) return memcmp(s1, s2, n);
458 for (; n != 0; ++s1, ++s2, --n) {
459 if (*s1 < *s2) return -1;
460 if (*s1 > *s2) return 1;
461 }
462 return 0;
463}
464
465namespace adl {
466using namespace std;
467
468template <typename Container>
470 -> decltype(back_inserter(std::declval<Container&>()));
471} // namespace adl
472
473template <typename It, typename Enable = std::true_type>
474struct is_back_insert_iterator : std::false_type {};
475
476template <typename It>
478 It, bool_constant<std::is_same<
479 decltype(adl::invoke_back_inserter<typename It::container_type>()),
480 It>::value>> : std::true_type {};
481
482// Extracts a reference to the container from *insert_iterator.
483template <typename OutputIt>
484inline FMT_CONSTEXPR20 auto get_container(OutputIt it) ->
485 typename OutputIt::container_type& {
486 struct accessor : OutputIt {
487 FMT_CONSTEXPR20 accessor(OutputIt base) : OutputIt(base) {}
488 using OutputIt::container;
489 };
490 return *accessor(it).container;
491}
492} // namespace detail
493
494// Parsing-related public API and forward declarations.
496
497/**
498 * An implementation of `std::basic_string_view` for pre-C++17. It provides a
499 * subset of the API. `fmt::basic_string_view` is used for format strings even
500 * if `std::basic_string_view` is available to prevent issues when a library is
501 * compiled with a different `-std` option than the client code (which is not
502 * recommended).
503 */
504template <typename Char> class basic_string_view {
505 private:
506 const Char* data_;
507 size_t size_;
508
509 public:
510 using value_type = Char;
511 using iterator = const Char*;
512
513 constexpr basic_string_view() noexcept : data_(nullptr), size_(0) {}
514
515 /// Constructs a string reference object from a C string and a size.
516 constexpr basic_string_view(const Char* s, size_t count) noexcept
517 : data_(s), size_(count) {}
518
519 constexpr basic_string_view(nullptr_t) = delete;
520
521 /// Constructs a string reference object from a C string.
522#if FMT_GCC_VERSION
524#endif
525 FMT_CONSTEXPR20 basic_string_view(const Char* s) : data_(s) {
526#if FMT_HAS_BUILTIN(__buitin_strlen) || FMT_GCC_VERSION || FMT_CLANG_VERSION
527 if (std::is_same<Char, char>::value) {
528 size_ = __builtin_strlen(detail::narrow(s));
529 return;
530 }
531#endif
532 size_t len = 0;
533 while (*s++) ++len;
534 size_ = len;
535 }
536
537 /// Constructs a string reference from a `std::basic_string` or a
538 /// `std::basic_string_view` object.
539 template <typename S,
541 typename S::value_type, Char>::value)>
543 : data_(s.data()), size_(s.size()) {}
544
545 /// Returns a pointer to the string data.
546 constexpr auto data() const noexcept -> const Char* { return data_; }
547
548 /// Returns the string size.
549 constexpr auto size() const noexcept -> size_t { return size_; }
550
551 constexpr auto begin() const noexcept -> iterator { return data_; }
552 constexpr auto end() const noexcept -> iterator { return data_ + size_; }
553
554 constexpr auto operator[](size_t pos) const noexcept -> const Char& {
555 return data_[pos];
556 }
557
558 FMT_CONSTEXPR void remove_prefix(size_t n) noexcept {
559 data_ += n;
560 size_ -= n;
561 }
562
564 -> bool {
565 return size_ >= sv.size_ && detail::compare(data_, sv.data_, sv.size_) == 0;
566 }
567 FMT_CONSTEXPR auto starts_with(Char c) const noexcept -> bool {
568 return size_ >= 1 && *data_ == c;
569 }
570 FMT_CONSTEXPR auto starts_with(const Char* s) const -> bool {
572 }
573
574 // Lexicographically compare this string reference to other.
575 FMT_CONSTEXPR auto compare(basic_string_view other) const -> int {
576 int result =
577 detail::compare(data_, other.data_, min_of(size_, other.size_));
578 if (result != 0) return result;
579 return size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
580 }
581
583 basic_string_view rhs) -> bool {
584 return lhs.compare(rhs) == 0;
585 }
586 friend auto operator!=(basic_string_view lhs, basic_string_view rhs) -> bool {
587 return lhs.compare(rhs) != 0;
588 }
589 friend auto operator<(basic_string_view lhs, basic_string_view rhs) -> bool {
590 return lhs.compare(rhs) < 0;
591 }
592 friend auto operator<=(basic_string_view lhs, basic_string_view rhs) -> bool {
593 return lhs.compare(rhs) <= 0;
594 }
595 friend auto operator>(basic_string_view lhs, basic_string_view rhs) -> bool {
596 return lhs.compare(rhs) > 0;
597 }
598 friend auto operator>=(basic_string_view lhs, basic_string_view rhs) -> bool {
599 return lhs.compare(rhs) >= 0;
600 }
601};
602
604
605/// Specifies if `T` is an extended character type. Can be specialized by users.
606template <typename T> struct is_xchar : std::false_type {};
607template <> struct is_xchar<wchar_t> : std::true_type {};
608template <> struct is_xchar<char16_t> : std::true_type {};
609template <> struct is_xchar<char32_t> : std::true_type {};
610#ifdef __cpp_char8_t
611template <> struct is_xchar<char8_t> : std::true_type {};
612#endif
613
614// DEPRECATED! Will be replaced with an alias to prevent specializations.
615template <typename T> struct is_char : is_xchar<T> {};
616template <> struct is_char<char> : std::true_type {};
617
618template <typename T> class basic_appender;
620
621// Checks whether T is a container with contiguous storage.
622template <typename T> struct is_contiguous : std::false_type {};
623
624class context;
625template <typename OutputIt, typename Char> class generic_context;
626template <typename Char> class parse_context;
627
628// Longer aliases for C++20 compatibility.
629template <typename Char> using basic_format_parse_context = parse_context<Char>;
631template <typename OutputIt, typename Char>
636
637template <typename Char>
641
642template <typename Context> class basic_format_arg;
643template <typename Context> class basic_format_args;
644
645// A separate type would result in shorter symbols but break ABI compatibility
646// between clang and gcc on ARM (#1919).
648
649// A formatter for objects of type T.
650template <typename T, typename Char = char, typename Enable = void>
651struct formatter {
652 // A deleted default constructor indicates a disabled formatter.
653 formatter() = delete;
654};
655
656/// Reports a format error at compile time or, via a `format_error` exception,
657/// at runtime.
658// This function is intentionally not constexpr to give a compile-time error.
659FMT_NORETURN FMT_API void report_error(const char* message);
660
661enum class presentation_type : unsigned char {
662 // Common specifiers:
663 none = 0,
664 debug = 1, // '?'
665 string = 2, // 's' (string, bool)
666
667 // Integral, bool and character specifiers:
668 dec = 3, // 'd'
669 hex, // 'x' or 'X'
670 oct, // 'o'
671 bin, // 'b' or 'B'
672 chr, // 'c'
673
674 // String and pointer specifiers:
675 pointer = 3, // 'p'
676
677 // Floating-point specifiers:
678 exp = 1, // 'e' or 'E' (1 since there is no FP debug presentation)
679 fixed, // 'f' or 'F'
680 general, // 'g' or 'G'
681 hexfloat // 'a' or 'A'
682};
683
684enum class align { none, left, right, center, numeric };
685enum class sign { none, minus, plus, space };
686enum class arg_id_kind { none, index, name };
687
688// Basic format specifiers for built-in and string types.
690 private:
691 // Data is arranged as follows:
692 //
693 // 0 1 2 3
694 // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
695 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
696 // |type |align| w | p | s |u|#|L| f | unused |
697 // +-----+-----+---+---+---+-+-+-+-----+---------------------------+
698 //
699 // w - dynamic width info
700 // p - dynamic precision info
701 // s - sign
702 // u - uppercase (e.g. 'X' for 'x')
703 // # - alternate form ('#')
704 // L - localized
705 // f - fill size
706 //
707 // Bitfields are not used because of compiler bugs such as gcc bug 61414.
708 enum : unsigned {
709 type_mask = 0x00007,
710 align_mask = 0x00038,
711 width_mask = 0x000C0,
712 precision_mask = 0x00300,
713 sign_mask = 0x00C00,
714 uppercase_mask = 0x01000,
715 alternate_mask = 0x02000,
716 localized_mask = 0x04000,
717 fill_size_mask = 0x38000,
718
719 align_shift = 3,
720 width_shift = 6,
721 precision_shift = 8,
722 sign_shift = 10,
723 fill_size_shift = 15,
724
725 max_fill_size = 4
726 };
727
728 size_t data_ = 1 << fill_size_shift;
729
730 // Character (code unit) type is erased to prevent template bloat.
731 char fill_data_[max_fill_size] = {' '};
732
733 FMT_CONSTEXPR void set_fill_size(size_t size) {
734 data_ = (data_ & ~fill_size_mask) | (size << fill_size_shift);
735 }
736
737 public:
738 constexpr auto type() const -> presentation_type {
739 return static_cast<presentation_type>(data_ & type_mask);
740 }
742 data_ = (data_ & ~type_mask) | static_cast<unsigned>(t);
743 }
744
745 constexpr auto align() const -> align {
746 return static_cast<fmt::align>((data_ & align_mask) >> align_shift);
747 }
748 FMT_CONSTEXPR void set_align(fmt::align a) {
749 data_ = (data_ & ~align_mask) | (static_cast<unsigned>(a) << align_shift);
750 }
751
752 constexpr auto dynamic_width() const -> arg_id_kind {
753 return static_cast<arg_id_kind>((data_ & width_mask) >> width_shift);
754 }
756 data_ = (data_ & ~width_mask) | (static_cast<unsigned>(w) << width_shift);
757 }
758
760 return static_cast<arg_id_kind>((data_ & precision_mask) >>
761 precision_shift);
762 }
764 data_ = (data_ & ~precision_mask) |
765 (static_cast<unsigned>(p) << precision_shift);
766 }
767
768 constexpr bool dynamic() const {
769 return (data_ & (width_mask | precision_mask)) != 0;
770 }
771
772 constexpr auto sign() const -> sign {
773 return static_cast<fmt::sign>((data_ & sign_mask) >> sign_shift);
774 }
775 FMT_CONSTEXPR void set_sign(fmt::sign s) {
776 data_ = (data_ & ~sign_mask) | (static_cast<unsigned>(s) << sign_shift);
777 }
778
779 constexpr auto upper() const -> bool { return (data_ & uppercase_mask) != 0; }
780 FMT_CONSTEXPR void set_upper() { data_ |= uppercase_mask; }
781
782 constexpr auto alt() const -> bool { return (data_ & alternate_mask) != 0; }
783 FMT_CONSTEXPR void set_alt() { data_ |= alternate_mask; }
784 FMT_CONSTEXPR void clear_alt() { data_ &= ~alternate_mask; }
785
786 constexpr auto localized() const -> bool {
787 return (data_ & localized_mask) != 0;
788 }
789 FMT_CONSTEXPR void set_localized() { data_ |= localized_mask; }
790
791 constexpr auto fill_size() const -> size_t {
792 return (data_ & fill_size_mask) >> fill_size_shift;
793 }
794
795 template <typename Char, FMT_ENABLE_IF(std::is_same<Char, char>::value)>
796 constexpr auto fill() const -> const Char* {
797 return fill_data_;
798 }
799 template <typename Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
800 constexpr auto fill() const -> const Char* {
801 return nullptr;
802 }
803
804 template <typename Char> constexpr auto fill_unit() const -> Char {
805 using uchar = unsigned char;
806 return static_cast<Char>(static_cast<uchar>(fill_data_[0]) |
807 (static_cast<uchar>(fill_data_[1]) << 8) |
808 (static_cast<uchar>(fill_data_[2]) << 16));
809 }
810
811 FMT_CONSTEXPR void set_fill(char c) {
812 fill_data_[0] = c;
813 set_fill_size(1);
814 }
815
816 template <typename Char>
818 auto size = s.size();
819 set_fill_size(size);
820 if (size == 1) {
821 unsigned uchar = static_cast<detail::unsigned_char<Char>>(s[0]);
822 fill_data_[0] = static_cast<char>(uchar);
823 fill_data_[1] = static_cast<char>(uchar >> 8);
824 fill_data_[2] = static_cast<char>(uchar >> 16);
825 return;
826 }
827 FMT_ASSERT(size <= max_fill_size, "invalid fill");
828 for (size_t i = 0; i < size; ++i)
829 fill_data_[i & 3] = static_cast<char>(s[i]);
830 }
831};
832
833// Format specifiers for built-in and string types.
835 int width;
837
838 constexpr format_specs() : width(0), precision(-1) {}
839};
840
841/**
842 * Parsing context consisting of a format string range being parsed and an
843 * argument counter for automatic indexing.
844 */
845template <typename Char = char> class parse_context {
846 private:
848 int next_arg_id_;
849
850 enum { use_constexpr_cast = !FMT_GCC_VERSION || FMT_GCC_VERSION >= 1200 };
851
852 FMT_CONSTEXPR void do_check_arg_id(int arg_id);
853
854 public:
855 using char_type = Char;
856 using iterator = const Char*;
857
859 int next_arg_id = 0)
860 : fmt_(fmt), next_arg_id_(next_arg_id) {}
861
862 /// Returns an iterator to the beginning of the format string range being
863 /// parsed.
864 constexpr auto begin() const noexcept -> iterator { return fmt_.begin(); }
865
866 /// Returns an iterator past the end of the format string range being parsed.
867 constexpr auto end() const noexcept -> iterator { return fmt_.end(); }
868
869 /// Advances the begin iterator to `it`.
873
874 /// Reports an error if using the manual argument indexing; otherwise returns
875 /// the next argument index and switches to the automatic indexing.
877 if (next_arg_id_ < 0) {
878 report_error("cannot switch from manual to automatic argument indexing");
879 return 0;
880 }
881 int id = next_arg_id_++;
882 do_check_arg_id(id);
883 return id;
884 }
885
886 /// Reports an error if using the automatic argument indexing; otherwise
887 /// switches to the manual indexing.
889 if (next_arg_id_ > 0) {
890 report_error("cannot switch from automatic to manual argument indexing");
891 return;
892 }
893 next_arg_id_ = -1;
894 do_check_arg_id(id);
895 }
897 next_arg_id_ = -1;
898 }
900};
901
903
904namespace detail {
905
906// Constructs fmt::basic_string_view<Char> from types implicitly convertible
907// to it, deducing Char. Explicitly convertible types such as the ones returned
908// from FMT_STRING are intentionally excluded.
909template <typename Char, FMT_ENABLE_IF(is_char<Char>::value)>
910constexpr auto to_string_view(const Char* s) -> basic_string_view<Char> {
911 return s;
912}
913template <typename T, FMT_ENABLE_IF(is_std_string_like<T>::value)>
914constexpr auto to_string_view(const T& s)
916 return s;
917}
918template <typename Char>
921 return s;
922}
923
924template <typename T, typename Enable = void>
925struct has_to_string_view : std::false_type {};
926// detail:: is intentional since to_string_view is not an extension point.
927template <typename T>
929 T, void_t<decltype(detail::to_string_view(std::declval<T>()))>>
930 : std::true_type {};
931
932/// String's character (code unit) type. detail:: is intentional to prevent ADL.
933template <typename S,
934 typename V = decltype(detail::to_string_view(std::declval<S>()))>
935using char_t = typename V::value_type;
936
937enum class type {
938 none_type,
939 // Integer types should go first,
940 int_type,
941 uint_type,
946 bool_type,
947 char_type,
949 // followed by floating-point types.
958};
959
960// Maps core type T to the corresponding type enum constant.
961template <typename T, typename Char>
962struct type_constant : std::integral_constant<type, type::custom_type> {};
963
964#define FMT_TYPE_CONSTANT(Type, constant) \
965 template <typename Char> \
966 struct type_constant<Type, Char> \
967 : std::integral_constant<type, type::constant> {}
968
983
984constexpr auto is_integral_type(type t) -> bool {
985 return t > type::none_type && t <= type::last_integer_type;
986}
987constexpr auto is_arithmetic_type(type t) -> bool {
988 return t > type::none_type && t <= type::last_numeric_type;
989}
990
991constexpr auto set(type rhs) -> int { return 1 << static_cast<int>(rhs); }
992constexpr auto in(type t, int set) -> bool {
993 return ((set >> static_cast<int>(t)) & 1) != 0;
994}
995
996// Bitsets of types.
997enum {
998 sint_set =
1010
1011struct view {};
1012
1013template <typename Char, typename T> struct named_arg;
1014template <typename T> struct is_named_arg : std::false_type {};
1015template <typename T> struct is_static_named_arg : std::false_type {};
1016
1017template <typename Char, typename T>
1018struct is_named_arg<named_arg<Char, T>> : std::true_type {};
1019
1020template <typename Char, typename T> struct named_arg : view {
1021 const Char* name;
1022 const T& value;
1023
1024 named_arg(const Char* n, const T& v) : name(n), value(v) {}
1025 static_assert(!is_named_arg<T>::value, "nested named arguments");
1026};
1027
1028template <bool B = false> constexpr auto count() -> int { return B ? 1 : 0; }
1029template <bool B1, bool B2, bool... Tail> constexpr auto count() -> int {
1030 return (B1 ? 1 : 0) + count<B2, Tail...>();
1031}
1032
1033template <typename... Args> constexpr auto count_named_args() -> int {
1034 return count<is_named_arg<Args>::value...>();
1035}
1036template <typename... Args> constexpr auto count_static_named_args() -> int {
1037 return count<is_static_named_arg<Args>::value...>();
1038}
1039
1040template <typename Char> struct named_arg_info {
1041 const Char* name;
1042 int id;
1043};
1044
1045template <typename Char, typename T, FMT_ENABLE_IF(!is_named_arg<T>::value)>
1046void init_named_arg(named_arg_info<Char>*, int& arg_index, int&, const T&) {
1047 ++arg_index;
1048}
1049template <typename Char, typename T, FMT_ENABLE_IF(is_named_arg<T>::value)>
1050void init_named_arg(named_arg_info<Char>* named_args, int& arg_index,
1051 int& named_arg_index, const T& arg) {
1052 named_args[named_arg_index++] = {arg.name, arg_index++};
1053}
1054
1055template <typename T, typename Char,
1056 FMT_ENABLE_IF(!is_static_named_arg<T>::value)>
1058 int&) {
1059 ++arg_index;
1060}
1061template <typename T, typename Char,
1062 FMT_ENABLE_IF(is_static_named_arg<T>::value)>
1063FMT_CONSTEXPR void init_static_named_arg(named_arg_info<Char>* named_args,
1064 int& arg_index, int& named_arg_index) {
1065 named_args[named_arg_index++] = {T::name, arg_index++};
1066}
1067
1068// To minimize the number of types we need to deal with, long is translated
1069// either to int or to long long depending on its size.
1070enum { long_short = sizeof(long) == sizeof(int) };
1073
1074template <typename T>
1077template <typename T>
1079 remove_cvref_t<decltype(formatter<T>::format_as(std::declval<const T&>()))>;
1080
1081template <typename T, typename Enable = std::true_type>
1082struct use_format_as : std::false_type {};
1083// format_as member is only used to avoid injection into the std namespace.
1084template <typename T, typename Enable = std::true_type>
1085struct use_format_as_member : std::false_type {};
1086
1087// Only map owning types because mapping views can be unsafe.
1088template <typename T>
1090 T, bool_constant<std::is_arithmetic<format_as_result<T>>::value>>
1091 : std::true_type {};
1092template <typename T>
1094 T, bool_constant<std::is_arithmetic<format_as_member_result<T>>::value>>
1095 : std::true_type {};
1096
1097template <typename T, typename U = remove_const_t<T>>
1099 bool_constant<(std::is_class<T>::value || std::is_enum<T>::value ||
1100 std::is_union<T>::value || std::is_array<T>::value) &&
1103
1104template <typename Char, typename T, typename U = remove_const_t<T>>
1106 -> decltype(formatter<U, Char>().format(*p, *ctx), std::true_type());
1107template <typename Char> auto has_formatter_impl(...) -> std::false_type;
1108
1109// T can be const-qualified to check if it is const-formattable.
1110template <typename T, typename Char> constexpr auto has_formatter() -> bool {
1111 return decltype(has_formatter_impl<Char>(static_cast<T*>(nullptr)))::value;
1112}
1113
1114// Maps formatting argument types to natively supported types or user-defined
1115// types with formatters. Returns void on errors to be SFINAE-friendly.
1116template <typename Char> struct type_mapper {
1117 static auto map(signed char) -> int;
1118 static auto map(unsigned char) -> unsigned;
1119 static auto map(short) -> int;
1120 static auto map(unsigned short) -> unsigned;
1121 static auto map(int) -> int;
1122 static auto map(unsigned) -> unsigned;
1123 static auto map(long) -> long_type;
1124 static auto map(unsigned long) -> ulong_type;
1125 static auto map(long long) -> long long;
1126 static auto map(unsigned long long) -> unsigned long long;
1127 static auto map(int128_opt) -> int128_opt;
1128 static auto map(uint128_opt) -> uint128_opt;
1129 static auto map(bool) -> bool;
1130
1131 template <int N>
1133 template <int N>
1134 static auto map(ubitint<N>)
1136
1137 template <typename T, FMT_ENABLE_IF(is_char<T>::value)>
1138 static auto map(T) -> conditional_t<
1139 std::is_same<T, char>::value || std::is_same<T, Char>::value, Char, void>;
1140
1141 static auto map(float) -> float;
1142 static auto map(double) -> double;
1143 static auto map(long double) -> long double;
1144
1145 static auto map(Char*) -> const Char*;
1146 static auto map(const Char*) -> const Char*;
1147 template <typename T, typename C = char_t<T>,
1148 FMT_ENABLE_IF(!std::is_pointer<T>::value)>
1150 basic_string_view<C>, void>;
1151
1152 static auto map(void*) -> const void*;
1153 static auto map(const void*) -> const void*;
1154 static auto map(volatile void*) -> const void*;
1155 static auto map(const volatile void*) -> const void*;
1156 static auto map(nullptr_t) -> const void*;
1157 template <typename T, FMT_ENABLE_IF(std::is_pointer<T>::value ||
1158 std::is_member_pointer<T>::value)>
1159 static auto map(const T&) -> void;
1160
1161 template <typename T, FMT_ENABLE_IF(use_format_as<T>::value)>
1162 static auto map(const T& x) -> decltype(map(format_as(x)));
1163 template <typename T, FMT_ENABLE_IF(use_format_as_member<T>::value)>
1164 static auto map(const T& x) -> decltype(map(formatter<T>::format_as(x)));
1165
1166 template <typename T, FMT_ENABLE_IF(use_formatter<T>::value)>
1167 static auto map(T&) -> conditional_t<has_formatter<T, Char>(), T&, void>;
1168
1169 template <typename T, FMT_ENABLE_IF(is_named_arg<T>::value)>
1170 static auto map(const T& named_arg) -> decltype(map(named_arg.value));
1171};
1172
1173// detail:: is used to workaround a bug in MSVC 2017.
1174template <typename T, typename Char>
1175using mapped_t = decltype(detail::type_mapper<Char>::map(std::declval<T&>()));
1176
1177// A type constant after applying type_mapper.
1178template <typename T, typename Char = char>
1180
1181template <typename T, typename Context,
1182 type TYPE =
1184using stored_type_constant = std::integral_constant<
1185 type, Context::builtin_types || TYPE == type::int_type ? TYPE
1187// A parse context with extra data used only in compile-time checks.
1188template <typename Char>
1190 private:
1191 int num_args_;
1192 const type* types_;
1193 using base = parse_context<Char>;
1194
1195 public:
1197 int num_args, const type* types,
1198 int next_arg_id = 0)
1199 : base(fmt, next_arg_id), num_args_(num_args), types_(types) {}
1200
1201 constexpr auto num_args() const -> int { return num_args_; }
1202 constexpr auto arg_type(int id) const -> type { return types_[id]; }
1203
1205 int id = base::next_arg_id();
1206 if (id >= num_args_) report_error("argument not found");
1207 return id;
1208 }
1209
1212 if (id >= num_args_) report_error("argument not found");
1213 }
1214 using base::check_arg_id;
1215
1217 ignore_unused(arg_id);
1218 if (arg_id < num_args_ && types_ && !is_integral_type(types_[arg_id]))
1219 report_error("width/precision is not integer");
1220 }
1221};
1222
1223// An argument reference.
1224template <typename Char> union arg_ref {
1225 FMT_CONSTEXPR arg_ref(int idx = 0) : index(idx) {}
1227
1230};
1231
1232// Format specifiers with width and precision resolved at formatting rather
1233// than parsing time to allow reusing the same parsed specifiers with
1234// different sets of arguments (precompilation of format strings).
1239
1240// Converts a character to ASCII. Returns '\0' on conversion failure.
1241template <typename Char, FMT_ENABLE_IF(std::is_integral<Char>::value)>
1242constexpr auto to_ascii(Char c) -> char {
1243 return c <= 0xff ? static_cast<char>(c) : '\0';
1244}
1245
1246// Returns the number of code units in a code point or 1 on error.
1247template <typename Char>
1248FMT_CONSTEXPR auto code_point_length(const Char* begin) -> int {
1249 if (const_check(sizeof(Char) != 1)) return 1;
1250 auto c = static_cast<unsigned char>(*begin);
1251 return static_cast<int>((0x3a55000000000000ull >> (2 * (c >> 3))) & 3) + 1;
1252}
1253
1254// Parses the range [begin, end) as an unsigned integer. This function assumes
1255// that the range is non-empty and the first character is a digit.
1256template <typename Char>
1257FMT_CONSTEXPR auto parse_nonnegative_int(const Char*& begin, const Char* end,
1258 int error_value) noexcept -> int {
1259 FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', "");
1260 unsigned value = 0, prev = 0;
1261 auto p = begin;
1262 do {
1263 prev = value;
1264 value = value * 10 + unsigned(*p - '0');
1265 ++p;
1266 } while (p != end && '0' <= *p && *p <= '9');
1267 auto num_digits = p - begin;
1268 begin = p;
1269 int digits10 = static_cast<int>(sizeof(int) * CHAR_BIT * 3 / 10);
1270 if (num_digits <= digits10) return static_cast<int>(value);
1271 // Check for overflow.
1272 unsigned max = INT_MAX;
1273 return num_digits == digits10 + 1 &&
1274 prev * 10ull + unsigned(p[-1] - '0') <= max
1275 ? static_cast<int>(value)
1276 : error_value;
1277}
1278
1279FMT_CONSTEXPR inline auto parse_align(char c) -> align {
1280 switch (c) {
1281 case '<': return align::left;
1282 case '>': return align::right;
1283 case '^': return align::center;
1284 }
1285 return align::none;
1286}
1287
1288template <typename Char> constexpr auto is_name_start(Char c) -> bool {
1289 return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '_';
1290}
1291
1292template <typename Char, typename Handler>
1293FMT_CONSTEXPR auto parse_arg_id(const Char* begin, const Char* end,
1294 Handler&& handler) -> const Char* {
1295 Char c = *begin;
1296 if (c >= '0' && c <= '9') {
1297 int index = 0;
1298 if (c != '0')
1299 index = parse_nonnegative_int(begin, end, INT_MAX);
1300 else
1301 ++begin;
1302 if (begin == end || (*begin != '}' && *begin != ':'))
1303 report_error("invalid format string");
1304 else
1305 handler.on_index(index);
1306 return begin;
1307 }
1308 if (FMT_OPTIMIZE_SIZE > 1 || !is_name_start(c)) {
1309 report_error("invalid format string");
1310 return begin;
1311 }
1312 auto it = begin;
1313 do {
1314 ++it;
1315 } while (it != end && (is_name_start(*it) || ('0' <= *it && *it <= '9')));
1316 handler.on_name({begin, to_unsigned(it - begin)});
1317 return it;
1318}
1319
1320template <typename Char> struct dynamic_spec_handler {
1324
1326 ref = id;
1328 ctx.check_arg_id(id);
1330 }
1336};
1337
1338template <typename Char> struct parse_dynamic_spec_result {
1339 const Char* end;
1341};
1342
1343// Parses integer | "{" [arg_id] "}".
1344template <typename Char>
1345FMT_CONSTEXPR auto parse_dynamic_spec(const Char* begin, const Char* end,
1346 int& value, arg_ref<Char>& ref,
1349 FMT_ASSERT(begin != end, "");
1350 auto kind = arg_id_kind::none;
1351 if ('0' <= *begin && *begin <= '9') {
1352 int val = parse_nonnegative_int(begin, end, -1);
1353 if (val == -1) report_error("number is too big");
1354 value = val;
1355 } else {
1356 if (*begin == '{') {
1357 ++begin;
1358 if (begin != end) {
1359 Char c = *begin;
1360 if (c == '}' || c == ':') {
1361 int id = ctx.next_arg_id();
1362 ref = id;
1363 kind = arg_id_kind::index;
1364 ctx.check_dynamic_spec(id);
1365 } else {
1366 begin = parse_arg_id(begin, end,
1367 dynamic_spec_handler<Char>{ctx, ref, kind});
1368 }
1369 }
1370 if (begin != end && *begin == '}') return {++begin, kind};
1371 }
1372 report_error("invalid format string");
1373 }
1374 return {begin, kind};
1375}
1376
1377template <typename Char>
1378FMT_CONSTEXPR auto parse_width(const Char* begin, const Char* end,
1379 format_specs& specs, arg_ref<Char>& width_ref,
1380 parse_context<Char>& ctx) -> const Char* {
1381 auto result = parse_dynamic_spec(begin, end, specs.width, width_ref, ctx);
1382 specs.set_dynamic_width(result.kind);
1383 return result.end;
1384}
1385
1386template <typename Char>
1387FMT_CONSTEXPR auto parse_precision(const Char* begin, const Char* end,
1388 format_specs& specs,
1389 arg_ref<Char>& precision_ref,
1390 parse_context<Char>& ctx) -> const Char* {
1391 ++begin;
1392 if (begin == end) {
1393 report_error("invalid precision");
1394 return begin;
1395 }
1396 auto result =
1397 parse_dynamic_spec(begin, end, specs.precision, precision_ref, ctx);
1398 specs.set_dynamic_precision(result.kind);
1399 return result.end;
1400}
1401
1403
1404// Parses standard format specifiers.
1405template <typename Char>
1406FMT_CONSTEXPR auto parse_format_specs(const Char* begin, const Char* end,
1408 parse_context<Char>& ctx, type arg_type)
1409 -> const Char* {
1410 auto c = '\0';
1411 if (end - begin > 1) {
1412 auto next = to_ascii(begin[1]);
1413 c = parse_align(next) == align::none ? to_ascii(*begin) : '\0';
1414 } else {
1415 if (begin == end) return begin;
1416 c = to_ascii(*begin);
1417 }
1418
1419 struct {
1420 state current_state = state::start;
1421 FMT_CONSTEXPR void operator()(state s, bool valid = true) {
1422 if (current_state >= s || !valid)
1423 report_error("invalid format specifier");
1424 current_state = s;
1425 }
1426 } enter_state;
1427
1428 using pres = presentation_type;
1429 constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;
1430 struct {
1431 const Char*& begin;
1432 format_specs& specs;
1433 type arg_type;
1434
1435 FMT_CONSTEXPR auto operator()(pres pres_type, int set) -> const Char* {
1436 if (!in(arg_type, set)) report_error("invalid format specifier");
1437 specs.set_type(pres_type);
1438 return begin + 1;
1439 }
1440 } parse_presentation_type{begin, specs, arg_type};
1441
1442 for (;;) {
1443 switch (c) {
1444 case '<':
1445 case '>':
1446 case '^':
1447 enter_state(state::align);
1448 specs.set_align(parse_align(c));
1449 ++begin;
1450 break;
1451 case '+':
1452 case ' ':
1453 specs.set_sign(c == ' ' ? sign::space : sign::plus);
1455 case '-':
1456 enter_state(state::sign, in(arg_type, sint_set | float_set));
1457 ++begin;
1458 break;
1459 case '#':
1460 enter_state(state::hash, is_arithmetic_type(arg_type));
1461 specs.set_alt();
1462 ++begin;
1463 break;
1464 case '0':
1465 enter_state(state::zero);
1466 if (!is_arithmetic_type(arg_type))
1467 report_error("format specifier requires numeric argument");
1468 if (specs.align() == align::none) {
1469 // Ignore 0 if align is specified for compatibility with std::format.
1470 specs.set_align(align::numeric);
1471 specs.set_fill('0');
1472 }
1473 ++begin;
1474 break;
1475 // clang-format off
1476 case '1': case '2': case '3': case '4': case '5':
1477 case '6': case '7': case '8': case '9': case '{':
1478 // clang-format on
1479 enter_state(state::width);
1480 begin = parse_width(begin, end, specs, specs.width_ref, ctx);
1481 break;
1482 case '.':
1483 enter_state(state::precision,
1484 in(arg_type, float_set | string_set | cstring_set));
1485 begin = parse_precision(begin, end, specs, specs.precision_ref, ctx);
1486 break;
1487 case 'L':
1488 enter_state(state::locale, is_arithmetic_type(arg_type));
1489 specs.set_localized();
1490 ++begin;
1491 break;
1492 case 'd': return parse_presentation_type(pres::dec, integral_set);
1493 case 'X': specs.set_upper(); FMT_FALLTHROUGH;
1494 case 'x': return parse_presentation_type(pres::hex, integral_set);
1495 case 'o': return parse_presentation_type(pres::oct, integral_set);
1496 case 'B': specs.set_upper(); FMT_FALLTHROUGH;
1497 case 'b': return parse_presentation_type(pres::bin, integral_set);
1498 case 'E': specs.set_upper(); FMT_FALLTHROUGH;
1499 case 'e': return parse_presentation_type(pres::exp, float_set);
1500 case 'F': specs.set_upper(); FMT_FALLTHROUGH;
1501 case 'f': return parse_presentation_type(pres::fixed, float_set);
1502 case 'G': specs.set_upper(); FMT_FALLTHROUGH;
1503 case 'g': return parse_presentation_type(pres::general, float_set);
1504 case 'A': specs.set_upper(); FMT_FALLTHROUGH;
1505 case 'a': return parse_presentation_type(pres::hexfloat, float_set);
1506 case 'c':
1507 if (arg_type == type::bool_type) report_error("invalid format specifier");
1508 return parse_presentation_type(pres::chr, integral_set);
1509 case 's':
1510 return parse_presentation_type(pres::string,
1512 case 'p':
1513 return parse_presentation_type(pres::pointer, pointer_set | cstring_set);
1514 case '?':
1515 return parse_presentation_type(pres::debug,
1517 case '}': return begin;
1518 default: {
1519 if (*begin == '}') return begin;
1520 // Parse fill and alignment.
1521 auto fill_end = begin + code_point_length(begin);
1522 if (end - fill_end <= 0) {
1523 report_error("invalid format specifier");
1524 return begin;
1525 }
1526 if (*begin == '{') {
1527 report_error("invalid fill character '{'");
1528 return begin;
1529 }
1530 auto alignment = parse_align(to_ascii(*fill_end));
1531 enter_state(state::align, alignment != align::none);
1532 specs.set_fill(
1533 basic_string_view<Char>(begin, to_unsigned(fill_end - begin)));
1534 specs.set_align(alignment);
1535 begin = fill_end + 1;
1536 }
1537 }
1538 if (begin == end) return begin;
1539 c = to_ascii(*begin);
1540 }
1541}
1542
1543template <typename Char, typename Handler>
1545 const Char* end,
1546 Handler&& handler)
1547 -> const Char* {
1548 ++begin;
1549 if (begin == end) {
1550 handler.on_error("invalid format string");
1551 return end;
1552 }
1553 int arg_id = 0;
1554 switch (*begin) {
1555 case '}':
1556 handler.on_replacement_field(handler.on_arg_id(), begin);
1557 return begin + 1;
1558 case '{': handler.on_text(begin, begin + 1); return begin + 1;
1559 case ':': arg_id = handler.on_arg_id(); break;
1560 default: {
1561 struct id_adapter {
1562 Handler& handler;
1563 int arg_id;
1564
1565 FMT_CONSTEXPR void on_index(int id) { arg_id = handler.on_arg_id(id); }
1566 FMT_CONSTEXPR void on_name(basic_string_view<Char> id) {
1567 arg_id = handler.on_arg_id(id);
1568 }
1569 } adapter = {handler, 0};
1570 begin = parse_arg_id(begin, end, adapter);
1571 arg_id = adapter.arg_id;
1572 Char c = begin != end ? *begin : Char();
1573 if (c == '}') {
1574 handler.on_replacement_field(arg_id, begin);
1575 return begin + 1;
1576 }
1577 if (c != ':') {
1578 handler.on_error("missing '}' in format string");
1579 return end;
1580 }
1581 break;
1582 }
1583 }
1584 begin = handler.on_format_specs(arg_id, begin + 1, end);
1585 if (begin == end || *begin != '}')
1586 return handler.on_error("unknown format specifier"), end;
1587 return begin + 1;
1588}
1589
1590template <typename Char, typename Handler>
1592 Handler&& handler) {
1593 auto begin = fmt.data(), end = begin + fmt.size();
1594 auto p = begin;
1595 while (p != end) {
1596 auto c = *p++;
1597 if (c == '{') {
1598 handler.on_text(begin, p - 1);
1599 begin = p = parse_replacement_field(p - 1, end, handler);
1600 } else if (c == '}') {
1601 if (p == end || *p != '}')
1602 return handler.on_error("unmatched '}' in format string");
1603 handler.on_text(begin, p);
1604 begin = ++p;
1605 }
1606 }
1607 handler.on_text(begin, end);
1608}
1609
1610// Checks char specs and returns true iff the presentation type is char-like.
1611FMT_CONSTEXPR inline auto check_char_specs(const format_specs& specs) -> bool {
1612 auto type = specs.type();
1615 return false;
1616 }
1617 if (specs.align() == align::numeric || specs.sign() != sign::none ||
1618 specs.alt()) {
1619 report_error("invalid format specifier for char");
1620 }
1621 return true;
1622}
1623
1624// A base class for compile-time strings.
1626
1627template <typename T, typename Char>
1628FMT_VISIBILITY("hidden") // Suppress an ld warning on macOS (#3769).
1629FMT_CONSTEXPR auto invoke_parse(parse_context<Char>& ctx) -> const Char* {
1630 using mapped_type = remove_cvref_t<mapped_t<T, Char>>;
1631 constexpr bool formattable =
1632 std::is_constructible<formatter<mapped_type, Char>>::value;
1633 if (!formattable) return ctx.begin(); // Error is reported in the value ctor.
1634 using formatted_type = conditional_t<formattable, mapped_type, int>;
1635 return formatter<formatted_type, Char>().parse(ctx);
1636}
1637
1638template <typename... T> struct arg_pack {};
1639
1640template <typename Char, int NUM_ARGS, int NUM_NAMED_ARGS, bool DYNAMIC_NAMES>
1642 private:
1643 type types_[max_of(1, NUM_ARGS)];
1644 named_arg_info<Char> named_args_[max_of(1, NUM_NAMED_ARGS)];
1646
1647 using parse_func = auto (*)(parse_context<Char>&) -> const Char*;
1648 parse_func parse_funcs_[max_of(1, NUM_ARGS)];
1649
1650 public:
1651 template <typename... T>
1654 : types_{mapped_type_constant<T, Char>::value...},
1655 named_args_{},
1656 context_(fmt, NUM_ARGS, types_),
1657 parse_funcs_{&invoke_parse<T, Char>...} {
1658 int arg_index = 0, named_arg_index = 0;
1660 init_static_named_arg<T>(named_args_, arg_index, named_arg_index));
1661 ignore_unused(arg_index, named_arg_index);
1662 }
1663
1664 FMT_CONSTEXPR void on_text(const Char*, const Char*) {}
1665
1666 FMT_CONSTEXPR auto on_arg_id() -> int { return context_.next_arg_id(); }
1667 FMT_CONSTEXPR auto on_arg_id(int id) -> int {
1668 context_.check_arg_id(id);
1669 return id;
1670 }
1672 for (int i = 0; i < NUM_NAMED_ARGS; ++i) {
1673 if (named_args_[i].name == id) return named_args_[i].id;
1674 }
1675 if (!DYNAMIC_NAMES) on_error("argument not found");
1676 return -1;
1677 }
1678
1679 FMT_CONSTEXPR void on_replacement_field(int id, const Char* begin) {
1680 on_format_specs(id, begin, begin); // Call parse() on empty specs.
1681 }
1682
1683 FMT_CONSTEXPR auto on_format_specs(int id, const Char* begin, const Char* end)
1684 -> const Char* {
1685 context_.advance_to(begin);
1686 if (id >= 0 && id < NUM_ARGS) return parse_funcs_[id](context_);
1687 while (begin != end && *begin != '}') ++begin;
1688 return begin;
1689 }
1690
1691 FMT_NORETURN FMT_CONSTEXPR void on_error(const char* message) {
1692 report_error(message);
1693 }
1694};
1695
1696/// A contiguous memory buffer with an optional growing ability. It is an
1697/// internal class and shouldn't be used directly, only via `memory_buffer`.
1698template <typename T> class buffer {
1699 private:
1700 T* ptr_;
1701 size_t size_;
1702 size_t capacity_;
1703
1704 using grow_fun = void (*)(buffer& buf, size_t capacity);
1705 grow_fun grow_;
1706
1707 protected:
1708 // Don't initialize ptr_ since it is not accessed to save a few cycles.
1709 FMT_MSC_WARNING(suppress : 26495)
1710 FMT_CONSTEXPR buffer(grow_fun grow, size_t sz) noexcept
1711 : size_(sz), capacity_(sz), grow_(grow) {}
1712
1713 constexpr buffer(grow_fun grow, T* p = nullptr, size_t sz = 0,
1714 size_t cap = 0) noexcept
1715 : ptr_(p), size_(sz), capacity_(cap), grow_(grow) {}
1716
1718 buffer(buffer&&) = default;
1719
1720 /// Sets the buffer data and capacity.
1721 FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept {
1722 ptr_ = buf_data;
1723 capacity_ = buf_capacity;
1724 }
1725
1726 public:
1727 using value_type = T;
1728 using const_reference = const T&;
1729
1730 buffer(const buffer&) = delete;
1731 void operator=(const buffer&) = delete;
1732
1733 auto begin() noexcept -> T* { return ptr_; }
1734 auto end() noexcept -> T* { return ptr_ + size_; }
1735
1736 auto begin() const noexcept -> const T* { return ptr_; }
1737 auto end() const noexcept -> const T* { return ptr_ + size_; }
1738
1739 /// Returns the size of this buffer.
1740 constexpr auto size() const noexcept -> size_t { return size_; }
1741
1742 /// Returns the capacity of this buffer.
1743 constexpr auto capacity() const noexcept -> size_t { return capacity_; }
1744
1745 /// Returns a pointer to the buffer data (not null-terminated).
1746 FMT_CONSTEXPR auto data() noexcept -> T* { return ptr_; }
1747 FMT_CONSTEXPR auto data() const noexcept -> const T* { return ptr_; }
1748
1749 /// Clears this buffer.
1750 FMT_CONSTEXPR void clear() { size_ = 0; }
1751
1752 // Tries resizing the buffer to contain `count` elements. If T is a POD type
1753 // the new elements may not be initialized.
1756 size_ = min_of(count, capacity_);
1757 }
1758
1759 // Tries increasing the buffer capacity to `new_capacity`. It can increase the
1760 // capacity by a smaller amount than requested but guarantees there is space
1761 // for at least one additional element either by increasing the capacity or by
1762 // flushing the buffer if it is full.
1763 FMT_CONSTEXPR void try_reserve(size_t new_capacity) {
1764 if (new_capacity > capacity_) grow_(*this, new_capacity);
1765 }
1766
1768 try_reserve(size_ + 1);
1769 ptr_[size_++] = value;
1770 }
1771
1772 /// Appends data to the end of the buffer.
1773 template <typename U>
1774// Workaround for MSVC2019 to fix error C2893: Failed to specialize function
1775// template 'void fmt::v11::detail::buffer<T>::append(const U *,const U *)'.
1776#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1940
1778#endif
1779 void
1780 append(const U* begin, const U* end) {
1781 while (begin != end) {
1782 auto count = to_unsigned(end - begin);
1783 try_reserve(size_ + count);
1784 auto free_cap = capacity_ - size_;
1785 if (free_cap < count) count = free_cap;
1786 // A loop is faster than memcpy on small sizes.
1787 T* out = ptr_ + size_;
1788 for (size_t i = 0; i < count; ++i) out[i] = begin[i];
1789 size_ += count;
1790 begin += count;
1791 }
1792 }
1793
1794 template <typename Idx> FMT_CONSTEXPR auto operator[](Idx index) -> T& {
1795 return ptr_[index];
1796 }
1797 template <typename Idx>
1798 FMT_CONSTEXPR auto operator[](Idx index) const -> const T& {
1799 return ptr_[index];
1800 }
1801};
1802
1804 constexpr explicit buffer_traits(size_t) {}
1805 constexpr auto count() const -> size_t { return 0; }
1806 constexpr auto limit(size_t size) const -> size_t { return size; }
1807};
1808
1810 private:
1811 size_t count_ = 0;
1812 size_t limit_;
1813
1814 public:
1815 constexpr explicit fixed_buffer_traits(size_t limit) : limit_(limit) {}
1816 constexpr auto count() const -> size_t { return count_; }
1817 FMT_CONSTEXPR auto limit(size_t size) -> size_t {
1818 size_t n = limit_ > count_ ? limit_ - count_ : 0;
1819 count_ += size;
1820 return min_of(size, n);
1821 }
1822};
1823
1824// A buffer that writes to an output iterator when flushed.
1825template <typename OutputIt, typename T, typename Traits = buffer_traits>
1826class iterator_buffer : public Traits, public buffer<T> {
1827 private:
1828 OutputIt out_;
1829 enum { buffer_size = 256 };
1830 T data_[buffer_size];
1831
1832 static FMT_CONSTEXPR void grow(buffer<T>& buf, size_t) {
1833 if (buf.size() == buffer_size) static_cast<iterator_buffer&>(buf).flush();
1834 }
1835
1836 void flush() {
1837 auto size = this->size();
1838 this->clear();
1839 const T* begin = data_;
1840 const T* end = begin + this->limit(size);
1841 while (begin != end) *out_++ = *begin++;
1842 }
1843
1844 public:
1845 explicit iterator_buffer(OutputIt out, size_t n = buffer_size)
1846 : Traits(n), buffer<T>(grow, data_, 0, buffer_size), out_(out) {}
1848 : Traits(other),
1849 buffer<T>(grow, data_, 0, buffer_size),
1850 out_(other.out_) {}
1852 // Don't crash if flush fails during unwinding.
1853 FMT_TRY { flush(); }
1854 FMT_CATCH(...) {}
1855 }
1856
1857 auto out() -> OutputIt {
1858 flush();
1859 return out_;
1860 }
1861 auto count() const -> size_t { return Traits::count() + this->size(); }
1862};
1863
1864template <typename T>
1866 public buffer<T> {
1867 private:
1868 T* out_;
1869 enum { buffer_size = 256 };
1870 T data_[buffer_size];
1871
1872 static FMT_CONSTEXPR void grow(buffer<T>& buf, size_t) {
1873 if (buf.size() == buf.capacity())
1874 static_cast<iterator_buffer&>(buf).flush();
1875 }
1876
1877 void flush() {
1878 size_t n = this->limit(this->size());
1879 if (this->data() == out_) {
1880 out_ += n;
1881 this->set(data_, buffer_size);
1882 }
1883 this->clear();
1884 }
1885
1886 public:
1887 explicit iterator_buffer(T* out, size_t n = buffer_size)
1888 : fixed_buffer_traits(n), buffer<T>(grow, out, 0, n), out_(out) {}
1890 : fixed_buffer_traits(other),
1891 buffer<T>(static_cast<iterator_buffer&&>(other)),
1892 out_(other.out_) {
1893 if (this->data() != out_) {
1894 this->set(data_, buffer_size);
1895 this->clear();
1896 }
1897 }
1898 ~iterator_buffer() { flush(); }
1899
1900 auto out() -> T* {
1901 flush();
1902 return out_;
1903 }
1904 auto count() const -> size_t {
1905 return fixed_buffer_traits::count() + this->size();
1906 }
1907};
1908
1909template <typename T> class iterator_buffer<T*, T> : public buffer<T> {
1910 public:
1911 explicit iterator_buffer(T* out, size_t = 0)
1912 : buffer<T>([](buffer<T>&, size_t) {}, out, 0, ~size_t()) {}
1913
1914 auto out() -> T* { return &*this->end(); }
1915};
1916
1917template <typename Container>
1918class container_buffer : public buffer<typename Container::value_type> {
1919 private:
1920 using value_type = typename Container::value_type;
1921
1922 static FMT_CONSTEXPR void grow(buffer<value_type>& buf, size_t capacity) {
1923 auto& self = static_cast<container_buffer&>(buf);
1924 self.container.resize(capacity);
1925 self.set(&self.container[0], capacity);
1926 }
1927
1928 public:
1929 Container& container;
1930
1931 explicit container_buffer(Container& c)
1932 : buffer<value_type>(grow, c.size()), container(c) {}
1933};
1934
1935// A buffer that writes to a container with the contiguous storage.
1936template <typename OutputIt>
1938 OutputIt,
1940 is_contiguous<typename OutputIt::container_type>::value,
1941 typename OutputIt::container_type::value_type>>
1942 : public container_buffer<typename OutputIt::container_type> {
1943 private:
1945
1946 public:
1947 explicit iterator_buffer(typename OutputIt::container_type& c) : base(c) {}
1948 explicit iterator_buffer(OutputIt out, size_t = 0)
1949 : base(get_container(out)) {}
1950
1951 auto out() -> OutputIt { return OutputIt(this->container); }
1952};
1953
1954// A buffer that counts the number of code units written discarding the output.
1955template <typename T = char> class counting_buffer : public buffer<T> {
1956 private:
1957 enum { buffer_size = 256 };
1958 T data_[buffer_size];
1959 size_t count_ = 0;
1960
1961 static FMT_CONSTEXPR void grow(buffer<T>& buf, size_t) {
1962 if (buf.size() != buffer_size) return;
1963 static_cast<counting_buffer&>(buf).count_ += buf.size();
1964 buf.clear();
1965 }
1966
1967 public:
1968 FMT_CONSTEXPR counting_buffer() : buffer<T>(grow, data_, 0, buffer_size) {}
1969
1970 constexpr auto count() const noexcept -> size_t {
1971 return count_ + this->size();
1972 }
1973};
1974
1975template <typename T>
1976struct is_back_insert_iterator<basic_appender<T>> : std::true_type {};
1977
1978template <typename OutputIt, typename InputIt, typename = void>
1980template <typename OutputIt, typename InputIt>
1982 OutputIt, InputIt,
1983 void_t<decltype(get_container(std::declval<OutputIt>())
1984 .append(std::declval<InputIt>(),
1985 std::declval<InputIt>()))>> : std::true_type {};
1986
1987// An optimized version of std::copy with the output value type (T).
1988template <typename T, typename InputIt, typename OutputIt,
1991 OutputIt, InputIt>::value)>
1992FMT_CONSTEXPR20 auto copy(InputIt begin, InputIt end, OutputIt out)
1993 -> OutputIt {
1994 get_container(out).append(begin, end);
1995 return out;
1996}
1997
1998template <typename T, typename InputIt, typename OutputIt,
1999 FMT_ENABLE_IF(is_back_insert_iterator<OutputIt>::value &&
2000 !has_back_insert_iterator_container_append<
2001 OutputIt, InputIt>::value)>
2002FMT_CONSTEXPR20 auto copy(InputIt begin, InputIt end, OutputIt out)
2003 -> OutputIt {
2004 auto& c = get_container(out);
2005 c.insert(c.end(), begin, end);
2006 return out;
2007}
2008
2009template <typename T, typename InputIt, typename OutputIt,
2010 FMT_ENABLE_IF(!is_back_insert_iterator<OutputIt>::value)>
2011FMT_CONSTEXPR auto copy(InputIt begin, InputIt end, OutputIt out) -> OutputIt {
2012 while (begin != end) *out++ = static_cast<T>(*begin++);
2013 return out;
2014}
2015
2016template <typename T, typename V, typename OutputIt>
2017FMT_CONSTEXPR auto copy(basic_string_view<V> s, OutputIt out) -> OutputIt {
2018 return copy<T>(s.begin(), s.end(), out);
2019}
2020
2021template <typename It, typename Enable = std::true_type>
2022struct is_buffer_appender : std::false_type {};
2023template <typename It>
2025 It, bool_constant<
2027 std::is_base_of<buffer<typename It::container_type::value_type>,
2028 typename It::container_type>::value>>
2029 : std::true_type {};
2030
2031// Maps an output iterator to a buffer.
2032template <typename T, typename OutputIt,
2035 return iterator_buffer<OutputIt, T>(out);
2036}
2037template <typename T, typename OutputIt,
2038 FMT_ENABLE_IF(is_buffer_appender<OutputIt>::value)>
2039auto get_buffer(OutputIt out) -> buffer<T>& {
2040 return get_container(out);
2041}
2042
2043template <typename Buf, typename OutputIt>
2044auto get_iterator(Buf& buf, OutputIt) -> decltype(buf.out()) {
2045 return buf.out();
2046}
2047template <typename T, typename OutputIt>
2048auto get_iterator(buffer<T>&, OutputIt out) -> OutputIt {
2049 return out;
2050}
2051
2052// This type is intentionally undefined, only used for errors.
2053template <typename T, typename Char> struct type_is_unformattable_for;
2054
2055template <typename Char> struct string_value {
2056 const Char* data;
2057 size_t size;
2058 auto str() const -> basic_string_view<Char> { return {data, size}; }
2059};
2060
2061template <typename Context> struct custom_value {
2062 using char_type = typename Context::char_type;
2063 void* value;
2064 void (*format)(void* arg, parse_context<char_type>& parse_ctx, Context& ctx);
2065};
2066
2067template <typename Char> struct named_arg_value {
2069 size_t size;
2070};
2071
2072struct custom_tag {};
2073
2074#if !FMT_BUILTIN_TYPES
2075# define FMT_BUILTIN , monostate
2076#else
2077# define FMT_BUILTIN
2078#endif
2079
2080// A formatting argument value.
2081template <typename Context> class value {
2082 public:
2083 using char_type = typename Context::char_type;
2084
2085 union {
2088 unsigned uint_value;
2090 unsigned long long ulong_long_value;
2098 const void* pointer;
2102 };
2103
2104 constexpr FMT_INLINE value() : no_value() {}
2105 constexpr FMT_INLINE value(signed char x) : int_value(x) {}
2106 constexpr FMT_INLINE value(unsigned char x FMT_BUILTIN) : uint_value(x) {}
2107 constexpr FMT_INLINE value(signed short x) : int_value(x) {}
2108 constexpr FMT_INLINE value(unsigned short x FMT_BUILTIN) : uint_value(x) {}
2109 constexpr FMT_INLINE value(int x) : int_value(x) {}
2110 constexpr FMT_INLINE value(unsigned x FMT_BUILTIN) : uint_value(x) {}
2114 constexpr FMT_INLINE value(long long x FMT_BUILTIN) : long_long_value(x) {}
2115 constexpr FMT_INLINE value(unsigned long long x FMT_BUILTIN)
2116 : ulong_long_value(x) {}
2119 constexpr FMT_INLINE value(bool x FMT_BUILTIN) : bool_value(x) {}
2120
2121 template <int N>
2123 static_assert(N <= 64, "unsupported _BitInt");
2124 }
2125 template <int N>
2127 static_assert(N <= 64, "unsupported _BitInt");
2128 }
2129
2130 template <typename T, FMT_ENABLE_IF(is_char<T>::value)>
2132 static_assert(
2133 std::is_same<T, char>::value || std::is_same<T, char_type>::value,
2134 "mixing character types is disallowed");
2135 }
2136
2137 constexpr FMT_INLINE value(float x FMT_BUILTIN) : float_value(x) {}
2138 constexpr FMT_INLINE value(double x FMT_BUILTIN) : double_value(x) {}
2140
2142 string.data = x;
2143 if (is_constant_evaluated()) string.size = 0;
2144 }
2146 string.data = x;
2147 if (is_constant_evaluated()) string.size = 0;
2148 }
2149 template <typename T, typename C = char_t<T>,
2150 FMT_ENABLE_IF(!std::is_pointer<T>::value)>
2152 static_assert(std::is_same<C, char_type>::value,
2153 "mixing character types is disallowed");
2154 auto sv = to_string_view(x);
2155 string.data = sv.data();
2156 string.size = sv.size();
2157 }
2159 FMT_INLINE value(const void* x FMT_BUILTIN) : pointer(x) {}
2160 FMT_INLINE value(volatile void* x FMT_BUILTIN)
2161 : pointer(const_cast<const void*>(x)) {}
2162 FMT_INLINE value(const volatile void* x FMT_BUILTIN)
2163 : pointer(const_cast<const void*>(x)) {}
2165
2166 template <typename T, FMT_ENABLE_IF(std::is_pointer<T>::value ||
2167 std::is_member_pointer<T>::value)>
2168 value(const T&) {
2169 // Formatting of arbitrary pointers is disallowed. If you want to format a
2170 // pointer cast it to `void*` or `const void*`. In particular, this forbids
2171 // formatting of `[const] volatile char*` printed as bool by iostreams.
2172 static_assert(sizeof(T) == 0,
2173 "formatting of non-void pointers is disallowed");
2174 }
2175
2176 template <typename T, FMT_ENABLE_IF(use_format_as<T>::value)>
2177 value(const T& x) : value(format_as(x)) {}
2178 template <typename T, FMT_ENABLE_IF(use_format_as_member<T>::value)>
2179 value(const T& x) : value(formatter<T>::format_as(x)) {}
2180
2181 template <typename T, FMT_ENABLE_IF(is_named_arg<T>::value)>
2183
2184 template <typename T,
2187
2189 : named_args{args, size} {}
2190
2191 private:
2192 template <typename T, FMT_ENABLE_IF(has_formatter<T, char_type>())>
2194 using value_type = remove_const_t<T>;
2195 // T may overload operator& e.g. std::vector<bool>::reference in libc++.
2196 if (!is_constant_evaluated()) {
2197 custom.value =
2198 const_cast<char*>(&reinterpret_cast<const volatile char&>(x));
2199 } else {
2200 custom.value = nullptr;
2201#if defined(__cpp_if_constexpr)
2202 if constexpr (std::is_same<decltype(&x), remove_reference_t<T>*>::value)
2203 custom.value = const_cast<value_type*>(&x);
2204#endif
2205 }
2206 custom.format = format_custom<value_type, formatter<value_type, char_type>>;
2207 }
2208
2209 template <typename T, FMT_ENABLE_IF(!has_formatter<T, char_type>())>
2210 FMT_CONSTEXPR value(const T&, custom_tag) {
2211 // Cannot format an argument; to make type T formattable provide a
2212 // formatter<T> specialization: https://fmt.dev/latest/api.html#udt.
2213 type_is_unformattable_for<T, char_type> _;
2214 }
2215
2216 // Formats an argument of a custom type, such as a user-defined class.
2217 template <typename T, typename Formatter>
2218 static void format_custom(void* arg, parse_context<char_type>& parse_ctx,
2219 Context& ctx) {
2220 auto f = Formatter();
2221 parse_ctx.advance_to(f.parse(parse_ctx));
2222 using qualified_type =
2224 // format must be const for compatibility with std::format and compilation.
2225 const auto& cf = f;
2226 ctx.advance_to(cf.format(*static_cast<qualified_type*>(arg), ctx));
2227 }
2228};
2229
2230enum { packed_arg_bits = 4 };
2231// Maximum number of arguments with packed types.
2233enum : unsigned long long { is_unpacked_bit = 1ULL << 63 };
2234enum : unsigned long long { has_named_args_bit = 1ULL << 62 };
2235
2236template <typename It, typename T, typename Enable = void>
2237struct is_output_iterator : std::false_type {};
2238
2239template <> struct is_output_iterator<appender, char> : std::true_type {};
2240
2241template <typename It, typename T>
2243 It, T,
2244 void_t<decltype(*std::declval<decay_t<It>&>()++ = std::declval<T>())>>
2245 : std::true_type {};
2246
2247#ifndef FMT_USE_LOCALE
2248# define FMT_USE_LOCALE (FMT_OPTIMIZE_SIZE <= 1)
2249#endif
2250
2251// A type-erased reference to an std::locale to avoid a heavy <locale> include.
2253#if FMT_USE_LOCALE
2254 private:
2255 const void* locale_; // A type-erased pointer to std::locale.
2256
2257 public:
2258 constexpr locale_ref() : locale_(nullptr) {}
2259
2260 template <typename Locale, FMT_ENABLE_IF(sizeof(Locale::collate) != 0)>
2261 locale_ref(const Locale& loc);
2262
2263 inline explicit operator bool() const noexcept { return locale_ != nullptr; }
2264#endif // FMT_USE_LOCALE
2265
2266 template <typename Locale> auto get() const -> Locale;
2267};
2268
2269template <typename> constexpr auto encode_types() -> unsigned long long {
2270 return 0;
2271}
2272
2273template <typename Context, typename Arg, typename... Args>
2274constexpr auto encode_types() -> unsigned long long {
2275 return static_cast<unsigned>(stored_type_constant<Arg, Context>::value) |
2277}
2278
2279template <typename Context, typename... T, size_t NUM_ARGS = sizeof...(T)>
2280constexpr auto make_descriptor() -> unsigned long long {
2281 return NUM_ARGS <= max_packed_args ? encode_types<Context, T...>()
2282 : is_unpacked_bit | NUM_ARGS;
2283}
2284
2285template <typename Context, int NUM_ARGS>
2288
2289template <typename Context, int NUM_ARGS, int NUM_NAMED_ARGS,
2290 unsigned long long DESC>
2292 // args_[0].named_args points to named_args to avoid bloating format_args.
2295
2296 template <typename... T>
2298 : args{{named_args, NUM_NAMED_ARGS}, values...} {
2299 int arg_index = 0, named_arg_index = 0;
2301 init_named_arg(named_args, arg_index, named_arg_index, values));
2302 }
2303
2305 args[0] = {named_args, NUM_NAMED_ARGS};
2306 for (size_t i = 1; i < sizeof(args) / sizeof(*args); ++i)
2307 args[i] = rhs.args[i];
2308 for (size_t i = 0; i < NUM_NAMED_ARGS; ++i)
2309 named_args[i] = rhs.named_args[i];
2310 }
2311
2312 named_arg_store(const named_arg_store& rhs) = delete;
2315 operator const arg_t<Context, NUM_ARGS>*() const { return args + 1; }
2316};
2317
2318// An array of references to arguments. It can be implicitly converted to
2319// `basic_format_args` for passing into type-erased formatting functions
2320// such as `vformat`. It is a plain struct to reduce binary size in debug mode.
2321template <typename Context, int NUM_ARGS, int NUM_NAMED_ARGS,
2322 unsigned long long DESC>
2324 // +1 to workaround a bug in gcc 7.5 that causes duplicated-branches warning.
2325 using type =
2326 conditional_t<NUM_NAMED_ARGS == 0,
2327 arg_t<Context, NUM_ARGS>[max_of(1, NUM_ARGS)],
2330};
2331
2332// TYPE can be different from type_constant<T>, e.g. for __float128.
2333template <typename T, typename Char, type TYPE> struct native_formatter {
2334 private:
2336
2337 public:
2338 using nonlocking = void;
2339
2340 FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
2341 if (ctx.begin() == ctx.end() || *ctx.begin() == '}') return ctx.begin();
2342 auto end = parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, TYPE);
2343 if (const_check(TYPE == type::char_type)) check_char_specs(specs_);
2344 return end;
2345 }
2346
2347 template <type U = TYPE,
2348 FMT_ENABLE_IF(U == type::string_type || U == type::cstring_type ||
2349 U == type::char_type)>
2353
2354 FMT_PRAGMA_CLANG(diagnostic ignored "-Wundefined-inline")
2355 template <typename FormatContext>
2356 FMT_CONSTEXPR auto format(const T& val, FormatContext& ctx) const
2357 -> decltype(ctx.out());
2358};
2359
2360template <typename T, typename Enable = void>
2362 : bool_constant<mapped_type_constant<T>::value == type::custom_type> {};
2363template <typename T>
2364struct locking<T, void_t<typename formatter<remove_cvref_t<T>>::nonlocking>>
2365 : std::false_type {};
2366
2367template <typename T = int> FMT_CONSTEXPR inline auto is_locking() -> bool {
2368 return locking<T>::value;
2369}
2370template <typename T1, typename T2, typename... Tail>
2371FMT_CONSTEXPR inline auto is_locking() -> bool {
2372 return locking<T1>::value || is_locking<T2, Tail...>();
2373}
2374
2375FMT_API void vformat_to(buffer<char>& buf, string_view fmt, format_args args,
2376 locale_ref loc = {});
2377
2378#if FMT_WIN32
2380#else // format_args is passed by reference since it is defined later.
2381inline void vprint_mojibake(FILE*, string_view, const format_args&, bool) {}
2382#endif
2383} // namespace detail
2384
2385// The main public API.
2386
2387template <typename Char>
2389 // Argument id is only checked at compile time during parsing because
2390 // formatting has its own validation.
2391 if (detail::is_constant_evaluated() && use_constexpr_cast) {
2392 auto ctx = static_cast<detail::compile_parse_context<Char>*>(this);
2393 if (arg_id >= ctx->num_args()) report_error("argument not found");
2394 }
2395}
2396
2397template <typename Char>
2400 if (detail::is_constant_evaluated() && use_constexpr_cast)
2401 static_cast<compile_parse_context<Char>*>(this)->check_dynamic_spec(arg_id);
2402}
2403
2405
2406// An output iterator that appends to a buffer. It is used instead of
2407// back_insert_iterator to reduce symbol sizes and avoid <iterator> dependency.
2408template <typename T> class basic_appender {
2409 protected:
2411
2412 public:
2414
2416
2418 container->push_back(c);
2419 return *this;
2420 }
2421 FMT_CONSTEXPR20 auto operator*() -> basic_appender& { return *this; }
2422 FMT_CONSTEXPR20 auto operator++() -> basic_appender& { return *this; }
2423 FMT_CONSTEXPR20 auto operator++(int) -> basic_appender { return *this; }
2424};
2425
2426// A formatting argument. Context is a template parameter for the compiled API
2427// where output can be unbuffered.
2428template <typename Context> class basic_format_arg {
2429 private:
2432
2433 friend class basic_format_args<Context>;
2434
2435 using char_type = typename Context::char_type;
2436
2437 public:
2438 class handle {
2439 private:
2441
2442 public:
2443 explicit handle(detail::custom_value<Context> custom) : custom_(custom) {}
2444
2445 void format(parse_context<char_type>& parse_ctx, Context& ctx) const {
2446 custom_.format(custom_.value, parse_ctx, ctx);
2447 }
2448 };
2449
2450 constexpr basic_format_arg() : type_(detail::type::none_type) {}
2452 : value_(args, size) {}
2453 template <typename T>
2455 : value_(val), type_(detail::stored_type_constant<T, Context>::value) {}
2456
2457 constexpr explicit operator bool() const noexcept {
2458 return type_ != detail::type::none_type;
2459 }
2460 auto type() const -> detail::type { return type_; }
2461
2462 /**
2463 * Visits an argument dispatching to the appropriate visit method based on
2464 * the argument type. For example, if the argument type is `double` then
2465 * `vis(value)` will be called with the value of type `double`.
2466 */
2467 template <typename Visitor>
2468 FMT_CONSTEXPR FMT_INLINE auto visit(Visitor&& vis) const -> decltype(vis(0)) {
2469 using detail::map;
2470 switch (type_) {
2471 case detail::type::none_type: break;
2472 case detail::type::int_type: return vis(value_.int_value);
2473 case detail::type::uint_type: return vis(value_.uint_value);
2474 case detail::type::long_long_type: return vis(value_.long_long_value);
2475 case detail::type::ulong_long_type: return vis(value_.ulong_long_value);
2476 case detail::type::int128_type: return vis(map(value_.int128_value));
2477 case detail::type::uint128_type: return vis(map(value_.uint128_value));
2478 case detail::type::bool_type: return vis(value_.bool_value);
2479 case detail::type::char_type: return vis(value_.char_value);
2480 case detail::type::float_type: return vis(value_.float_value);
2481 case detail::type::double_type: return vis(value_.double_value);
2482 case detail::type::long_double_type: return vis(value_.long_double_value);
2483 case detail::type::cstring_type: return vis(value_.string.data);
2484 case detail::type::string_type: return vis(value_.string.str());
2485 case detail::type::pointer_type: return vis(value_.pointer);
2486 case detail::type::custom_type: return vis(handle(value_.custom));
2487 }
2488 return vis(monostate());
2489 }
2490
2491 auto format_custom(const char_type* parse_begin,
2492 parse_context<char_type>& parse_ctx, Context& ctx)
2493 -> bool {
2494 if (type_ != detail::type::custom_type) return false;
2495 parse_ctx.advance_to(parse_begin);
2496 value_.custom.format(value_.custom.value, parse_ctx, ctx);
2497 return true;
2498 }
2499};
2500
2501/**
2502 * A view of a collection of formatting arguments. To avoid lifetime issues it
2503 * should only be used as a parameter type in type-erased functions such as
2504 * `vformat`:
2505 *
2506 * void vlog(fmt::string_view fmt, fmt::format_args args); // OK
2507 * fmt::format_args args = fmt::make_format_args(); // Dangling reference
2508 */
2509template <typename Context> class basic_format_args {
2510 private:
2511 // A descriptor that contains information about formatting arguments.
2512 // If the number of arguments is less or equal to max_packed_args then
2513 // argument types are passed in the descriptor. This reduces binary code size
2514 // per formatting function call.
2515 unsigned long long desc_;
2516 union {
2517 // If is_packed() returns true then argument values are stored in values_;
2518 // otherwise they are stored in args_. This is done to improve cache
2519 // locality and reduce compiled code size since storing larger objects
2520 // may require more code (at least on x86-64) even if the same amount of
2521 // data is actually copied to stack. It saves ~10% on the bloat test.
2524 };
2525
2526 constexpr auto is_packed() const -> bool {
2527 return (desc_ & detail::is_unpacked_bit) == 0;
2528 }
2529 constexpr auto has_named_args() const -> bool {
2530 return (desc_ & detail::has_named_args_bit) != 0;
2531 }
2532
2533 FMT_CONSTEXPR auto type(int index) const -> detail::type {
2534 int shift = index * detail::packed_arg_bits;
2535 unsigned mask = (1 << detail::packed_arg_bits) - 1;
2536 return static_cast<detail::type>((desc_ >> shift) & mask);
2537 }
2538
2539 template <int NUM_ARGS, int NUM_NAMED_ARGS, unsigned long long DESC>
2540 using store =
2542
2543 public:
2545
2546 constexpr basic_format_args() : desc_(0), args_(nullptr) {}
2547
2548 /// Constructs a `basic_format_args` object from `format_arg_store`.
2549 template <int NUM_ARGS, int NUM_NAMED_ARGS, unsigned long long DESC,
2553 : desc_(DESC | (NUM_NAMED_ARGS != 0 ? +detail::has_named_args_bit : 0)),
2554 values_(s.args) {}
2555
2556 template <int NUM_ARGS, int NUM_NAMED_ARGS, unsigned long long DESC,
2559 : desc_(DESC | (NUM_NAMED_ARGS != 0 ? +detail::has_named_args_bit : 0)),
2560 args_(s.args) {}
2561
2562 /// Constructs a `basic_format_args` object from a dynamic list of arguments.
2563 constexpr basic_format_args(const format_arg* args, int count,
2564 bool has_named = false)
2565 : desc_(detail::is_unpacked_bit | detail::to_unsigned(count) |
2566 (has_named ? +detail::has_named_args_bit : 0)),
2567 args_(args) {}
2568
2569 /// Returns the argument with the specified id.
2570 FMT_CONSTEXPR auto get(int id) const -> format_arg {
2571 auto arg = format_arg();
2572 if (!is_packed()) {
2573 if (id < max_size()) arg = args_[id];
2574 return arg;
2575 }
2576 if (static_cast<unsigned>(id) >= detail::max_packed_args) return arg;
2577 arg.type_ = type(id);
2578 if (arg.type_ != detail::type::none_type) arg.value_ = values_[id];
2579 return arg;
2580 }
2581
2582 template <typename Char>
2584 int id = get_id(name);
2585 return id >= 0 ? get(id) : format_arg();
2586 }
2587
2588 template <typename Char>
2590 if (!has_named_args()) return -1;
2591 const auto& named_args =
2592 (is_packed() ? values_[-1] : args_[-1].value_).named_args;
2593 for (size_t i = 0; i < named_args.size; ++i) {
2594 if (named_args.data[i].name == name) return named_args.data[i].id;
2595 }
2596 return -1;
2597 }
2598
2599 auto max_size() const -> int {
2600 unsigned long long max_packed = detail::max_packed_args;
2601 return static_cast<int>(is_packed() ? max_packed
2602 : desc_ & ~detail::is_unpacked_bit);
2603 }
2604};
2605
2606// A formatting context.
2608 private:
2609 appender out_;
2610 format_args args_;
2611
2612 public:
2613 /// The character type for the output.
2614 using char_type = char;
2615
2618 using parse_context_type FMT_DEPRECATED = parse_context<>;
2619 template <typename T> using formatter_type FMT_DEPRECATED = formatter<T>;
2621
2622 /// Constructs a `context` object. References to the arguments are stored
2623 /// in the object so make sure they have appropriate lifetimes.
2625 detail::locale_ref loc = {})
2626 : locale_ref(loc), out_(out), args_(args) {}
2627 context(context&&) = default;
2628 context(const context&) = delete;
2629 void operator=(const context&) = delete;
2630
2631 FMT_CONSTEXPR auto arg(int id) const -> format_arg { return args_.get(id); }
2632 inline auto arg(string_view name) const -> format_arg {
2633 return args_.get(name);
2634 }
2635 FMT_CONSTEXPR auto arg_id(string_view name) const -> int {
2636 return args_.get_id(name);
2637 }
2638
2639 // Returns an iterator to the beginning of the output range.
2640 FMT_CONSTEXPR auto out() const -> iterator { return out_; }
2641
2642 // Advances the begin iterator to `it`.
2644
2645 FMT_CONSTEXPR auto locale() const -> detail::locale_ref { return *this; }
2646};
2647
2648template <typename Char = char> struct runtime_format_string {
2650};
2651
2652/**
2653 * Creates a runtime format string.
2654 *
2655 * **Example**:
2656 *
2657 * // Check format string at runtime instead of compile-time.
2658 * fmt::print(fmt::runtime("{:d}"), "I am not a number");
2659 */
2660inline auto runtime(string_view s) -> runtime_format_string<> { return {{s}}; }
2661
2662/// A compile-time format string.
2663template <typename... T> struct fstring {
2664 private:
2665 static constexpr int num_static_named_args =
2667
2669 char, static_cast<int>(sizeof...(T)), num_static_named_args,
2670 num_static_named_args != detail::count_named_args<T...>()>;
2671
2672 using arg_pack = detail::arg_pack<T...>;
2673
2674 public:
2676 using t = fstring;
2677
2678 // Reports a compile-time error if S is not a valid format string for T.
2679 template <size_t N>
2680 FMT_CONSTEVAL FMT_ALWAYS_INLINE fstring(const char (&s)[N]) : str(s, N - 1) {
2681 using namespace detail;
2682 static_assert(count<(std::is_base_of<view, remove_reference_t<T>>::value &&
2683 std::is_reference<T>::value)...>() == 0,
2684 "passing views as lvalues is disallowed");
2685 if (FMT_USE_CONSTEVAL) parse_format_string<char>(s, checker(s, arg_pack()));
2686#ifdef FMT_ENFORCE_COMPILE_STRING
2687 static_assert(
2688 FMT_USE_CONSTEVAL && sizeof(s) != 0,
2689 "FMT_ENFORCE_COMPILE_STRING requires format strings to use FMT_STRING");
2690#endif
2691 }
2692 template <typename S,
2693 FMT_ENABLE_IF(std::is_convertible<const S&, string_view>::value)>
2695 auto sv = string_view(str);
2698#ifdef FMT_ENFORCE_COMPILE_STRING
2699 static_assert(
2700 FMT_USE_CONSTEVAL && sizeof(s) != 0,
2701 "FMT_ENFORCE_COMPILE_STRING requires format strings to use FMT_STRING");
2702#endif
2703 }
2704 template <typename S,
2705 FMT_ENABLE_IF(std::is_base_of<detail::compile_string, S>::value&&
2706 std::is_same<typename S::char_type, char>::value)>
2708 FMT_CONSTEXPR auto sv = string_view(S());
2709 FMT_CONSTEXPR int ignore =
2710 (parse_format_string(sv, checker(sv, arg_pack())), 0);
2711 detail::ignore_unused(ignore);
2712 }
2714
2715 // Returning by reference generates better code in debug mode.
2716 FMT_ALWAYS_INLINE operator const string_view&() const { return str; }
2717 auto get() const -> string_view { return str; }
2718};
2719
2720template <typename... T> using format_string = typename fstring<T...>::t;
2721
2722template <typename T, typename Char = char>
2723using is_formattable = bool_constant<!std::is_same<
2725 void>::value>;
2726#ifdef __cpp_concepts
2727template <typename T, typename Char = char>
2728concept formattable = is_formattable<remove_reference_t<T>, Char>::value;
2729#endif
2730
2731template <typename T, typename Char>
2732using has_formatter FMT_DEPRECATED = std::is_constructible<formatter<T, Char>>;
2733
2734// A formatter specialization for natively supported types.
2735template <typename T, typename Char>
2736struct formatter<T, Char,
2737 enable_if_t<detail::type_constant<T, Char>::value !=
2739 : detail::native_formatter<T, Char, detail::type_constant<T, Char>::value> {
2740};
2741
2742/**
2743 * Constructs an object that stores references to arguments and can be
2744 * implicitly converted to `format_args`. `Context` can be omitted in which case
2745 * it defaults to `context`. See `arg` for lifetime considerations.
2746 */
2747// Take arguments by lvalue references to avoid some lifetime issues, e.g.
2748// auto args = make_format_args(std::string());
2749template <typename Context = context, typename... T,
2750 int NUM_ARGS = sizeof...(T),
2751 int NUM_NAMED_ARGS = detail::count_named_args<T...>(),
2752 unsigned long long DESC = detail::make_descriptor<Context, T...>()>
2753constexpr FMT_ALWAYS_INLINE auto make_format_args(T&... args)
2755 // Suppress warnings for pathological types convertible to detail::value.
2756 FMT_PRAGMA_GCC(diagnostic ignored "-Wconversion")
2757 return {{args...}};
2758}
2759
2760template <typename... T>
2761using vargs =
2762 detail::format_arg_store<context, sizeof...(T),
2765
2766/**
2767 * Returns a named argument to be used in a formatting function.
2768 * It should only be used in a call to a formatting function.
2769 *
2770 * **Example**:
2771 *
2772 * fmt::print("The answer is {answer}.", fmt::arg("answer", 42));
2773 */
2774template <typename Char, typename T>
2775inline auto arg(const Char* name, const T& arg) -> detail::named_arg<Char, T> {
2776 return {name, arg};
2777}
2778
2779/// Formats a string and writes the output to `out`.
2780template <typename OutputIt,
2782 char>::value)>
2783auto vformat_to(OutputIt&& out, string_view fmt, format_args args)
2785 auto&& buf = detail::get_buffer<char>(out);
2786 detail::vformat_to(buf, fmt, args, {});
2787 return detail::get_iterator(buf, out);
2788}
2789
2790/**
2791 * Formats `args` according to specifications in `fmt`, writes the result to
2792 * the output iterator `out` and returns the iterator past the end of the output
2793 * range. `format_to` does not append a terminating null character.
2794 *
2795 * **Example**:
2796 *
2797 * auto out = std::vector<char>();
2798 * fmt::format_to(std::back_inserter(out), "{}", 42);
2799 */
2800template <typename OutputIt, typename... T,
2802 char>::value)>
2803FMT_INLINE auto format_to(OutputIt&& out, format_string<T...> fmt, T&&... args)
2805 return vformat_to(out, fmt.str, vargs<T...>{{args...}});
2806}
2807
2808template <typename OutputIt> struct format_to_n_result {
2809 /// Iterator past the end of the output range.
2810 OutputIt out;
2811 /// Total (not truncated) output size.
2812 size_t size;
2813};
2814
2815template <typename OutputIt, typename... T,
2817auto vformat_to_n(OutputIt out, size_t n, string_view fmt, format_args args)
2819 using traits = detail::fixed_buffer_traits;
2821 detail::vformat_to(buf, fmt, args, {});
2822 return {buf.out(), buf.count()};
2823}
2824
2825/**
2826 * Formats `args` according to specifications in `fmt`, writes up to `n`
2827 * characters of the result to the output iterator `out` and returns the total
2828 * (not truncated) output size and the iterator past the end of the output
2829 * range. `format_to_n` does not append a terminating null character.
2830 */
2831template <typename OutputIt, typename... T,
2833FMT_INLINE auto format_to_n(OutputIt out, size_t n, format_string<T...> fmt,
2834 T&&... args) -> format_to_n_result<OutputIt> {
2835 return vformat_to_n(out, n, fmt.str, vargs<T...>{{args...}});
2836}
2837
2839 /// Pointer to just after the last successful write in the array.
2840 char* out;
2841 /// Specifies if the output was truncated.
2843
2844 FMT_CONSTEXPR operator char*() const {
2845 // Report truncation to prevent silent data loss.
2846 if (truncated) report_error("output is truncated");
2847 return out;
2848 }
2849};
2850
2851template <size_t N>
2852auto vformat_to(char (&out)[N], string_view fmt, format_args args)
2853 -> format_to_result {
2854 auto result = vformat_to_n(out, N, fmt, args);
2855 return {result.out, result.size > N};
2856}
2857
2858template <size_t N, typename... T>
2859FMT_INLINE auto format_to(char (&out)[N], format_string<T...> fmt, T&&... args)
2860 -> format_to_result {
2861 auto result = vformat_to_n(out, N, fmt.str, vargs<T...>{{args...}});
2862 return {result.out, result.size > N};
2863}
2864
2865/// Returns the number of chars in the output of `format(fmt, args...)`.
2866template <typename... T>
2868 T&&... args) -> size_t {
2869 auto buf = detail::counting_buffer<>();
2870 detail::vformat_to(buf, fmt.str, vargs<T...>{{args...}}, {});
2871 return buf.count();
2872}
2873
2874FMT_API void vprint(string_view fmt, format_args args);
2875FMT_API void vprint(FILE* f, string_view fmt, format_args args);
2876FMT_API void vprintln(FILE* f, string_view fmt, format_args args);
2878
2879/**
2880 * Formats `args` according to specifications in `fmt` and writes the output
2881 * to `stdout`.
2882 *
2883 * **Example**:
2884 *
2885 * fmt::print("The answer is {}.", 42);
2886 */
2887template <typename... T>
2888FMT_INLINE void print(format_string<T...> fmt, T&&... args) {
2889 vargs<T...> va = {{args...}};
2891 return detail::vprint_mojibake(stdout, fmt.str, va, false);
2892 return detail::is_locking<T...>() ? vprint_buffered(stdout, fmt.str, va)
2893 : vprint(fmt.str, va);
2894}
2895
2896/**
2897 * Formats `args` according to specifications in `fmt` and writes the
2898 * output to the file `f`.
2899 *
2900 * **Example**:
2901 *
2902 * fmt::print(stderr, "Don't {}!", "panic");
2903 */
2904template <typename... T>
2905FMT_INLINE void print(FILE* f, format_string<T...> fmt, T&&... args) {
2906 vargs<T...> va = {{args...}};
2908 return detail::vprint_mojibake(f, fmt.str, va, false);
2909 return detail::is_locking<T...>() ? vprint_buffered(f, fmt.str, va)
2910 : vprint(f, fmt.str, va);
2911}
2912
2913/// Formats `args` according to specifications in `fmt` and writes the output
2914/// to the file `f` followed by a newline.
2915template <typename... T>
2916FMT_INLINE void println(FILE* f, format_string<T...> fmt, T&&... args) {
2917 vargs<T...> va = {{args...}};
2919 ? vprintln(f, fmt.str, va)
2920 : detail::vprint_mojibake(f, fmt.str, va, true);
2921}
2922
2923/// Formats `args` according to specifications in `fmt` and writes the output
2924/// to `stdout` followed by a newline.
2925template <typename... T>
2927 return fmt::println(stdout, fmt, static_cast<T&&>(args)...);
2928}
2929
2931FMT_PRAGMA_CLANG(diagnostic pop)
2932FMT_PRAGMA_GCC(pop_options)
2934
2935#ifdef FMT_HEADER_ONLY
2936# include "format.h"
2937#endif
2938#endif // FMT_BASE_H_
constexpr auto format_as(HAL_AddressableLEDColorOrder order)
Definition AddressableLEDTypes.h:34
Definition base.h:2408
FMT_CONSTEXPR20 auto operator=(T c) -> basic_appender &
Definition base.h:2417
FMT_CONSTEXPR20 auto operator++(int) -> basic_appender
Definition base.h:2423
detail::buffer< T > * container
Definition base.h:2410
FMT_CONSTEXPR20 auto operator++() -> basic_appender &
Definition base.h:2422
FMT_CONSTEXPR20 auto operator*() -> basic_appender &
Definition base.h:2421
FMT_CONSTEXPR basic_appender(detail::buffer< T > &buf)
Definition base.h:2415
Definition base.h:2438
handle(detail::custom_value< Context > custom)
Definition base.h:2443
void format(parse_context< char_type > &parse_ctx, Context &ctx) const
Definition base.h:2445
Definition base.h:2428
constexpr basic_format_arg()
Definition base.h:2450
auto type() const -> detail::type
Definition base.h:2460
auto format_custom(const char_type *parse_begin, parse_context< char_type > &parse_ctx, Context &ctx) -> bool
Definition base.h:2491
basic_format_arg(const detail::named_arg_info< char_type > *args, size_t size)
Definition base.h:2451
basic_format_arg(T &&val)
Definition base.h:2454
FMT_CONSTEXPR FMT_INLINE auto visit(Visitor &&vis) const -> decltype(vis(0))
Visits an argument dispatching to the appropriate visit method based on the argument type.
Definition base.h:2468
A view of a collection of formatting arguments.
Definition base.h:2509
constexpr basic_format_args()
Definition base.h:2546
FMT_CONSTEXPR auto get(int id) const -> format_arg
Returns the argument with the specified id.
Definition base.h:2570
const detail::value< Context > * values_
Definition base.h:2522
FMT_CONSTEXPR auto get_id(basic_string_view< Char > name) const -> int
Definition base.h:2589
constexpr basic_format_args(const store< NUM_ARGS, NUM_NAMED_ARGS, DESC > &s)
Definition base.h:2558
auto max_size() const -> int
Definition base.h:2599
constexpr FMT_ALWAYS_INLINE basic_format_args(const store< NUM_ARGS, NUM_NAMED_ARGS, DESC > &s)
Constructs a basic_format_args object from format_arg_store.
Definition base.h:2551
const basic_format_arg< Context > * args_
Definition base.h:2523
constexpr basic_format_args(const format_arg *args, int count, bool has_named=false)
Constructs a basic_format_args object from a dynamic list of arguments.
Definition base.h:2563
auto get(basic_string_view< Char > name) const -> format_arg
Definition base.h:2583
basic_format_arg< Context > format_arg
Definition base.h:2544
Definition base.h:689
constexpr bool dynamic() const
Definition base.h:768
FMT_CONSTEXPR void set_fill(char c)
Definition base.h:811
constexpr auto align() const -> align
Definition base.h:745
FMT_CONSTEXPR void set_dynamic_precision(arg_id_kind p)
Definition base.h:763
FMT_CONSTEXPR auto dynamic_precision() const -> arg_id_kind
Definition base.h:759
FMT_CONSTEXPR void set_fill(basic_string_view< Char > s)
Definition base.h:817
constexpr auto sign() const -> sign
Definition base.h:772
FMT_CONSTEXPR void set_alt()
Definition base.h:783
constexpr auto localized() const -> bool
Definition base.h:786
FMT_CONSTEXPR void set_sign(fmt::sign s)
Definition base.h:775
constexpr auto upper() const -> bool
Definition base.h:779
FMT_CONSTEXPR void clear_alt()
Definition base.h:784
constexpr auto type() const -> presentation_type
Definition base.h:738
constexpr auto fill() const -> const Char *
Definition base.h:796
FMT_CONSTEXPR void set_upper()
Definition base.h:780
constexpr auto alt() const -> bool
Definition base.h:782
constexpr auto dynamic_width() const -> arg_id_kind
Definition base.h:752
constexpr auto fill_unit() const -> Char
Definition base.h:804
FMT_CONSTEXPR void set_align(fmt::align a)
Definition base.h:748
FMT_CONSTEXPR void set_type(presentation_type t)
Definition base.h:741
FMT_CONSTEXPR void set_dynamic_width(arg_id_kind w)
Definition base.h:755
constexpr auto fill_size() const -> size_t
Definition base.h:791
FMT_CONSTEXPR void set_localized()
Definition base.h:789
An implementation of std::basic_string_view for pre-C++17.
Definition base.h:504
constexpr auto end() const noexcept -> iterator
Definition base.h:552
const Char * iterator
Definition base.h:511
constexpr auto size() const noexcept -> size_t
Returns the string size.
Definition base.h:549
constexpr basic_string_view(nullptr_t)=delete
FMT_CONSTEXPR basic_string_view(const S &s) noexcept
Constructs a string reference from a std::basic_string or a std::basic_string_view object.
Definition base.h:542
constexpr auto data() const noexcept -> const Char *
Returns a pointer to the string data.
Definition base.h:546
friend auto operator>(basic_string_view lhs, basic_string_view rhs) -> bool
Definition base.h:595
FMT_CONSTEXPR auto starts_with(Char c) const noexcept -> bool
Definition base.h:567
constexpr auto begin() const noexcept -> iterator
Definition base.h:551
friend auto operator<(basic_string_view lhs, basic_string_view rhs) -> bool
Definition base.h:589
Char value_type
Definition base.h:510
FMT_CONSTEXPR auto starts_with(const Char *s) const -> bool
Definition base.h:570
friend auto operator<=(basic_string_view lhs, basic_string_view rhs) -> bool
Definition base.h:592
FMT_CONSTEXPR void remove_prefix(size_t n) noexcept
Definition base.h:558
FMT_CONSTEXPR friend auto operator==(basic_string_view lhs, basic_string_view rhs) -> bool
Definition base.h:582
friend auto operator!=(basic_string_view lhs, basic_string_view rhs) -> bool
Definition base.h:586
constexpr auto operator[](size_t pos) const noexcept -> const Char &
Definition base.h:554
constexpr basic_string_view(const Char *s, size_t count) noexcept
Constructs a string reference object from a C string and a size.
Definition base.h:516
FMT_CONSTEXPR20 basic_string_view(const Char *s)
Constructs a string reference object from a C string.
Definition base.h:525
FMT_CONSTEXPR auto starts_with(basic_string_view< Char > sv) const noexcept -> bool
Definition base.h:563
constexpr basic_string_view() noexcept
Definition base.h:513
friend auto operator>=(basic_string_view lhs, basic_string_view rhs) -> bool
Definition base.h:598
FMT_CONSTEXPR auto compare(basic_string_view other) const -> int
Definition base.h:575
Definition base.h:2607
FMT_CONSTEXPR void advance_to(iterator)
Definition base.h:2643
void operator=(const context &)=delete
FMT_CONSTEXPR auto locale() const -> detail::locale_ref
Definition base.h:2645
FMT_CONSTEXPR auto arg_id(string_view name) const -> int
Definition base.h:2635
context(context &&)=default
char char_type
The character type for the output.
Definition base.h:2614
FMT_CONSTEXPR context(iterator out, format_args args, detail::locale_ref loc={})
Constructs a context object.
Definition base.h:2624
@ builtin_types
Definition base.h:2620
FMT_CONSTEXPR auto out() const -> iterator
Definition base.h:2640
auto arg(string_view name) const -> format_arg
Definition base.h:2632
context(const context &)=delete
FMT_CONSTEXPR auto arg(int id) const -> format_arg
Definition base.h:2631
A contiguous memory buffer with an optional growing ability.
Definition base.h:1698
FMT_CONSTEXPR buffer(grow_fun grow, size_t sz) noexcept
Definition base.h:1710
auto end() const noexcept -> const T *
Definition base.h:1737
FMT_CONSTEXPR20 void append(const U *begin, const U *end)
Appends data to the end of the buffer.
Definition base.h:1780
auto begin() const noexcept -> const T *
Definition base.h:1736
FMT_CONSTEXPR void push_back(const T &value)
Definition base.h:1767
T value_type
Definition base.h:1727
FMT_CONSTEXPR void set(T *buf_data, size_t buf_capacity) noexcept
Sets the buffer data and capacity.
Definition base.h:1721
FMT_CONSTEXPR auto operator[](Idx index) const -> const T &
Definition base.h:1798
constexpr auto size() const noexcept -> size_t
Returns the size of this buffer.
Definition base.h:1740
FMT_CONSTEXPR void try_reserve(size_t new_capacity)
Definition base.h:1763
FMT_CONSTEXPR auto data() const noexcept -> const T *
Definition base.h:1747
constexpr buffer(grow_fun grow, T *p=nullptr, size_t sz=0, size_t cap=0) noexcept
Definition base.h:1713
buffer(const buffer &)=delete
auto end() noexcept -> T *
Definition base.h:1734
FMT_CONSTEXPR void try_resize(size_t count)
Definition base.h:1754
constexpr auto capacity() const noexcept -> size_t
Returns the capacity of this buffer.
Definition base.h:1743
FMT_CONSTEXPR20 ~buffer()=default
auto begin() noexcept -> T *
Definition base.h:1733
const T & const_reference
Definition base.h:1728
FMT_CONSTEXPR auto operator[](Idx index) -> T &
Definition base.h:1794
void operator=(const buffer &)=delete
FMT_CONSTEXPR auto data() noexcept -> T *
Returns a pointer to the buffer data (not null-terminated).
Definition base.h:1746
buffer(buffer &&)=default
FMT_CONSTEXPR void clear()
Clears this buffer.
Definition base.h:1750
Definition base.h:1189
constexpr auto num_args() const -> int
Definition base.h:1201
FMT_CONSTEXPR compile_parse_context(basic_string_view< Char > fmt, int num_args, const type *types, int next_arg_id=0)
Definition base.h:1196
FMT_CONSTEXPR auto next_arg_id() -> int
Definition base.h:1204
FMT_CONSTEXPR void check_arg_id(int id)
Definition base.h:1210
constexpr auto arg_type(int id) const -> type
Definition base.h:1202
FMT_CONSTEXPR void check_dynamic_spec(int arg_id)
Definition base.h:1216
Definition base.h:1918
Container & container
Definition base.h:1929
container_buffer(Container &c)
Definition base.h:1931
Definition base.h:1955
FMT_CONSTEXPR counting_buffer()
Definition base.h:1968
constexpr auto count() const noexcept -> size_t
Definition base.h:1970
Definition base.h:1809
constexpr auto count() const -> size_t
Definition base.h:1816
constexpr fixed_buffer_traits(size_t limit)
Definition base.h:1815
FMT_CONSTEXPR auto limit(size_t size) -> size_t
Definition base.h:1817
Definition base.h:1641
FMT_CONSTEXPR auto on_arg_id(basic_string_view< Char > id) -> int
Definition base.h:1671
FMT_CONSTEXPR format_string_checker(basic_string_view< Char > fmt, arg_pack< T... >)
Definition base.h:1652
FMT_CONSTEXPR void on_replacement_field(int id, const Char *begin)
Definition base.h:1679
FMT_CONSTEXPR auto on_format_specs(int id, const Char *begin, const Char *end) -> const Char *
Definition base.h:1683
FMT_CONSTEXPR auto on_arg_id() -> int
Definition base.h:1666
FMT_CONSTEXPR void on_text(const Char *, const Char *)
Definition base.h:1664
FMT_CONSTEXPR auto on_arg_id(int id) -> int
Definition base.h:1667
FMT_NORETURN FMT_CONSTEXPR void on_error(const char *message)
Definition base.h:1691
auto count() const -> size_t
Definition base.h:1904
iterator_buffer(T *out, size_t n=buffer_size)
Definition base.h:1887
iterator_buffer(iterator_buffer &&other) noexcept
Definition base.h:1889
auto out() -> T *
Definition base.h:1914
iterator_buffer(T *out, size_t=0)
Definition base.h:1911
Definition base.h:1826
iterator_buffer(iterator_buffer &&other) noexcept
Definition base.h:1847
iterator_buffer(OutputIt out, size_t n=buffer_size)
Definition base.h:1845
auto count() const -> size_t
Definition base.h:1861
~iterator_buffer()
Definition base.h:1851
auto out() -> OutputIt
Definition base.h:1857
Definition base.h:2081
int int_value
Definition base.h:2087
FMT_INLINE value(long double x FMT_BUILTIN)
Definition base.h:2139
value(const T &)
Definition base.h:2168
uint128_opt uint128_value
Definition base.h:2092
bool bool_value
Definition base.h:2093
FMT_INLINE value(uint128_opt x FMT_BUILTIN)
Definition base.h:2118
value(const T &named_arg)
Definition base.h:2182
constexpr FMT_INLINE value(bitint< N > x FMT_BUILTIN)
Definition base.h:2122
constexpr FMT_INLINE value(T x FMT_BUILTIN)
Definition base.h:2131
unsigned long long ulong_long_value
Definition base.h:2090
double double_value
Definition base.h:2096
FMT_CONSTEXPR FMT_INLINE value(unsigned long x FMT_BUILTIN)
Definition base.h:2112
constexpr FMT_INLINE value(int x)
Definition base.h:2109
long double long_double_value
Definition base.h:2097
FMT_CONSTEXPR FMT_INLINE value(const char_type *x FMT_BUILTIN)
Definition base.h:2145
constexpr FMT_INLINE value(double x FMT_BUILTIN)
Definition base.h:2138
FMT_INLINE value(const volatile void *x FMT_BUILTIN)
Definition base.h:2162
FMT_INLINE value(const void *x FMT_BUILTIN)
Definition base.h:2159
constexpr FMT_INLINE value(unsigned long long x FMT_BUILTIN)
Definition base.h:2115
FMT_CONSTEXPR20 FMT_INLINE value(T &x)
Definition base.h:2186
FMT_CONSTEXPR FMT_INLINE value(char_type *x FMT_BUILTIN)
Definition base.h:2141
FMT_CONSTEXPR value(const T &x FMT_BUILTIN)
Definition base.h:2151
float float_value
Definition base.h:2095
constexpr FMT_INLINE value()
Definition base.h:2104
constexpr FMT_INLINE value(float x FMT_BUILTIN)
Definition base.h:2137
int128_opt int128_value
Definition base.h:2091
FMT_CONSTEXPR FMT_INLINE value(long x FMT_BUILTIN)
Definition base.h:2111
constexpr FMT_INLINE value(unsigned char x FMT_BUILTIN)
Definition base.h:2106
FMT_INLINE value(volatile void *x FMT_BUILTIN)
Definition base.h:2160
custom_value< Context > custom
Definition base.h:2100
FMT_ALWAYS_INLINE value(const named_arg_info< char_type > *args, size_t size)
Definition base.h:2188
constexpr FMT_INLINE value(ubitint< N > x FMT_BUILTIN)
Definition base.h:2126
named_arg_value< char_type > named_args
Definition base.h:2101
constexpr FMT_INLINE value(signed char x)
Definition base.h:2105
constexpr FMT_INLINE value(unsigned x FMT_BUILTIN)
Definition base.h:2110
FMT_INLINE value(int128_opt x FMT_BUILTIN)
Definition base.h:2117
constexpr FMT_INLINE value(long long x FMT_BUILTIN)
Definition base.h:2114
char_type char_value
Definition base.h:2094
string_value< char_type > string
Definition base.h:2099
typename Context::char_type char_type
Definition base.h:2083
monostate no_value
Definition base.h:2086
FMT_INLINE value(void *x FMT_BUILTIN)
Definition base.h:2158
constexpr FMT_INLINE value(unsigned short x FMT_BUILTIN)
Definition base.h:2108
const void * pointer
Definition base.h:2098
value(const T &x)
Definition base.h:2177
unsigned uint_value
Definition base.h:2088
FMT_INLINE value(nullptr_t)
Definition base.h:2164
constexpr FMT_INLINE value(bool x FMT_BUILTIN)
Definition base.h:2119
long long long_long_value
Definition base.h:2089
constexpr FMT_INLINE value(signed short x)
Definition base.h:2107
Definition format.h:3678
Parsing context consisting of a format string range being parsed and an argument counter for automati...
Definition base.h:845
const Char * iterator
Definition base.h:856
constexpr auto begin() const noexcept -> iterator
Returns an iterator to the beginning of the format string range being parsed.
Definition base.h:864
FMT_CONSTEXPR void check_arg_id(basic_string_view< Char >)
Definition base.h:896
FMT_CONSTEXPR void check_dynamic_spec(int arg_id)
Definition base.h:2398
FMT_CONSTEXPR void check_arg_id(int id)
Reports an error if using the automatic argument indexing; otherwise switches to the manual indexing.
Definition base.h:888
FMT_CONSTEXPR auto next_arg_id() -> int
Reports an error if using the manual argument indexing; otherwise returns the next argument index and...
Definition base.h:876
constexpr parse_context(basic_string_view< Char > fmt, int next_arg_id=0)
Definition base.h:858
FMT_CONSTEXPR void advance_to(iterator it)
Advances the begin iterator to it.
Definition base.h:870
Char char_type
Definition base.h:855
constexpr auto end() const noexcept -> iterator
Returns an iterator past the end of the format string range being parsed.
Definition base.h:867
FMT_FUNC void report_error(const char *message)
Reports a format error at compile time or, via a format_error exception, at runtime.
Definition format-inl.h:135
FMT_INLINE auto format(detail::locale_ref loc, format_string< T... > fmt, T &&... args) -> std::string
Definition format.h:4146
auto invoke_back_inserter() -> decltype(back_inserter(std::declval< Container & >()))
detail namespace with internal helper functions
Definition input_adapters.h:32
FMT_CONSTEXPR auto code_point_length(const Char *begin) -> int
Definition base.h:1248
auto get_iterator(Buf &buf, OutputIt) -> decltype(buf.out())
Definition base.h:2044
conditional_t< long_short, int, long long > long_type
Definition base.h:1071
FMT_CONSTEXPR auto is_locking() -> bool
Definition base.h:2367
constexpr auto to_ascii(Char c) -> char
Definition base.h:1242
FMT_CONSTEXPR auto parse_dynamic_spec(const Char *begin, const Char *end, int &value, arg_ref< Char > &ref, parse_context< Char > &ctx) -> parse_dynamic_spec_result< Char >
Definition base.h:1345
FMT_CONSTEXPR auto compare(const Char *s1, const Char *s2, std::size_t n) -> int
Definition base.h:455
@ long_short
Definition base.h:1070
FMT_CONSTEXPR void ignore_unused(const T &...)
Definition base.h:348
constexpr auto count_static_named_args() -> int
Definition base.h:1036
void vprint_mojibake(FILE *, string_view, const format_args &, bool)
Definition base.h:2381
FMT_CONSTEXPR auto parse_precision(const Char *begin, const Char *end, format_specs &specs, arg_ref< Char > &precision_ref, parse_context< Char > &ctx) -> const Char *
Definition base.h:1387
void init_named_arg(named_arg_info< Char > *, int &arg_index, int &, const T &)
Definition base.h:1046
uint128_opt
Definition base.h:401
constexpr auto is_integral_type(type t) -> bool
Definition base.h:984
constexpr auto count_named_args() -> int
Definition base.h:1033
FMT_CONSTEXPR auto parse_nonnegative_int(const Char *&begin, const Char *end, int error_value) noexcept -> int
Definition base.h:1257
constexpr auto digits10() noexcept -> int
Definition format.h:1125
FMT_CONSTEXPR void init_static_named_arg(named_arg_info< Char > *, int &arg_index, int &)
Definition base.h:1057
FMT_CONSTEXPR auto invoke_parse(parse_context< Char > &ctx) -> const Char *
Definition base.h:1629
conditional_t< long_short, unsigned, unsigned long long > ulong_type
Definition base.h:1072
@ is_unpacked_bit
Definition base.h:2233
@ has_named_args_bit
Definition base.h:2234
typename std::enable_if< B, T >::type enable_if_t
Definition cpp_future.h:38
int128_opt
Definition base.h:400
@ value
the parser finished reading a JSON value
FMT_CONSTEXPR auto to_unsigned(Int value) -> make_unsigned_t< Int >
Definition base.h:422
auto has_formatter_impl(T *p, buffered_context< Char > *ctx=nullptr) -> decltype(formatter< U, Char >().format(*p, *ctx), std::true_type())
constexpr auto is_name_start(Char c) -> bool
Definition base.h:1288
@ is_utf8_enabled
Definition base.h:441
constexpr auto in(type t, int set) -> bool
Definition base.h:992
FMT_CONSTEXPR auto check_char_specs(const format_specs &specs) -> bool
Definition base.h:1611
auto map(int128_opt) -> monostate
Definition base.h:403
@ bool_set
Definition base.h:1002
@ uint_set
Definition base.h:1000
@ pointer_set
Definition base.h:1008
@ float_set
Definition base.h:1004
@ cstring_set
Definition base.h:1007
@ char_set
Definition base.h:1003
@ sint_set
Definition base.h:998
@ string_set
Definition base.h:1006
constexpr auto is_constant_evaluated(bool default_value=false) noexcept -> bool
Definition base.h:350
@ max_packed_args
Definition base.h:2232
constexpr const char * narrow(const T *)
Definition base.h:451
constexpr auto is_arithmetic_type(type t) -> bool
Definition base.h:987
@ use_utf8
Definition base.h:442
FMT_ALWAYS_INLINE constexpr auto const_check(T val) -> T
Definition base.h:367
@ packed_arg_bits
Definition base.h:2230
FMT_CONSTEXPR void parse_format_string(basic_string_view< Char > fmt, Handler &&handler)
Definition base.h:1591
FMT_CONSTEXPR auto parse_width(const Char *begin, const Char *end, format_specs &specs, arg_ref< Char > &width_ref, parse_context< Char > &ctx) -> const Char *
Definition base.h:1378
FMT_CONSTEXPR20 auto copy(InputIt begin, InputIt end, OutputIt out) -> OutputIt
Definition base.h:1992
typename make_void< Ts... >::type void_t
Definition void_t.h:21
decltype(detail::type_mapper< Char >::map(std::declval< T & >())) mapped_t
Definition base.h:1175
FMT_CONSTEXPR auto parse_align(const Char *begin, const Char *end, format_specs &specs) -> const Char *
Definition format.h:2184
remove_cvref_t< decltype(format_as(std::declval< const T & >()))> format_as_result
Definition base.h:1075
typename V::value_type char_t
String's character (code unit) type. detail:: is intentional to prevent ADL.
Definition base.h:935
constexpr auto to_string_view(const Char *s) -> basic_string_view< Char >
Definition base.h:910
FMT_CONSTEXPR auto parse_arg_id(const Char *begin, const Char *end, Handler &&handler) -> const Char *
Definition base.h:1293
std::integral_constant< bool, Value > bool_constant
Definition type_traits.h:743
state
Definition base.h:1402
conditional_t< NUM_ARGS<=max_packed_args, value< Context >, basic_format_arg< Context > > arg_t
Definition base.h:2286
type
Definition base.h:937
auto get_buffer(OutputIt out) -> iterator_buffer< OutputIt, T >
Definition base.h:2034
FMT_CONSTEXPR FMT_INLINE auto parse_replacement_field(const Char *begin, const Char *end, Handler &&handler) -> const Char *
Definition base.h:1544
constexpr auto count() -> int
Definition base.h:1028
bool_constant<(std::is_class< T >::value||std::is_enum< T >::value|| std::is_union< T >::value||std::is_array< T >::value) && !has_to_string_view< T >::value &&!is_named_arg< T >::value && !use_format_as< T >::value &&!use_format_as_member< T >::value > use_formatter
Definition base.h:1098
constexpr auto has_formatter() -> bool
Definition base.h:1110
constexpr auto make_descriptor() -> unsigned long long
Definition base.h:2280
remove_cvref_t< decltype(formatter< T >::format_as(std::declval< const T & >()))> format_as_member_result
Definition base.h:1078
void vformat_to(buffer< Char > &buf, basic_string_view< Char > fmt, typename vformat_args< Char >::type args, locale_ref loc={})
Definition format.h:3665
conditional_t< sizeof(Char)==1, unsigned char, unsigned > unsigned_char
Definition base.h:428
constexpr auto encode_types() -> unsigned long long
Definition base.h:2269
FMT_FUNC void assert_fail(const char *file, int line, const char *message)
Definition format-inl.h:36
std::integral_constant< type, Context::builtin_types||TYPE==type::int_type ? TYPE :type::custom_type > stored_type_constant
Definition base.h:1184
FMT_CONSTEXPR20 auto get_container(OutputIt it) -> typename OutputIt::container_type &
Definition base.h:484
FMT_CONSTEXPR auto parse_format_specs(const Char *begin, const Char *end, dynamic_format_specs< Char > &specs, parse_context< Char > &ctx, type arg_type) -> const Char *
Definition base.h:1406
Implement std::hash so that hash_code can be used in STL containers.
Definition PointerIntPair.h:280
Definition base.h:1638
Definition base.h:416
Definition base.h:1803
constexpr buffer_traits(size_t)
Definition base.h:1804
constexpr auto limit(size_t size) const -> size_t
Definition base.h:1806
constexpr auto count() const -> size_t
Definition base.h:1805
Definition base.h:1625
Definition base.h:2072
Definition base.h:2061
void(* format)(void *arg, parse_context< char_type > &parse_ctx, Context &ctx)
Definition base.h:2064
typename Context::char_type char_type
Definition base.h:2062
void * value
Definition base.h:2063
Definition base.h:1235
arg_ref< Char > width_ref
Definition base.h:1236
arg_ref< Char > precision_ref
Definition base.h:1237
Definition base.h:1320
arg_ref< Char > & ref
Definition base.h:1322
FMT_CONSTEXPR void on_index(int id)
Definition base.h:1325
FMT_CONSTEXPR void on_name(basic_string_view< Char > id)
Definition base.h:1331
arg_id_kind & kind
Definition base.h:1323
parse_context< Char > & ctx
Definition base.h:1321
Definition base.h:2323
conditional_t< NUM_NAMED_ARGS==0, arg_t< Context, NUM_ARGS >[max_of(1, NUM_ARGS)], named_arg_store< Context, NUM_ARGS, NUM_NAMED_ARGS, DESC > > type
Definition base.h:2325
type args
Definition base.h:2329
Definition base.h:925
Definition base.h:474
Definition base.h:2022
Definition base.h:1014
Definition base.h:2237
Definition base.h:1015
Definition base.h:433
Definition base.h:2252
auto get() const -> Locale
Definition format-inl.h:101
Definition format-inl.h:92
Definition base.h:2362
Definition base.h:1040
int id
Definition base.h:1042
const Char * name
Definition base.h:1041
Definition base.h:2291
named_arg_info< typename Context::char_type > named_args[NUM_NAMED_ARGS]
Definition base.h:2294
FMT_CONSTEXPR FMT_ALWAYS_INLINE named_arg_store(T &... values)
Definition base.h:2297
named_arg_store(named_arg_store &&rhs)
Definition base.h:2304
named_arg_store & operator=(const named_arg_store &rhs)=delete
named_arg_store(const named_arg_store &rhs)=delete
named_arg_store & operator=(named_arg_store &&rhs)=delete
arg_t< Context, NUM_ARGS > args[1+NUM_ARGS]
Definition base.h:2293
Definition base.h:2067
const named_arg_info< Char > * data
Definition base.h:2068
size_t size
Definition base.h:2069
Definition base.h:1020
const T & value
Definition base.h:1022
const Char * name
Definition base.h:1021
named_arg(const Char *n, const T &v)
Definition base.h:1024
Definition base.h:2333
FMT_CONSTEXPR auto parse(parse_context< Char > &ctx) -> const Char *
Definition base.h:2340
void nonlocking
Definition base.h:2338
FMT_CONSTEXPR void set_debug_format(bool set=true)
Definition base.h:2350
Definition base.h:1338
const Char * end
Definition base.h:1339
arg_id_kind kind
Definition base.h:1340
Definition base.h:2055
const Char * data
Definition base.h:2056
auto str() const -> basic_string_view< Char >
Definition base.h:2058
size_t size
Definition base.h:2057
Definition base.h:962
Definition base.h:2053
Definition base.h:1116
static auto map(signed char) -> int
static auto map(unsigned short) -> unsigned
static auto map(Char *) -> const Char *
static auto map(const volatile void *) -> const void *
static auto map(unsigned char) -> unsigned
static auto map(const T &) -> conditional_t< std::is_same< C, Char >::value, basic_string_view< C >, void >
static auto map(const void *) -> const void *
static auto map(long long) -> long long
static auto map(T) -> conditional_t< std::is_same< T, char >::value||std::is_same< T, Char >::value, Char, void >
static auto map(const T &named_arg) -> decltype(map(named_arg.value))
static auto map(unsigned long long) -> unsigned long long
static auto map(void *) -> const void *
static auto map(float) -> float
static auto map(bool) -> bool
static auto map(T &) -> conditional_t< has_formatter< T, Char >(), T &, void >
static auto map(long double) -> long double
static auto map(unsigned) -> unsigned
static auto map(unsigned long) -> ulong_type
static auto map(nullptr_t) -> const void *
static auto map(double) -> double
static auto map(const T &) -> void
static auto map(const T &x) -> decltype(map(formatter< T >::format_as(x)))
static auto map(short) -> int
static auto map(int) -> int
static auto map(const T &x) -> decltype(map(format_as(x)))
static auto map(int128_opt) -> int128_opt
static auto map(const Char *) -> const Char *
static auto map(volatile void *) -> const void *
static auto map(uint128_opt) -> uint128_opt
static auto map(bitint< N >) -> conditional_t< N<=64, long long, void >
static auto map(ubitint< N >) -> conditional_t< N<=64, unsigned long long, void >
static auto map(long) -> long_type
Definition base.h:417
Definition base.h:1085
Definition base.h:1082
Definition base.h:1011
Definition base.h:834
int width
Definition base.h:835
constexpr format_specs()
Definition base.h:838
int precision
Definition base.h:836
Definition base.h:2808
OutputIt out
Iterator past the end of the output range.
Definition base.h:2810
size_t size
Total (not truncated) output size.
Definition base.h:2812
Definition base.h:2838
char * out
Pointer to just after the last successful write in the array.
Definition base.h:2840
bool truncated
Specifies if the output was truncated.
Definition base.h:2842
Definition base.h:651
formatter()=delete
A compile-time format string.
Definition base.h:2663
string_view str
Definition base.h:2675
auto get() const -> string_view
Definition base.h:2717
fstring(runtime_format_string<> fmt)
Definition base.h:2713
FMT_CONSTEVAL FMT_ALWAYS_INLINE fstring(const char(&s)[N])
Definition base.h:2680
FMT_ALWAYS_INLINE fstring(const S &)
Definition base.h:2707
FMT_CONSTEVAL FMT_ALWAYS_INLINE fstring(const S &s)
Definition base.h:2694
Definition base.h:615
Definition base.h:622
Specifies if T is an extended character type. Can be specialized by users.
Definition base.h:606
Definition base.h:324
constexpr monostate()
Definition base.h:325
Definition base.h:2648
basic_string_view< Char > str
Definition base.h:2649
Definition base.h:1224
FMT_CONSTEXPR arg_ref(int idx=0)
Definition base.h:1225
int index
Definition base.h:1228
basic_string_view< Char > name
Definition base.h:1229
FMT_CONSTEXPR arg_ref(basic_string_view< Char > n)
Definition base.h:1226
#define S(label, offset, message)
Definition Errors.h:113
typename std::enable_if< B, T >::type enable_if_t
Definition base.h:297
#define FMT_ASSERT(condition, message)
Definition base.h:381
#define FMT_END_EXPORT
Definition base.h:250
std::integral_constant< bool, B > bool_constant
Definition base.h:300
FMT_NODISCARD FMT_INLINE auto formatted_size(format_string< T... > fmt, T &&... args) -> size_t
Returns the number of chars in the output of format(fmt, args...).
Definition base.h:2867
#define FMT_BUILTIN_TYPES
Definition base.h:279
#define FMT_PRAGMA_CLANG(x)
Definition base.h:230
#define FMT_CONSTEVAL
Definition base.h:140
#define FMT_TYPE_CONSTANT(Type, constant)
Definition base.h:964
basic_string_view< char > string_view
Definition base.h:603
#define FMT_UNICODE
Definition base.h:445
auto arg(const Char *name, const T &arg) -> detail::named_arg< Char, T >
Returns a named argument to be used in a formatting function.
Definition base.h:2775
constexpr auto min_of(T a, T b) -> T
Definition base.h:337
typename std::remove_const< T >::type remove_const_t
Definition base.h:304
FMT_API void vprintln(FILE *f, string_view fmt, format_args args)
#define FMT_FALLTHROUGH
Definition base.h:172
auto vformat_to(OutputIt &&out, string_view fmt, format_args args) -> remove_cvref_t< OutputIt >
Formats a string and writes the output to out.
Definition base.h:2783
#define FMT_NODISCARD
Definition base.h:187
typename std::remove_reference< T >::type remove_reference_t
Definition base.h:302
#define FMT_WIN32
Definition base.h:256
FMT_API void vprint(string_view fmt, format_args args)
Definition format-inl.h:1750
auto vformat_to_n(OutputIt out, size_t n, string_view fmt, format_args args) -> format_to_n_result< OutputIt >
Definition base.h:2817
FMT_INLINE auto format_to(OutputIt &&out, format_string< T... > fmt, T &&... args) -> remove_cvref_t< OutputIt >
Formats args according to specifications in fmt, writes the result to the output iterator out and ret...
Definition base.h:2803
typename fstring< T... >::t format_string
Definition base.h:2720
#define FMT_TRY
Definition base.h:160
#define FMT_VISIBILITY(value)
Definition base.h:215
#define FMT_GCC_VERSION
Definition base.h:35
typename std::make_unsigned< T >::type make_unsigned_t
Definition base.h:308
#define FMT_PRAGMA_GCC(x)
Definition base.h:225
#define FMT_OPTIMIZE_SIZE
Definition base.h:273
FMT_INLINE void print(format_string< T... > fmt, T &&... args)
Formats args according to specifications in fmt and writes the output to stdout.
Definition base.h:2888
basic_appender< char > appender
Definition base.h:619
typename std::remove_cv< remove_reference_t< T > >::type remove_cvref_t
Definition base.h:306
constexpr auto max_of(T a, T b) -> T
Definition base.h:340
#define FMT_CONSTEXPR
Definition base.h:113
align
Definition base.h:684
#define FMT_ALWAYS_INLINE
Definition base.h:203
FMT_INLINE void println(FILE *f, format_string< T... > fmt, T &&... args)
Formats args according to specifications in fmt and writes the output to the file f followed by a new...
Definition base.h:2916
arg_id_kind
Definition base.h:686
FMT_NORETURN FMT_API void report_error(const char *message)
Reports a format error at compile time or, via a format_error exception, at runtime.
Definition format-inl.h:135
#define FMT_BEGIN_NAMESPACE
Definition base.h:239
sign
Definition base.h:685
auto runtime(string_view s) -> runtime_format_string<>
Creates a runtime format string.
Definition base.h:2660
#define FMT_BUILTIN
Definition base.h:2075
conditional_t< std::is_same< OutputIt, appender >::value, context, generic_context< OutputIt, Char > > basic_format_context
Definition base.h:632
#define FMT_API
Definition base.h:269
#define FMT_USE_CONSTEVAL
Definition base.h:118
#define FMT_APPLY_VARIADIC(expr)
Definition base.h:282
#define FMT_ENABLE_IF(...)
Definition base.h:334
#define FMT_BEGIN_EXPORT
Definition base.h:249
FMT_INLINE auto format_to_n(OutputIt out, size_t n, format_string< T... > fmt, T &&... args) -> format_to_n_result< OutputIt >
Formats args according to specifications in fmt, writes up to n characters of the result to the outpu...
Definition base.h:2833
void void_t
Definition base.h:321
#define FMT_CATCH(x)
Definition base.h:161
#define FMT_INLINE
Definition base.h:209
typename std::decay< T >::type decay_t
Definition base.h:311
std::is_constructible< formatter< T, Char > > FMT_DEPRECATED
Definition base.h:2732
#define FMT_NORETURN
Definition base.h:179
#define FMT_MSC_WARNING(...)
Definition base.h:235
typename std::conditional< B, T, F >::type conditional_t
Definition base.h:299
#define FMT_CONSTEXPR20
Definition base.h:141
typename std::underlying_type< T >::type underlying_t
Definition base.h:310
presentation_type
Definition base.h:661
#define FMT_END_NAMESPACE
Definition base.h:242
FMT_API void vprint_buffered(FILE *f, string_view fmt, format_args args)
conditional_t< std::is_same< Char, char >::value, context, generic_context< basic_appender< Char >, Char > > buffered_context
Definition base.h:638
decltype(nullptr) nullptr_t
Definition base.h:312
bool_constant<!std::is_same< detail::mapped_t< conditional_t< std::is_void< T >::value, int *, T >, Char >, void >::value > is_formattable
Definition base.h:2723
constexpr FMT_ALWAYS_INLINE auto make_format_args(T &... args) -> detail::format_arg_store< Context, NUM_ARGS, NUM_NAMED_ARGS, DESC >
Constructs an object that stores references to arguments and can be implicitly converted to format_ar...
Definition base.h:2753