format_compile.hpp

#pragma once
 
#include <array>
#include <bit>
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <limits>
 
#include "format_protocol.hpp"
#include "print_contract.hpp"
 
namespace LibXR::Print
{
template <typename Frontend>
class FormatCompiler
{
 private:
  static_assert(SourceFrontend<Frontend>,
                "LibXR::Print::FormatCompiler: frontend must expose ErrorType, "
                "SourceData(), and SourceSize()");
 
  using Error = typename Frontend::ErrorType;
 
  template <size_t BlobBytes, size_t ArgCount>
  struct ResultData
  {
    using CodeList =
        std::array<uint8_t, BlobBytes>;  
    using ArgumentListData =
        std::array<FormatArgumentInfo,
                   ArgCount>;  
 
    CodeList codes{};  
    ArgumentListData
        arg_info{};  
    FormatProfile profile =
        FormatProfile::None;  
    Error compile_error =
        Error::None;  
  };
 
  template <size_t BlobBytes, size_t ArgCount>
  using Result = ResultData<BlobBytes, ArgCount>;
 
  static constexpr size_t inline_text_limit = 2 * sizeof(size_t) - 1;
 
  // 基于原始源串给单遍构建器预留的保守上界：
  // - 普通文本最坏可膨胀为每字节 3 个码流字节（TextInline）
  // - 值记录最坏约为每字节 2 个码流字节（如 %x -> 4 字节）
  // - 因此 3 * SourceSize() + 1 足以覆盖临时记录流与最终结束标记。
  // Conservative single-pass scratch bounds derived from the original source:
  // - literal text can cost up to 3 code bytes per source byte (TextInline)
  // - value records cost at most 2 code bytes per source byte (%x -> 4 bytes)
  // - therefore 3 * SourceSize() + 1 safely covers the temporary record stream
  //   plus the final End marker.
  static constexpr size_t max_code_bytes = 3 * Frontend::SourceSize() + 1;
  static constexpr size_t max_text_pool_bytes = Frontend::SourceSize();
  static constexpr size_t max_arg_count = Frontend::SourceSize();
  static constexpr uint8_t unspecified_precision = std::numeric_limits<uint8_t>::max();
 
  static consteval void EmitByte(auto& data, size_t& out, uint8_t value)
  {
    data[out++] = value;
  }
 
  template <typename T>
  static consteval void EmitNative(auto& data, size_t& out, T value)
  {
    auto bytes = std::bit_cast<std::array<uint8_t, sizeof(T)>>(value);
    for (auto byte : bytes)
    {
      data[out++] = byte;
    }
  }
 
  template <typename T>
  [[nodiscard]] static consteval T ReadNative(const auto& data, size_t& pos)
  {
    std::array<uint8_t, sizeof(T)> bytes{};
    for (size_t i = 0; i < sizeof(T); ++i)
    {
      bytes[i] = data[pos++];
    }
    return std::bit_cast<T>(bytes);
  }
 
  [[nodiscard]] static consteval auto Failed(Error error)
  {
    Result<1, 0> result{};
    result.compile_error = error;
    return result;
  }
 
  [[nodiscard]] static consteval FormatProfile ProfileForOp(FormatOp op)
  {
    switch (op)
    {
      case FormatOp::U32Dec:
      case FormatOp::U32ZeroPadWidth:
      case FormatOp::I32Dec:
      case FormatOp::U32Binary:
      case FormatOp::U32Octal:
      case FormatOp::U32HexLower:
      case FormatOp::U32HexUpper:
        return FormatProfile::NarrowInt;
      case FormatOp::StringRaw:
      case FormatOp::CharacterRaw:
        return FormatProfile::TextArg;
      case FormatOp::GenericField:
        return FormatProfile::None;
      case FormatOp::TextInline:
      case FormatOp::TextRef:
      case FormatOp::TextSpace:
      case FormatOp::End:
        return FormatProfile::None;
    }
 
    return FormatProfile::None;
  }
 
