format_frontend_binding_integer.hpp

#pragma once
 
namespace ArgumentResolution
{
 
[[nodiscard]] consteval ResolvedField ResolveIntegerField(const ParsedField& parsed,
                                                          bool signed_decimal,
                                                          bool uses_64bit_storage)
{
  if (!Config::enable_integer)
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
  if (uses_64bit_storage && !Config::enable_integer_64bit)
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
 
  if (parsed.has_precision)
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
 
  if (parsed.presentation == 'c')
  {
    if (parsed.alternate || HasSignOption(parsed) || parsed.zero_pad)
    {
      return ResolvedField{.error = Error::ArgumentTypeMismatch};
    }
    return ResolvedField{
        .field = MakeField(parsed, FormatType::Character, FormatPackKind::Character)};
  }
 
  if (IsDefaultOr(parsed.presentation, 'd'))
  {
    if (parsed.alternate)
    {
      return ResolvedField{.error = Error::ArgumentTypeMismatch};
    }
    if (!signed_decimal && HasSignOption(parsed))
    {
      return ResolvedField{.error = Error::ArgumentTypeMismatch};
    }
 
    if (signed_decimal)
    {
      return ResolvedField{
          .field = MakeField(
              parsed, uses_64bit_storage ? FormatType::Signed64 : FormatType::Signed32,
              uses_64bit_storage ? FormatPackKind::I64 : FormatPackKind::I32)};
    }
 
    return ResolvedField{
        .field = MakeField(
            parsed, uses_64bit_storage ? FormatType::Unsigned64 : FormatType::Unsigned32,
            uses_64bit_storage ? FormatPackKind::U64 : FormatPackKind::U32)};
  }
 
  if (!Config::enable_integer_base8_16 || HasSignOption(parsed))
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
 
  switch (parsed.presentation)
  {
    case 'b':
      return ResolvedField{
          .field = MakeField(
              parsed, uses_64bit_storage ? FormatType::Binary64 : FormatType::Binary32,
              uses_64bit_storage ? FormatPackKind::U64 : FormatPackKind::U32)};
    case 'B':
      return ResolvedField{
          .field = MakeField(
              parsed, uses_64bit_storage ? FormatType::Binary64 : FormatType::Binary32,
              uses_64bit_storage ? FormatPackKind::U64 : FormatPackKind::U32, true)};
    case 'o':
      return ResolvedField{
          .field = MakeField(
              parsed, uses_64bit_storage ? FormatType::Octal64 : FormatType::Octal32,
              uses_64bit_storage ? FormatPackKind::U64 : FormatPackKind::U32)};
    case 'x':
      return ResolvedField{
          .field = MakeField(
              parsed,
              uses_64bit_storage ? FormatType::HexLower64 : FormatType::HexLower32,
              uses_64bit_storage ? FormatPackKind::U64 : FormatPackKind::U32)};
    case 'X':
      return ResolvedField{
          .field = MakeField(
              parsed,
              uses_64bit_storage ? FormatType::HexUpper64 : FormatType::HexUpper32,
              uses_64bit_storage ? FormatPackKind::U64 : FormatPackKind::U32, true)};
    default:
      return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
}
 
[[nodiscard]] consteval ResolvedField ResolveBoolField(const ParsedField& parsed)
{
  if (parsed.presentation == 0)
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
  return ResolveIntegerField(parsed, false, false);
}
 
[[nodiscard]] consteval ResolvedField ResolveCharacterField(const ParsedField& parsed)
{
  if (parsed.presentation != 0 && parsed.presentation != 'c')
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
  if (parsed.alternate || HasSignOption(parsed) || parsed.zero_pad ||
      parsed.has_precision)
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
  if (!Config::enable_text)
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
 
  ParsedField adjusted = parsed;
  if (adjusted.align == Align::None)
  {
    adjusted.align = Align::Left;
  }
 
  return ResolvedField{
      .field = MakeField(adjusted, FormatType::Character, FormatPackKind::Character)};
}
 
[[nodiscard]] consteval ResolvedField ResolveStringField(const ParsedField& parsed)
{
  if (parsed.presentation != 0 && parsed.presentation != 's')
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
  if (parsed.alternate || HasSignOption(parsed) || parsed.zero_pad)
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
  if (!Config::enable_text)
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
 
  ParsedField adjusted = parsed;
  if (adjusted.align == Align::None)
  {
    adjusted.align = Align::Left;
  }
 
  return ResolvedField{
      .field = MakeField(adjusted, FormatType::String, FormatPackKind::StringView)};
}
 
[[nodiscard]] consteval ResolvedField ResolvePointerField(const ParsedField& parsed)
{
  if (parsed.presentation != 0 && parsed.presentation != 'p')
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
  if (parsed.alternate || HasSignOption(parsed) || parsed.zero_pad ||
      parsed.has_precision)
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
  if (!Config::enable_pointer)
  {
    return ResolvedField{.error = Error::ArgumentTypeMismatch};
  }
 
  return ResolvedField{
      .field = MakeField(parsed, FormatType::Pointer, FormatPackKind::Pointer)};
}
}  // namespace ArgumentResolution