blame: source/misc/embedded_libs/fmt-8.1.1/include/fmt/chrono.h

// Formatting library for C++ - chrono support

//

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

// All rights reserved.

//

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

#ifndef FMT_CHRONO_H_

#define FMT_CHRONO_H_

#include <algorithm>

#include <chrono>

#include <ctime>

#include <iterator>

#include <locale>

#include <ostream>

#include <type_traits>

#include "format.h"

FMT_BEGIN_NAMESPACE

// Enable tzset.

#ifndef FMT_USE_TZSET

// UWP doesn't provide _tzset.

#  if FMT_HAS_INCLUDE("winapifamily.h")

#    include <winapifamily.h>

#  endif

#  if defined(_WIN32) && (!defined(WINAPI_FAMILY) || \

                          (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP))

#    define FMT_USE_TZSET 1

#  else

#    define FMT_USE_TZSET 0

#  endif

#endif

// Enable safe chrono durations, unless explicitly disabled.

#ifndef FMT_SAFE_DURATION_CAST

#  define FMT_SAFE_DURATION_CAST 1

#endif

#if FMT_SAFE_DURATION_CAST

// For conversion between std::chrono::durations without undefined

// behaviour or erroneous results.

// This is a stripped down version of duration_cast, for inclusion in fmt.

// See https://github.com/pauldreik/safe_duration_cast

//

// Copyright Paul Dreik 2019

namespace safe_duration_cast {

template <typename To, typename From,

          FMT_ENABLE_IF(!std::is_same<From, To>::value &&

                        std::numeric_limits<From>::is_signed ==

                            std::numeric_limits<To>::is_signed)>

FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {

  ec = 0;

  using F = std::numeric_limits<From>;

  using T = std::numeric_limits<To>;

  static_assert(F::is_integer, "From must be integral");

  static_assert(T::is_integer, "To must be integral");

  // A and B are both signed, or both unsigned.

  if (detail::const_check(F::digits <= T::digits)) {

    // From fits in To without any problem.

  } else {

    // From does not always fit in To, resort to a dynamic check.

    if (from < (T::min)() || from > (T::max)()) {

      // outside range.

      ec = 1;

      return {};

    }

  }

  return static_cast<To>(from);

}

/**

 * converts From to To, without loss. If the dynamic value of from

 * can't be converted to To without loss, ec is set.

 */

template <typename To, typename From,

          FMT_ENABLE_IF(!std::is_same<From, To>::value &&

                        std::numeric_limits<From>::is_signed !=

                            std::numeric_limits<To>::is_signed)>

FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {

  ec = 0;

  using F = std::numeric_limits<From>;

  using T = std::numeric_limits<To>;

  static_assert(F::is_integer, "From must be integral");

  static_assert(T::is_integer, "To must be integral");

  if (detail::const_check(F::is_signed && !T::is_signed)) {

    // From may be negative, not allowed!

    if (fmt::detail::is_negative(from)) {

      ec = 1;

      return {};

    }

    // From is positive. Can it always fit in To?

    if (detail::const_check(F::digits > T::digits) &&

        from > static_cast<From>(detail::max_value<To>())) {

      ec = 1;

      return {};

    }

  }

  if (detail::const_check(!F::is_signed && T::is_signed &&

                          F::digits >= T::digits) &&

      from > static_cast<From>(detail::max_value<To>())) {

    ec = 1;

    return {};

  }

  return static_cast<To>(from);  // Lossless conversion.

}

template <typename To, typename From,

          FMT_ENABLE_IF(std::is_same<From, To>::value)>

FMT_CONSTEXPR To lossless_integral_conversion(const From from, int& ec) {

  ec = 0;

  return from;

}  // function

// clang-format off

/**

 * converts From to To if possible, otherwise ec is set.

 *

 * input                            |    output

 * ---------------------------------|---------------

 * NaN                              | NaN

 * Inf                              | Inf

 * normal, fits in output           | converted (possibly lossy)

 * normal, does not fit in output   | ec is set

 * subnormal                        | best effort

 * -Inf                             | -Inf

 */

// clang-format on

template <typename To, typename From,

