blame: source/misc/embedded_libs/fmt-11.0.2/include/fmt/base.h

// Formatting library for C++ - the base API for char/UTF-8

//

// Copyright (c) 2012 - present, Victor Zverovich

// All rights reserved.

//

// For the license information refer to format.h.

#ifndef FMT_BASE_H_

#define FMT_BASE_H_

#if defined(FMT_IMPORT_STD) && !defined(FMT_MODULE)

#  define FMT_MODULE

#endif

#ifndef FMT_MODULE

#  include <limits.h>  // CHAR_BIT

#  include <stdio.h>   // FILE

#  include <string.h>  // strlen

// <cstddef> is also included transitively from <type_traits>.

#  include <cstddef>      // std::byte

#  include <type_traits>  // std::enable_if

#endif

// The fmt library version in the form major * 10000 + minor * 100 + patch.

#define FMT_VERSION 110002

// Detect compiler versions.

#if defined(__clang__) && !defined(__ibmxl__)

#  define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)

#else

#  define FMT_CLANG_VERSION 0

#endif

#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER)

#  define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)

#else

#  define FMT_GCC_VERSION 0

#endif

#if defined(__ICL)

#  define FMT_ICC_VERSION __ICL

#elif defined(__INTEL_COMPILER)

#  define FMT_ICC_VERSION __INTEL_COMPILER

#else

#  define FMT_ICC_VERSION 0

#endif

#if defined(_MSC_VER)

#  define FMT_MSC_VERSION _MSC_VER

#else

#  define FMT_MSC_VERSION 0

#endif

// Detect standard library versions.

#ifdef _GLIBCXX_RELEASE

#  define FMT_GLIBCXX_RELEASE _GLIBCXX_RELEASE

#else

#  define FMT_GLIBCXX_RELEASE 0

#endif

#ifdef _LIBCPP_VERSION

#  define FMT_LIBCPP_VERSION _LIBCPP_VERSION

#else

#  define FMT_LIBCPP_VERSION 0

#endif

#ifdef _MSVC_LANG

#  define FMT_CPLUSPLUS _MSVC_LANG

#else

#  define FMT_CPLUSPLUS __cplusplus

#endif

// Detect __has_*.

#ifdef __has_feature

#  define FMT_HAS_FEATURE(x) __has_feature(x)

#else

#  define FMT_HAS_FEATURE(x) 0

#endif

#ifdef __has_include

#  define FMT_HAS_INCLUDE(x) __has_include(x)

#else

#  define FMT_HAS_INCLUDE(x) 0

#endif

#ifdef __has_cpp_attribute

#  define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)

#else

#  define FMT_HAS_CPP_ATTRIBUTE(x) 0

#endif

#define FMT_HAS_CPP14_ATTRIBUTE(attribute) \

  (FMT_CPLUSPLUS >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute))

#define FMT_HAS_CPP17_ATTRIBUTE(attribute) \

  (FMT_CPLUSPLUS >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute))

// Detect C++14 relaxed constexpr.

#ifdef FMT_USE_CONSTEXPR

// Use the provided definition.

#elif FMT_GCC_VERSION >= 600 && FMT_CPLUSPLUS >= 201402L

// GCC only allows throw in constexpr since version 6:

// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67371.

#  define FMT_USE_CONSTEXPR 1

#elif FMT_ICC_VERSION

#  define FMT_USE_CONSTEXPR 0  // https://github.com/fmtlib/fmt/issues/1628

#elif FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VERSION >= 1912

#  define FMT_USE_CONSTEXPR 1

#else

#  define FMT_USE_CONSTEXPR 0

#endif

#if FMT_USE_CONSTEXPR

#  define FMT_CONSTEXPR constexpr

#else

#  define FMT_CONSTEXPR

#endif

// Detect consteval, C++20 constexpr extensions and std::is_constant_evaluated.

#if !defined(__cpp_lib_is_constant_evaluated)

#  define FMT_USE_CONSTEVAL 0

#elif FMT_CPLUSPLUS < 201709L

#  define FMT_USE_CONSTEVAL 0

#elif FMT_GLIBCXX_RELEASE && FMT_GLIBCXX_RELEASE < 10

