Re: Generating a simple hand-coded like recursive descent parser

On 9692 day of my life Robert A. Duff wrote:
> Ada has a seemingly similar problem. For example, "X(Y)" might mean
> call function X passing actual parameter Y, or array indexing with X
> as the array and Y as the index, or convert expression Y to type X.
> It might even mean call parameterless function X, which returns an
> array, and use Y as the index.


These operations are very close and they syntax is absolutely same.
And even some optimizations can be performed without distinguishing
them.


> The typical solution in Ada compilers is for the parser to build a
> tree that means "this could be any of ..."...
>
> My question is: can that technique work for the above C and C++
> ambiguities? Does it make the problem easier or harder? Is the
> answer different for C++ than for C?


Type declarations and arithmetic expressions are different: you can
use +, -, /, && etc in arithmetic expressions but you cannot do it in
type declarations. If we just "glue" declarations and expressions, then
parser will accept programs like this:


typedef int b;


...
a = (b+k)-c;


Semantic analysis, of course, can detect such errors, but it I don't
think it is easier than "feedback" parsing.


--
Ivan Boldyrev


                                                                                                        Чуешь "Тайд", чуешь?

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