          FMT_ENABLE_IF(!std::is_same<From, To>::value)>

FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) {

  ec = 0;

  using T = std::numeric_limits<To>;

  static_assert(std::is_floating_point<From>::value, "From must be floating");

  static_assert(std::is_floating_point<To>::value, "To must be floating");

  // catch the only happy case

  if (std::isfinite(from)) {

    if (from >= T::lowest() && from <= (T::max)()) {

      return static_cast<To>(from);

    }

    // not within range.

    ec = 1;

    return {};

  }

  // nan and inf will be preserved

  return static_cast<To>(from);

}  // function

template <typename To, typename From,

          FMT_ENABLE_IF(std::is_same<From, To>::value)>

FMT_CONSTEXPR To safe_float_conversion(const From from, int& ec) {

  ec = 0;

  static_assert(std::is_floating_point<From>::value, "From must be floating");

  return from;

}

/**

 * safe duration cast between integral durations

 */

template <typename To, typename FromRep, typename FromPeriod,

          FMT_ENABLE_IF(std::is_integral<FromRep>::value),

          FMT_ENABLE_IF(std::is_integral<typename To::rep>::value)>

To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,

                      int& ec) {

  using From = std::chrono::duration<FromRep, FromPeriod>;

  ec = 0;

  // the basic idea is that we need to convert from count() in the from type

  // to count() in the To type, by multiplying it with this:

  struct Factor

      : std::ratio_divide<typename From::period, typename To::period> {};

  static_assert(Factor::num > 0, "num must be positive");

  static_assert(Factor::den > 0, "den must be positive");

  // the conversion is like this: multiply from.count() with Factor::num

  // /Factor::den and convert it to To::rep, all this without

  // overflow/underflow. let's start by finding a suitable type that can hold

  // both To, From and Factor::num

  using IntermediateRep =

      typename std::common_type<typename From::rep, typename To::rep,

                                decltype(Factor::num)>::type;

  // safe conversion to IntermediateRep

  IntermediateRep count =

      lossless_integral_conversion<IntermediateRep>(from.count(), ec);

  if (ec) return {};

  // multiply with Factor::num without overflow or underflow

  if (detail::const_check(Factor::num != 1)) {

    const auto max1 = detail::max_value<IntermediateRep>() / Factor::num;

    if (count > max1) {

      ec = 1;

      return {};

    }

    const auto min1 =

        (std::numeric_limits<IntermediateRep>::min)() / Factor::num;

    if (count < min1) {

      ec = 1;

      return {};

    }

    count *= Factor::num;

  }

  if (detail::const_check(Factor::den != 1)) count /= Factor::den;

  auto tocount = lossless_integral_conversion<typename To::rep>(count, ec);

  return ec ? To() : To(tocount);

}

/**

 * safe duration_cast between floating point durations

 */

template <typename To, typename FromRep, typename FromPeriod,

          FMT_ENABLE_IF(std::is_floating_point<FromRep>::value),

          FMT_ENABLE_IF(std::is_floating_point<typename To::rep>::value)>