#  define FMT_USE_CONSTEVAL 0

#elif FMT_LIBCPP_VERSION && FMT_LIBCPP_VERSION < 10000

#  define FMT_USE_CONSTEVAL 0

#elif defined(__apple_build_version__) && __apple_build_version__ < 14000029L

#  define FMT_USE_CONSTEVAL 0  // consteval is broken in Apple clang < 14.

#elif FMT_MSC_VERSION && FMT_MSC_VERSION < 1929

#  define FMT_USE_CONSTEVAL 0  // consteval is broken in MSVC VS2019 < 16.10.

#elif defined(__cpp_consteval)

#  define FMT_USE_CONSTEVAL 1

#elif FMT_GCC_VERSION >= 1002 || FMT_CLANG_VERSION >= 1101

#  define FMT_USE_CONSTEVAL 1

#else

#  define FMT_USE_CONSTEVAL 0

#endif

#if FMT_USE_CONSTEVAL

#  define FMT_CONSTEVAL consteval

#  define FMT_CONSTEXPR20 constexpr

#else

#  define FMT_CONSTEVAL

#  define FMT_CONSTEXPR20

#endif

#if defined(FMT_USE_NONTYPE_TEMPLATE_ARGS)

// Use the provided definition.

#elif defined(__NVCOMPILER)

#  define FMT_USE_NONTYPE_TEMPLATE_ARGS 0

#elif FMT_GCC_VERSION >= 903 && FMT_CPLUSPLUS >= 201709L

#  define FMT_USE_NONTYPE_TEMPLATE_ARGS 1

#elif defined(__cpp_nontype_template_args) && \

    __cpp_nontype_template_args >= 201911L

#  define FMT_USE_NONTYPE_TEMPLATE_ARGS 1

#elif FMT_CLANG_VERSION >= 1200 && FMT_CPLUSPLUS >= 202002L

#  define FMT_USE_NONTYPE_TEMPLATE_ARGS 1

#else

#  define FMT_USE_NONTYPE_TEMPLATE_ARGS 0

#endif

#ifdef FMT_USE_CONCEPTS

// Use the provided definition.

#elif defined(__cpp_concepts)

#  define FMT_USE_CONCEPTS 1

#else

#  define FMT_USE_CONCEPTS 0

#endif

// Check if exceptions are disabled.

#ifdef FMT_EXCEPTIONS

// Use the provided definition.

#elif defined(__GNUC__) && !defined(__EXCEPTIONS)

#  define FMT_EXCEPTIONS 0

#elif FMT_MSC_VERSION && !_HAS_EXCEPTIONS

#  define FMT_EXCEPTIONS 0

#else

#  define FMT_EXCEPTIONS 1

#endif

#if FMT_EXCEPTIONS

#  define FMT_TRY try

#  define FMT_CATCH(x) catch (x)

#else

#  define FMT_TRY if (true)

#  define FMT_CATCH(x) if (false)

#endif

#if FMT_HAS_CPP17_ATTRIBUTE(fallthrough)

#  define FMT_FALLTHROUGH [[fallthrough]]

#elif defined(__clang__)

#  define FMT_FALLTHROUGH [[clang::fallthrough]]

#elif FMT_GCC_VERSION >= 700 && \

    (!defined(__EDG_VERSION__) || __EDG_VERSION__ >= 520)

#  define FMT_FALLTHROUGH [[gnu::fallthrough]]

#else

#  define FMT_FALLTHROUGH

#endif

// Disable [[noreturn]] on MSVC/NVCC because of bogus unreachable code warnings.

#if FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VERSION && !defined(__NVCC__)

#  define FMT_NORETURN [[noreturn]]

#else

#  define FMT_NORETURN

#endif

#ifndef FMT_NODISCARD

#  if FMT_HAS_CPP17_ATTRIBUTE(nodiscard)

#    define FMT_NODISCARD [[nodiscard]]

#  else

#    define FMT_NODISCARD

#  endif

#endif

#ifdef FMT_DEPRECATED

// Use the provided definition.

#elif FMT_HAS_CPP14_ATTRIBUTE(deprecated)

