Re: converting this grammar to LL1

> > E-> F = E
> > E -> F
> >
> > F -> id| & id | ( E ) | E [ int ]
>
> I think you'll have to factor out the e[int] alternative as well. How
> the exact rules should be depends on how you want to parse E=E[int]: as
> (E=E)[int] or as E=(E[int])?


If I modify the last rule in the above grammar to


F->id|&id|(E) | F[int]


(just replace 'E' with 'F')


the purpose of last rule is to generate E=(E[int]) instead of (E=E)[int]


then, the modified grammar should be unambiguous.


The problem is "How do I know the modified grammar generate the SAME
language as the original one?"
Or I should ask this question "Is there any algorithm to make this kind of
ambiguity go away?" I am NOT asking for
very general algorithms which can translate ANY ambiguous grammar to
umanbiguous ones because they
might not exist.


For example, there are some general rules to translate this kind of
ambiguous grammar


E->E+E


to either left-recursive or right-recursive grammars. With those
general rules, we are sure that modified grammar can alwasy generate
the same language.


Any rules to translate ambiguity from F->E[int]


thanks


tcs

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