format_protocol.hpp

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <string_view>
#include <type_traits>
 
#ifndef LIBXR_PRINT_ENABLE_INTEGER
#define LIBXR_PRINT_ENABLE_INTEGER 1
#endif
 
#ifndef LIBXR_PRINT_ENABLE_TEXT
#define LIBXR_PRINT_ENABLE_TEXT 1
#endif
 
#ifndef LIBXR_PRINT_ENABLE_POINTER
#define LIBXR_PRINT_ENABLE_POINTER 0
#endif
 
#ifndef LIBXR_PRINT_ENABLE_FLOAT
#define LIBXR_PRINT_ENABLE_FLOAT 1
#endif
 
#ifndef LIBXR_PRINT_INTEGER_ENABLE_BASE8_16
#define LIBXR_PRINT_INTEGER_ENABLE_BASE8_16 1
#endif
 
#ifndef LIBXR_PRINT_INTEGER_ENABLE_64BIT
#define LIBXR_PRINT_INTEGER_ENABLE_64BIT 0
#endif
 
#ifndef LIBXR_PRINT_FLOAT_ENABLE_FIXED
#define LIBXR_PRINT_FLOAT_ENABLE_FIXED 1
#endif
 
#ifndef LIBXR_PRINT_FLOAT_ENABLE_DOUBLE
#define LIBXR_PRINT_FLOAT_ENABLE_DOUBLE 0
#endif
 
#ifndef LIBXR_PRINT_FLOAT_ENABLE_SCIENTIFIC
#define LIBXR_PRINT_FLOAT_ENABLE_SCIENTIFIC 0
#endif
 
#ifndef LIBXR_PRINT_FLOAT_ENABLE_GENERAL
#define LIBXR_PRINT_FLOAT_ENABLE_GENERAL 0
#endif
 
#ifndef LIBXR_PRINT_FLOAT_ENABLE_LONG_DOUBLE
#define LIBXR_PRINT_FLOAT_ENABLE_LONG_DOUBLE 0
#endif
 
#ifndef LIBXR_PRINT_ENABLE_WIDTH
#define LIBXR_PRINT_ENABLE_WIDTH 1
#endif
 
#ifndef LIBXR_PRINT_ENABLE_PRECISION
#define LIBXR_PRINT_ENABLE_PRECISION 1
#endif
 
#ifndef LIBXR_PRINT_ENABLE_ALTERNATE
#define LIBXR_PRINT_ENABLE_ALTERNATE 0
#endif
 
#ifndef LIBXR_PRINT_ENABLE_EXPLICIT_ARGUMENT_INDEXING
#define LIBXR_PRINT_ENABLE_EXPLICIT_ARGUMENT_INDEXING 0
#endif
 
namespace LibXR::Print::Config
{
inline constexpr bool enable_integer = LIBXR_PRINT_ENABLE_INTEGER;
inline constexpr bool enable_text = LIBXR_PRINT_ENABLE_TEXT;
inline constexpr bool enable_pointer = LIBXR_PRINT_ENABLE_POINTER;
inline constexpr bool enable_float = LIBXR_PRINT_ENABLE_FLOAT;
 
inline constexpr bool enable_integer_base8_16 =
    enable_integer && LIBXR_PRINT_INTEGER_ENABLE_BASE8_16;
inline constexpr bool enable_integer_64bit =
    enable_integer && LIBXR_PRINT_INTEGER_ENABLE_64BIT;
 
inline constexpr bool enable_float_fixed =
    enable_float && LIBXR_PRINT_FLOAT_ENABLE_FIXED;
inline constexpr bool enable_float_double =
    enable_float && LIBXR_PRINT_FLOAT_ENABLE_DOUBLE;
inline constexpr bool enable_float_scientific =
    enable_float && LIBXR_PRINT_FLOAT_ENABLE_SCIENTIFIC;
inline constexpr bool enable_float_general =
    enable_float && LIBXR_PRINT_FLOAT_ENABLE_GENERAL;
inline constexpr bool enable_float_long_double =
    enable_float_double && LIBXR_PRINT_FLOAT_ENABLE_LONG_DOUBLE;
 
inline constexpr bool enable_width = LIBXR_PRINT_ENABLE_WIDTH;
inline constexpr bool enable_precision = LIBXR_PRINT_ENABLE_PRECISION;
inline constexpr bool enable_alternate = LIBXR_PRINT_ENABLE_ALTERNATE;
inline constexpr bool enable_explicit_argument_indexing =
    LIBXR_PRINT_ENABLE_EXPLICIT_ARGUMENT_INDEXING;
}  // namespace LibXR::Print::Config
 
