Compiler Explorer

Source code

#include <algorithm>
#include <ranges>
#include <fmt/format.h>
#include <fmt/ranges.h>
#include <fmt/compile.h>
#include <vector>
#include <list>
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include <doctest.h>
#include <cassert>

template <class T>
concept formattable_impl =
    std::semiregular<fmt::formatter<T>> &&
    requires (fmt::formatter<T> f,
              const T t,
              fmt::basic_format_context<char*, char> fc,
              fmt::basic_format_parse_context<char> pc)
    {
        { f.parse(pc) } -> std::same_as<fmt::basic_format_parse_context<char>::iterator>;
        { f.format(t, fc) } -> std::same_as<char*>;
    };

template <class T>
concept formattable = formattable_impl<std::remove_cvref_t<T>>;

static_assert(formattable<int>);

namespace fmt {
    inline constexpr presentation_type presentation_type_map =
        static_cast<presentation_type>((int)presentation_type::pointer + 1);

template <class T, template <typename...> class Z>
    inline constexpr bool is_specialization_of_v = false;

template <class... Ts, template <typename...> class Z>
    inline constexpr bool is_specialization_of_v<Z<Ts...>, Z> = true;

template <typename T>
    struct wrapped_debug_formatter : formatter<T> {
        // really formatter<T> should do this already, but want to avoid making
        // any direct changes there for now
        bool use_debug = false;

void format_as_debug() {
            use_debug = true;
        }

template <typename FormatContext>
        constexpr auto format(T const& value, FormatContext& ctx) const {
            if constexpr (detail::is_std_string_like<T>::value || std::is_same_v<T, char>) {
                if (use_debug) {
                    return detail::write_range_entry<char>(ctx.out(), value);
                }
            }

return formatter<T>::format(value, ctx);
        }
    };

// the tuple formatter already knows what's up, doesn't need extra help
    template <typename T> requires requires (formatter<T> f) { f.format_as_debug(); }
    struct wrapped_debug_formatter<T> : formatter<T> { };

template <typename V>
    struct range_formatter {
        detail::dynamic_format_specs<char> specs;
        wrapped_debug_formatter<V> underlying;
        bool is_debug = false;
        bool use_brackets = true;

template <typename Iterator, typename Handler>
        constexpr auto parse_range_specs(Iterator begin, Iterator end, Handler&& handler) {
            // parse_align isn't quite right because we need to escape the
            // : if that's the desired fill
            if (*begin == '\\') {
                FMT_ASSERT(begin[1] == ':', "expected colon");
                begin = parse_align(begin + 1, end, handler);
                FMT_ASSERT(specs.align != align::none, "escape but no align?");
                end = std::ranges::find(begin, end, ':');
            } else {
                end = std::ranges::find(begin, end, ':');
                if (begin == end) return begin;
                begin = parse_align(begin, end, handler);
            }

if (begin == end) return end;

begin = parse_width(begin, end, handler);
            if (begin == end) return begin;

if (*begin == '?') {
                is_debug = true;
                ++begin;
                if (begin == end) return begin;
            }

if (begin != end && *begin != '}') {
                switch (*begin++) {
                case 's':
                    specs.type = presentation_type::string;
                    break;
                case 'm':
                    specs.type = presentation_type_map;
                    if constexpr (is_specialization_of_v<V, std::pair> or is_specialization_of_v<V, std::tuple>) {
                        if constexpr (std::tuple_size_v<V> == 2) {
                            underlying.specs.type = presentation_type_map;
                        } else {
                            throw fmt::format_error("wrong kind of tuple");
                        }
                    } else {
                        throw fmt::format_error("wat");
                    }
                    break;
                case 'e':
                    use_brackets = false;
                    break;
                default:
                    throw fmt::format_error("unknown type");
                }
            }

return begin;
        }

template <typename ParseContext>
        constexpr auto parse(ParseContext& ctx) {
            auto begin = ctx.begin();
            auto end = ctx.end();
            if (begin == end || *begin == '}') {
                if constexpr (requires { underlying.format_as_debug(); }) {
                    underlying.format_as_debug();
                }
                return begin;
            }

using handler_type = detail::dynamic_specs_handler<ParseContext>;
            auto checker =
                detail::specs_checker<handler_type>(handler_type(specs, ctx), detail::type::none_type);
            auto it = parse_range_specs(ctx.begin(), ctx.end(), checker);

if (it == ctx.end() || *it == '}') {
                if constexpr (requires { underlying.format_as_debug(); }) {
                    underlying.format_as_debug();
                }
            } else {
                ++it;
            }

ctx.advance_to(it);
            return underlying.parse(ctx);
        }

template <typename R, typename FormatContext>
            requires std::same_as<std::remove_cvref_t<std::ranges::range_reference_t<R>>, V>
        constexpr auto format(R&& r, FormatContext& ctx) const -> typename FormatContext::iterator
        {
            if (specs.type == presentation_type::string) {
                if constexpr (std::same_as<V, char>) {
                    auto s = std::string(std::ranges::begin(r), std::ranges::end(r));
                    if (is_debug) {
                        return detail::write_range_entry<char>(ctx.out(), s);
                    } else {
                        return write(ctx.out(), fmt::string_view(s), specs);
                    }
                } else {
                    throw fmt::format_error("wat");
                }
            }

memory_buffer buf;
            basic_format_context<appender, typename FormatContext::char_type>
                bctx(appender(buf), ctx.args(), ctx.locale());

auto out = bctx.out();
            if (use_brackets) {
                *out++ = specs.type == presentation_type_map ? '{' : '[';
            }
            auto first = std::ranges::begin(r);
            auto last = std::ranges::end(r);
            if (first != last) {
                // have to format every element via the underlying formatter
                bctx.advance_to(std::move(out));
                out = underlying.format(*first, bctx);
                for (++first; first != last; ++first) {
                    *out++ = ',';
                    *out++ = ' ';
                    bctx.advance_to(std::move(out));
                    out = underlying.format(*first, bctx);
                }
            }

if (use_brackets) {
                *out++ = specs.type == presentation_type_map ? '}' : ']';
            }

return write(ctx.out(), fmt::string_view(buf.data(), buf.size()), specs);
        }
    };

// take priority over the specialization in fmt/ranges.h
    template <std::ranges::range T, typename Char>
        requires formattable<std::ranges::range_reference_t<T>>
              && (!std::same_as<T, fmt::basic_string_view<char>>)
              && (!std::same_as<T, std::string>)
    struct formatter<
        T, Char,
        enable_if_t<
            is_range<T, Char>::value
        // Workaround a bug in MSVC 2019 and earlier.
        #if !FMT_MSC_VER
                && (is_formattable<detail::value_type<T>, Char>::value ||
                    detail::has_fallback_formatter<detail::value_type<T>, Char>::value)
        #endif
        >> : range_formatter<std::remove_cvref_t<std::ranges::range_reference_t<T>>> { };

////////////////////////////////////////////////////////////////////////////
    // need to standardize this probably to avoid this hack
    template <typename Context>
    struct bfpc_member {
        using type = basic_string_view<typename Context::char_type> Context::*;
        friend type get_private(bfpc_member);
    };

template<typename Tag, typename Tag::type M>
    struct Rob {
        friend typename Tag::type get_private(Tag) {
            return M;
        }
    };

template struct Rob<bfpc_member<format_parse_context>, &format_parse_context::format_str_>;

template <typename Context>
    struct end_sentry {
        Context& ctx;
        typename Context::iterator real_end;

end_sentry(Context& ctx, typename Context::iterator it)
            : ctx(ctx)
            , real_end(ctx.end())
        {
            auto& sv = ctx.*get_private(bfpc_member<Context>());
            sv = basic_string_view(sv.data(), it - ctx.begin());
        }

~end_sentry() {
            auto& sv = ctx.*get_private(bfpc_member<Context>());
            sv = basic_string_view(ctx.begin(), real_end - ctx.begin());
        }
    };
    //
    ////////////////////////////////////////////////////////////////////////////

template <formattable... Ts>
    struct tuple_formatter {
        std::tuple<wrapped_debug_formatter<Ts>...> underlying;
        detail::dynamic_format_specs<char> specs;

template <typename Tuple, typename F>
        static constexpr void tuple_for_each(Tuple&& tuple, F&& f) {
            std::apply([&]<typename... Es>(Es&&... elems){
                (f((Es&&)elems), ...);
            }, (Tuple&&)tuple);
        }

template <typename Tuple, typename F>
        static constexpr void tuple_for_each_index(Tuple&& tuple, F&& f) {
            [&]<size_t... Is>(std::index_sequence<Is...>) {
                (f(std::integral_constant<size_t, Is>{}, std::get<Is>((Tuple&&)tuple)), ...);
            }(std::make_index_sequence<std::tuple_size_v<std::remove_cvref_t<Tuple>>>());
        }

void format_as_debug() {
            tuple_for_each(underlying, [&](auto& f){
                if constexpr (requires { f.format_as_debug(); }) {
                    f.format_as_debug();
                }
            });
        }

template <typename Iterator, typename Handler>
        constexpr auto parse_tuple_specs(Iterator begin, Iterator end, Handler&& handler) -> Iterator {
            begin = parse_align(begin, end, handler);
            if (begin == end) return begin;

begin = parse_width(begin, end, handler);
            if (begin == end) return begin;

return begin;
        }

template <typename ParseContext>
        constexpr auto parse(ParseContext& ctx) {
            auto begin = ctx.begin();
            auto end = ctx.end();
            if (begin == end or *begin == '}') {
                format_as_debug();
                return begin;
            }

if (begin == end or *begin == '}') {
                format_as_debug();
                return begin;
            }

auto delim = *begin++;
            ctx.advance_to(begin);
            tuple_for_each_index(underlying, [&](auto I, auto& f){
                auto next_delim = std::find(ctx.begin(), end, delim);
                if constexpr (I + 1 < sizeof...(Ts)) {
                    if (next_delim == end) {
                        throw fmt::format_error("ran out");
                    }
                }

end_sentry _(ctx, next_delim);
                auto i = f.parse(ctx);
                if (i != next_delim && *i != '}') {
                    throw fmt::format_error("oops");
                }

if (next_delim != end) {
                    ++i;
                }
                ctx.advance_to(i);
            });
            return ctx.begin();
        }

template <typename R, typename FormatContext>
        constexpr auto format(R&& r, FormatContext& ctx) const -> typename FormatContext::iterator
        {
            memory_buffer buf;
            basic_format_context<appender, typename FormatContext::char_type>
                bctx(appender(buf), ctx.args(), ctx.locale());

bool const is_map = specs.type == presentation_type_map;

auto out = bctx.out();
            if (not is_map) {
                *out++ = '(';
            }

tuple_for_each_index(underlying, [&](auto I, auto& f){
                if (I > 0) {
                    *out++ = is_map ? ':' : ',';
                    *out++ = ' ';
                }
                bctx.advance_to(out);
                out = f.format(std::get<I>(r), bctx);
            });

if (not is_map) {
                *out++ = ')';
            }

return write(ctx.out(), fmt::string_view(buf.data(), buf.size()), specs);
        }
    };

// take priority over the specialization in fmt/ranges.h
    template <formattable T, formattable U, typename Char>
    struct formatter<std::pair<T, U>, Char, enable_if_t<fmt::is_tuple_like<std::pair<T, U>>::value>>
        : tuple_formatter<T, U>
    { };

template <formattable... T, typename Char>
    struct formatter<std::tuple<T...>, Char, enable_if_t<fmt::is_tuple_like<std::tuple<T...>>::value>>
        : tuple_formatter<T...>
    { };
}

