printf_frontend_parser.hpp

#pragma once
 
#include "printf_frontend_parse_util.hpp"
 
[[nodiscard]] consteval Error ParseFlags(std::string_view source, size_t& pos,
                                         Conversion& conversion)
{
  while (pos < source.size())
  {
    switch (source[pos])
    {
      case '-':
        conversion.left_align = true;
        break;
      case '+':
        conversion.force_sign = true;
        break;
      case ' ':
        conversion.space_sign = true;
        break;
      case '#':
        if (!Config::enable_alternate)
        {
          return Error::InvalidSpecifier;
        }
        conversion.alternate = true;
        break;
      case '0':
        conversion.zero_pad = true;
        break;
      default:
        return Error::None;
    }
    ++pos;
  }
 
  return Error::None;
}
 
[[nodiscard]] consteval Error ParseWidth(std::string_view source, size_t& pos,
                                         Conversion& conversion)
{
  if (pos < source.size() && source[pos] == '*')
  {
    return Error::DynamicField;
  }
 
  if (!Config::enable_width && pos < source.size() && IsDigit(source[pos]))
  {
    return Error::InvalidSpecifier;
  }
 
  return ParseByte(source, pos, std::numeric_limits<uint8_t>::max(), conversion.width);
}
 
[[nodiscard]] consteval Error ParsePrecision(std::string_view source, size_t& pos,
                                             Conversion& conversion)
{
  if (pos >= source.size() || source[pos] != '.')
  {
    return Error::None;
  }
 
  if (!Config::enable_precision)
  {
    return Error::InvalidSpecifier;
  }
 
  ++pos;
  if (pos < source.size() && source[pos] == '*')
  {
    return Error::DynamicField;
  }
 
  if (pos < source.size() && IsDigit(source[pos]))
  {
    conversion.has_precision = true;
    return ParseByte(source, pos,
                     static_cast<uint8_t>(std::numeric_limits<uint8_t>::max() - 1),
                     conversion.precision);
  }
 
  conversion.has_precision = true;
  conversion.precision = 0;
  return Error::None;
}
 
consteval void ParseLength(std::string_view source, size_t& pos, Conversion& conversion)
{
  if (pos >= source.size())
  {
    return;
  }
 
  char token = source[pos];
  if (token == 'h' || token == 'l')
  {
    ++pos;
    conversion.length = (token == 'h') ? Length::Short : Length::Long;
    if (pos < source.size() && source[pos] == token)
    {
      conversion.length = (token == 'h') ? Length::Char : Length::LongLong;
      ++pos;
    }
    return;
  }
 
  switch (token)
  {
    case 'j':
      conversion.length = Length::IntMax;
      ++pos;
      return;
    case 'z':
      conversion.length = Length::Size;
      ++pos;
      return;
    case 't':
      conversion.length = Length::PtrDiff;
      ++pos;
      return;
    case 'L':
      conversion.length = Length::LongDouble;
      ++pos;
      return;
    default:
      return;
  }
}
 
[[nodiscard]] consteval Error ParseSpecifier(std::string_view source, size_t& pos,
                                             Conversion& conversion)
{
  if (pos >= source.size())
  {
    return Error::UnexpectedEnd;
  }
 
  auto descriptor = FieldSelection::LookupSpecifier(source[pos]);
  if (descriptor.type == ValueKind::None)
  {
    return Error::InvalidSpecifier;
  }
  if (!FieldSelection::LengthAllowed(descriptor.length_policy, conversion.length))
  {
    return Error::InvalidLength;
  }
  if (!FieldSelection::TypeEnabled(descriptor.gate, conversion.length))
  {
    return Error::InvalidSpecifier;
  }
 
  conversion.type = descriptor.type;
  conversion.upper_case = conversion.upper_case || descriptor.upper_case;
  ++pos;
  return Error::None;
}
 
[[nodiscard]] consteval Error Parse(std::string_view source, size_t& pos,
                                    IndexingState& indexing, Conversion& conversion)
{
  ++pos;
  if (pos >= source.size())
  {
    return Error::UnexpectedEnd;
  }
 
  auto error = ParseArgumentIndex(source, pos, indexing, conversion);
  if (error != Error::None)
  {
    return error;
  }
 
  error = ParseFlags(source, pos, conversion);
  if (error != Error::None)
  {
    return error;
  }
 
  error = ParseWidth(source, pos, conversion);
  if (error != Error::None)
  {
    return error;
  }
 
  error = ParsePrecision(source, pos, conversion);
  if (error != Error::None)
  {
    return error;
  }
 
  ParseLength(source, pos, conversion);
  error = ParseSpecifier(source, pos, conversion);
  if (error != Error::None)
  {
    return error;
  }
 
  error = FieldSelection::ValidateConversion(conversion);
  if (error != Error::None)
  {
    return error;
  }
 
  if (!conversion.positional)
  {
    if (indexing.uses_positional)
    {
      return Error::MixedIndexing;
    }
 
    indexing.uses_sequential = true;
    conversion.arg_index = indexing.next_index++;
  }
 
  return Error::None;
}