printf_frontend_source.hpp

#pragma once
 
#include "printf_frontend_lowering_base.hpp"
#include "printf_frontend_lowering_field.hpp"
 
namespace SourceSyntax
{
template <size_t MaxFieldCount>
struct SourceAnalysisScratch
{
  std::array<size_t, MaxFieldCount> order{};  
  size_t field_count = 0;                     
  size_t argument_count = 0;                  
  Error error = Error::None;                  
 
  [[nodiscard]] consteval Error Text(size_t, size_t) const { return Error::None; }
 
  [[nodiscard]] consteval Error Field(const Conversion& conversion)
  {
    order[field_count++] = conversion.arg_index;
    size_t used_argument_count = conversion.arg_index + 1;
    if (used_argument_count > argument_count)
    {
      argument_count = used_argument_count;
    }
    return Error::None;
  }
};
 
template <size_t FieldCount, size_t ArgCount>
struct SourceAnalysis
{
  std::array<size_t, FieldCount> order{};          
  std::array<FormatArgumentInfo, ArgCount> args{};  
  Error error = Error::None;                       
};
 
template <size_t FieldCount, size_t ArgCount>
struct ResolvedArgumentVisitor
{
  SourceAnalysis<FieldCount, ArgCount>& analysis;
 
  [[nodiscard]] consteval Error Text(size_t, size_t) const { return Error::None; }
 
  [[nodiscard]] consteval Error Field(const Conversion& conversion)
  {
    auto field = FieldSelection::BuildFormatField(conversion);
    auto info = FormatArgumentInfo{
        .pack = field.pack,
        .rule = field.rule,
    };
    auto& slot = analysis.args[conversion.arg_index];
    if (slot.rule != FormatArgumentRule::None &&
        (slot.rule != info.rule || slot.pack != info.pack))
    {
      return Error::ConflictingArgument;
    }
 
    slot = info;
    return Error::None;
  }
};
 
#include "printf_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] != '%')
    {
      ++pos;
      continue;
    }
 
    auto error = visitor.Text(text_begin, pos - text_begin);
    if (error != Error::None)
    {
      return error;
    }
 
    if (pos + 1 < source.size() && source[pos + 1] == '%')
    {
      error = visitor.Text(pos, 1);
      if (error != Error::None)
      {
        return error;
      }
 
      pos += 2;
      text_begin = pos;
      continue;
    }
 
    auto parse_pos = pos;
    Conversion conversion{};
    error = Parse(source, parse_pos, indexing, conversion);
    if (error != Error::None)
    {
      return error;
    }
 
    error = visitor.Field(conversion);
    if (error != Error::None)
    {
      return error;
    }
 
    pos = parse_pos;
    text_begin = 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, scratch.argument_count> result{};
  result.error = scratch.error;
  for (size_t i = 0; i < scratch.field_count; ++i)
  {
    result.order[i] = scratch.order[i];
  }
 
  if constexpr (scratch.error != Error::None)
  {
    return result;
  }
  else
  {
    ResolvedArgumentVisitor<scratch.field_count, scratch.argument_count> visitor{
        result};
    result.error = WalkSource(std::string_view(Source.Data(), Source.Size()), visitor);
    return result;
  }
}
}  // namespace SourceSyntax