#  define FMT_DEPRECATED [[deprecated]]

#else

#  define FMT_DEPRECATED /* deprecated */

#endif

#ifdef FMT_INLINE

// Use the provided definition.

#elif FMT_GCC_VERSION || FMT_CLANG_VERSION

#  define FMT_ALWAYS_INLINE inline __attribute__((always_inline))

#else

#  define FMT_ALWAYS_INLINE inline

#endif

// A version of FMT_INLINE to prevent code bloat in debug mode.

#ifdef NDEBUG

#  define FMT_INLINE FMT_ALWAYS_INLINE

#else

#  define FMT_INLINE inline

#endif

#if FMT_GCC_VERSION || FMT_CLANG_VERSION

#  define FMT_VISIBILITY(value) __attribute__((visibility(value)))

#else

#  define FMT_VISIBILITY(value)

#endif

#ifndef FMT_GCC_PRAGMA

// Workaround a _Pragma bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59884

// and an nvhpc warning: https://github.com/fmtlib/fmt/pull/2582.

#  if FMT_GCC_VERSION >= 504 && !defined(__NVCOMPILER)

#    define FMT_GCC_PRAGMA(arg) _Pragma(arg)

#  else

#    define FMT_GCC_PRAGMA(arg)

#  endif

#endif

// GCC < 5 requires this-> in decltype.

#if FMT_GCC_VERSION && FMT_GCC_VERSION < 500

#  define FMT_DECLTYPE_THIS this->

#else

#  define FMT_DECLTYPE_THIS

#endif

#if FMT_MSC_VERSION

#  define FMT_MSC_WARNING(...) __pragma(warning(__VA_ARGS__))

#  define FMT_UNCHECKED_ITERATOR(It) \

    using _Unchecked_type = It  // Mark iterator as checked.

#else

#  define FMT_MSC_WARNING(...)

#  define FMT_UNCHECKED_ITERATOR(It) using unchecked_type = It

#endif

#ifndef FMT_BEGIN_NAMESPACE

#  define FMT_BEGIN_NAMESPACE \

    namespace fmt {           \

    inline namespace v11 {

#  define FMT_END_NAMESPACE \

    }                       \

    }

#endif

#ifndef FMT_EXPORT

#  define FMT_EXPORT

#  define FMT_BEGIN_EXPORT

#  define FMT_END_EXPORT

#endif

#if !defined(FMT_HEADER_ONLY) && defined(_WIN32)

#  if defined(FMT_LIB_EXPORT)

#    define FMT_API __declspec(dllexport)

#  elif defined(FMT_SHARED)

#    define FMT_API __declspec(dllimport)

#  endif

#elif defined(FMT_LIB_EXPORT) || defined(FMT_SHARED)

#  define FMT_API FMT_VISIBILITY("default")

#endif

#ifndef FMT_API

#  define FMT_API

#endif

#ifndef FMT_UNICODE

#  define FMT_UNICODE 1

#endif

// Check if rtti is available.

#ifndef FMT_USE_RTTI

// __RTTI is for EDG compilers. _CPPRTTI is for MSVC.

#  if defined(__GXX_RTTI) || FMT_HAS_FEATURE(cxx_rtti) || defined(_CPPRTTI) || \

      defined(__INTEL_RTTI__) || defined(__RTTI)

#    define FMT_USE_RTTI 1

#  else

#    define FMT_USE_RTTI 0

#  endif

#endif

#define FMT_FWD(...) static_cast<decltype(__VA_ARGS__)&&>(__VA_ARGS__)

// Enable minimal optimizations for more compact code in debug mode.

FMT_GCC_PRAGMA("GCC push_options")

#if !defined(__OPTIMIZE__) && !defined(__CUDACC__)

FMT_GCC_PRAGMA("GCC optimize(\"Og\")")

#endif

FMT_BEGIN_NAMESPACE

// Implementations of enable_if_t and other metafunctions for older systems.

template <bool B, typename T = void>

using enable_if_t = typename std::enable_if<B, T>::type;

template <bool B, typename T, typename F>

using conditional_t = typename std::conditional<B, T, F>::type;

