format_frontend_source.hpp

#pragma once
 
namespace SourceSyntax
{
template <size_t FieldCount>
struct SourceAnalysis
{
  std::array<size_t, FieldCount> argument_order{};  
  size_t required_argument_count = 0;  
  Error error = Error::None;           
};
 
template <size_t MaxFieldCount>
struct SourceAnalysisScratch
{
  std::array<size_t, MaxFieldCount> order{};  
  size_t field_count = 0;                     
  size_t required_argument_count = 0;         
  Error error = Error::None;                  
 
  [[nodiscard]] consteval Error Text(size_t, size_t) const { return Error::None; }
 
  [[nodiscard]] consteval Error Field(const ParsedField& field)
  {
    order[field_count++] = field.arg_index;
    size_t used_argument_count = field.arg_index + 1;
    if (used_argument_count > required_argument_count)
    {
      required_argument_count = used_argument_count;
    }
    return Error::None;
  }
};
 
#include "format_frontend_parser.hpp"
 
[[nodiscard]] consteval Error WalkSource(std::string_view source, auto& visitor)
{
  if (HasEmbeddedNul(source))
  {
    return Error::EmbeddedNul;
  }
 
  size_t pos = 0;
  size_t text_begin = 0;
  IndexingState indexing{};
 
  while (pos < source.size())
  {
    if (source[pos] == '{')
    {
      if (pos + 1 < source.size() && source[pos + 1] == '{')
      {
        auto error = visitor.Text(text_begin, pos - text_begin);
        if (error != Error::None)
        {
          return error;
        }
        error = visitor.Text(pos, 1);
        if (error != Error::None)
        {
          return error;
        }
        pos += 2;
        text_begin = pos;
        continue;
      }
 
      auto error = visitor.Text(text_begin, pos - text_begin);
      if (error != Error::None)
      {
        return error;
      }
 
      ParsedField field{};
      error = ParseField(source, pos, indexing, field);
      if (error != Error::None)
      {
        return error;
      }
 
      error = visitor.Field(field);
      if (error != Error::None)
      {
        return error;
      }
 
      text_begin = pos;
      continue;
    }
 
    if (source[pos] == '}')
    {
      if (pos + 1 < source.size() && source[pos + 1] == '}')
      {
        auto error = visitor.Text(text_begin, pos - text_begin);
        if (error != Error::None)
        {
          return error;
        }
        error = visitor.Text(pos, 1);
        if (error != Error::None)
        {
          return error;
        }
        pos += 2;
        text_begin = pos;
        continue;
      }
 
      return Error::UnmatchedBrace;
    }
 
    ++pos;
  }
 
  return visitor.Text(text_begin, source.size() - text_begin);
}
 
template <Text Source>
[[nodiscard]] consteval auto Analyze()
{
  constexpr auto scratch = []() consteval {
    SourceAnalysisScratch<Source.Size()> visitor{};
    visitor.error = WalkSource(std::string_view(Source.Data(), Source.Size()), visitor);
    return visitor;
  }();
 
  SourceAnalysis<scratch.field_count> result{};
  result.required_argument_count = scratch.required_argument_count;
  result.error = scratch.error;
  for (size_t i = 0; i < scratch.field_count; ++i)
  {
    result.argument_order[i] = scratch.order[i];
  }
  return result;
}
}  // namespace SourceSyntax