Compilers. Predictive Parsing. Alex Aiken

Size: px

Start display at page:

Download "Compilers. Predictive Parsing. Alex Aiken"

Myron Dennis
5 years ago
Views:

1 Compilers

2 Like recursive-descent but parser can predict which production to use By looking at the next fewtokens 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

3 In recursive descent, At each step, many choices of production touse Backtracking used to undo badchoices In LL(1), At each step, only one choice of production That is: When a non-terminal A is leftmost in a derivation The next input symbol is t There is either a unique production A α to use Or no production to use (an error state)

4 Recall the grammar Hard to predict because For T two productions start with int For E itis not clear how to predict We need to left-factor the grammar

5 Recall the grammar Factor out common prefixes of productions

6 Choose the alternative that correctlyleft factors if statements in the given grammar EXPR if true then {EXPR } if false then { EXPR} iftrue then { EXPR } else { EXPR } iffalse then { EXPR } else { EXPR } EXPR if BOOL then { EXPR} if BOOL then { EXPR } else { EXPR} BOOL EXPR EXPR BOOL true false EXPR EXPR else { EXPR} if BOOL then { EXPR} true false EXPR if BOOLEXPR EXPR then { EXPR} then { EXPR } else { EXPR} BOOL true false EXPR EXPR BOOL if BOOL then { EXPR } EXPR else { EXPR } true false

7 Choose the alternative that correctlyleft factors if statements in the given grammar EXPR if true then {EXPR } if false then { EXPR} iftrue then { EXPR } else { EXPR } iffalse then { EXPR } else { EXPR } EXPR if BOOL then { EXPR} if BOOL then { EXPR } else { EXPR} BOOL EXPR EXPR BOOL true false EXPR EXPR else { EXPR} if BOOL then { EXPR} true false EXPR if BOOLEXPR EXPR then { EXPR} then { EXPR } else { EXPR} BOOL true false EXPR EXPR BOOL if BOOL then { EXPR } EXPR else { EXPR } true false

8 Left-factored grammar E TX T (E) int Y The LL(1) parsing table: X + E Y * T next input token int * + ( ) $ E T X T X X + E T int Y ( E ) Y * T leftmost non-terminal rhs of production to use

9 Consider the [E, int] entry When current non-terminal is E and next input is int, use production E TX This can generate an int in the first position int * + ( ) $ E T X T X X + E T int Y ( E ) Y * T

10 Consider the [Y,+] entry When current non-terminal is Y and current token is +, get rid of Y Y can be followed by + only if Y int * + ( ) $ E T X T X X + E T int Y ( E ) Y * T

11 Blank entries indicate error situations Consider the [E,*] entry There is no way to derive a string starting with* from non-terminal E int * + ( ) $ E T X T X X + E T int Y ( E ) Y * T

12 Method similar to recursive descent,except For the leftmost non-terminal S We look at the next input tokena And choose the production shown at [S,a] A stack records frontier of parse tree Non-terminals that have yet to beexpanded Terminals that have yet to matched against theinput Top of stack = leftmost pending terminal or non-terminal Reject on reaching error state Accept on end of input &empty stack

13 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 == < >

14 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 == < > For terminal t on top of stack, check t matches next input token. $ marks bottom of stack For non-terminal X on top of stack, look up production Pop X, push production rhs on stack. Note leftmost symbol of rhs is on top of the stack.

15 Stack Input Action E $ int * int $ TX

16 Stack Input Action E $ int * int $ TX T X $ int * int $ int Y

17 Stack Input Action E $ int * int $ TX T X $ int * int $ int Y int Y X$ int * int $ terminal

18 Stack Input Action E $ int * int $ TX T X $ int * int $ int Y int Y X $ int * int $ terminal Y X $ * int $ * T

19 Stack Input Action E $ int * int $ TX T X $ int * int $ int Y int Y X $ int * int $ terminal Y X $ * int $ * T * T X $ * int $ terminal

20 Stack Input Action E $ int * int $ TX T X $ int * int $ int Y int YX $ int * int $ terminal Y X $ * int $ * T * T X $ * int $ terminal T X $ int $ int Y

21 Stack Input Action E $ int * int $ TX 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