To safe_duration_cast(std::chrono::duration<FromRep, FromPeriod> from,

                      int& ec) {

  using From = std::chrono::duration<FromRep, FromPeriod>;

  ec = 0;

  if (std::isnan(from.count())) {

    // nan in, gives nan out. easy.

    return To{std::numeric_limits<typename To::rep>::quiet_NaN()};

  }

  // maybe we should also check if from is denormal, and decide what to do about

  // it.

  // +-inf should be preserved.

  if (std::isinf(from.count())) {

    return To{from.count()};

  }

  // the basic idea is that we need to convert from count() in the from type

  // to count() in the To type, by multiplying it with this:

  struct Factor

      : std::ratio_divide<typename From::period, typename To::period> {};

  static_assert(Factor::num > 0, "num must be positive");

  static_assert(Factor::den > 0, "den must be positive");

  // the conversion is like this: multiply from.count() with Factor::num

  // /Factor::den and convert it to To::rep, all this without

  // overflow/underflow. let's start by finding a suitable type that can hold

  // both To, From and Factor::num

  using IntermediateRep =

      typename std::common_type<typename From::rep, typename To::rep,

                                decltype(Factor::num)>::type;

  // force conversion of From::rep -> IntermediateRep to be safe,

  // even if it will never happen be narrowing in this context.

  IntermediateRep count =

      safe_float_conversion<IntermediateRep>(from.count(), ec);

  if (ec) {

    return {};

  }

  // multiply with Factor::num without overflow or underflow

  if (detail::const_check(Factor::num != 1)) {

    constexpr auto max1 = detail::max_value<IntermediateRep>() /

                          static_cast<IntermediateRep>(Factor::num);

    if (count > max1) {

      ec = 1;

      return {};

    }

    constexpr auto min1 = std::numeric_limits<IntermediateRep>::lowest() /

                          static_cast<IntermediateRep>(Factor::num);

    if (count < min1) {

      ec = 1;

      return {};

    }

    count *= static_cast<IntermediateRep>(Factor::num);

  }

  // this can't go wrong, right? den>0 is checked earlier.

  if (detail::const_check(Factor::den != 1)) {

    using common_t = typename std::common_type<IntermediateRep, intmax_t>::type;

    count /= static_cast<common_t>(Factor::den);

  }

  // convert to the to type, safely

  using ToRep = typename To::rep;

  const ToRep tocount = safe_float_conversion<ToRep>(count, ec);

  if (ec) {

    return {};

  }

  return To{tocount};

}

}  // namespace safe_duration_cast

#endif

// Prevents expansion of a preceding token as a function-style macro.

// Usage: f FMT_NOMACRO()

#define FMT_NOMACRO

namespace detail {

template <typename T = void> struct null {};

inline null<> localtime_r FMT_NOMACRO(...) { return null<>(); }

inline null<> localtime_s(...) { return null<>(); }

inline null<> gmtime_r(...) { return null<>(); }

inline null<> gmtime_s(...) { return null<>(); }

inline const std::locale& get_classic_locale() {

  static const auto& locale = std::locale::classic();

  return locale;

}

template <typename CodeUnit> struct codecvt_result {

  static constexpr const size_t max_size = 32;

  CodeUnit buf[max_size];

  CodeUnit* end;

};

template <typename CodeUnit>

constexpr const size_t codecvt_result<CodeUnit>::max_size;

template <typename CodeUnit>

void write_codecvt(codecvt_result<CodeUnit>& out, string_view in_buf,

                   const std::locale& loc) {

  using codecvt = std::codecvt<CodeUnit, char, std::mbstate_t>;

#if FMT_CLANG_VERSION

#  pragma clang diagnostic push

#  pragma clang diagnostic ignored "-Wdeprecated"

  auto& f = std::use_facet<codecvt>(loc);

#  pragma clang diagnostic pop

#else

  auto& f = std::use_facet<codecvt>(loc);

#endif

  auto mb = std::mbstate_t();

  const char* from_next = nullptr;

  auto result = f.in(mb, in_buf.begin(), in_buf.end(), from_next,

                     std::begin(out.buf), std::end(out.buf), out.end);

  if (result != std::codecvt_base::ok)

    FMT_THROW(format_error("failed to format time"));

}

template <typename OutputIt>

auto write_encoded_tm_str(OutputIt out, string_view in, const std::locale& loc)

