What about error recovery?

[skyrich62]

Consider a grammar such as:

struct expr : list<term, binary_adding_operator> { };
struct statement : seq<expr, one<';'>> { };

(Where both term and binary_adding_operator are appropriately defined.)

Suppose that the input is malformed, e.g.:

x + ;

Note missing operand. I would want an appropriate error message, (easy enough to put out in control<term>::failure, but I also want to consume the input up to the semicolon, throw it away and continue parsing. Would that need to be embedded in the grammar something like this?

template <typename R, typename S>
struct recover : sor<R, until<S>> { };
struct semi : one<';'> { }
struct expr : list<recover<term, semi>, semi> { }

(That's not quite what I had in mind, but I wonder if I'm even on the right track here.)

For more context, here's the project I'm working on: https://github.com/skyrich62/AFE

[d-frey]

This is interesting, but not something we explored further in the past. I think that error recovery is hard and very specific to your use-case, so I don't see any general way that the PEGTL (or any parser library) can really help with that.

What you have done so far looks like a reasonable approach for languages where, for example, statements always end in a semicolon. I wouldn't use the Control class, though, but instead apply an action to the skipping part. You also might avoid some redundancy, so how about something like:

template<typename T, typename T>
struct skipping : until< T > {};

template<typename R, typename T>
struct recoverable : sor< seq< R, T >, skipping< R, T > > {};

given that the terminator T can never occur inside the rule R. Just attach the action to R or seq< R, T > as usual, and attach a generic action to skipping< R, T > which emits a diagnostic for the user (plus setting some error flag for the final success/failure of the parsing run). The R is part of the template so you can emit a more helpful error message. (The recoverable template might even be a templated type alias (using recoverable =) if you don't plan to attach an action to it). I think you are on the right track, it is "just" a question of how to arrange a few helper template and how you language is constructed so that error recovery is really helpful to the user.

[skyrich62]

Sounds good. I didn't expect the PEGTL to have a generic response to error recovery; I just wanted to know if you guys had thought about methodology.

Thanks for the suggestion, I'll give it a whirl. :)

[ColinH]

We'd be very interested in seeing what you come up with, for future reference, and who knows, perhaps something generic can be found, if not concrete code then at least an idea that can be documented...

[skyrich62]

Hi,
I've played around with it a bit, and created a repository with my experiments:
https://github.com/skyrich62/toy-calc

I'd appreciate any feedback. :)

[d-frey]

@skyrich62 I just committed a small experiment on my own, based on some of your ideas. I am too tired to write more now, but I'll try to give more feedback in the next days.

[skyrich62]

@d-frey "Get some rest, if you haven't got your health, you haven't got anything." -- Count Rugen, The Princess Bride