libshit

format_opcode_argument.cpp (5193B)

---

 #include "libshit/translate/format_opcode_argument.hpp"
 
 #include "libshit/doctest.hpp"
 #include "libshit/except.hpp"
 #include "libshit/maybe_owning_vector.hpp"
 #include "libshit/number_format.hpp"
 #include "libshit/translate/context.hpp"
 #include "libshit/translate/format_test_helper.hpp"
 #include "libshit/translate/plural.hpp"
 #include "libshit/utils.hpp"
 
 #include <boost/container/small_vector.hpp> // IWYU pragma: keep
 
 #include <cstdint>
 #include <sstream>
 #include <variant>
 #include <vector>
 
 namespace Libshit::Translate
 {
   TEST_SUITE_BEGIN("Libshit::Translate::Format");
   using namespace std::string_literals;
   namespace { using ArgOC = FormatOpcodes<FormatOpcode::ARGUMENT>; }
 
   void ArgOC::UpdateTypes(Types& types)
   {
     auto code = data.code.GetSpan();
     auto index = (code[pc] >> 8) & 0xff;
     auto type = (code[pc] >> 16) & 0xff;
     SetType(types, index, static_cast<Type>(type));
     pc += 2;
   }
 
   void ArgOC::Format(
     std::string& out, const Context& ctx, Span<const ArgumentType> args)
   {
     pc += 2;
     if (pc > data.code.size())
       LIBSHIT_THROW(InvalidFormat, "Invalid code size",
                     "PC", pc, "Size", data.code.size());
 
     auto code = data.code.GetSpan();
     auto index = (code[pc-2] >> 8) & 0xff;
     if (index >= args.size())
     {
       out += "???";
       return;
     }
 
     FormatParams fp{code[pc-1]};
     Overloaded ol{
       [&](auto x)
       {
         static_assert(std::is_integral_v<decltype(x)>);
         auto info = ctx.GetInfo();
         FormatInt(out, x, fp.GetDigits(), fp.GetShowPos(), info.digit_sep,
                   fp.GetGrouping() ? info.grouping : 0);
       },
       [&](double d)
       {
         auto info = ctx.GetInfo();
         FormatDouble(
           out, d, fp.GetDoubleFormat(), fp.GetDigits(), fp.GetPrecision(),
           fp.GetShowPos(), info.digit_sep, info.decimal_sep,
           fp.GetGrouping() ? info.grouping : 0);
       },
       [&](StringView v) { out += v; },
       [&](const TranslationPtr& ptr) { out += ptr->Get({fp.GetCaseId()}).str; },
       [&](const NotNullSmartPtr<Printer>& p) { p->Print(out); },
     };
     std::visit(Move(ol), args[index].ToBase());
   }
 
   unsigned ArgOC::RegisterCommon(RegisterArgs&& r, Type type)
   {
     r.parser.FinishVerb();
     r.parser.code.push_back(
       FormatOpcode::ARGUMENT | (r.index << 8) | (unsigned(type) << 16));
     r.parser.code.push_back(r.fp.GetRaw());
     return r.index + 1;
   }
 
   namespace
   {
     struct X {};
     LIBSHIT_TEST_FUN std::ostream& operator<<(std::ostream& os, X)
     { return os << "X::op<<"; }
   }
 
   TEST_CASE("Argument format")
   {
     // ctxp, index, fp
 #define REG(ctxp, ...)                                         \
     FormatData data;                                           \
     Context ctx = ctxp;                                        \
     FormatParser parser{{}, ctx, data};                        \
     ArgOC::Register<Type::GENERIC>({parser, __VA_ARGS__, {}}); \
     parser.Finish()
 
     auto fmt = Test::Format<FormatOpcode::ARGUMENT>;
 #define CHK(exp, argv, ctxp, ...)                   \
     do                                              \
     {                                               \
       REG(ctxp, 0, __VA_ARGS__);                    \
       FAST_CHECK_EQ(fmt(parser, {argv}), exp##_ns); \
     }                                               \
     while (0)
 
     CHK("3", 3, {}, {});
     CHK("3140000", 3.14, {}, {}); // decimal dot is an empty string!
     CHK("foo", "foo", {}, {});
     CHK("foo", "foo"s, {}, {});
     CHK("foo", "foo"_ns, {}, {});
     CHK("X::op<<", X{}, {}, {});
 
     using DF = DoubleFormat;
     LanguageInfo a{"", "", "", ".", "'", 3, {}, {}, {}, 0, {}};
     CHK("003", 3, {}, {{}, {}, {}, 0, 3, 0});
     CHK("3.140", 3.14, a, {{}, {}, {}, 0, 0, 3});
     CHK("012.346", 12.34567, a, {{}, {}, {}, 0, 6, 3});
     CHK("+01'234", 1234, a, {true, true, {}, 0, 5, 6});
     CHK("+0'000'012.340", 12.34, a, {true, true, DF::FIXED, 0, 10, 3});
     CHK("+0'001.234e+01", 12.34, a, {true, true, DF::SCIENTIFIC, 0, 7, 3});
     CHK("foo", "foo", a, {true, true, DF::SCIENTIFIC, 0, 7, 6});
 
     LanguageInfo b{"", "", "", "::", "()", 2, {}, {}, {}, 0, {}};
     CHK("0()12()34", 1234, b, {false, true, {}, 0, 5, 6});
     CHK("1()23::456", 123.456, b, {false, true, DF::GENERIC, 0, 0, 6});
 
     ArgumentType case_ptr = MakeSmart<Test::Case>();
     CHK("aa", case_ptr, a, {{}, {}, {}, 0, 0, 6});
     CHK("bb", case_ptr, a, {{}, {}, {}, 1, 0, 6});
     CHK("cc", case_ptr, a, {{}, {}, {}, 2, 0, 6});
 #undef CHK
 
     // non first arg
     ArgumentType args[] = { 0, "1str", 2.03 };
     {
       REG({}, 1, {});
       // Span(args): workaround gcc bug https://godbolt.org/z/Ev3n7eo3G
       CHECK(fmt(parser, Span(args)) == "1str"_ns);
     }
 
     {
       REG({}, 2, {});
       CHECK(fmt(parser, Span(args)) == "2030000"_ns);
     }
 
     // not enough args
     {
       REG({}, 0, {});
       CHECK(fmt(parser, {}) == "???"_ns);
     }
 
     // FormatParams missing
     {
       REG({}, 0, {});
       data.code = MaybeOwningVector<const std::uint32_t>::Copy(
         data.code.GetSpan().subspan(0, 1));
       CHECK_THROWS(fmt(parser, {1}));
     }
   }
 #undef REG
 
   TEST_SUITE_END();
 }