template <typename... Args>
auto runtime_format(char const* fmt, Args&&... args) {
    return fmt::vformat(fmt, fmt::make_format_args(args...));
}

template <typename... Args>
auto runtime_print(char const* fmt, Args&&... args) {
    std::string s = runtime_format(fmt, fmt::make_format_args(args...));
    fmt::print("{}\n", s);
}

using namespace std::literals;
using std::vector, std::pair, std::tuple;

TEST_CASE("ranges") {
    CHECK(runtime_format("{:*^30:#04x}", vector{10, 20, 30}) == "******[0x0a, 0x14, 0x1e]******");
    CHECK(runtime_format("{}", vector{"hello"s, "world"s}) == "[\"hello\", \"world\"]");
    CHECK(fmt::format("{}", vector{"hello"s, "world"s}) == "[\"hello\", \"world\"]");
    CHECK(runtime_format("{:}", vector{"hello"s, "world"s}) == "[\"hello\", \"world\"]");
    CHECK(runtime_format("{:e}", vector{"hello"s, "world"s}) == "\"hello\", \"world\"");
    CHECK(runtime_format("{:*^14}", vector{"he"s, "wo"s}) == "*[\"he\", \"wo\"]*");
    CHECK(runtime_format("{::*^14}", vector{"he"s, "wo"s}) == "[******he******, ******wo******]");
    CHECK(runtime_format("{::d}", vector<char>{'H', 'e', 'l', 'l', 'o'}) == "[72, 101, 108, 108, 111]");
    CHECK(runtime_format("{::#x}", vector<char>{'H', 'e', 'l', 'l', 'o'}) == "[0x48, 0x65, 0x6c, 0x6c, 0x6f]");
    CHECK(runtime_format("{:s}", vector<char>{'H', 'e', 'l', 'l', 'o'}) == "Hello");
    CHECK(runtime_format("{:?s}", vector<char>{'H', 'e', 'l', 'l', 'o'}) == "\"Hello\"");
    CHECK(runtime_format("{}", vector{vector{'a'}, vector{'b', 'c'}}) == "[[a], [b, c]]");
    CHECK(fmt::format("{}", vector{vector{'a'}, vector{'b', 'c'}}) == "[[a], [b, c]]");
    CHECK(runtime_format("{::?s}", vector{vector{'a'}, vector{'b', 'c'}}) == "[\"a\", \"bc\"]");
    CHECK(runtime_format("{:::d}", vector{vector{'a'}, vector{'b', 'c'}}) == "[[97], [98, 99]]");
    CHECK(fmt::format("{:::d}", vector{vector{'a'}, vector{'b', 'c'}}) == "[[97], [98, 99]]");
    // CHECK(fmt::format(FMT_COMPILE("{:::d}"), vector{vector{'a'}, vector{'b', 'c'}}) == "[[97], [98, 99]]");
}

