format_frontend_parser.hpp

#pragma once
 
[[nodiscard]] constexpr bool IsDigit(char ch) { return ch >= '0' && ch <= '9'; }
 
[[nodiscard]] constexpr bool IsAlign(char ch)
{
  return ch == '<' || ch == '>' || ch == '^';
}
 
[[nodiscard]] constexpr Align ParseAlign(char ch)
{
  switch (ch)
  {
    case '<':
      return Align::Left;
    case '>':
      return Align::Right;
    case '^':
      return Align::Center;
    default:
      return Align::None;
  }
}
 
[[nodiscard]] constexpr bool HasEmbeddedNul(std::string_view source)
{
  for (char ch : source)
  {
    if (ch == '\0')
    {
      return true;
    }
  }
  return false;
}
 
[[nodiscard]] constexpr bool IsSupportedPresentation(char ch)
{
  switch (ch)
  {
    case 'd':
    case 'b':
    case 'B':
    case 'o':
    case 'x':
    case 'X':
    case 'c':
    case 's':
    case 'p':
    case 'f':
    case 'F':
    case 'e':
    case 'E':
    case 'g':
    case 'G':
      return true;
    default:
      return false;
  }
}
 
template <typename UInt>
[[nodiscard]] consteval Error ParseUnsigned(std::string_view source, size_t& pos,
                                            UInt limit, UInt& value)
{
  static_assert(std::is_unsigned_v<UInt>);
 
  value = 0;
  if (pos >= source.size() || !IsDigit(source[pos]))
  {
    return Error::InvalidSpecifier;
  }
 
  while (pos < source.size() && IsDigit(source[pos]))
  {
    auto digit = static_cast<UInt>(source[pos] - '0');
    if (value > static_cast<UInt>((limit - digit) / 10))
    {
      return Error::NumberOverflow;
    }
    value = static_cast<UInt>(value * 10 + digit);
    ++pos;
  }
 
  return Error::None;
}
 
struct IndexingState
{
  bool uses_manual = false;    
  bool uses_auto = false;      
  size_t next_auto_index = 0;  
};
 
[[nodiscard]] consteval Error ParseFieldHead(std::string_view source, size_t& pos,
                                             IndexingState& indexing, ParsedField& field)
{
  if (pos >= source.size())
  {
    return Error::UnexpectedEnd;
  }
 
  if (source[pos] == ':' || source[pos] == '}')
  {
    if (indexing.uses_manual)
    {
      return Error::MixedIndexing;
    }
 
    indexing.uses_auto = true;
    field.arg_index = indexing.next_auto_index++;
    return Error::None;
  }
 
  if (!IsDigit(source[pos]))
  {
    return Error::InvalidArgumentIndex;
  }
 
  size_t index = 0;
  auto error = ParseUnsigned(source, pos, std::numeric_limits<size_t>::max(), index);
  if (error != Error::None)
  {
    return error;
  }
 
  if (indexing.uses_auto)
  {
    return Error::MixedIndexing;
  }
 
  if (!Config::enable_explicit_argument_indexing)
  {
    return Error::ManualIndexingDisabled;
  }
 
  indexing.uses_manual = true;
  field.arg_index = index;
  return Error::None;
}
 
[[nodiscard]] consteval Error ParseFormatSpec(std::string_view source, size_t& pos,
                                              ParsedField& field)
{
  if (pos >= source.size())
  {
    return Error::UnexpectedEnd;
  }
 
  if (pos + 1 < source.size() && IsAlign(source[pos + 1]))
  {
    if (source[pos] == '{' || source[pos] == '}')
    {
      return Error::InvalidSpecifier;
    }
    field.fill = source[pos];
    field.align = ParseAlign(source[pos + 1]);
    pos += 2;
  }
  else if (IsAlign(source[pos]))
  {
    field.align = ParseAlign(source[pos]);
    ++pos;
  }
 
  if (pos < source.size() &&
      (source[pos] == '+' || source[pos] == '-' || source[pos] == ' '))
  {
    if (source[pos] == '+')
    {
      field.force_sign = true;
    }
    else if (source[pos] == ' ')
    {
      field.space_sign = true;
    }
    // '-' is the default sign mode (negative values only); accepted for
    // fmt/std::format compatibility and produces the same output as omitting
    // the sign option entirely.
    ++pos;
  }
 
  if (pos < source.size() && source[pos] == '#')
  {
    if (!Config::enable_alternate)
    {
      return Error::InvalidSpecifier;
    }
    field.alternate = true;
    ++pos;
  }
 
  if (pos < source.size() && source[pos] == '0')
  {
    field.zero_pad = true;
    ++pos;
  }
 
  if (pos < source.size() && source[pos] == '{')
  {
    return Error::DynamicField;
  }
 
  if (pos < source.size() && IsDigit(source[pos]))
  {
    if (!Config::enable_width)
    {
      return Error::InvalidSpecifier;
    }
    auto error =
        ParseUnsigned(source, pos, std::numeric_limits<uint8_t>::max(), field.width);
    if (error != Error::None)
    {
      return error;
    }
  }
 
  if (pos < source.size() && source[pos] == '.')
  {
    if (!Config::enable_precision)
    {
      return Error::InvalidSpecifier;
    }
 
    ++pos;
    if (pos < source.size() && source[pos] == '{')
    {
      return Error::DynamicField;
    }
 
    field.has_precision = true;
    auto error = ParseUnsigned(
        source, pos, static_cast<uint8_t>(std::numeric_limits<uint8_t>::max() - 1),
        field.precision);
    if (error != Error::None)
    {
      return error;
    }
  }
 
  if (pos < source.size() && source[pos] != '}')
  {
    field.presentation = source[pos++];
    if (!IsSupportedPresentation(field.presentation))
    {
      return Error::InvalidPresentation;
    }
  }
 
  return Error::None;
}
 
[[nodiscard]] consteval Error ParseField(std::string_view source, size_t& pos,
                                         IndexingState& indexing, ParsedField& field)
{
  ++pos;
  if (pos >= source.size())
  {
    return Error::UnexpectedEnd;
  }
 
  auto error = ParseFieldHead(source, pos, indexing, field);
  if (error != Error::None)
  {
    return error;
  }
 
  if (pos < source.size() && source[pos] != ':' && source[pos] != '}')
  {
    return Error::InvalidArgumentIndex;
  }
 
  if (pos < source.size() && source[pos] == ':')
  {
    ++pos;
    error = ParseFormatSpec(source, pos, field);
    if (error != Error::None)
    {
      return error;
    }
  }
 
  if (pos >= source.size())
  {
    return Error::UnexpectedEnd;
  }
  if (source[pos] != '}')
  {
    return Error::InvalidSpecifier;
  }
 
  ++pos;
  return Error::None;
}