Is there an easy way to get an error-string from a lexy::parse call?

[Cthaeeh]

E.g.

std::expected<X, std::string> parseX(
      const std::string &str)
{
    auto result = lexy::parse<grammar::Table>(lexy::string_input(str),
                                              lexy_ext::report_error);

    if (result.is_success()) {
        return result.value();
    } else {
        return std::unexpected( ? ); //<-
    }
}

Or do I have to implement my own lexy_ext::report_error in some form?

[foonathan]

You can do lexy_ext::report_error.to(std::back_inserter(error)), where error is a std::string. It will then format the diagnostic into the std::string. You probably want to override the visualization options to something that doesn't include color information though:

lexy/include/lexy_ext/report_error.hpp

Lines 318 to 382 in 14467db

	namespace lexy_ext
	{
	template <typename OutputIterator = int>
	struct _report_error
	{
	OutputIterator _iter;
	lexy::visualization_options _opts;
	const char* _path;
	struct _sink
	{
	OutputIterator _iter;
	lexy::visualization_options _opts;
	const char* _path;
	std::size_t _count;
	using return_type = std::size_t;
	template <typename Input, typename Reader, typename Tag>
	void operator()(const lexy::error_context<Input>& context,
	const lexy::error<Reader, Tag>& error)
	{
	if constexpr (std::is_same_v<OutputIterator, int>)
	_detail::write_error(lexy::cfile_output_iterator{stderr}, context, error, _opts,
	_path);
	else
	_iter = _detail::write_error(_iter, context, error, _opts, _path);
	++_count;
	}
	std::size_t finish() &&
	{
	if (_count != 0)
	std::fputs("\n", stderr);
	return _count;
	}
	};
	constexpr auto sink() const
	{
	return _sink{_iter, _opts, _path, 0};
	}
	/// Specifies a path that will be printed alongside the diagnostic.
	constexpr _report_error path(const char* path) const
	{
	return {_iter, _opts, path};
	}
	/// Specifies an output iterator where the errors are written to.
	template <typename OI>
	constexpr _report_error<OI> to(OI out) const
	{
	return {out, _opts, _path};
	}
	/// Overrides visualization options.
	constexpr _report_error opts(lexy::visualization_options opts) const
	{
	return {_iter, opts, _path};
	}
	};
	/// An error callback that uses diagnostic_writer to print to stderr (by default).
	constexpr auto report_error = _report_error<>{};
	} // namespace lexy_ext

[Cthaeeh]

Thank you a lot for the answer!

Regarding the color information, it seems to me that the default doesn't use any colors:

enum visualization_flags
{
    visualize_default = 0,

    /// Visualization can use unicode characters.
    visualize_use_unicode = 1 << 0,
    /// Visualization can use ANSI color escape sequences.
    visualize_use_color = 1 << 1,
    /// Visualization can use Unicode symbols e.g. for newline/space instead of the code point.
    visualize_use_symbols = 1 << 2,

    /// Visualization can use unicode, color and symbols.
    visualize_fancy = visualize_use_unicode | visualize_use_color | visualize_use_symbols,

    /// Visualize space ' ' as visible character/symbol.
    visualize_space = 1 << 3,
};

So that should be fine.

But here is still a small issue with this solution, it prints a \n to std::cerr if an error is encountered (from the finnish-member-fkt of the sink.) . I am trying to find a way around that.

[foonathan]

But here is still a small issue with this solution, it prints a \n to std::cerr if an error is encountered (from the finnish-member-fkt of the sink.) . I am trying to find a way around that.

That's a bug, fixed in 8869a8b.

[Cthaeeh]

Currently my best solution is:

struct CollectErrors
{
    struct _sink
    {
        using return_type = std::vector<std::string>;

        template <typename Input, typename Reader, typename Tag>
        void operator()(const lexy::error_context<Input> &context,
                        const lexy::error<Reader, Tag> &error)
        {
            std::string out;
            lexy_ext::_detail::write_error(std::back_inserter(out),
                                           context,
                                           error,
                                           {},
                                           nullptr);
            errors.push_back(out);
        }

        std::vector<std::string> finish() && { return errors; }

        std::vector<std::string> errors;
    };

    constexpr auto sink() const { return _sink{}; }
};