format_frontend_detail.hpp

#pragma once
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <string_view>
#include <type_traits>
 
#include "../format_argument.hpp"
#include "../format_compile.hpp"
#include "../printf.hpp"
 
namespace LibXR::Print::Detail::FormatFrontend
{
enum class Error : uint8_t
{
  None,            
  NumberOverflow,  
  FloatPrecisionLimitExceeded,  
  UnexpectedEnd,   
  EmbeddedNul,     
  UnmatchedBrace,  
  MixedIndexing,  
  ManualIndexingDisabled,  
  DynamicField,            
  InvalidArgumentIndex,    
  InvalidSpecifier,        
  InvalidPresentation,     
  MissingArgument,         
  ArgumentTypeMismatch,    
  UnsupportedArgumentType,  
  TextOffsetOverflow,       
  TextSizeOverflow,         
};
 
enum class Align : uint8_t
{
  None,    
  Left,    
  Right,   
  Center,  
};
 
struct ParsedField
{
  size_t arg_index = 0;       
  Align align = Align::None;  
  char fill = ' ';            
  bool force_sign = false;    
  bool space_sign = false;    
  bool alternate = false;     
  bool zero_pad = false;      
  uint8_t width = 0;          
  bool has_precision =
      false;  
  uint8_t precision = 0;  
  char presentation =
      0;  
};
 
enum class ArgumentKind : uint8_t
{
  Unsupported,  
  Bool,         
  Character,    
  Signed,       
  Unsigned,     
  String,       
  Pointer,      
  Float32,      
  Float64,      
  LongDouble,   
};
 
struct ArgumentSummary
{
  ArgumentKind kind =
      ArgumentKind::Unsupported;  
  bool uses_64bit_storage =
      false;  
};
 
struct ResolvedField
{
  Error error = Error::None;  
  FormatField field{};        
};
 
// These implementation headers form an ordered dependency chain.
// clang-format off
#include "format_frontend_source.hpp"
 
#include "format_frontend_binding_base.hpp"
#include "format_frontend_binding_integer.hpp"
#include "format_frontend_binding_float.hpp"
// clang-format on
 
template <Text Source>
[[nodiscard]] consteval auto Analyze()
{
  return SourceSyntax::Analyze<Source>();
}
 
template <Text Source, typename... Args>
[[nodiscard]] consteval Error WalkSourceAsFormatFields(auto& visitor)
{
  struct ResolvingVisitor
  {
    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 ParsedField& parsed)
    {
      auto resolved = ArgumentResolution::ResolveField<Args...>(parsed);
      if (resolved.error != Error::None)
      {
        return resolved.error;
      }
      return inner.Field(resolved.field);
    }
  };
 
  ResolvingVisitor resolving{visitor};
  return SourceSyntax::WalkSource(std::string_view(Source.Data(), Source.Size()),
                                  resolving);
}
 
template <Text Source, typename... Args>
class Compiler
{
 public:
  using ErrorType = 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 WalkSourceAsFormatFields<Source, Args...>(visitor);
  }
};
}  // namespace LibXR::Print::Detail::FormatFrontend