printf_frontend_spec.hpp

#pragma once
 
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},
}};