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},
}};