format_frontend_binding_float.hpp

#pragma once
 
namespace ArgumentResolution
{
 
[[nodiscard]] consteval ResolvedField ResolveFloatField(const ParsedField& parsed,
                                                        ArgumentKind kind)
{
  if (parsed.has_precision && parsed.precision > Config::max_float_precision)
  {
    return ResolvedField{.error = Error::FloatPrecisionLimitExceeded};
  }
 
  char presentation =
      parsed.presentation == 0 ? DefaultFloatPresentation() : parsed.presentation;
  if (presentation == 0)
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
  bool upper_case =
      presentation == 'F' || presentation == 'E' || presentation == 'G';
 
  FormatType type = FormatType::End;
  FormatPackKind pack = FormatPackKind::F32;
 
  auto pick_type = [&](FormatType f32_type, FormatType f64_type,
                       FormatType ld_type) consteval -> bool {
    switch (kind)
    {
      case ArgumentKind::Float32:
        type = f32_type;
        pack = FormatPackKind::F32;
        return true;
      case ArgumentKind::Float64:
        type = Config::enable_float_double ? f64_type : f32_type;
        pack = Config::enable_float_double ? FormatPackKind::F64 : FormatPackKind::F32;
        return true;
      case ArgumentKind::LongDouble:
        if (!Config::enable_float_long_double)
        {
          return false;
        }
        type = ld_type;
        pack = FormatPackKind::LongDouble;
        return true;
      default:
        return false;
    }
  };
 
  switch (presentation)
  {
    case 'f':
    case 'F':
      if (!Config::enable_float_fixed ||
          !pick_type(FormatType::FloatFixed, FormatType::DoubleFixed,
                     FormatType::LongDoubleFixed))
      {
        return ResolvedField{.error = Error::ArgumentTypeMismatch};
      }
      break;
    case 'e':
    case 'E':
      if (!Config::enable_float_scientific ||
          !pick_type(FormatType::FloatScientific, FormatType::DoubleScientific,
                     FormatType::LongDoubleScientific))
      {
        return ResolvedField{.error = Error::ArgumentTypeMismatch};
      }
      break;
    case 'g':
    case 'G':
      if (!Config::enable_float_general ||
          !pick_type(FormatType::FloatGeneral, FormatType::DoubleGeneral,
                     FormatType::LongDoubleGeneral))
      {
        return ResolvedField{.error = Error::ArgumentTypeMismatch};
      }
      break;
    default:
      return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
 
  return ResolvedField{.field = MakeField(parsed, type, pack, upper_case)};
}
 
template <typename... Args>
[[nodiscard]] consteval ResolvedField ResolveField(const ParsedField& parsed)
{
  constexpr auto argument_summaries = ClassifyArguments<Args...>();
  if (parsed.arg_index >= argument_summaries.size())
  {
    return ResolvedField{.error = Error::MissingArgument};
  }
 
  auto argument = argument_summaries[parsed.arg_index];
  switch (argument.kind)
  {
    case ArgumentKind::Bool:
      return ResolveBoolField(parsed);
    case ArgumentKind::Character:
      return ResolveCharacterField(parsed);
    case ArgumentKind::Signed:
      return ResolveIntegerField(parsed, true, argument.uses_64bit_storage);
    case ArgumentKind::Unsigned:
      return ResolveIntegerField(parsed, false, argument.uses_64bit_storage);
    case ArgumentKind::String:
      return ResolveStringField(parsed);
    case ArgumentKind::Pointer:
      return ResolvePointerField(parsed);
    case ArgumentKind::Float32:
    case ArgumentKind::Float64:
    case ArgumentKind::LongDouble:
      return ResolveFloatField(parsed, argument.kind);
    case ArgumentKind::Unsupported:
    default:
      return ResolvedField{.error = Error::UnsupportedArgumentType};
  }
}
}  // namespace ArgumentResolution