template <bool B> using bool_constant = std::integral_constant<bool, B>;

template <typename T>

using remove_reference_t = typename std::remove_reference<T>::type;

template <typename T>

using remove_const_t = typename std::remove_const<T>::type;

template <typename T>

using remove_cvref_t = typename std::remove_cv<remove_reference_t<T>>::type;

template <typename T> struct type_identity {

  using type = T;

};

template <typename T> using type_identity_t = typename type_identity<T>::type;

template <typename T>

using make_unsigned_t = typename std::make_unsigned<T>::type;

template <typename T>

using underlying_t = typename std::underlying_type<T>::type;

#if FMT_GCC_VERSION && FMT_GCC_VERSION < 500

// A workaround for gcc 4.8 to make void_t work in a SFINAE context.

template <typename...> struct void_t_impl {

  using type = void;

};

template <typename... T> using void_t = typename void_t_impl<T...>::type;

#else

template <typename...> using void_t = void;

#endif

struct monostate {

  constexpr monostate() {}

};

// An enable_if helper to be used in template parameters which results in much

// shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed

// to workaround a bug in MSVC 2019 (see #1140 and #1186).

#ifdef FMT_DOC

#  define FMT_ENABLE_IF(...)

#else

#  define FMT_ENABLE_IF(...) fmt::enable_if_t<(__VA_ARGS__), int> = 0

#endif

// This is defined in base.h instead of format.h to avoid injecting in std.

// It is a template to avoid undesirable implicit conversions to std::byte.

#ifdef __cpp_lib_byte

template <typename T, FMT_ENABLE_IF(std::is_same<T, std::byte>::value)>

inline auto format_as(T b) -> unsigned char {

  return static_cast<unsigned char>(b);

}

#endif

namespace detail {

// Suppresses "unused variable" warnings with the method described in

// https://herbsutter.com/2009/10/18/mailbag-shutting-up-compiler-warnings/.

// (void)var does not work on many Intel compilers.

template <typename... T> FMT_CONSTEXPR void ignore_unused(const T&...) {}

constexpr auto is_constant_evaluated(bool default_value = false) noexcept

    -> bool {

// Workaround for incompatibility between libstdc++ consteval-based

// std::is_constant_evaluated() implementation and clang-14:

// https://github.com/fmtlib/fmt/issues/3247.

#if FMT_CPLUSPLUS >= 202002L && FMT_GLIBCXX_RELEASE >= 12 && \

    (FMT_CLANG_VERSION >= 1400 && FMT_CLANG_VERSION < 1500)

  ignore_unused(default_value);

  return __builtin_is_constant_evaluated();

#elif defined(__cpp_lib_is_constant_evaluated)

  ignore_unused(default_value);

  return std::is_constant_evaluated();

#else

  return default_value;

#endif

}

// Suppresses "conditional expression is constant" warnings.

template <typename T> constexpr auto const_check(T value) -> T { return value; }

FMT_NORETURN FMT_API void assert_fail(const char* file, int line,

                                      const char* message);

#if defined(FMT_ASSERT)

// Use the provided definition.

#elif defined(NDEBUG)

// FMT_ASSERT is not empty to avoid -Wempty-body.

#  define FMT_ASSERT(condition, message) \

    fmt::detail::ignore_unused((condition), (message))

#else

#  define FMT_ASSERT(condition, message)                                    \

    ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \

         ? (void)0                                                          \

         : fmt::detail::assert_fail(__FILE__, __LINE__, (message)))

#endif

#ifdef FMT_USE_INT128

// Do nothing.

#elif defined(__SIZEOF_INT128__) && !defined(__NVCC__) && \

    !(FMT_CLANG_VERSION && FMT_MSC_VERSION)

#  define FMT_USE_INT128 1

using int128_opt = __int128_t;  // An optional native 128-bit integer.

using uint128_opt = __uint128_t;

template <typename T> inline auto convert_for_visit(T value) -> T {

  return value;

}

#else

#  define FMT_USE_INT128 0

#endif

#if !FMT_USE_INT128

enum class int128_opt {};

enum class uint128_opt {};

// Reduce template instantiations.

template <typename T> auto convert_for_visit(T) -> monostate { return {}; }

