printf_frontend_binding_field.hpp

#pragma once
 
namespace SourceSyntax
{
namespace FieldSelection
{
[[nodiscard]] consteval FormatType SelectFormatType(const Conversion& conversion,
                                                    FormatArgumentRule rule)
{
  if (conversion.length == Length::LongDouble)
  {
    if (conversion.type == ValueKind::FloatFixed)
    {
      return FormatType::LongDoubleFixed;
    }
    if (conversion.type == ValueKind::FloatScientific)
    {
      return FormatType::LongDoubleScientific;
    }
    if (conversion.type == ValueKind::FloatGeneral)
    {
      return FormatType::LongDoubleGeneral;
    }
  }
 
  if (conversion.type == ValueKind::Signed)
  {
    return RuleUses64BitStorage(rule) ? FormatType::Signed64 : FormatType::Signed32;
  }
  if (conversion.type == ValueKind::Unsigned)
  {
    return RuleUses64BitStorage(rule) ? FormatType::Unsigned64 : FormatType::Unsigned32;
  }
  if (conversion.type == ValueKind::Binary)
  {
    return RuleUses64BitStorage(rule) ? FormatType::Binary64 : FormatType::Binary32;
  }
  if (conversion.type == ValueKind::Octal)
  {
    return RuleUses64BitStorage(rule) ? FormatType::Octal64 : FormatType::Octal32;
  }
  if (conversion.type == ValueKind::HexLower)
  {
    return RuleUses64BitStorage(rule) ? FormatType::HexLower64 : FormatType::HexLower32;
  }
  if (conversion.type == ValueKind::HexUpper)
  {
    return RuleUses64BitStorage(rule) ? FormatType::HexUpper64 : FormatType::HexUpper32;
  }
 
  switch (conversion.type)
  {
    case ValueKind::Pointer:
      return FormatType::Pointer;
    case ValueKind::Character:
      return FormatType::Character;
    case ValueKind::String:
      return FormatType::String;
    case ValueKind::FloatFixed:
      return UsesDoubleFloatStorage() ? FormatType::DoubleFixed : FormatType::FloatFixed;
    case ValueKind::FloatScientific:
      return UsesDoubleFloatStorage() ? FormatType::DoubleScientific
                                      : FormatType::FloatScientific;
    case ValueKind::FloatGeneral:
      return UsesDoubleFloatStorage() ? FormatType::DoubleGeneral
                                      : FormatType::FloatGeneral;
    case ValueKind::None:
    case ValueKind::Signed:
    case ValueKind::Unsigned:
    case ValueKind::Binary:
    case ValueKind::Octal:
    case ValueKind::HexLower:
    case ValueKind::HexUpper:
      return FormatType::End;
  }
 
  return FormatType::End;
}
 
[[nodiscard]] consteval FormatPackKind SelectPackKind(FormatType type)
{
  switch (type)
  {
    case FormatType::Signed32:
      return FormatPackKind::I32;
    case FormatType::Signed64:
      return FormatPackKind::I64;
    case FormatType::Unsigned32:
    case FormatType::Binary32:
    case FormatType::Octal32:
    case FormatType::HexLower32:
    case FormatType::HexUpper32:
      return FormatPackKind::U32;
    case FormatType::Unsigned64:
    case FormatType::Binary64:
    case FormatType::Octal64:
    case FormatType::HexLower64:
    case FormatType::HexUpper64:
      return FormatPackKind::U64;
    case FormatType::Pointer:
      return FormatPackKind::Pointer;
    case FormatType::Character:
      return FormatPackKind::Character;
    case FormatType::String:
      return FormatPackKind::StringView;
    case FormatType::FloatFixed:
    case FormatType::FloatScientific:
    case FormatType::FloatGeneral:
      return FormatPackKind::F32;
    case FormatType::DoubleFixed:
    case FormatType::DoubleScientific:
    case FormatType::DoubleGeneral:
      return FormatPackKind::F64;
    case FormatType::LongDoubleFixed:
    case FormatType::LongDoubleScientific:
    case FormatType::LongDoubleGeneral:
      return FormatPackKind::LongDouble;
    case FormatType::End:
    case FormatType::TextInline:
    case FormatType::TextRef:
    case FormatType::TextSpace:
      ASSERT(false);
      return FormatPackKind::U32;
  }
 
  ASSERT(false);
  return FormatPackKind::U32;
}
 
[[nodiscard]] consteval FormatArgumentRule SelectArgumentRule(
    const Conversion& conversion)
{
  if (conversion.type == ValueKind::Signed)
  {
    return RuleFromTable(signed_rules, conversion.length);
  }
 
  if (IsUnsignedType(conversion.type))
  {
    return RuleFromTable(unsigned_rules, conversion.length);
  }
 
  switch (conversion.type)
  {
    case ValueKind::Pointer:
      return FormatArgumentRule::Pointer;
    case ValueKind::Character:
      return FormatArgumentRule::Character;
    case ValueKind::String:
      return FormatArgumentRule::String;
    case ValueKind::FloatFixed:
    case ValueKind::FloatScientific:
    case ValueKind::FloatGeneral:
      return (conversion.length == Length::LongDouble) ? FormatArgumentRule::LongDouble
                                                       : FormatArgumentRule::Float;
    case ValueKind::None:
    case ValueKind::Signed:
    case ValueKind::Unsigned:
    case ValueKind::Binary:
    case ValueKind::Octal:
    case ValueKind::HexLower:
    case ValueKind::HexUpper:
      break;
  }
 
  return FormatArgumentRule::None;
}
 
[[nodiscard]] consteval Error ValidateConversion(const Conversion& conversion)
{
  if ((conversion.type == ValueKind::FloatFixed ||
       conversion.type == ValueKind::FloatScientific ||
       conversion.type == ValueKind::FloatGeneral) &&
      conversion.has_precision && conversion.precision > Config::max_float_precision)
  {
    return Error::FloatPrecisionLimitExceeded;
  }
 
  if ((conversion.type == ValueKind::Signed || IsUnsignedType(conversion.type)) &&
      RuleUses64BitStorage(SelectArgumentRule(conversion)) &&
      !Config::enable_integer_64bit)
  {
    return Error::InvalidLength;
  }
 
  return Error::None;
}
 
[[nodiscard]] consteval FormatField BuildFormatField(const Conversion& conversion)
{
  auto rule = SelectArgumentRule(conversion);
  auto type = SelectFormatType(conversion, rule);
  return FormatField{
      .type = type,
      .pack = SelectPackKind(type),
      .rule = rule,
      .flags = conversion.FlagsByte(),
      .width = conversion.width,
      .precision = conversion.PrecisionByte(),
  };
}
}  // namespace FieldSelection
}  // namespace SourceSyntax