format_protocol.hpp

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <limits>
#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_FLOAT_MAX_PRECISION
#define LIBXR_PRINT_FLOAT_MAX_PRECISION 32
#endif
 
#ifndef LIBXR_PRINT_FLOAT_MAX_INTEGER_DIGITS
#define LIBXR_PRINT_FLOAT_MAX_INTEGER_DIGITS 32
#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;
static_assert(LIBXR_PRINT_FLOAT_MAX_PRECISION <=
                  static_cast<int>(std::numeric_limits<uint8_t>::max() - 1),
              "LibXR::Print: LIBXR_PRINT_FLOAT_MAX_PRECISION must fit in uint8_t "
              "and stay below the unspecified-precision sentinel");
static_assert(LIBXR_PRINT_FLOAT_MAX_INTEGER_DIGITS > 0,
              "LibXR::Print: LIBXR_PRINT_FLOAT_MAX_INTEGER_DIGITS must be positive");
inline constexpr uint8_t max_float_precision =
    static_cast<uint8_t>(LIBXR_PRINT_FLOAT_MAX_PRECISION);
inline constexpr size_t max_float_integer_digits =
    static_cast<size_t>(LIBXR_PRINT_FLOAT_MAX_INTEGER_DIGITS);
 
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,  
  I32Dec = 0x12,           
  U32Binary = 0x13,        
  U32Octal = 0x14,         
  U32HexLower =
      0x15,  
  U32HexUpper =
      0x16,  
  StringRaw = 0x20,     
  CharacterRaw = 0x21,  
  GenericField = 0xF0,  
  End = 0xFF,           
};
 
[[nodiscard]] constexpr size_t FormatOpPayloadBytes(FormatOp op)
{
  switch (op)
  {
    case FormatOp::TextInline:
      return 0;
    case FormatOp::TextRef:
      return 2 * sizeof(uint16_t);
    case FormatOp::U32ZeroPadWidth:
      return 1;
    case FormatOp::GenericField:
      return 5;
    case FormatOp::TextSpace:
    case FormatOp::U32Dec:
    case FormatOp::I32Dec:
    case FormatOp::U32Binary:
    case FormatOp::U32Octal:
    case FormatOp::U32HexLower:
    case FormatOp::U32HexUpper:
    case FormatOp::StringRaw:
    case FormatOp::CharacterRaw:
    case FormatOp::End:
      return 0;
  }
 
  // Unreachable for valid streams: every FormatOp value is enumerated above.
  // A corrupt/unknown opcode falls through here and yields 0 payload bytes.
  return 0;
}
 
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 : uint32_t
{
  None = 0,             
  NarrowInt = 1U << 0,  
  TextArg = 1U << 1,    
  GenericSigned32 = 1U << 2,  
  GenericSigned64 = 1U << 3,  
  GenericUnsigned32 =
      1U << 4,  
  GenericUnsigned64 =
      1U << 5,  
  GenericBinary32 = 1U << 6,  
  GenericBinary64 = 1U << 7,  
  GenericOctal32 = 1U << 8,   
  GenericOctal64 = 1U << 9,   
  GenericHexLower32 =
      1U << 10,  
  GenericHexLower64 =
      1U << 11,  
  GenericHexUpper32 =
      1U << 12,  
  GenericHexUpper64 =
      1U << 13,                 
  GenericPointer = 1U << 14,    
  GenericCharacter = 1U << 15,  
  GenericString = 1U << 16,     
  GenericFloatFixed = 1U << 17,  
  GenericFloatScientific =
      1U << 18,                    
  GenericFloatGeneral = 1U << 19,  
  GenericDoubleFixed = 1U << 20,   
  GenericDoubleScientific =
      1U << 21,  
  GenericDoubleGeneral = 1U << 22,  
  GenericLongDoubleFixed =
      1U << 23,  
  GenericLongDoubleScientific =
      1U << 24,  
  GenericLongDoubleGeneral =
      1U << 25,           
  Generic = 0x03FFFFFCU,  
};
 
[[nodiscard]] constexpr FormatProfile operator|(FormatProfile left, FormatProfile right)
{
  return static_cast<FormatProfile>(static_cast<uint32_t>(left) |
                                    static_cast<uint32_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<uint32_t>(profile) & static_cast<uint32_t>(bit)) != 0;
}
 
[[nodiscard]] constexpr FormatProfile GenericProfileFor(FormatType type)
{
  auto value = static_cast<uint8_t>(type);
  auto first = static_cast<uint8_t>(FormatType::Signed32);
  auto last = static_cast<uint8_t>(FormatType::LongDoubleGeneral);
  if (value < first || value > last)
  {
    return FormatProfile::None;
  }
  return static_cast<FormatProfile>(uint32_t{1} << (2U + value - first));
}
 
static_assert(GenericProfileFor(FormatType::Signed32) == FormatProfile::GenericSigned32);
static_assert(GenericProfileFor(FormatType::LongDoubleGeneral) ==
              FormatProfile::GenericLongDoubleGeneral);
static_assert(GenericProfileFor(FormatType::TextSpace) == FormatProfile::None);
static_assert(static_cast<uint32_t>(FormatProfile::Generic) ==
              ((uint32_t{1} << 26U) - (uint32_t{1} << 2U)));
 
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