    -> OutputIt {

  if (detail::is_utf8() && loc != get_classic_locale()) {

    // char16_t and char32_t codecvts are broken in MSVC (linkage errors) and

    // gcc-4.

#if FMT_MSC_VER != 0 || \

    (defined(__GLIBCXX__) && !defined(_GLIBCXX_USE_DUAL_ABI))

    // The _GLIBCXX_USE_DUAL_ABI macro is always defined in libstdc++ from gcc-5

    // and newer.

    using code_unit = wchar_t;

#else

    using code_unit = char32_t;

#endif

    using unit_t = codecvt_result<code_unit>;

    unit_t unit;

    write_codecvt(unit, in, loc);

    // In UTF-8 is used one to four one-byte code units.

    auto&& buf = basic_memory_buffer<char, unit_t::max_size * 4>();

    for (code_unit* p = unit.buf; p != unit.end; ++p) {

      uint32_t c = static_cast<uint32_t>(*p);

      if (sizeof(code_unit) == 2 && c >= 0xd800 && c <= 0xdfff) {

        // surrogate pair

        ++p;

        if (p == unit.end || (c & 0xfc00) != 0xd800 ||

            (*p & 0xfc00) != 0xdc00) {

          FMT_THROW(format_error("failed to format time"));

        }

        c = (c << 10) + static_cast<uint32_t>(*p) - 0x35fdc00;

      }

      if (c < 0x80) {

        buf.push_back(static_cast<char>(c));

      } else if (c < 0x800) {

        buf.push_back(static_cast<char>(0xc0 | (c >> 6)));

        buf.push_back(static_cast<char>(0x80 | (c & 0x3f)));

      } else if ((c >= 0x800 && c <= 0xd7ff) || (c >= 0xe000 && c <= 0xffff)) {

        buf.push_back(static_cast<char>(0xe0 | (c >> 12)));

        buf.push_back(static_cast<char>(0x80 | ((c & 0xfff) >> 6)));

        buf.push_back(static_cast<char>(0x80 | (c & 0x3f)));

      } else if (c >= 0x10000 && c <= 0x10ffff) {

        buf.push_back(static_cast<char>(0xf0 | (c >> 18)));

        buf.push_back(static_cast<char>(0x80 | ((c & 0x3ffff) >> 12)));

        buf.push_back(static_cast<char>(0x80 | ((c & 0xfff) >> 6)));

        buf.push_back(static_cast<char>(0x80 | (c & 0x3f)));

      } else {

        FMT_THROW(format_error("failed to format time"));

      }

    }

    return copy_str<char>(buf.data(), buf.data() + buf.size(), out);

  }

  return copy_str<char>(in.data(), in.data() + in.size(), out);

}

template <typename Char, typename OutputIt,

          FMT_ENABLE_IF(!std::is_same<Char, char>::value)>

auto write_tm_str(OutputIt out, string_view sv, const std::locale& loc)

    -> OutputIt {

  codecvt_result<Char> unit;

  write_codecvt(unit, sv, loc);

  return copy_str<Char>(unit.buf, unit.end, out);

}

template <typename Char, typename OutputIt,

          FMT_ENABLE_IF(std::is_same<Char, char>::value)>

auto write_tm_str(OutputIt out, string_view sv, const std::locale& loc)

    -> OutputIt {

  return write_encoded_tm_str(out, sv, loc);

}

template <typename Char>

inline void do_write(buffer<Char>& buf, const std::tm& time,

                     const std::locale& loc, char format, char modifier) {

  auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf);

  auto&& os = std::basic_ostream<Char>(&format_buf);

  os.imbue(loc);

  using iterator = std::ostreambuf_iterator<Char>;

  const auto& facet = std::use_facet<std::time_put<Char, iterator>>(loc);

  auto end = facet.put(os, os, Char(' '), &time, format, modifier);

  if (end.failed()) FMT_THROW(format_error("failed to format time"));

}

template <typename Char, typename OutputIt,

          FMT_ENABLE_IF(!std::is_same<Char, char>::value)>

auto write(OutputIt out, const std::tm& time, const std::locale& loc,

           char format, char modifier = 0) -> OutputIt {

  auto&& buf = get_buffer<Char>(out);

  do_write<Char>(buf, time, loc, format, modifier);

  return buf.out();

}

template <typename Char, typename OutputIt,

          FMT_ENABLE_IF(std::is_same<Char, char>::value)>

auto write(OutputIt out, const std::tm& time, const std::locale& loc,

           char format, char modifier = 0) -> OutputIt {

  auto&& buf = basic_memory_buffer<Char>();

  do_write<char>(buf, time, loc, format, modifier);

  return write_encoded_tm_str(out, string_view(buf.data(), buf.size()), loc);

}

}  // namespace detail

