Question

The following simple ‘calculator expression’ grammar (BNF) can be easily parsed with the a trivial recursive-descent parser, which is predictive LL(1):

<expr>      :=  <term> + <term>             |   <term> - <term>             |   <term> <term>      :=  <factor> * <factor>                 <factor> / <factor>                 <factor> <factor>    :=  <number>             |   <id>             |   ( <expr> ) <number>    :=  \d+ <id>        :=  [a-zA-Z_]\w+ 

Because it is always enough to see the next token in order to know the rule to pick. However, suppose that I add the following rule:

<command>   :=  <expr>             |   <id> = <expr> 

For the purpose of interacting with the calculator on the command line, with variables, like this:

calc> 5+5 => 10 calc> x = 8 calc> 6 * x + 1 => 49 

Is it true that I can not use a simple LL(1) predictive parser to parse <command> rules ? I tried to write the parser for it, but it seems that I need to know more tokens forward. Is the solution to use backtracking, or can I just implement LL(2) and always look two tokens forward ?

How to RD parser generators handle this problem (ANTLR, for instance)?

Answer 1

THe problem with

<command>   :=  <expr>             |   <id> = <expr> 

is that when you ‘see’ <id> you can’t tell if it’s the beginning of an assignement (second rule) or it’s a ‘<factor>‘. You will only know when you’ll read the next token.

AFAIK ANTLR is LL(*) (and is also able to generate rat-pack parsers if I’m not mistaken) so it will probably handle this grammare considering two tokens at once.

If you can play with the grammar I would suggest to either add a keyword for the assignment (e.g. let x = 8) :

<command>   :=  <expr>             |   'let' <id> '=' <expr> 

or use the = to signify evaluation:

<command>   :=  '=' <expr>             |   <id> '=' <expr>