CS1622. Today. A Recursive Descent Parser. Preliminaries. Lecture 9 Parsing (4)

Size: px

Start display at page:

Download "CS1622. Today. A Recursive Descent Parser. Preliminaries. Lecture 9 Parsing (4)"

Camron Robertson
6 years ago
Views:

1 CS1622 Lecture 9 Parsing (4) CS 1622 Lecture 9 1 Today Example of a recursive descent parser Predictive & LL(1) parsers Building parse tables CS 1622 Lecture 9 2 A Recursive Descent Parser. Preliminaries Let TOKEN be the type of tokens Special tokens INT, OPEN, CLOSE, PLUS, TIMES Let the global variable next point to the next token CS 1622 Lecture 9 3 1

2 A Recursive Descent Parser (2) Define boolean functions that check the token string for a match of A given token terminal bool term(token tok) { return *next++ == tok; } S -> S 1 S 2 S S n A given production of S (the n th ) bool S n () { } Any production of S: bool S() { } These functions advance next CS 1622 Lecture 9 4 A Recursive Descent Parser (3) For production E T bool E 1 () { return T(); } For production E T + E bool E 2 () { return T() && term(plus) && E(); } For all productions of E (with backtracking) bool E() { TOKEN *save = next; return (next = save, E 1 ()) (next = save, E 2 ()); } CS 1622 Lecture 9 5 A Recursive Descent Parser (4) Functions for non-terminal T bool T 1 () { return term(open) && E() && term(close); } bool T 2 () { return term(int) && term(times) && T(); } bool T 3 () { return term(int); } bool T() { TOKEN *save = next; return (next = save, T 1 ()) (next = save, T 2 ()) (next = save, T 3 ()); } CS 1622 Lecture 9 6 2

3 Recursive Descent Parsing. Notes. To start the parser Initialize next to point to first token Invoke E() Notice how this simulates our previous example Easy to implement by hand But does not always work CS 1622 Lecture 9 7 When Recursive Descent Does Not Work Consider a production S S a bool S 1 () { return S() && term(a); } bool S() { return S 1 (); } S() will get into an infinite loop A left-recursive grammar has a non-terminal S S + Sα for some α Recursive descent does not work in such cases CS 1622 Lecture 9 8 Elimination of Left Recursion Consider the left-recursive grammar S S α β S generates all strings starting with a β and followed by a number of α Can rewrite using right-recursion S β S S α S ε CS 1622 Lecture 9 9 3

4 More Elimination of Left- Recursion In general S S α 1 S α n β 1 β m All strings derived from S start with one of β 1,,β m and continue with several instances of α 1,,α n Rewrite as S β 1 S β m S S α 1 S α n S ε CS 1622 Lecture 9 10 General Left Recursion The grammar S A α δ A S β is also left-recursive because S + S β α This left-recursion can also be eliminated - won t go into this CS 1622 Lecture 9 11 Summary of Recursive Descent Simple and general parsing strategy Left-recursion must be eliminated first but that can be done automatically Unpopular because of backtracking Too inefficient In practice, backtracking is eliminated by restricting the grammar CS 1622 Lecture

5 When Recursive Descent Does Not Work Consider a production S S a bool S 1 () { return S() && term(a); } bool S() { return S 1 (); } S() will get into an infinite loop A left-recursive grammar has a non-terminal S S + Sα for some α Recursive descent does not work in such cases CS 1622 Lecture 9 13 Elimination of Left Recursion Consider the left-recursive grammar S S α β S generates all strings starting with a β and followed by a number of α Can rewrite using right-recursion S β S S α S ε CS 1622 Lecture 9 14 More Elimination of Left- Recursion In general S S α 1 S α n β 1 β m All strings derived from S start with one of β 1,,β m and continue with several instances of α 1,,α n Rewrite as S β 1 S β m S S α 1 S α n S ε CS 1622 Lecture