#endif

// Casts a nonnegative integer to unsigned.

template <typename Int>

FMT_CONSTEXPR auto to_unsigned(Int value) -> make_unsigned_t<Int> {

  FMT_ASSERT(std::is_unsigned<Int>::value || value >= 0, "negative value");

  return static_cast<make_unsigned_t<Int>>(value);

}

// A heuristic to detect std::string and std::[experimental::]string_view.

// It is mainly used to avoid dependency on <[experimental/]string_view>.

template <typename T, typename Enable = void>

struct is_std_string_like : std::false_type {};

template <typename T>

struct is_std_string_like<T, void_t<decltype(std::declval<T>().find_first_of(

                                 typename T::value_type(), 0))>>

    : std::is_convertible<decltype(std::declval<T>().data()),

                          const typename T::value_type*> {};

// Returns true iff the literal encoding is UTF-8.

constexpr auto is_utf8_enabled() -> bool {

  // Avoid an MSVC sign extension bug: https://github.com/fmtlib/fmt/pull/2297.

  using uchar = unsigned char;

  return sizeof("\u00A7") == 3 && uchar("\u00A7"[0]) == 0xC2 &&

         uchar("\u00A7"[1]) == 0xA7;

}

constexpr auto use_utf8() -> bool {

  return !FMT_MSC_VERSION || is_utf8_enabled();

}

static_assert(!FMT_UNICODE || use_utf8(),

              "Unicode support requires compiling with /utf-8");

template <typename Char> FMT_CONSTEXPR auto length(const Char* s) -> size_t {

  size_t len = 0;

  while (*s++) ++len;

  return len;

}

template <typename Char>

FMT_CONSTEXPR auto compare(const Char* s1, const Char* s2, std::size_t n)

    -> int {

  if (!is_constant_evaluated() && sizeof(Char) == 1) return memcmp(s1, s2, n);

  for (; n != 0; ++s1, ++s2, --n) {

    if (*s1 < *s2) return -1;

    if (*s1 > *s2) return 1;

  }

  return 0;

}

namespace adl {

using namespace std;

template <typename Container>

auto invoke_back_inserter()

    -> decltype(back_inserter(std::declval<Container&>()));

}  // namespace adl

template <typename It, typename Enable = std::true_type>

struct is_back_insert_iterator : std::false_type {};

template <typename It>

struct is_back_insert_iterator<

    It, bool_constant<std::is_same<

            decltype(adl::invoke_back_inserter<typename It::container_type>()),

            It>::value>> : std::true_type {};

// Extracts a reference to the container from *insert_iterator.

template <typename OutputIt>

inline auto get_container(OutputIt it) -> typename OutputIt::container_type& {

  struct accessor : OutputIt {

    accessor(OutputIt base) : OutputIt(base) {}

    using OutputIt::container;

  };

  return *accessor(it).container;

}

}  // namespace detail

// Checks whether T is a container with contiguous storage.

template <typename T> struct is_contiguous : std::false_type {};

/**

 * An implementation of `std::basic_string_view` for pre-C++17. It provides a

 * subset of the API. `fmt::basic_string_view` is used for format strings even

 * if `std::basic_string_view` is available to prevent issues when a library is

 * compiled with a different `-std` option than the client code (which is not

 * recommended).

 */

FMT_EXPORT

