Massaging Grammars

Massaging Grammars

1. We have seen that for a given language some grammars may be harder to parse with than others (In fact, some may be impossible to parse with "deterministically"). Accordingly, one sometimes must apply techniques for rewriting a grammar into a more appropriate form.

2. We have already used on of these techniques known as left-factoring. Remember the problem I noted with using the standard rules for an if statement in a top down parser.

   < stmt >		if < expr > then < stmt > end
   	|	if < expr > then < stmt > else < stmt > end

   The problem can be remedied by "factoring" out the common prefix of these two productions giving the rules:

   < stmt >		if < expr > then < stmt > < iftail >
   < iftail >		else < stmt > end
   	|	end

   Note, however, that the phrase structure one gets by parsing may no longer be quite what you had in mind.

3. Another common problem one may encounter in a grammar is a self-recursive rule.

   • A left recursive rule (i.e. of the form A A alpha) is fatal in a top-down parser because if the parser chooses to apply such a rule once it will do so indefinitely .

   • A right recursive rule (i.e. of the form A alpha A) is undesirable (i.e. I better not see any in your parsers) in a bottom up parser because it may lead to overflow in the parser's stack.

4. Grammar alterations designed to avoid undesirable forms of recursion can seriously impact phrase structure.

   • Consider a simple grammar for statement lists:

     < slist >		< stmt >
     	|	< stmt > ; < slist >

   • The parse tree produced for a list of statement using this grammar would look like:

     

     With the exception of the dangling semi-colons, this should look a lot like the syntax tree my parser builds for statement lists (and other list nodes).

   • Unfortunately, A grammar of this form forces a bottom-up parser to shift all the statements onto the stack before reducing any of them to "slists". This wastes memory.

   • It isn't difficult to fix this by switching to the grammar:

     < slist >		< stmt >
     	|	< slist > ; < stmt >

     This grammar:

     • describes the same language, and

     • can be parsed efficiently bottom-up.

   • The trees produced by the alternate grammar would look more like:

     

     If you think about how to process the statements in this tree in the order in which they would be executed, you will quickly realize that a simple loop can't do it.

Massaging Grammars