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,               
    FloatPrecisionLimitExceeded,  
    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/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::FloatPrecisionLimitExceeded,
      "LibXR::Print::Printf: float precision exceeds the configured print limit");
  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