template <typename Char> class basic_string_view {

 private:

  const Char* data_;

  size_t size_;

 public:

  using value_type = Char;

  using iterator = const Char*;

  constexpr basic_string_view() noexcept : data_(nullptr), size_(0) {}

  /// Constructs a string reference object from a C string and a size.

  constexpr basic_string_view(const Char* s, size_t count) noexcept

      : data_(s), size_(count) {}

  constexpr basic_string_view(std::nullptr_t) = delete;

  /// Constructs a string reference object from a C string.

  FMT_CONSTEXPR20

  basic_string_view(const Char* s)

      : data_(s),

        size_(detail::const_check(std::is_same<Char, char>::value &&

                                  !detail::is_constant_evaluated(false))

                  ? strlen(reinterpret_cast<const char*>(s))

                  : detail::length(s)) {}

  /// Constructs a string reference from a `std::basic_string` or a

  /// `std::basic_string_view` object.

  template <typename S,

            FMT_ENABLE_IF(detail::is_std_string_like<S>::value&& std::is_same<

                          typename S::value_type, Char>::value)>

  FMT_CONSTEXPR basic_string_view(const S& s) noexcept

      : data_(s.data()), size_(s.size()) {}

  /// Returns a pointer to the string data.

  constexpr auto data() const noexcept -> const Char* { return data_; }

  /// Returns the string size.

  constexpr auto size() const noexcept -> size_t { return size_; }

  constexpr auto begin() const noexcept -> iterator { return data_; }

  constexpr auto end() const noexcept -> iterator { return data_ + size_; }

  constexpr auto operator[](size_t pos) const noexcept -> const Char& {

    return data_[pos];

  }

  FMT_CONSTEXPR void remove_prefix(size_t n) noexcept {

    data_ += n;

    size_ -= n;

  }

  FMT_CONSTEXPR auto starts_with(basic_string_view<Char> sv) const noexcept

      -> bool {

    return size_ >= sv.size_ && detail::compare(data_, sv.data_, sv.size_) == 0;

  }

  FMT_CONSTEXPR auto starts_with(Char c) const noexcept -> bool {

    return size_ >= 1 && *data_ == c;

  }

  FMT_CONSTEXPR auto starts_with(const Char* s) const -> bool {

    return starts_with(basic_string_view<Char>(s));

  }

  // Lexicographically compare this string reference to other.

  FMT_CONSTEXPR auto compare(basic_string_view other) const -> int {

    size_t str_size = size_ < other.size_ ? size_ : other.size_;

    int result = detail::compare(data_, other.data_, str_size);

    if (result == 0)

      result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);

    return result;

  }

  FMT_CONSTEXPR friend auto operator==(basic_string_view lhs,

                                       basic_string_view rhs) -> bool {

    return lhs.compare(rhs) == 0;

  }

  friend auto operator!=(basic_string_view lhs, basic_string_view rhs) -> bool {

    return lhs.compare(rhs) != 0;

  }

  friend auto operator<(basic_string_view lhs, basic_string_view rhs) -> bool {

    return lhs.compare(rhs) < 0;

  }

  friend auto operator<=(basic_string_view lhs, basic_string_view rhs) -> bool {

    return lhs.compare(rhs) <= 0;

  }

  friend auto operator>(basic_string_view lhs, basic_string_view rhs) -> bool {

    return lhs.compare(rhs) > 0;

  }

  friend auto operator>=(basic_string_view lhs, basic_string_view rhs) -> bool {

    return lhs.compare(rhs) >= 0;

  }

};

FMT_EXPORT

using string_view = basic_string_view<char>;

/// Specifies if `T` is a character type. Can be specialized by users.

FMT_EXPORT

template <typename T> struct is_char : std::false_type {};

template <> struct is_char<char> : std::true_type {};

namespace detail {

// Constructs fmt::basic_string_view<Char> from types implicitly convertible

// to it, deducing Char. Explicitly convertible types such as the ones returned

// from FMT_STRING are intentionally excluded.

template <typename Char, FMT_ENABLE_IF(is_char<Char>::value)>

constexpr auto to_string_view(const Char* s) -> basic_string_view<Char> {

  return s;

}

template <typename T, FMT_ENABLE_IF(is_std_string_like<T>::value)>

constexpr auto to_string_view(const T& s)

    -> basic_string_view<typename T::value_type> {

  return s;

}

template <typename Char>

constexpr auto to_string_view(basic_string_view<Char> s)

    -> basic_string_view<Char> {

  return s;

}

template <typename T, typename Enable = void>

struct has_to_string_view : std::false_type {};

// detail:: is intentional since to_string_view is not an extension point.

template <typename T>

struct has_to_string_view<

    T, void_t<decltype(detail::to_string_view(std::declval<T>()))>>

