Re: LL(1)/Recursive Descent Parsing Question

"Neelakantan Krishnaswami" <neelk@alum.mit.edu> wrote in message
> I'm working on the syntax for a small programming language, and I'd
> like to make sure that my language is parseable with an LL(1) grammar.
> However, I'm still messing around with the grammar, and it's quite
> unpleasant to have to write my grammar rules in an epsilon-free,
> left-factored left-recursion-free form.
>
Yes, grammars are difficult.


[snip]


> Eg, I might write
>
> sequence(start:RPAREN, element:<expr>, delimiter:COMMA, close:LPAREN)
>
OK.
You want then:


')' <expr> ',' expr , ... until you hit '('


The right paren is quite difficult for a start. At any expresion you can
have:
        a = (b+C);
That right parentheses could be mis-understood.


I am supposing that you mean:


( (expr ,) *)


i.e. a sequence of expressions separated by commas enclosed in parentheses.


You scan an expression, looking for the "end of expression" marker, in this
case either the comma or (probably) the semi-colon. Your software knows if
it is in a sequence or not after it has scanned the first expression. You
are in a sequence only if a comma has been seen.


Not very difficult. Keep things simple, with as little complexity as
possible.




But...
Enclosing a sequence of expressions in parentheses and attach some meaning
to that?


Interesting... I associate it with a parallel language, statement lists that
could be executed in parallel.


A bucket would be a set of independent calculations, that can be performed
in parallel, separated by commas.


good luck


jacob

Return to the comp.compilers page.
Search the comp.compilers archives again.