6 General Left Recursion The grammar S A α δ A S β is also left-recursive because S + S β α This left-recursion can also be eliminated - won t go into this CS 1622 Lecture 9 16 Summary of Recursive Descent Simple and general parsing strategy Left-recursion must be eliminated first but that can be done automatically Unpopular because of backtracking Thought to be too inefficient In practice, backtracking is eliminated by restricting the grammar CS 1622 Lecture 9 17 Predictive Parsers Like recursive-descent but parser can predict which production to use By looking at the next few tokens No backtracking Predictive parsers accept LL(k) grammars L means left-to-right scan of input L means leftmost derivation k means predict based on k tokens of lookahead In practice, LL(1) is used CS 1622 Lecture

7 LL(1) Languages In recursive-descent, for each non-terminal and input token there may be a choice of production LL(1) means that for each non-terminal and token there is only one production Implementation Recursive procedures Table driven: Can be specified via 2D table One dimension for current non-terminal to expand One dimension for next token A table entry contains one production CS 1622 Lecture 9 19 Predictive Parser Avoid Backtracking by selecting the correct production How? Use look ahead LL(1) uses 1 lookahead Must structure the grammar to enable this A a B c D e F Not A a B a C CS 1622 Lecture 9 20 Predictive Parsing and Left Factoring Consider the expression grammar E T + E T T int int * T ( E ) Hard to predict because For T two productions start with int For E it is not clear how to predict A grammar must be left-factored before use for predictive parsing CS 1622 Lecture

8 Left-Factoring Example Recall the grammar E T + E T T int int * T ( E ) Factor out common prefixes of productions E T X X + E ε T ( E ) int Y Y * T ε CS 1622 Lecture 9 22 Predictive Parsing Basic idea Given A α β, the parser should be able to choose between α & β FIRST sets (see later how to compute) For some rhs α G, define FIRST(α) as the set of tokens that appear as the first symbol in some string derived from α That is, x FIRST(α) iff α * x γ, for some γ (Pursuing this idea leads to LL(1) parser generators...) Note: x is terminal token CS 1622 Lecture 9 23 LL(1) Property The LL(1) Property If A α β both appear in the grammar, α and β are strings consisting of terminal and non-terminals, we would like FIRST(α) FIRST(β) = (see later how to compute) This would allow the parser to make a correct choice with a lookahead of exactly one symbol! CS 1622 Lecture

9 LL(1) Parsing Consider A β 1 β 2 β 3, with FIRST(β 1 ) FIRST(β 2 ) FIRST(β 3 ) = /* find an A */ if (current_word FIRST(β 1 )) do β 1 else if (current_word FIRST(β 2 )) do β 2 else if (current_word FIRST(β 3 )) do β 3 else report an error and return false CS 1622 Lecture 9 25 Predictive Recursive Descent Parsing 1 Goal! Expr 2 Expr! Term Expr" 3 Expr"! + Term Expr" 4 - Term Expr" 5 # 6 Term! Factor Term" 7 Term"! * Factor Term" 8 / Factor Term" 9 # 10 Factor! number 11 id This produces a parser with six mutually recursive routines: Goal Expr Expr_Prime Term Term_Prime Factor Each recognizes one nonterminal CS 1622 Lecture 9 26 Recursive Descent Parsing Goal( ) token next_token( ); if (Expr( ) = true) then next compilation step; else return false; Expr( ) result true; if (Term( ) = false) then result false; else if (EPrime( ) = false) then result false; return result; Factor( ) result true; if (token = Number) then token next_token( ); else if (token = identifier) then token next_token( ); else report syntax error; result false; return result; CS 1622 Lecture

10 Implementation Alternative Recursive procedures expensive Stack space & call overhead Parsing table + driver normally used as alternative CS 1622 Lecture 9 28 LL(1) Parsing Table Example E X T Y Left-factored grammar E T X T ( E ) int Y The LL(1) parsing table: int T X int Y * * T + + E ε ( T X ( E ) X + E ε Y * T ε CS 1622 Lecture 9 29 ) ε ε $ ε ε LL(1) Parsing Table Example (Cont.) Consider the [E, int] entry When current non-terminal is E and next input is int, use production E T X This production can generate an int in the first place Consider the [Y,+] entry When current non-terminal is Y and current token is +, get rid of Y Y can be followed by + only in a derivation in which Y ε CS 1622 Lecture