    : std::true_type {};

template <typename Char, Char... C> struct string_literal {

  static constexpr Char value[sizeof...(C)] = {C...};

  constexpr operator basic_string_view<Char>() const {

    return {value, sizeof...(C)};

  }

};

#if FMT_CPLUSPLUS < 201703L

template <typename Char, Char... C>

constexpr Char string_literal<Char, C...>::value[sizeof...(C)];

#endif

enum class type {

  none_type,

  // Integer types should go first,

  int_type,

  uint_type,

  long_long_type,

  ulong_long_type,

  int128_type,

  uint128_type,

  bool_type,

  char_type,

  last_integer_type = char_type,

  // followed by floating-point types.

  float_type,

  double_type,

  long_double_type,

  last_numeric_type = long_double_type,

  cstring_type,

  string_type,

  pointer_type,

  custom_type

};

// Maps core type T to the corresponding type enum constant.

template <typename T, typename Char>

struct type_constant : std::integral_constant<type, type::custom_type> {};

#define FMT_TYPE_CONSTANT(Type, constant) \

  template <typename Char>                \

  struct type_constant<Type, Char>        \

      : std::integral_constant<type, type::constant> {}

FMT_TYPE_CONSTANT(int, int_type);

FMT_TYPE_CONSTANT(unsigned, uint_type);

FMT_TYPE_CONSTANT(long long, long_long_type);

FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type);

FMT_TYPE_CONSTANT(int128_opt, int128_type);

FMT_TYPE_CONSTANT(uint128_opt, uint128_type);

FMT_TYPE_CONSTANT(bool, bool_type);

FMT_TYPE_CONSTANT(Char, char_type);

FMT_TYPE_CONSTANT(float, float_type);

FMT_TYPE_CONSTANT(double, double_type);

FMT_TYPE_CONSTANT(long double, long_double_type);

FMT_TYPE_CONSTANT(const Char*, cstring_type);

FMT_TYPE_CONSTANT(basic_string_view<Char>, string_type);

FMT_TYPE_CONSTANT(const void*, pointer_type);

constexpr auto is_integral_type(type t) -> bool {

  return t > type::none_type && t <= type::last_integer_type;

}

constexpr auto is_arithmetic_type(type t) -> bool {

  return t > type::none_type && t <= type::last_numeric_type;

}

constexpr auto set(type rhs) -> int { return 1 << static_cast<int>(rhs); }

constexpr auto in(type t, int set) -> bool {

  return ((set >> static_cast<int>(t)) & 1) != 0;

}

// Bitsets of types.

enum {

  sint_set =

      set(type::int_type) | set(type::long_long_type) | set(type::int128_type),

  uint_set = set(type::uint_type) | set(type::ulong_long_type) |

             set(type::uint128_type),

  bool_set = set(type::bool_type),

  char_set = set(type::char_type),

  float_set = set(type::float_type) | set(type::double_type) |

              set(type::long_double_type),

  string_set = set(type::string_type),

  cstring_set = set(type::cstring_type),

  pointer_set = set(type::pointer_type)

};

}  // namespace detail

/// Reports a format error at compile time or, via a `format_error` exception,

/// at runtime.

// This function is intentionally not constexpr to give a compile-time error.

FMT_NORETURN FMT_API void report_error(const char* message);

FMT_DEPRECATED FMT_NORETURN inline void throw_format_error(

    const char* message) {

  report_error(message);

}

/// String's character (code unit) type.

template <typename S,

          typename V = decltype(detail::to_string_view(std::declval<S>()))>

using char_t = typename V::value_type;

/**

 * Parsing context consisting of a format string range being parsed and an

 * argument counter for automatic indexing.

 * You can use the `format_parse_context` type alias for `char` instead.

 */

FMT_EXPORT