TEST_CASE("tuples") {
    CHECK(runtime_format("{}", pair{42, "hello"s}) == "(42, \"hello\")");
    CHECK(runtime_format("{}", tuple{42, "hello"s, 'x'}) == "(42, \"hello\", 'x')");
    CHECK(runtime_format("{}", vector{pair{42, "hello"s}, pair{17, "goodbye"s}}) == "[(42, \"hello\"), (17, \"goodbye\")]");
    CHECK(runtime_format("{:m}", vector{pair{42, "hello"s}, pair{17, "goodbye"s}}) == "{42: \"hello\", 17: \"goodbye\"}");
    CHECK(runtime_format("{::#x:*^10}", pair{42, "hello"s}) == "(0x2a, **hello***)");
    CHECK(runtime_format("{:|#x|*^10}", pair{42, "hello"s}) == "(0x2a, **hello***)");
    CHECK_THROWS(runtime_format("{:|#x|*^10}", tuple{42, "hello"s, 'x'}));
    CHECK(runtime_format("{:*>15}", pair{42, "h"s}) == "******(42, \"h\")");
    CHECK(runtime_format("{:*>15|#x|s}", pair{42, "h"s}) == "******(0x2a, h)");
    CHECK(runtime_format("{:*>15|#x|}", pair{42, "h"s}) == "******(0x2a, h)");
}