printf_frontend_binding_base.hpp

#pragma once
 
namespace SourceSyntax
{
namespace FieldSelection
{
 
[[nodiscard]] constexpr size_t LengthIndex(Length length)
{
  return static_cast<size_t>(length);
}
 
[[nodiscard]] constexpr bool IsUnsignedType(ValueKind type)
{
  switch (type)
  {
    case ValueKind::Unsigned:
    case ValueKind::Binary:
    case ValueKind::Octal:
    case ValueKind::HexLower:
    case ValueKind::HexUpper:
      return true;
    default:
      return false;
  }
}
 
[[nodiscard]] consteval SpecifierDescriptor LookupSpecifier(char token)
{
  for (const auto& descriptor : specifiers)
  {
    if (descriptor.token == token)
    {
      return descriptor;
    }
  }
 
  return {};
}
 
[[nodiscard]] constexpr bool TypeEnabled(FeatureGate gate, Length length)
{
  switch (gate)
  {
    case FeatureGate::Integer:
      return Config::enable_integer;
    case FeatureGate::IntegerBase8_16:
      return Config::enable_integer_base8_16;
    case FeatureGate::Pointer:
      return Config::enable_pointer;
    case FeatureGate::Text:
      return Config::enable_text;
    case FeatureGate::FloatFixed:
      return Config::enable_float_fixed &&
             (length != Length::LongDouble || Config::enable_float_long_double);
    case FeatureGate::FloatScientific:
      return Config::enable_float_scientific &&
             (length != Length::LongDouble || Config::enable_float_long_double);
    case FeatureGate::FloatGeneral:
      return Config::enable_float_general &&
             (length != Length::LongDouble || Config::enable_float_long_double);
  }
 
  return false;
}
 
[[nodiscard]] constexpr bool LengthAllowed(LengthPolicy policy, Length length)
{
  switch (policy)
  {
    case LengthPolicy::Integer:
      return length != Length::LongDouble;
    case LengthPolicy::NoneOnly:
      return length == Length::Default;
    case LengthPolicy::Float:
      return length == Length::Default || length == Length::LongDouble;
  }
 
  return false;
}
 
[[nodiscard]] constexpr FormatArgumentRule RuleFromTable(
    const std::array<FormatArgumentRule, length_rule_count>& rules, Length length)
{
  return rules[LengthIndex(length)];
}
 
[[nodiscard]] consteval bool RuleUses64BitStorage(FormatArgumentRule rule)
{
  switch (rule)
  {
    case FormatArgumentRule::SignedLong:
      return sizeof(long) > sizeof(int32_t);
    case FormatArgumentRule::SignedLongLong:
      return sizeof(long long) > sizeof(int32_t);
    case FormatArgumentRule::SignedIntMax:
      return sizeof(intmax_t) > sizeof(int32_t);
    case FormatArgumentRule::SignedSize:
      return sizeof(std::make_signed_t<size_t>) > sizeof(int32_t);
    case FormatArgumentRule::SignedPtrDiff:
      return sizeof(ptrdiff_t) > sizeof(int32_t);
    case FormatArgumentRule::UnsignedLong:
      return sizeof(unsigned long) > sizeof(uint32_t);
    case FormatArgumentRule::UnsignedLongLong:
      return sizeof(unsigned long long) > sizeof(uint32_t);
    case FormatArgumentRule::UnsignedIntMax:
      return sizeof(uintmax_t) > sizeof(uint32_t);
    case FormatArgumentRule::UnsignedSize:
      return sizeof(size_t) > sizeof(uint32_t);
    case FormatArgumentRule::UnsignedPtrDiff:
      return sizeof(std::make_unsigned_t<ptrdiff_t>) > sizeof(uint32_t);
    default:
      return false;
  }
}
 
[[nodiscard]] constexpr bool UsesDoubleFloatStorage()
{
  return Config::enable_float_double;
}
}  // namespace FieldSelection
}  // namespace SourceSyntax