FMT_MODULE_EXPORT_BEGIN

/**

  Converts given time since epoch as ``std::time_t`` value into calendar time,

  expressed in local time. Unlike ``std::localtime``, this function is

  thread-safe on most platforms.

 */

inline std::tm localtime(std::time_t time) {

  struct dispatcher {

    std::time_t time_;

    std::tm tm_;

    dispatcher(std::time_t t) : time_(t) {}

    bool run() {

      using namespace fmt::detail;

      return handle(localtime_r(&time_, &tm_));

    }

    bool handle(std::tm* tm) { return tm != nullptr; }

    bool handle(detail::null<>) {

      using namespace fmt::detail;

      return fallback(localtime_s(&tm_, &time_));

    }

    bool fallback(int res) { return res == 0; }

#if !FMT_MSC_VER

    bool fallback(detail::null<>) {

      using namespace fmt::detail;

      std::tm* tm = std::localtime(&time_);

      if (tm) tm_ = *tm;

      return tm != nullptr;

    }

#endif

  };

  dispatcher lt(time);

  // Too big time values may be unsupported.

  if (!lt.run()) FMT_THROW(format_error("time_t value out of range"));

  return lt.tm_;

}

inline std::tm localtime(

    std::chrono::time_point<std::chrono::system_clock> time_point) {

  return localtime(std::chrono::system_clock::to_time_t(time_point));

}

/**

  Converts given time since epoch as ``std::time_t`` value into calendar time,

  expressed in Coordinated Universal Time (UTC). Unlike ``std::gmtime``, this

  function is thread-safe on most platforms.

 */

inline std::tm gmtime(std::time_t time) {

  struct dispatcher {

    std::time_t time_;

    std::tm tm_;

    dispatcher(std::time_t t) : time_(t) {}

    bool run() {

      using namespace fmt::detail;

      return handle(gmtime_r(&time_, &tm_));

    }

    bool handle(std::tm* tm) { return tm != nullptr; }

    bool handle(detail::null<>) {

      using namespace fmt::detail;

      return fallback(gmtime_s(&tm_, &time_));

    }

    bool fallback(int res) { return res == 0; }

#if !FMT_MSC_VER

    bool fallback(detail::null<>) {

      std::tm* tm = std::gmtime(&time_);

      if (tm) tm_ = *tm;

      return tm != nullptr;

    }

#endif

  };

  dispatcher gt(time);

  // Too big time values may be unsupported.

  if (!gt.run()) FMT_THROW(format_error("time_t value out of range"));

  return gt.tm_;

}

inline std::tm gmtime(

    std::chrono::time_point<std::chrono::system_clock> time_point) {

  return gmtime(std::chrono::system_clock::to_time_t(time_point));

}

FMT_BEGIN_DETAIL_NAMESPACE

// Writes two-digit numbers a, b and c separated by sep to buf.

// The method by Pavel Novikov based on

// https://johnnylee-sde.github.io/Fast-unsigned-integer-to-time-string/.

inline void write_digit2_separated(char* buf, unsigned a, unsigned b,

                                   unsigned c, char sep) {

  unsigned long long digits =

      a | (b << 24) | (static_cast<unsigned long long>(c) << 48);

  // Convert each value to BCD.

  // We have x = a * 10 + b and we want to convert it to BCD y = a * 16 + b.

  // The difference is

  //   y - x = a * 6

  // a can be found from x:

  //   a = floor(x / 10)

  // then

  //   y = x + a * 6 = x + floor(x / 10) * 6

  // floor(x / 10) is (x * 205) >> 11 (needs 16 bits).

  digits += (((digits * 205) >> 11) & 0x000f00000f00000f) * 6;

  // Put low nibbles to high bytes and high nibbles to low bytes.

  digits = ((digits & 0x00f00000f00000f0) >> 4) |

           ((digits & 0x000f00000f00000f) << 8);

  auto usep = static_cast<unsigned long long>(sep);

  // Add ASCII '0' to each digit byte and insert separators.

  digits |= 0x3030003030003030 | (usep << 16) | (usep << 40);

  constexpr const size_t len = 8;

  if (const_check(is_big_endian())) {

    char tmp[len];

    memcpy(tmp, &digits, len);

    std::reverse_copy(tmp, tmp + len, buf);

  } else {

    memcpy(buf, &digits, len);

  }

}

