YACC | Syntax Parser Programming

I have no idea why it doesn't work

But it seems it works with sly created by the same author
(but few years later - so he could have experience after writing ply)

Use a dictionary of dictionaries.

You can't use BEGIN as a token name, because token names are used as C values, and BEGIN is a macro defined by flex (you use it to switch start states).

That causes a syntax error in the enum declaration which you quote in your answer, with the result that all the enum members after BEGIN are undeclared. But the most important error message was the one referring to the syntax error in the enum declaration itself:

Every production for PROG is recursive. So the recursion can never end, and PROG cannot derive a finite sentence.

Since the only production for START is PROG, that also applies to START.

I try to "nvm unalias default". It worked. Ref: https://github.com/react-native-community/upgrade-support/issues/161

Generally, recognizing constructors (and destructors) in C++ requires recognizing the name of the containing class specially, distinct from any other identifier.

This can be done with a contextual lookup in the lexer returning distinct tokens. Inside the {...} composing the class A body, the lexer could recognize the A token and return a different token type for it (distinct from the TYPENAME token it would return for B)

If you just want to ensure that a G command is followed by something, you can do this:

The issue you're going to have to confront is how to deal with function calls. I can't really give you any concrete advice based on your question, because the grammar you provide lacks any indication of the intended syntax of functions calls, but the hint that print(5) is a valid statement makes it clear that there are two distinct situations, which need to be handled separately.

Consider:

Note: There's pretty well no reason to write {1} in a regular expression. It means that the previous element should be repeated exactly once, which is what would have happened without the repetition operator. So all it does is to obfuscate the regular expression (and slow down matching).

But that's not your problem. Your problem is likely the order in which Ply applies the regular expressions. Ply creates a single massive Python regular expression by concatenating all patterns into a set of alternatives: