Compiler Explorer

Source code

#include <algorithm>
#include <ranges>
#include <fmt/format.h>
#include <fmt/ranges.h>
#include <fmt/compile.h>
#include <fmt/args.h>
#include <vector>
#include <list>
#include <cassert>
#include <source_location>

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;

constexpr 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 Old>
    struct custom_appender : appender {
        using appender::appender;
    };

template <typename Old>
    struct basic_format_args<basic_format_context<custom_appender<Old>, char>> {
        using old_args = basic_format_args<basic_format_context<Old, char>>;
        using new_context = basic_format_context<custom_appender<Old>, char>;
        using format_arg = basic_format_arg<new_context>;
        using size_type = int;

old_args const& orig_args;

basic_format_args(old_args const& orig)
            : orig_args(orig)
        { }

constexpr auto get(int id) const -> format_arg {
            return visit_format_arg([]<typename T>(T const& arg) -> format_arg {
                if constexpr (std::same_as<T, typename old_args::format_arg::handle>) {
                    return format_arg();
                } else if constexpr (std::same_as<T, monostate>) {
                    return format_arg();
                } else {
                    return detail::make_arg<new_context>(arg);
                }
            }, orig_args.get(id));
        }

constexpr auto get(fmt::string_view name) const -> format_arg {
            int id = orig_args.get_id(name);
            return id >= 0 ? get(id) : format_arg();
        }

constexpr auto get_id(fmt::string_view name) const -> int {
            return orig_args.get_id(name);
        }
    };

template <typename Context, typename OutputIt>
    struct retargeted_format_context {
        detail::iterator_buffer<OutputIt, char> buffer;

using iterator = custom_appender<typename Context::iterator>;
        using new_context = basic_format_context<iterator, char>;
        new_context erased_ctx;

retargeted_format_context(Context& ctx, OutputIt it)
            : buffer(it)
            , erased_ctx(iterator(buffer),
                         basic_format_args<new_context>(ctx.args()),
                         ctx.locale())
        { }

auto context() -> new_context& {
            return erased_ctx;
        }

void flush() {
            (void)buffer.out();
        }
    };

template <typename CharT, typename OutputIt>
    struct retargeted_format_context<basic_format_context<OutputIt, CharT>, OutputIt>
    {
        basic_format_context<OutputIt, CharT> ctx;

retargeted_format_context(basic_format_context<OutputIt, CharT>& ctx, OutputIt it)
            : ctx(it, ctx.args(), ctx.locale())
        { }

auto context() -> basic_format_context<OutputIt, CharT>& { return ctx; }

void flush() { }
    };

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;

string_view static_delimiter = ", ";
        detail::arg_ref<char> dynamic_delimiter;

template <typename Context>
        struct delimiter_adapter {
            range_formatter* self;
            Context& ctx;

constexpr void operator()() { self->dynamic_delimiter = detail::arg_ref<char>(ctx.next_arg_id()); }
            constexpr void operator()(auto id) { self->dynamic_delimiter = detail::arg_ref<char>(id); }
            constexpr void on_error(char const* msg) { throw fmt::format_error(msg); }
        };

template <typename Context, typename Handler>
        constexpr auto parse_range_specs(Context& ctx, Handler&& handler)
        {
            auto begin = ctx.begin();
            auto end = ctx.end();

// 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 == 'e') {
                use_brackets = false;
                ++begin;
                if (begin == end) return begin;
            }

if (*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 'd': {
                    if (*begin == '{') {
                        // dynamic delimiter
                        ++begin;
                        if (begin != end) {
                            begin = detail::parse_arg_id(begin, end, delimiter_adapter{this, ctx});
                        }
                        if (begin == end or *begin != '}') {
                            throw fmt::format_error("invalid range delimiter 1");
                        }
                        ++begin;
                    } else if (*begin == '[') {
                        // static delimiter: we look for ctx.end() here, not
                        // just end, because end might actually refer into the
                        // static delimiter (e.g. "d[:]").
                        ++begin;
                        auto close = std::find(begin, ctx.end(), ']');
                        if (close == ctx.end()) {
                            throw fmt::format_error("invalid range delimiter 2");
                        }
                        static_delimiter = string_view(begin, close - begin);
                        begin = close + 1;
                        end = std::ranges::find(close, ctx.end(), ':');
                    } else {
                        throw fmt::format_error("invalid range delimiter 3");
                    }
                    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, 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");
                }
            }

basic_format_arg<FormatContext> dynamic_delim_arg;
            fmt::string_view delimiter = static_delimiter;

if (dynamic_delimiter.kind == detail::arg_id_kind::index) {
                dynamic_delim_arg = ctx.arg(dynamic_delimiter.val.index);
                delimiter =
                    visit_format_arg([&]<typename T>(T const& i) -> fmt::string_view {
                        if constexpr (std::same_as<T, char const*> or std::same_as<T, fmt::string_view>) {
                            return i;
                        } else if constexpr (std::same_as<T, char>) {
                            return fmt::string_view(&i, 1);
                        } else {
                            throw fmt::format_error("delimiter is not a string");
                        }
                    }, dynamic_delim_arg);
            }

memory_buffer buf;
            retargeted_format_context rctx(ctx, appender(buf));
            auto& bctx = rctx.context();

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 = std::copy(delimiter.begin(), delimiter.end(), out);
                    bctx.advance_to(std::move(out));
                    out = underlying.format(*first, bctx);
                }
            }

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

rctx.flush();
            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
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wnon-template-friend"
    template <typename Context>
    struct bfpc_member {
        using type = basic_string_view<typename Context::char_type> Context::*;
        friend type get_private(bfpc_member);
    };
    #pragma GCC diagnostic push

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 of specifiers");
                    }
                }

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

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;
            retargeted_format_context rctx(ctx, appender(buf));
            auto& bctx = rctx.context();

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++ = ')';
            }

rctx.flush();
            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<std::remove_cvref_t<T>, std::remove_cvref_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<std::remove_cvref_t<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;

int num_errors = 0;

void check_eq(char const* lhs_expr, char const* rhs_expr,
              std::string const& lhs, std::string const& rhs,
              std::source_location sloc)
{
    if (lhs != rhs) {
        fmt::print("{}: ERROR: CHECK_EQ({}, {}) failed!\n", sloc.line(), lhs_expr, rhs_expr);
        fmt::print("Got:      '{}'\n", lhs);
        fmt::print("Expected: '{}'\n", rhs);
        ++num_errors;
    }
}

template <typename F>
void check_throws(char const* expr, F f, std::source_location sloc)
{
    try {
        f();

fmt::print("{}: ERROR: CHECK_THROWS({}) did not throw\n", sloc.line(), expr);
        ++num_errors;
    } catch (...) {
        ;
    }
}

#define CHECK_EQ(a, b) check_eq(#a, #b, a, b, std::source_location::current())
#define CHECK_THROWS(e) check_throws(#e, [&]{ e; }, std::source_location::current());

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

CHECK_EQ(runtime_format("{:d{}}", vector{1, 2, 3}, "--"), "[1--2--3]");
    CHECK_EQ(runtime_format("{:d{}}", vector{1, 2, 3}, '-'), "[1-2-3]");
    CHECK_EQ(runtime_format("{:d[--]}", vector{1, 2, 3}), "[1--2--3]");
    CHECK_THROWS(runtime_format("{:d{}}", vector{1, 2, 3}, 2));
    CHECK_EQ(runtime_format("{::*^{}}", vector{1, 2, 3}, 3), "[*1*, *2*, *3*]");
    CHECK_EQ(runtime_format("{::02x}", std::vector<uint8_t>{0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff}), "[aa, bb, cc, dd, ee, ff]");
    CHECK_EQ(runtime_format("{:ed{}:02x}", std::vector<uint8_t>{0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff}, ":"), "aa:bb:cc:dd:ee:ff");
    CHECK_EQ(runtime_format("{:ed[:]:02x}", std::vector<uint8_t>{0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff}), "aa:bb:cc:dd:ee:ff");
    CHECK_EQ(runtime_format("{:ed{}:*^3}", vector{1, 2, 3}, "--"), "*1*--*2*--*3*");
    CHECK_EQ(runtime_format("{:ed[--]:*^3}", vector{1, 2, 3}), "*1*--*2*--*3*");
    CHECK_EQ(runtime_format("{:*^3}", fmt::join(vector{1, 2, 3}, "--")), "*1*--*2*--*3*");
    CHECK_EQ(runtime_format("{:ed[\n]:e}", vector<vector<int>>{{1, 2, 3}, {4, 5, 6}}), "1, 2, 3\n4, 5, 6");

if (num_errors == 0) {
        fmt::print("Passed!\n");
    }
    return num_errors;
}