An LL parser is called an LL(k) parser if it uses k tokens of lookahead when parsing a sentence. If such a parser exists for a certain grammar and it can parse sentences of this grammar without backtracking then it is called an LL(k) grammar. Of these grammars LL(1) grammars, although fairly restrictive, are very popular because the corresponding LL parsers only need to look at the next token to make their parsing decisions.
A tablebased topdown parser can be schematically presented as in Figure 1.
+++++++ Input:  (  1  +  1  )  $  +++++++ ^  Stack:  ++ ++    + < Parser > Output ++    S  ++ ++ ^  )   ++   $  ++ ++  Parsing   table  ++ 
Figure 1. Architecture of a tablebased topdown parser 
The parsing table for this grammar looks as follows:
(  )  1  +  $  
S  2    1     
F      3     
Note that there is also a column for the special terminal $ that is used to indicate the end of the input stream.
When the parser starts it always starts on its stack with
[ S, $ ]
where $ is a special terminal to indicate the bottom of the stack and the end of the input stream, and S is the start symbol of the grammar. The parser will attempt to rewrite the contents of this stack to what it sees on the input stream. However, it only keeps on the stack what still needs to be rewritten. For example, let's assume that the input is "( 1 + 1 )". When the parser reads the first "(" it knows that it has to rewrite S to "( S + F )" and writes the number of this rule to the output. The stack then becomes:
[ (, S, +, F, ), $ ]
In the next step it removes the '(' from its input stream and from its stack:
[ S, +, F, ), $ ]
Now the parser sees an '1' on its input stream so it knows that it has to apply rule (1) and then rule (3) from the grammar and write their number to the output stream. This results in the following stacks:
[ F, +, F, ), $ ] [ 1, +, F, ), $ ]
In the next two steps the parser reads the '1' and '+' from the input stream and also removes them from the stack, resulting in:
[ F, ), $ ]
In the next three steps the 'F' will be replaced on the stack with '1', the number 3 will be written to the output stream and then the '1' and ')' will be removed from the stack and the input stream. So the parser ends with both '$' on its stack and on its input steam. In this case it will report that it has accepted the input string and on the output stream it has written the list of numbers [ 2, 1, 3, 3 ] which is indeed a rightmost derivation if the input string in reverse.
As can be seen from the example the parser performs three types of steps depending on whether the top of the stack is a nonterminal, a terminal or the special symbol $:
In order to fill the parsing table we have to establish what grammar rule the parser should choose if it sees a nonterminal A on the top of its stack and symbol a on its input stream. It is easy to see that such a rule should be of the from A > w and that the language corresponding with w should have at least one string starting with a. For this purpose we define the Firstset of w, written here as Fi(w), as the terminals with which the strings that belong to w start plus ε if the empty strings also belongs to w. Given a grammar with the rules A_{1} > w_{1}, ..., A_{n} > w_{n} we can compute the Fi(w_{i}) and Fi(A_{i}) for every rule as follows:
Unfortunately the Firstsets are not sufficient to compute the parsing table. This is because a righthand side w of a rule might ultimately be rewritten to the empty string. So the parser should also use the a rule A > w if ε is in Fi(w) and it sees on the input stream a symbol that could follow A. Therefore we also need the Followset of A, written as Fo(A) here, which is defined as the set of terminals a such that there is a string of symbols αAaβ that can be derived from the start symbol. Computing the Followsets for the nonterminals in a grammar can be done as follows:
Now we can define exactly which rules will be contained where in the parsing table. If T[A, a] denotes the entry in the table for nonterminal A and terminal a then
If the table will contain at most one rule in every one of its cells then the parser will always know which rule it has to use and can therefore parse strings without backtracking. It is precisely in this case that the grammar is called an LL(1) grammar.
... yet to be written ...
Search Encyclopedia

Featured Article