template <typename Period> FMT_CONSTEXPR inline const char* get_units() {

  if (std::is_same<Period, std::atto>::value) return "as";

  if (std::is_same<Period, std::femto>::value) return "fs";

  if (std::is_same<Period, std::pico>::value) return "ps";

  if (std::is_same<Period, std::nano>::value) return "ns";

  if (std::is_same<Period, std::micro>::value) return "µs";

  if (std::is_same<Period, std::milli>::value) return "ms";

  if (std::is_same<Period, std::centi>::value) return "cs";

  if (std::is_same<Period, std::deci>::value) return "ds";

  if (std::is_same<Period, std::ratio<1>>::value) return "s";

  if (std::is_same<Period, std::deca>::value) return "das";

  if (std::is_same<Period, std::hecto>::value) return "hs";

  if (std::is_same<Period, std::kilo>::value) return "ks";

  if (std::is_same<Period, std::mega>::value) return "Ms";

  if (std::is_same<Period, std::giga>::value) return "Gs";

  if (std::is_same<Period, std::tera>::value) return "Ts";

  if (std::is_same<Period, std::peta>::value) return "Ps";

  if (std::is_same<Period, std::exa>::value) return "Es";

  if (std::is_same<Period, std::ratio<60>>::value) return "m";

  if (std::is_same<Period, std::ratio<3600>>::value) return "h";

  return nullptr;

}

enum class numeric_system {

  standard,

  // Alternative numeric system, e.g. 十二 instead of 12 in ja_JP locale.

  alternative

};

// Parses a put_time-like format string and invokes handler actions.

template <typename Char, typename Handler>