namespace LibXR::Print
{
enum class FormatArgumentRule : uint8_t
{
  None,              
  SignedAny,         
  SignedChar,        
  SignedShort,       
  SignedLong,        
  SignedLongLong,    
  SignedIntMax,      
  SignedSize,        
  SignedPtrDiff,     
  UnsignedAny,       
  UnsignedChar,      
  UnsignedShort,     
  UnsignedLong,      
  UnsignedLongLong,  
  UnsignedIntMax,    
  UnsignedSize,      
  UnsignedPtrDiff,   
  Pointer,           
  Character,         
  String,            
  Float,             
  LongDouble,        
};
 
enum class FormatFlag : uint8_t
{
  LeftAlign = 1U << 0,  
  ForceSign = 1U << 1,  
  SpaceSign = 1U << 2,  
  Alternate = 1U << 3,  
  ZeroPad = 1U << 4,    
  UpperCase = 1U << 5,  
  CenterAlign = 1U << 6,  
};
 
enum class FormatOp : uint8_t
{
  TextInline = 0x01,       
  TextRef = 0x02,          
  TextSpace = 0x03,        
  U32Dec = 0x10,           
  U32ZeroPadWidth = 0x11,  
  StringRaw = 0x20,        
  F32FixedPrec = 0x30,     
  F64FixedPrec = 0x31,     
  GenericField = 0xF0,     
  End = 0xFF,              
};
 
enum class FormatType : uint8_t
{
  End,                   
  TextInline,            
  TextRef,               
  TextSpace,             
  Signed32,              
  Signed64,              
  Unsigned32,            
  Unsigned64,            
  Binary32,              
  Binary64,              
  Octal32,               
  Octal64,               
  HexLower32,            
  HexLower64,            
  HexUpper32,            
  HexUpper64,            
  Pointer,               
  Character,             
  String,                
  FloatFixed,            
  FloatScientific,       
  FloatGeneral,          
  DoubleFixed,           
  DoubleScientific,      
  DoubleGeneral,         
  LongDoubleFixed,       
  LongDoubleScientific,  
  LongDoubleGeneral,     
};
 
enum class FormatPackKind : uint8_t
{
  U32,         
  U64,         
  I32,         
  I64,         
  Pointer,     
  Character,   
  StringView,  
  F32,         
  F64,         
  LongDouble,  
};
 
enum class FormatProfile : uint8_t
{
  None = 0,            
  U32 = 1U << 0,       
  TextArg = 1U << 1,   
  F32Fixed = 1U << 2,  
  F64Fixed = 1U << 3,  
  Generic = 1U << 7,   
};
 
[[nodiscard]] constexpr FormatProfile operator|(FormatProfile left, FormatProfile right)
{
  return static_cast<FormatProfile>(static_cast<uint8_t>(left) |
                                    static_cast<uint8_t>(right));
}
 
constexpr FormatProfile& operator|=(FormatProfile& left, FormatProfile right)
{
  left = left | right;
  return left;
}
 
[[nodiscard]] constexpr bool HasProfile(FormatProfile profile, FormatProfile bit)
{
  return (static_cast<uint8_t>(profile) & static_cast<uint8_t>(bit)) != 0;
}
 
struct FormatArgumentInfo
{
  FormatPackKind pack{};  
  FormatArgumentRule rule =
      FormatArgumentRule::None;  
};
static_assert(sizeof(FormatArgumentInfo) == 2,
              "LibXR::Print::FormatArgumentInfo must stay tightly packed");
 
struct FormatField
{
  FormatType type = FormatType::End;  
  FormatPackKind pack{};              
  FormatArgumentRule rule =
      FormatArgumentRule::None;  
  uint8_t flags = 0;             
  char fill = ' ';               
  uint8_t width = 0;             
  uint8_t precision = 0xFF;      
};
 
[[nodiscard]] constexpr size_t FormatArgumentBytes(FormatPackKind pack)
{
  switch (pack)
  {
    case FormatPackKind::I32:
      return sizeof(int32_t);
    case FormatPackKind::I64:
      return sizeof(int64_t);
    case FormatPackKind::U32:
      return sizeof(uint32_t);
    case FormatPackKind::U64:
      return sizeof(uint64_t);
    case FormatPackKind::Pointer:
      return sizeof(uintptr_t);
    case FormatPackKind::Character:
      return sizeof(char);
    case FormatPackKind::StringView:
      return sizeof(std::string_view);
    case FormatPackKind::F32:
      return sizeof(float);
    case FormatPackKind::F64:
      return sizeof(double);
    case FormatPackKind::LongDouble:
      return sizeof(long double);
  }
 
  return 0;
}
 
}  // namespace LibXR::Print