printf.hpp

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <type_traits>
 
#include "format_argument.hpp"
 
namespace LibXR::Print
{
template <size_t N>
struct Text
{
  char data[N]{};
 
  constexpr Text(const char (&text)[N])
  {
    for (size_t i = 0; i < N; ++i)
    {
      data[i] = text[i];
    }
  }
 
  [[nodiscard]] constexpr size_t Size() const { return N - 1; }
  [[nodiscard]] constexpr const char* Data() const { return data; }
};
 
class Printf
{
 public:
  enum class Length : uint8_t
  {
    Default,     
    Char,        
    Short,       
    Long,        
    LongLong,    
    IntMax,      
    Size,        
    PtrDiff,     
    LongDouble,  
  };
 
  enum class Error : uint8_t
  {
    None,                
    NumberOverflow,      
    UnexpectedEnd,       
    EmbeddedNul,         
    MixedIndexing,       
    PositionalArgumentDisabled,  
    DynamicField,        
    InvalidArgumentIndex,  
    InvalidSpecifier,    
    InvalidLength,       
    ConflictingArgument,  
    TextOffsetOverflow,  
    TextSizeOverflow,    
  };
 
  template <Text Source>
  class Compiler;
 
  template <Text Source>
  struct Compiled;
 
  template <Text Source>
  [[nodiscard]] static consteval Compiled<Source> Build()
  {
    return {};
  }
 
  template <Text Source, typename... Args>
  [[nodiscard]] static consteval bool Matches()
  {
    return Compiled<Source>::template Matches<Args...>();
  }
};
}  // namespace LibXR::Print
 
#include "printf_frontend_detail.hpp"
namespace LibXR::Print
{
template <Text Source>
struct Printf::Compiled
{
 private:
  using Frontend = typename Printf::template Compiler<Source>;
  inline static constexpr auto source_analysis = Detail::PrintfCompile::Analyze<Source>();
  inline static constexpr auto result = FormatCompiler<Frontend>::Compile();
 
  static_assert(result.compile_error != Printf::Error::NumberOverflow,
                "LibXR::Print::Printf: numeric field is too large");
  static_assert(result.compile_error != Printf::Error::UnexpectedEnd,
                "LibXR::Print::Printf: unexpected end of format string");
  static_assert(result.compile_error != Printf::Error::EmbeddedNul,
                "LibXR::Print::Printf: embedded NUL bytes are not supported in the format literal");
  static_assert(result.compile_error != Printf::Error::MixedIndexing,
                "LibXR::Print::Printf: positional and sequential arguments cannot be mixed");
  static_assert(result.compile_error != Printf::Error::PositionalArgumentDisabled,
                "LibXR::Print::Printf: positional argument indexing is disabled in the current profile");
  static_assert(result.compile_error != Printf::Error::DynamicField,
                "LibXR::Print::Printf: dynamic width and precision are not supported");
  static_assert(result.compile_error != Printf::Error::InvalidArgumentIndex,
                "LibXR::Print::Printf: invalid positional argument index");
  static_assert(result.compile_error != Printf::Error::InvalidSpecifier,
                "LibXR::Print::Printf: invalid format specifier");
  static_assert(result.compile_error != Printf::Error::InvalidLength,
                "LibXR::Print::Printf: invalid length modifier");
  static_assert(result.compile_error != Printf::Error::ConflictingArgument,
                "LibXR::Print::Printf: one positional argument is reused with incompatible conversions");
  static_assert(result.compile_error != Printf::Error::TextOffsetOverflow,
                "LibXR::Print::Printf: text pool offset is too large");
  static_assert(result.compile_error != Printf::Error::TextSizeOverflow,
                "LibXR::Print::Printf: text span is too large");
  static_assert(source_analysis.error != Printf::Error::ConflictingArgument,
                "LibXR::Print::Printf: one positional argument is reused with incompatible conversions");
 
 public:
  inline static constexpr auto codes = result.codes;
  inline static constexpr FormatProfile profile = result.profile;
 
  [[nodiscard]] static constexpr auto ArgumentList()
  {
    return result.arg_info;
  }
 
  [[nodiscard]] static constexpr auto ArgumentOrder()
  {
    return source_analysis.order;
  }
 
  [[nodiscard]] static constexpr auto SourceArgumentList()
  {
    return source_analysis.args;
  }
 
  [[nodiscard]] static constexpr const auto& Codes()
  {
    return codes;
  }
 
  [[nodiscard]] static constexpr FormatProfile Profile()
  {
    return profile;
  }
 
  template <typename... Args>
  [[nodiscard]] static consteval bool Matches()
  {
    return Detail::FormatArgument::template Matches<Args...>(SourceArgumentList());
  }
};
}  // namespace LibXR::Print