printf_frontend_detail.hpp

#pragma once
 
#include <array>
#include <limits>
#include <string_view>
 
#include "format_compile.hpp"
 
namespace LibXR::Print::Detail::PrintfCompile
{
using Error = Printf::Error;
using Length = Printf::Length;
 
enum class ValueKind : uint8_t
{
  None,               
  Signed,             
  Unsigned,           
  Binary,             
  Octal,              
  HexLower,           
  HexUpper,           
  Pointer,            
  Character,          
  String,             
  FloatFixed,         
  FloatScientific,    
  FloatGeneral,       
};
 
struct Conversion
{
  size_t arg_index = 0;            
  ValueKind type = ValueKind::None;   
  Length length = Length::Default;    
  bool left_align = false;            
  bool force_sign = false;            
  bool space_sign = false;            
  bool alternate = false;             
  bool zero_pad = false;              
  bool upper_case = false;            
  bool positional = false;            
  uint8_t width = 0;                  
  bool has_precision = false;         
  uint8_t precision = 0;              
 
  [[nodiscard]] constexpr uint8_t FlagsByte() const
  {
    uint8_t flags = 0;
    if (left_align)
    {
      flags |= static_cast<uint8_t>(FormatFlag::LeftAlign);
    }
    if (force_sign)
    {
      flags |= static_cast<uint8_t>(FormatFlag::ForceSign);
    }
    if (space_sign)
    {
      flags |= static_cast<uint8_t>(FormatFlag::SpaceSign);
    }
    if (alternate)
    {
      flags |= static_cast<uint8_t>(FormatFlag::Alternate);
    }
    if (zero_pad)
    {
      flags |= static_cast<uint8_t>(FormatFlag::ZeroPad);
    }
    if (upper_case)
    {
      flags |= static_cast<uint8_t>(FormatFlag::UpperCase);
    }
    return flags;
  }
 