  [[nodiscard]] static consteval FormatOp FastFieldOp(const FormatField& field)
  {
    const bool raw_integer_field = IsRawIntegerField(field);
    const bool raw_text_field = IsRawTextField(field);
 
    if (raw_integer_field && field.type == FormatType::Signed32 &&
        field.pack == FormatPackKind::I32)
    {
      return FormatOp::I32Dec;
    }
 
    if (field.type == FormatType::Unsigned32 && field.pack == FormatPackKind::U32 &&
        raw_integer_field)
    {
      return FormatOp::U32Dec;
    }
 
    if (raw_integer_field && field.type == FormatType::Binary32 &&
        field.pack == FormatPackKind::U32)
    {
      return FormatOp::U32Binary;
    }
 
    if (raw_integer_field && field.type == FormatType::Octal32 &&
        field.pack == FormatPackKind::U32)
    {
      return FormatOp::U32Octal;
    }
 
    if (raw_integer_field && field.type == FormatType::HexLower32 &&
        field.pack == FormatPackKind::U32)
    {
      return FormatOp::U32HexLower;
    }
 
    if (raw_integer_field && field.type == FormatType::HexUpper32 &&
        field.pack == FormatPackKind::U32)
    {
      return FormatOp::U32HexUpper;
    }
 
    if (raw_text_field && field.type == FormatType::Character &&
        field.pack == FormatPackKind::Character)
    {
      return FormatOp::CharacterRaw;
    }
 
    if (raw_text_field && field.type == FormatType::String &&
        field.pack == FormatPackKind::StringView)
    {
      return FormatOp::StringRaw;
    }
 
    if (field.type == FormatType::Unsigned32 && field.pack == FormatPackKind::U32 &&
        field.flags == static_cast<uint8_t>(FormatFlag::ZeroPad) && field.fill == ' ' &&
        field.width != 0 && field.precision == unspecified_precision)
    {
      return FormatOp::U32ZeroPadWidth;
    }
 
    return FormatOp::GenericField;
  }
 
  [[nodiscard]] static consteval bool IsRawIntegerField(const FormatField& field)
  {
    return field.flags == 0 && field.fill == ' ' && field.width == 0 &&
           field.precision == unspecified_precision;
  }
 
  [[nodiscard]] static consteval bool IsRawTextField(const FormatField& field)
  {
    return (field.flags == 0 ||
            field.flags == static_cast<uint8_t>(FormatFlag::LeftAlign)) &&
           field.fill == ' ' && field.width == 0 &&
           field.precision == unspecified_precision;
  }
 
  struct ScratchBuilder
  {
    std::array<uint8_t, max_code_bytes>
        code_scratch{};  
    std::array<uint8_t, max_text_pool_bytes>
        text_scratch{};  
    std::array<FormatArgumentInfo, max_arg_count>
        arg_scratch{};  
 
    size_t code_bytes =
        0;  
    size_t text_pool_bytes = 0;  
    size_t arg_count = 0;        
    FormatProfile profile = FormatProfile::None;  
    Error frontend_error = Error::None;  
 
    [[nodiscard]] consteval Error Text(size_t offset, size_t text_size)
    {
      if (text_size == 0)
      {
        return Error::None;
      }
 
      if (text_size == 1 && Frontend::SourceData()[offset] == ' ')
      {
        EmitByte(code_scratch, code_bytes, static_cast<uint8_t>(FormatOp::TextSpace));
        return Error::None;
      }
 
      if (text_size <= inline_text_limit)
      {
        EmitByte(code_scratch, code_bytes, static_cast<uint8_t>(FormatOp::TextInline));
        for (size_t i = 0; i < text_size; ++i)
        {
          EmitByte(code_scratch, code_bytes,
                   static_cast<uint8_t>(Frontend::SourceData()[offset + i]));
        }
        EmitByte(code_scratch, code_bytes, 0);
        return Error::None;
      }
 
      if (text_pool_bytes > std::numeric_limits<uint16_t>::max())
      {
        return Error::TextOffsetOverflow;
      }
      if (text_size > std::numeric_limits<uint16_t>::max())
      {
        return Error::TextSizeOverflow;
      }
 
      EmitByte(code_scratch, code_bytes, static_cast<uint8_t>(FormatOp::TextRef));
      EmitNative(code_scratch, code_bytes, static_cast<uint16_t>(text_pool_bytes));
      EmitNative(code_scratch, code_bytes, static_cast<uint16_t>(text_size));
 
      for (size_t i = 0; i < text_size; ++i)
      {
        text_scratch[text_pool_bytes++] =
            static_cast<uint8_t>(Frontend::SourceData()[offset + i]);
      }
 
      return Error::None;
    }
 