template <typename Char> class basic_format_parse_context {

 private:

  basic_string_view<Char> format_str_;

  int next_arg_id_;

  FMT_CONSTEXPR void do_check_arg_id(int id);

 public:

  using char_type = Char;

  using iterator = const Char*;

  explicit constexpr basic_format_parse_context(

      basic_string_view<Char> format_str, int next_arg_id = 0)

      : format_str_(format_str), next_arg_id_(next_arg_id) {}

  /// Returns an iterator to the beginning of the format string range being

  /// parsed.

  constexpr auto begin() const noexcept -> iterator {

    return format_str_.begin();

  }

  /// Returns an iterator past the end of the format string range being parsed.

  constexpr auto end() const noexcept -> iterator { return format_str_.end(); }

  /// Advances the begin iterator to `it`.

  FMT_CONSTEXPR void advance_to(iterator it) {

    format_str_.remove_prefix(detail::to_unsigned(it - begin()));

  }

  /// Reports an error if using the manual argument indexing; otherwise returns

  /// the next argument index and switches to the automatic indexing.

  FMT_CONSTEXPR auto next_arg_id() -> int {

    if (next_arg_id_ < 0) {

      report_error("cannot switch from manual to automatic argument indexing");

      return 0;

    }

    int id = next_arg_id_++;

    do_check_arg_id(id);

    return id;

  }

  /// Reports an error if using the automatic argument indexing; otherwise

  /// switches to the manual indexing.

  FMT_CONSTEXPR void check_arg_id(int id) {

    if (next_arg_id_ > 0) {

      report_error("cannot switch from automatic to manual argument indexing");

      return;

    }

    next_arg_id_ = -1;

    do_check_arg_id(id);

  }

  FMT_CONSTEXPR void check_arg_id(basic_string_view<Char>) {

    next_arg_id_ = -1;

  }

  FMT_CONSTEXPR void check_dynamic_spec(int arg_id);

};

FMT_EXPORT

using format_parse_context = basic_format_parse_context<char>;

namespace detail {

// A parse context with extra data used only in compile-time checks.

template <typename Char>

class compile_parse_context : public basic_format_parse_context<Char> {

 private:

  int num_args_;

  const type* types_;

  using base = basic_format_parse_context<Char>;

 public:

  explicit FMT_CONSTEXPR compile_parse_context(

      basic_string_view<Char> format_str, int num_args, const type* types,

      int next_arg_id = 0)

      : base(format_str, next_arg_id), num_args_(num_args), types_(types) {}

  constexpr auto num_args() const -> int { return num_args_; }

  constexpr auto arg_type(int id) const -> type { return types_[id]; }

  FMT_CONSTEXPR auto next_arg_id() -> int {

    int id = base::next_arg_id();

    if (id >= num_args_) report_error("argument not found");

    return id;

  }

  FMT_CONSTEXPR void check_arg_id(int id) {

    base::check_arg_id(id);

    if (id >= num_args_) report_error("argument not found");

  }

  using base::check_arg_id;

  FMT_CONSTEXPR void check_dynamic_spec(int arg_id) {

    detail::ignore_unused(arg_id);

    if (arg_id < num_args_ && types_ && !is_integral_type(types_[arg_id]))

      report_error("width/precision is not integer");

  }

};

/// A contiguous memory buffer with an optional growing ability. It is an

/// internal class and shouldn't be used directly, only via `memory_buffer`.

template <typename T> class buffer {

 private:

  T* ptr_;

  size_t size_;

  size_t capacity_;

  using grow_fun = void (*)(buffer& buf, size_t capacity);

  grow_fun grow_;

 protected:

  // Don't initialize ptr_ since it is not accessed to save a few cycles.

  FMT_MSC_WARNING(suppress : 26495)

  FMT_CONSTEXPR20 buffer(grow_fun grow, size_t sz) noexcept

      : size_(sz), capacity_(sz), grow_(grow) {}

  constexpr buffer(grow_fun grow, T* p = nullptr, size_t sz = 0,

                   size_t cap = 0) noexcept

      : ptr_(p), size_(sz), capacity_(cap), grow_(grow) {}

  FMT_CONSTEXPR20 ~buffer() = default;

  buffer(buffer&&) = default;

  /// Sets the buffer data and capacity.

  FMT_CONSTEXPR void set(T* buf_data, size_t buf_capacity) noexcept {

    ptr_ = buf_data;

    capacity_ = buf_capacity;

  }

 public:

  using value_type = T;

  using const_reference = const T&;

  buffer(const buffer&) = delete;

  void operator=(const buffer&) = delete;

  auto begin() noexcept -> T* { return ptr_; }

  auto end() noexcept -> T* { return ptr_ + size_; }