  [[nodiscard]] constexpr uint8_t PrecisionByte() const
  {
    return has_precision ? precision : std::numeric_limits<uint8_t>::max();
  }
};
 
enum class FeatureGate : uint8_t
{
  Integer,          
  IntegerBase8_16,  
  Pointer,          
  Text,             
  FloatFixed,       
  FloatScientific,  
  FloatGeneral,     
};
 
enum class LengthPolicy : uint8_t
{
  Integer,   
  NoneOnly,  
  Float,     
};
 
struct SpecifierDescriptor
{
  char token = 0;  
  ValueKind type = ValueKind::None;   
  FeatureGate gate =
      FeatureGate::Integer;  
  LengthPolicy length_policy =
      LengthPolicy::NoneOnly;  
  bool upper_case = false;  
};
 
inline constexpr size_t length_rule_count =
    static_cast<size_t>(Length::LongDouble) + 1;
 
inline constexpr std::array<FormatArgumentRule, length_rule_count> signed_rules{
    FormatArgumentRule::SignedAny,
    FormatArgumentRule::SignedChar,
    FormatArgumentRule::SignedShort,
    FormatArgumentRule::SignedLong,
    FormatArgumentRule::SignedLongLong,
    FormatArgumentRule::SignedIntMax,
    FormatArgumentRule::SignedSize,
    FormatArgumentRule::SignedPtrDiff,
    FormatArgumentRule::None,
};
 
inline constexpr std::array<FormatArgumentRule, length_rule_count> unsigned_rules{
    FormatArgumentRule::UnsignedAny,
    FormatArgumentRule::UnsignedChar,
    FormatArgumentRule::UnsignedShort,
    FormatArgumentRule::UnsignedLong,
    FormatArgumentRule::UnsignedLongLong,
    FormatArgumentRule::UnsignedIntMax,
    FormatArgumentRule::UnsignedSize,
    FormatArgumentRule::UnsignedPtrDiff,
    FormatArgumentRule::None,
};
 
inline constexpr std::array<SpecifierDescriptor, 17> specifiers{{
    {'d', ValueKind::Signed, FeatureGate::Integer, LengthPolicy::Integer, false},
    {'i', ValueKind::Signed, FeatureGate::Integer, LengthPolicy::Integer, false},
    {'u', ValueKind::Unsigned, FeatureGate::Integer, LengthPolicy::Integer, false},
    {'b', ValueKind::Binary, FeatureGate::IntegerBase8_16, LengthPolicy::Integer, false},
    {'B', ValueKind::Binary, FeatureGate::IntegerBase8_16, LengthPolicy::Integer, true},
    {'o', ValueKind::Octal, FeatureGate::IntegerBase8_16, LengthPolicy::Integer, false},
    {'x', ValueKind::HexLower, FeatureGate::IntegerBase8_16, LengthPolicy::Integer,
     false},
    {'X', ValueKind::HexUpper, FeatureGate::IntegerBase8_16, LengthPolicy::Integer,
     false},
    {'p', ValueKind::Pointer, FeatureGate::Pointer, LengthPolicy::NoneOnly, false},
    {'c', ValueKind::Character, FeatureGate::Text, LengthPolicy::NoneOnly, false},
    {'s', ValueKind::String, FeatureGate::Text, LengthPolicy::NoneOnly, false},
    {'f', ValueKind::FloatFixed, FeatureGate::FloatFixed, LengthPolicy::Float, false},
    {'F', ValueKind::FloatFixed, FeatureGate::FloatFixed, LengthPolicy::Float, true},
    {'e', ValueKind::FloatScientific, FeatureGate::FloatScientific,
     LengthPolicy::Float, false},
    {'E', ValueKind::FloatScientific, FeatureGate::FloatScientific,
     LengthPolicy::Float, true},
    {'g', ValueKind::FloatGeneral, FeatureGate::FloatGeneral, LengthPolicy::Float,
     false},
    {'G', ValueKind::FloatGeneral, FeatureGate::FloatGeneral, LengthPolicy::Float,
     true},
}};
 
namespace SourceSyntax
{
struct IndexingState
{
  bool uses_positional = false;  
  bool uses_sequential = false;  
  size_t next_index = 0;         
};
 
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;                       
};
 
[[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;
}
 
namespace Lowering
{
[[nodiscard]] constexpr size_t LengthIndex(Length length)
{
  return static_cast<size_t>(length);
}
 
[[nodiscard]] constexpr bool IsUnsignedType(ValueKind type)
{
  switch (type)
  {
    case ValueKind::Unsigned:
    case ValueKind::Binary:
    case ValueKind::Octal:
    case ValueKind::HexLower:
    case ValueKind::HexUpper:
      return true;
    default:
      return false;
  }
}
 
[[nodiscard]] consteval SpecifierDescriptor LookupSpecifier(char token)
{
  for (const auto& descriptor : specifiers)
  {
    if (descriptor.token == token)
    {
      return descriptor;
    }
  }
 
  return {};
}
 
[[nodiscard]] constexpr bool TypeEnabled(FeatureGate gate, Length length)
{
  switch (gate)
  {
    case FeatureGate::Integer:
      return Config::enable_integer;
    case FeatureGate::IntegerBase8_16:
      return Config::enable_integer_base8_16;
    case FeatureGate::Pointer:
      return Config::enable_pointer;
    case FeatureGate::Text:
      return Config::enable_text;
    case FeatureGate::FloatFixed:
      return Config::enable_float_fixed &&
             (length != Length::LongDouble || Config::enable_float_long_double);
    case FeatureGate::FloatScientific:
      return Config::enable_float_scientific &&
             (length != Length::LongDouble || Config::enable_float_long_double);
    case FeatureGate::FloatGeneral:
      return Config::enable_float_general &&
             (length != Length::LongDouble || Config::enable_float_long_double);
  }
 
  return false;
}
 
[[nodiscard]] constexpr bool LengthAllowed(LengthPolicy policy, Length length)
{
  switch (policy)
  {
    case LengthPolicy::Integer:
      return length != Length::LongDouble;
    case LengthPolicy::NoneOnly:
      return length == Length::Default;
    case LengthPolicy::Float:
      return length == Length::Default || length == Length::LongDouble;
  }
 
  return false;
}
 
[[nodiscard]] constexpr FormatArgumentRule RuleFromTable(
    const std::array<FormatArgumentRule, length_rule_count>& rules, Length length)
{
  return rules[LengthIndex(length)];
}
 
[[nodiscard]] consteval bool RuleUses64BitStorage(FormatArgumentRule rule)
{
  switch (rule)
  {
    case FormatArgumentRule::SignedLong:
      return sizeof(long) > sizeof(int32_t);
    case FormatArgumentRule::SignedLongLong:
      return sizeof(long long) > sizeof(int32_t);
    case FormatArgumentRule::SignedIntMax:
      return sizeof(intmax_t) > sizeof(int32_t);
    case FormatArgumentRule::SignedSize:
      return sizeof(std::make_signed_t<size_t>) > sizeof(int32_t);
    case FormatArgumentRule::SignedPtrDiff:
      return sizeof(ptrdiff_t) > sizeof(int32_t);
    case FormatArgumentRule::UnsignedLong:
      return sizeof(unsigned long) > sizeof(uint32_t);
    case FormatArgumentRule::UnsignedLongLong:
      return sizeof(unsigned long long) > sizeof(uint32_t);
    case FormatArgumentRule::UnsignedIntMax:
      return sizeof(uintmax_t) > sizeof(uint32_t);
    case FormatArgumentRule::UnsignedSize:
      return sizeof(size_t) > sizeof(uint32_t);
    case FormatArgumentRule::UnsignedPtrDiff:
      return sizeof(std::make_unsigned_t<ptrdiff_t>) > sizeof(uint32_t);
    default:
      return false;
  }
}
 
[[nodiscard]] constexpr bool UsesDoubleFloatStorage()
{
  return Config::enable_float_double;
}
 
[[nodiscard]] consteval FormatType LowerType(const Conversion& conversion,
                                             FormatArgumentRule rule)
{
  if (conversion.length == Length::LongDouble)
  {
    if (conversion.type == ValueKind::FloatFixed)
    {
      return FormatType::LongDoubleFixed;
    }
    if (conversion.type == ValueKind::FloatScientific)
    {
      return FormatType::LongDoubleScientific;
    }
    if (conversion.type == ValueKind::FloatGeneral)
    {
      return FormatType::LongDoubleGeneral;
    }
  }
 
  if (conversion.type == ValueKind::Signed)
  {
    return RuleUses64BitStorage(rule) ? FormatType::Signed64 : FormatType::Signed32;
  }
  if (conversion.type == ValueKind::Unsigned)
  {
    return RuleUses64BitStorage(rule) ? FormatType::Unsigned64
                                      : FormatType::Unsigned32;
  }
  if (conversion.type == ValueKind::Binary)
  {
    return RuleUses64BitStorage(rule) ? FormatType::Binary64 : FormatType::Binary32;
  }
  if (conversion.type == ValueKind::Octal)
  {
    return RuleUses64BitStorage(rule) ? FormatType::Octal64 : FormatType::Octal32;
  }
  if (conversion.type == ValueKind::HexLower)
  {
    return RuleUses64BitStorage(rule) ? FormatType::HexLower64
                                      : FormatType::HexLower32;
  }
  if (conversion.type == ValueKind::HexUpper)
  {
    return RuleUses64BitStorage(rule) ? FormatType::HexUpper64
                                      : FormatType::HexUpper32;
  }
 
  switch (conversion.type)
  {
    case ValueKind::Pointer:
      return FormatType::Pointer;
    case ValueKind::Character:
      return FormatType::Character;
    case ValueKind::String:
      return FormatType::String;
    case ValueKind::FloatFixed:
      return UsesDoubleFloatStorage() ? FormatType::DoubleFixed
                                      : FormatType::FloatFixed;
    case ValueKind::FloatScientific:
      return UsesDoubleFloatStorage() ? FormatType::DoubleScientific
                                      : FormatType::FloatScientific;
    case ValueKind::FloatGeneral:
      return UsesDoubleFloatStorage() ? FormatType::DoubleGeneral
                                      : FormatType::FloatGeneral;
    case ValueKind::None:
    case ValueKind::Signed:
    case ValueKind::Unsigned:
    case ValueKind::Binary:
    case ValueKind::Octal:
    case ValueKind::HexLower:
    case ValueKind::HexUpper:
      return FormatType::End;
  }
 
  return FormatType::End;
}
 
[[nodiscard]] consteval FormatPackKind LowerPackKind(FormatType type)
{
  switch (type)
  {
    case FormatType::Signed32:
      return FormatPackKind::I32;
    case FormatType::Signed64:
      return FormatPackKind::I64;
    case FormatType::Unsigned32:
    case FormatType::Binary32:
    case FormatType::Octal32:
    case FormatType::HexLower32:
    case FormatType::HexUpper32:
      return FormatPackKind::U32;
    case FormatType::Unsigned64:
    case FormatType::Binary64:
    case FormatType::Octal64:
    case FormatType::HexLower64:
    case FormatType::HexUpper64:
      return FormatPackKind::U64;
    case FormatType::Pointer:
      return FormatPackKind::Pointer;
    case FormatType::Character:
      return FormatPackKind::Character;
    case FormatType::String:
      return FormatPackKind::StringView;
    case FormatType::FloatFixed:
    case FormatType::FloatScientific:
    case FormatType::FloatGeneral:
      return FormatPackKind::F32;
    case FormatType::DoubleFixed:
    case FormatType::DoubleScientific:
    case FormatType::DoubleGeneral:
      return FormatPackKind::F64;
    case FormatType::LongDoubleFixed:
    case FormatType::LongDoubleScientific:
    case FormatType::LongDoubleGeneral:
      return FormatPackKind::LongDouble;
    case FormatType::End:
    case FormatType::TextInline:
    case FormatType::TextRef:
    case FormatType::TextSpace:
      return FormatPackKind::U32;
  }
 
  return FormatPackKind::U32;
}
 
[[nodiscard]] consteval FormatArgumentRule LowerRule(const Conversion& conversion)
{
  if (conversion.type == ValueKind::Signed)
  {
    return RuleFromTable(signed_rules, conversion.length);
  }
 
  if (IsUnsignedType(conversion.type))
  {
    return RuleFromTable(unsigned_rules, conversion.length);
  }
 
  switch (conversion.type)
  {
    case ValueKind::Pointer:
      return FormatArgumentRule::Pointer;
    case ValueKind::Character:
      return FormatArgumentRule::Character;
    case ValueKind::String:
      return FormatArgumentRule::String;
    case ValueKind::FloatFixed:
    case ValueKind::FloatScientific:
    case ValueKind::FloatGeneral:
      return (conversion.length == Length::LongDouble)
                 ? FormatArgumentRule::LongDouble
                 : FormatArgumentRule::Float;
    case ValueKind::None:
    case ValueKind::Signed:
    case ValueKind::Unsigned:
    case ValueKind::Binary:
    case ValueKind::Octal:
    case ValueKind::HexLower:
    case ValueKind::HexUpper:
      break;
  }
 
  return FormatArgumentRule::None;
}
 
[[nodiscard]] consteval Error ValidateConversion(const Conversion& conversion)
{
  if ((conversion.type == ValueKind::Signed || IsUnsignedType(conversion.type)) &&
      RuleUses64BitStorage(LowerRule(conversion)) && !Config::enable_integer_64bit)
  {
    return Error::InvalidLength;
  }
 
  return Error::None;
}
 
[[nodiscard]] consteval FormatField LowerField(const Conversion& conversion)
{
  auto rule = LowerRule(conversion);
  auto type = LowerType(conversion, rule);
  return FormatField{
      .type = type,
      .pack = LowerPackKind(type),
      .rule = rule,
      .flags = conversion.FlagsByte(),
      .width = conversion.width,
      .precision = conversion.PrecisionByte(),
  };
}
}  // namespace Lowering
 
[[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;
}
 
[[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 = Lowering::LookupSpecifier(source[pos]);
  if (descriptor.type == ValueKind::None)
  {
    return Error::InvalidSpecifier;
  }
  if (!Lowering::LengthAllowed(descriptor.length_policy, conversion.length))
  {
    return Error::InvalidLength;
  }
  if (!Lowering::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 = Lowering::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;
}
 
[[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
  {
    struct AnalysisVisitor
    {
      SourceAnalysis<scratch.field_count, scratch.argument_count>& result;
 
      [[nodiscard]] consteval Error Text(size_t, size_t) const { return Error::None; }
 
      [[nodiscard]] consteval Error Field(const Conversion& conversion)
      {
        auto field = Lowering::LowerField(conversion);
        auto info = FormatArgumentInfo{
            .pack = field.pack,
            .rule = field.rule,
        };
        auto& slot = result.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;
      }
    };
 
    AnalysisVisitor visitor{result};
    result.error = WalkSource(std::string_view(Source.Data(), Source.Size()), visitor);
    return result;
  }
}
}  // namespace SourceSyntax
 
namespace Lowering = SourceSyntax::Lowering;
 
template <Text Source>
[[nodiscard]] consteval auto Analyze()
{
  return SourceSyntax::Analyze<Source>();
}
 
template <Text Source>
[[nodiscard]] consteval Error WalkAndLower(auto& visitor)
{
  struct LoweringVisitor
  {
    decltype(visitor)& inner;
 
    [[nodiscard]] consteval Error Text(size_t offset, size_t text_size)
    {
      return inner.Text(offset, text_size);
    }
 
    [[nodiscard]] consteval Error Field(const Conversion& conversion)
    {
      return inner.Field(Lowering::LowerField(conversion));
    }
  };
 
  LoweringVisitor lowering{visitor};
  return SourceSyntax::WalkSource(std::string_view(Source.Data(), Source.Size()),
                                  lowering);
}
}  // namespace LibXR::Print::Detail::PrintfCompile
 
namespace LibXR::Print
{
template <Text Source>
class Printf::Compiler
{
 public:
  using ErrorType = Printf::Error;
 
  [[nodiscard]] static constexpr const char* SourceData() { return Source.Data(); }
  [[nodiscard]] static constexpr size_t SourceSize() { return Source.Size(); }
 
  [[nodiscard]] static consteval ErrorType Walk(auto& visitor)
  {
    return Detail::PrintfCompile::WalkAndLower<Source>(visitor);
  }
};
}  // namespace LibXR::Print