22 Stack Input Action E $ int * int $ TX T X $ int * int $ int Y int Y X $ int * int $ terminal YX $ * int $ * T * T X $ * int $ terminal T X $ int $ int Y int Y X $ int $ terminal YX $ $

23 Stack Input Action E $ int * int $ TX T X $ int * int $ int Y int YX $ int * int $ terminal YX $ * int $ * T * T X $ * int $ terminal T X $ int $ int Y int Y X $ int $ terminal YX $ $ X $ $

24 Stack Input Action E $ int * int $ TX 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 YX $ $ X $ $ $ $ ACCEPT

25 Choose the next parse state given the grammar, parse table,and current state below. The initial string is: if true then { true } else { if false then { false } } $ Current if then else { } true false $ E if B then { E}E B B E else { E} B true false Stack E $ $ Input else { if false then { false } } $ $ else {E } $ else { if false then { false } } $ E } $ iffalse then { false } } $ else {if B then {E } E } $ else { if false then { false } } $ E if B then { E} E B E else { E } B true false

26 Choose the next parse state given the grammar, parse table,and current state below. The initial string is: if true then { true } else { if false then { false } } $ Current if then else { } true false $ E if B then { E}E B B E else { E} B true false Stack E $ $ Input else { if false then { false } } $ $ else {E } $ else { if false then { false } } $ E } $ iffalse then { false } } $ else {if B then {E } E } $ else { if false then { false } } $ E if B then { E } E B E else { E } B true false

27 Compilers First Sets AlexAiken

28 First Sets Consider non-terminal A, productiona, & token t T[A,t] = in twocases: If * t can derive a t inthe first position We say that t First( ) If A and * and S * A t Useful if stack has A, input is t, and A cannot derive t In this case only option is to get rid of A (by deriving ) Can work only if t can follow A in at least one derivation We say t Follow(A) AlexAiken

29 First Sets Definition First(X) = { t X * t } { X * } Algorithm sketch: 1. First(t) = {t} 2. First(X) if X if X A 1 A n and First(A i ) for 1 i n 3. First( ) First(X) if X A 1 A n and First(A i ) for 1 i n AlexAiken

30 First Sets Recall the grammar AlexAiken

31 Compilers Follow Sets AlexAiken

32 Follow Sets Definition: Follow(X) = { t S * X t } Intuition If X A B then First(B) Follow(A) and Follow(X) Follow(B) if B * then Follow(X) Follow(A) If S is the start symbol then $ Follow(S) AlexAiken

33 Follow Sets Algorithm sketch: 1. $ Follow(S) 2. First( ) - { } Follow(X) For each production A X 3. Follow(A) Follow(X) For each production A X where First( ) AlexAiken

34 Follow Sets Recall the grammar AlexAiken

35 Compilers LL(1) Parsing Tables

36 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, $] =

37 E TX T (E ) int Y X + E Y * T LL(1) Parsing Tables int * + ( ) $ E T X T X X + E T int Y ( E ) Y * T

38 S S a b First( S ) = { b } Follow( S ) = { $, a } LL(1) Parsing Tables S a b $ b,sa

39 LL(1) Parsing Tables If any entry is multiply defined then G is not LL(1) If G is ambiguous If G is left recursive If G is not left-factored And in other cases as well Most programming language CFGs are not LL(1)

40 LL(1) Grammars LL(1) grammars == they have no multiply-defined entries in the parsing table. Properties of LL(1) grammars: Grammar can t be ambiguous or left recursive Grammar is LL(1) when for all A 1. First( ) First( ) = ; besides, only one of or can derive 2. if derives, then Follow(A) First( ) = Note: It may not be possible for a grammar to be manipulated into an LL(1) grammar

41 Compilers Transition Diagrams

42 Transition Diagrams Unlike lexical equivalents, each edge represents a token Transition implies: if token, match input else call proc

43 Transition Diagrams

44 Transition Diagrams

45 Transition Diagrams

46 Transition Diagrams

47 Transition Diagrams

48 Similar steps for T and T Transition Diagrams

49 Simplified Transition diagrams Transition Diagrams

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

CS1622. Today. A Recursive Descent Parser. Preliminaries. Lecture 9 Parsing (4) 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