FMT_CONSTEXPR const Char* parse_chrono_format(const Char* begin,

                                              const Char* end,

                                              Handler&& handler) {

  auto ptr = begin;

  while (ptr != end) {

    auto c = *ptr;

    if (c == '}') break;

    if (c != '%') {

      ++ptr;

      continue;

    }

    if (begin != ptr) handler.on_text(begin, ptr);

    ++ptr;  // consume '%'

    if (ptr == end) FMT_THROW(format_error("invalid format"));

    c = *ptr++;

    switch (c) {

    case '%':

      handler.on_text(ptr - 1, ptr);

      break;

    case 'n': {

      const Char newline[] = {'\n'};

      handler.on_text(newline, newline + 1);

      break;

    }

    case 't': {

      const Char tab[] = {'\t'};

      handler.on_text(tab, tab + 1);

      break;

    }

    // Year:

    case 'Y':

      handler.on_year(numeric_system::standard);

      break;

    case 'y':

      handler.on_short_year(numeric_system::standard);

      break;

    case 'C':

      handler.on_century(numeric_system::standard);

      break;

    case 'G':

      handler.on_iso_week_based_year();

      break;

    case 'g':

      handler.on_iso_week_based_short_year();

      break;

    // Day of the week:

    case 'a':

      handler.on_abbr_weekday();

      break;

    case 'A':

      handler.on_full_weekday();

      break;

    case 'w':

      handler.on_dec0_weekday(numeric_system::standard);

      break;

    case 'u':

      handler.on_dec1_weekday(numeric_system::standard);

      break;

    // Month:

    case 'b':

    case 'h':

      handler.on_abbr_month();

      break;

    case 'B':

      handler.on_full_month();

      break;

    case 'm':

      handler.on_dec_month(numeric_system::standard);

      break;

    // Day of the year/month:

    case 'U':

      handler.on_dec0_week_of_year(numeric_system::standard);

      break;

    case 'W':

      handler.on_dec1_week_of_year(numeric_system::standard);

      break;

    case 'V':

      handler.on_iso_week_of_year(numeric_system::standard);

      break;

    case 'j':

      handler.on_day_of_year();

      break;

    case 'd':

      handler.on_day_of_month(numeric_system::standard);

      break;

    case 'e':

      handler.on_day_of_month_space(numeric_system::standard);

      break;

    // Hour, minute, second:

    case 'H':

      handler.on_24_hour(numeric_system::standard);

      break;

    case 'I':

      handler.on_12_hour(numeric_system::standard);

      break;

    case 'M':

      handler.on_minute(numeric_system::standard);

      break;

    case 'S':

      handler.on_second(numeric_system::standard);

      break;

    // Other:

    case 'c':

      handler.on_datetime(numeric_system::standard);

      break;

    case 'x':

      handler.on_loc_date(numeric_system::standard);

      break;

    case 'X':

      handler.on_loc_time(numeric_system::standard);

      break;

    case 'D':

      handler.on_us_date();

      break;

    case 'F':

      handler.on_iso_date();

      break;

    case 'r':

      handler.on_12_hour_time();

      break;

    case 'R':

      handler.on_24_hour_time();

      break;

    case 'T':

      handler.on_iso_time();

      break;

    case 'p':

      handler.on_am_pm();

      break;

    case 'Q':

      handler.on_duration_value();

      break;

    case 'q':

      handler.on_duration_unit();

      break;

    case 'z':

      handler.on_utc_offset();

      break;

    case 'Z':

      handler.on_tz_name();

      break;

    // Alternative representation:

    case 'E': {

      if (ptr == end) FMT_THROW(format_error("invalid format"));

      c = *ptr++;

      switch (c) {

      case 'Y':

        handler.on_year(numeric_system::alternative);

        break;

      case 'y':

        handler.on_offset_year();

        break;

      case 'C':

        handler.on_century(numeric_system::alternative);

        break;

      case 'c':

        handler.on_datetime(numeric_system::alternative);

        break;

      case 'x':

        handler.on_loc_date(numeric_system::alternative);

        break;

      case 'X':

        handler.on_loc_time(numeric_system::alternative);

        break;

      default:

        FMT_THROW(format_error("invalid format"));

      }

      break;

    }

    case 'O':

      if (ptr == end) FMT_THROW(format_error("invalid format"));

      c = *ptr++;

      switch (c) {

      case 'y':

        handler.on_short_year(numeric_system::alternative);

        break;

      case 'm':

        handler.on_dec_month(numeric_system::alternative);

        break;

      case 'U':

        handler.on_dec0_week_of_year(numeric_system::alternative);

        break;

      case 'W':

        handler.on_dec1_week_of_year(numeric_system::alternative);

        break;

      case 'V':

        handler.on_iso_week_of_year(numeric_system::alternative);

        break;

      case 'd':

        handler.on_day_of_month(numeric_system::alternative);

        break;

      case 'e':

        handler.on_day_of_month_space(numeric_system::alternative);

        break;

      case 'w':

        handler.on_dec0_weekday(numeric_system::alternative);

        break;

      case 'u':

        handler.on_dec1_weekday(numeric_system::alternative);

        break;

      case 'H':

        handler.on_24_hour(numeric_system::alternative);

        break;

      case 'I':

        handler.on_12_hour(numeric_system::alternative);

        break;

      case 'M':

        handler.on_minute(numeric_system::alternative);

        break;

      case 'S':

        handler.on_second(numeric_system::alternative);

        break;

      default:

        FMT_THROW(format_error("invalid format"));

      }

      break;

    default:

      FMT_THROW(format_error("invalid format"));

    }

    begin = ptr;

  }

  if (begin != ptr) handler.on_text(begin, ptr);

  return ptr;

}

