printf_frontend_parse_util.hpp

#pragma once
 
struct IndexingState
{
  bool uses_positional =
      false;  
  bool uses_sequential = false;  
  size_t next_index = 0;         
};
 
[[nodiscard]] constexpr bool IsDigit(char ch) { return ch >= '0' && ch <= '9'; }
 
[[nodiscard]] constexpr bool HasEmbeddedNul(std::string_view source)
{
  for (char ch : source)
  {
    if (ch == '\0')
    {
      return true;
    }
  }
  return false;
}
 
[[nodiscard]] consteval Error ParseArgumentIndex(std::string_view source, size_t& pos,
                                                 IndexingState& indexing,
                                                 Conversion& conversion)
{
  if (pos >= source.size() || !IsDigit(source[pos]))
  {
    return Error::None;
  }
 
  size_t probe = pos;
  size_t index = 0;
  while (probe < source.size() && IsDigit(source[probe]))
  {
    auto digit = static_cast<size_t>(source[probe] - '0');
    if (index > (std::numeric_limits<size_t>::max() - digit) / 10)
    {
      return Error::NumberOverflow;
    }
 
    index = index * 10 + digit;
    ++probe;
  }
 
  if (probe >= source.size() || source[probe] != '$')
  {
    return Error::None;
  }
 
  if (!Config::enable_explicit_argument_indexing)
  {
    return Error::PositionalArgumentDisabled;
  }
 
  if (index == 0)
  {
    return Error::InvalidArgumentIndex;
  }
  if (indexing.uses_sequential)
  {
    return Error::MixedIndexing;
  }
 
  indexing.uses_positional = true;
  conversion.positional = true;
  conversion.arg_index = index - 1;
  pos = probe + 1;
  return Error::None;
}
 
[[nodiscard]] consteval Error ParseByte(std::string_view source, size_t& pos,
                                        uint8_t limit, uint8_t& value)
{
  value = 0;
  if (pos >= source.size() || !IsDigit(source[pos]))
  {
    return Error::None;
  }
 
  while (pos < source.size() && IsDigit(source[pos]))
  {
    auto digit = static_cast<uint8_t>(source[pos] - '0');
    if (value > static_cast<uint8_t>((limit - digit) / 10))
    {
      return Error::NumberOverflow;
    }
 
    value = static_cast<uint8_t>(value * 10 + digit);
    ++pos;
  }
 
  return Error::None;
}