11 LL(1) Parsing Tables. Errors Blank entries indicate error situations Consider the [E,*] entry There is no way to derive a string starting with * from non-terminal E CS 1622 Lecture 9 31 Using Parsing Tables Method similar to recursive descent, except For each non-terminal S We look at the next token a And chose the production shown at [S,a] We use a stack to keep track of pending nonterminals - instead of procedure stack! We reject when we encounter an error state We accept when we encounter end-of-input CS 1622 Lecture 9 32 LL(1) Parsing Algorithm initialize stack = <S $> and next repeat case stack of <X, rest> : if T[X,*next] = Y 1 Y n then stack <Y 1 Y n rest>; else error (); <t, rest> : if t == *next ++ then stack <rest>; else error (); until stack == < > CS 1622 Lecture

12 LL(1) Parsing Example Stack Input Action E $ int * int $ T X T X $ int * int $ int Y int Y X $ int * int $ terminal Y X $ * int $ * T * T X $ * int $ terminal T X $ int $ int Y int Y X $ int $ terminal Y X $ $ ε X $ $ ε $ $ ACCEPT CS 1622 Lecture 9 34 Constructing Parsing Tables LL(1) languages are those defined by a parsing table for the LL(1) algorithm No table entry can be multiply defined We want to generate parsing tables from CFG CS 1622 Lecture 9 35 Constructing Parsing Tables (Cont.) If A α, where in the line of A we place α? In the column of t where t can start a string derived from α α * t β We say that t First(α) In the column of t if α is ε and t can follow an A S * β A t δ We say t Follow(A) CS 1622 Lecture

13 Computing First Sets Definition First(X) = { t X * tα} {ε X * ε} Algorithm: First(t) = { t } ε First(X) if X ε is a production ε First(X) if X A 1 A n and ε First(A i ) for 1 i n First(α) First(X) if X A 1 A n α and ε First(A i ) for 1 i n CS 1622 Lecture 9 37 First Sets. Example Recall the grammar E T X X + E ε T ( E ) int Y Y * T ε First sets First( ( ) = { ( } First( T ) = {int, ( } First( ) ) = { ) } First( E ) = {int, ( } First( int) = { int } First( X ) = {+, ε } First( + ) = { + } First( Y ) = {*, ε } First( * ) = { * } CS 1622 Lecture 9 38 Computing Follow Sets for Nonterminals Follow(S) needed for productions that generate the empty string ε Definition: Follow(X) = { t S * β X t δ } Note that ε CAN NEVER BE IN FOLLOW(X)!! Intuition If X A B then First(B) Follow(A) and Follow(X) Follow(B) Also if B * ε then Follow(X) Follow(A) If S is the start symbol then $ Follow(S) CS 1622 Lecture

14 Computing Follow Sets (Cont.) Algorithm sketch: $ Follow(S) For each production A α X β First(β) - {ε} Follow(X) For each production A α X β where ε First(β) Follow(A) Follow(X) CS 1622 Lecture 9 40 Follow Sets. Example Recall the grammar E T X T ( E ) int Y Follow sets X + E ε Y * T ε Follow( E ) = {), $} Follow( X ) = {$, ) } Follow( T ) = {+, ), $} Follow( Y ) = {+, ), $} CS 1622 Lecture 9 41 Constructing LL(1) Parsing Tables Construct a parsing table T for CFG G For each production A α in G do: For each terminal t First(α) do T[A, t] = α If ε First(α), for each t Follow(A) do T[A, t] = α If ε First(α) and $ Follow(A) do T[A, $] = α CS 1622 Lecture

15 Notes on LL(1) Parsing Tables If any entry is multiply defined then G is not LL(1). Possible reasons: If G is ambiguous If G is left recursive If G is not left-factored Grammar is not LL(1) Most programming language grammars are not LL(1) Some can be made LL(1) though but others can t There are tools that build LL(1) tables E.g. LLGen CS 1622 Lecture

Building a Parser III. CS164 3:30-5:00 TT 10 Evans. Prof. Bodik CS 164 Lecture 6 1

Building a Parser III. CS164 3:30-5:00 TT 10 Evans. Prof. Bodik CS 164 Lecture 6 1 Building a Parser III CS164 3:30-5:00 TT 10 Evans 1 Overview Finish recursive descent parser when it breaks down and how to fix it eliminating left recursion reordering productions Predictive parsers (aka