    [[nodiscard]] consteval Error Field(const FormatField& field)
    {
      auto op = FastFieldOp(field);
      EmitByte(code_scratch, code_bytes, static_cast<uint8_t>(op));
 
      switch (op)
      {
        case FormatOp::U32Dec:
        case FormatOp::I32Dec:
        case FormatOp::U32Binary:
        case FormatOp::U32Octal:
        case FormatOp::U32HexLower:
        case FormatOp::U32HexUpper:
        case FormatOp::StringRaw:
        case FormatOp::CharacterRaw:
          break;
        case FormatOp::U32ZeroPadWidth:
          EmitByte(code_scratch, code_bytes, field.width);
          break;
        case FormatOp::GenericField:
          EmitByte(code_scratch, code_bytes, static_cast<uint8_t>(field.type));
          EmitByte(code_scratch, code_bytes, field.flags);
          EmitByte(code_scratch, code_bytes, static_cast<uint8_t>(field.fill));
          EmitByte(code_scratch, code_bytes, field.width);
          EmitByte(code_scratch, code_bytes, field.precision);
          break;
        case FormatOp::TextInline:
        case FormatOp::TextRef:
        case FormatOp::TextSpace:
        case FormatOp::End:
          break;
      }
 
      profile |=
          op == FormatOp::GenericField ? GenericProfileFor(field.type) : ProfileForOp(op);
 
      arg_scratch[arg_count++] = FormatArgumentInfo{
          .pack = field.pack,
          .rule = field.rule,
      };
      return Error::None;
    }
 
    [[nodiscard]] constexpr size_t FinalCodeBytes() const { return code_bytes + 1; }
    [[nodiscard]] constexpr size_t FinalBlobBytes() const
    {
      return FinalCodeBytes() + text_pool_bytes;
    }
 
    template <size_t CodeBytes, size_t BlobBytes, size_t ArgCount>
    [[nodiscard]] consteval auto Finish() const
    {
      Result<BlobBytes, ArgCount> result{};
      result.profile = profile;
      size_t scratch_in = 0;
      size_t code_out = 0;
 
      while (scratch_in < code_bytes)
      {
        auto op = static_cast<FormatOp>(code_scratch[scratch_in++]);
        EmitByte(result.codes, code_out, static_cast<uint8_t>(op));
 
        if (op == FormatOp::TextInline)
        {
          while (true)
          {
            uint8_t byte = code_scratch[scratch_in++];
            EmitByte(result.codes, code_out, byte);
            if (byte == 0)
            {
              break;
            }
          }
          continue;
        }
 
        const size_t payload_bytes = FormatOpPayloadBytes(op);
        if (payload_bytes == 0)
        {
          continue;
        }
 
        if (op == FormatOp::TextRef)
        {
          auto relative_offset = ReadNative<uint16_t>(code_scratch, scratch_in);
          auto text_size = ReadNative<uint16_t>(code_scratch, scratch_in);
          size_t absolute_offset = CodeBytes + relative_offset;
          if (absolute_offset > std::numeric_limits<uint16_t>::max())
          {
            result.compile_error = Error::TextOffsetOverflow;
            return result;
          }
          EmitNative(result.codes, code_out, static_cast<uint16_t>(absolute_offset));
          EmitNative(result.codes, code_out, text_size);
          continue;
        }
 
        if (payload_bytes == 1)
        {
          EmitByte(result.codes, code_out, code_scratch[scratch_in++]);
          continue;
        }
 
        if (op == FormatOp::GenericField)
        {
          for (size_t i = 0; i < payload_bytes; ++i)
          {
            EmitByte(result.codes, code_out, code_scratch[scratch_in++]);
          }
        }
      }
 
      EmitByte(result.codes, code_out, static_cast<uint8_t>(FormatOp::End));
 
      for (size_t i = 0; i < text_pool_bytes; ++i)
      {
        result.codes[CodeBytes + i] = text_scratch[i];
      }
      for (size_t i = 0; i < ArgCount; ++i)
      {
        result.arg_info[i] = arg_scratch[i];
      }
 
      return result;
    }
  };
 
  static_assert(WalkableFrontend<Frontend, ScratchBuilder>,
                "LibXR::Print::FormatCompiler: frontend Walk(visitor) must accept "
                "the shared builder and return ErrorType");
 
 public:
  [[nodiscard]] static consteval auto Compile()
  {
    constexpr auto scratch = []() consteval
    {
      ScratchBuilder builder{};
      builder.frontend_error = Frontend::Walk(builder);
      return builder;
    }();
 
    if constexpr (scratch.frontend_error != Error::None)
    {
      return Failed(scratch.frontend_error);
    }
    else
    {
      return scratch.template Finish<scratch.FinalCodeBytes(), scratch.FinalBlobBytes(),
                                     scratch.arg_count>();
    }
  }
};
}  // namespace LibXR::Print