template <typename Derived> struct null_chrono_spec_handler {

  FMT_CONSTEXPR void unsupported() {

    static_cast<Derived*>(this)->unsupported();

  }

  FMT_CONSTEXPR void on_year(numeric_system) { unsupported(); }

  FMT_CONSTEXPR void on_short_year(numeric_system) { unsupported(); }

  FMT_CONSTEXPR void on_offset_year() { unsupported(); }

  FMT_CONSTEXPR void on_century(numeric_system) { unsupported(); }

  FMT_CONSTEXPR void on_iso_week_based_year() { unsupported(); }

  FMT_CONSTEXPR void on_iso_week_based_short_year() { unsupported(); }

  FMT_CONSTEXPR void on_abbr_weekday() { unsupported(); }

  FMT_CONSTEXPR void on_full_weekday() { unsupported(); }

  FMT_CONSTEXPR void on_dec0_weekday(numeric_system) { unsupported(); }

  FMT_CONSTEXPR void on_dec1_weekday(numeric_system) { unsupported(); }

  FMT_CONSTEXPR void on_abbr_month() { unsupported(); }

  FMT_CONSTEXPR void on_full_month() { unsupported(); }

  FMT_CONSTEXPR void on_dec_month(numeric_system) { unsupported(); }

  FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system) { unsupported(); }

  FMT_CONSTEXPR void on_dec1_week_of_year(numeric_system) { unsupported(); }

  FMT_CONSTEXPR void on_iso_week_of_year(numeric_system) { unsupported(); }

  FMT_CONSTEXPR void on_day_of_year() { unsupported(); }

  FMT_CONSTEXPR void on_day_of_month(numeric_system) { unsupported(); }

  FMT_CONSTEXPR void on_day_of_month_space(numeric_system) { unsupported(); }

  FMT_CONSTEXPR void on_24_hour(numeric_system) { unsupported(); }

  FMT_CONSTEXPR void on_12_hour(numeric_system) { unsupported(); }

  FMT_CONSTEXPR void on_minute(numeric_system) { unsupported(); }

  FMT_CONSTEXPR void on_second(numeric_system) { unsupported(); }

  FMT_CONSTEXPR void on_datetime(numeric_system) { unsupported(); }

  FMT_CONSTEXPR void on_loc_date(numeric_system) { unsupported(); }

  FMT_CONSTEXPR void on_loc_time(numeric_system) { unsupported(); }

  FMT_CONSTEXPR void on_us_date() { unsupported(); }

  FMT_CONSTEXPR void on_iso_date() { unsupported(); }

  FMT_CONSTEXPR void on_12_hour_time() { unsupported(); }

  FMT_CONSTEXPR void on_24_hour_time() { unsupported(); }

  FMT_CONSTEXPR void on_iso_time() { unsupported(); }

  FMT_CONSTEXPR void on_am_pm() { unsupported(); }

  FMT_CONSTEXPR void on_duration_value() { unsupported(); }

  FMT_CONSTEXPR void on_duration_unit() { unsupported(); }

  FMT_CONSTEXPR void on_utc_offset() { unsupported(); }

  FMT_CONSTEXPR void on_tz_name() { unsupported(); }

};

struct tm_format_checker : null_chrono_spec_handler<tm_format_checker> {

  FMT_NORETURN void unsupported() { FMT_THROW(format_error("no format")); }

  template <typename Char>

  FMT_CONSTEXPR void on_text(const Char*, const Char*) {}

  FMT_CONSTEXPR void on_year(numeric_system) {}

  FMT_CONSTEXPR void on_short_year(numeric_system) {}

  FMT_CONSTEXPR void on_offset_year() {}

  FMT_CONSTEXPR void on_century(numeric_system) {}

  FMT_CONSTEXPR void on_iso_week_based_year() {}

  FMT_CONSTEXPR void on_iso_week_based_short_year() {}

  FMT_CONSTEXPR void on_abbr_weekday() {}

  FMT_CONSTEXPR void on_full_weekday() {}

  FMT_CONSTEXPR void on_dec0_weekday(numeric_system) {}

  FMT_CONSTEXPR void on_dec1_weekday(numeric_system) {}

  FMT_CONSTEXPR void on_abbr_month() {}

  FMT_CONSTEXPR void on_full_month() {}

  FMT_CONSTEXPR void on_dec_month(numeric_system) {}

  FMT_CONSTEXPR void on_dec0_week_of_year(numeric_system) {}