Error Handling Syntax-Directed Translation Recursive Descent Parsing

Transcription

1 Error Handling Syntax-Directed Translation Recursive Descent Parsing Lecture 6 by Professor Vijay Ganesh) 1

2 Outline Recursive descent Extensions of CFG for parsing Precedence declarations Error handling Semantic actions Constructing a parse tree 2

3 Recursive Descent Parsing E T T + E T int int * T ( E ) E ( int 5 ) 3

4 Recursive Descent Parsing E T T + E T int int * T ( E ) E T ( int 5 ) 4

5 Recursive Descent Parsing E T T + E T int int * T ( E ) E T int Mismatch: int is not (! Backtrack ( int 5 ) 5

6 Recursive Descent Parsing E T T + E T int int * T ( E ) E T ( int 5 ) 6

7 Recursive Descent Parsing E T T + E T int int * T ( E ) E T int * T Mismatch: int is not (! Backtrack ( int 5 ) 7

8 Recursive Descent Parsing E T T + E T int int * T ( E ) E T ( int 5 ) 8

9 Recursive Descent Parsing E T T + E T int int * T ( E ) E T ( E ) Match! Advance input. ( int 5 ) 9

10 Recursive Descent Parsing E T T + E T int int * T ( E ) E T ( E ) ( int 5 ) 10

11 Recursive Descent Parsing E T T + E T int int * T ( E ) E T ( E ) ( int 5 ) T 11

12 Recursive Descent Parsing E T T + E T int int * T ( E ) E T ( E ) Match! Advance input. ( int 5 ) T int 12

13 Recursive Descent Parsing E T T + E T int int * T ( E ) E T ( E ) Match! Advance input. ( int 5 ) T int 13

14 Recursive Descent Parsing E T T + E T int int * T ( E ) E T ( E ) End of input, accept. ( int 5 ) T int 14

15 A Recursive Descent Parser. Preliminaries Let TOKEN be the type of tokens Special tokens INT, OPEN, CLOSE, PLUS, TIMES Let the global next point to the next token 15

16 A (Limited) 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; } The nth production of S: bool S n () { } Try all productions of S: bool S() { } 16

17 A (Limited) 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 ()); } 17

18 A (Limited) Recursive Descent Parser (4) Functions for non-terminal T bool T 1 () { return term(int); } bool T 2 () { return term(int) && term(times) && T(); } bool T 3 () { return term(open) && E() && term(close); } bool T() { TOKEN *save = next; return (next = save, T 1 ()) (next = save, T 2 ()) (next = save, T 3 ()); } 18

19 Recursive Descent Parsing. Notes. To start the parser Initialize next to point to first token Invoke E() Notice how this simulates the example parse Easy to implement by hand But not completely general Cannot backtrack once a production is successful Works for grammars where at most one production can succeed for a non-terminal 19

20 Example E T T + E ( int ) T int int * T ( E ) bool term(token tok) { return *next++ == tok; } bool E 1 () { return T(); } bool E 2 () { return T() && term(plus) && E(); } bool E() {TOKEN *save = next; return (next = save, E 1 ()) (next = save, E 2 ()); } bool T 1 () { return term(int); } bool T 2 () { return term(int) && term(times) && T(); } bool T 3 () { return term(open) && E() && term(close); } bool T() { TOKEN *save = next; return (next = save, T 1 ()) (next = save, T 2 ()) (next = save, T 3 ()); } 20

21 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() goes 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 21

22 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 ε 22

23 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 ε 23

24 General Left Recursion The grammar S A α δ A S β is also left-recursive because S + S β α This left-recursion can also be eliminated See Dragon Book for general algorithm Section

25 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 25

26 Error Handling Purpose of the compiler is To detect non-valid programs To translate the valid ones Many kinds of possible errors (e.g. in C) Error kind Example Detected by Lexical $ Lexer Syntax x *% Parser Semantic int x; y = x(3); Type checker Correctness your favorite program Tester/User 26

27 Syntax Error Handling Error handler should Report errors accurately and clearly Recover from an error quickly Not slow down compilation of valid code Good error handling is not easy to achieve 27

28 Approaches to Syntax Error Recovery From simple to complex Panic mode Error productions Automatic local or global correction Not all are supported by all parser generators 28

29 Error Recovery: Panic Mode Simplest, most popular method When an error is detected: Discard tokens until one with a clear role is found Continue from there Such tokens are called synchronizing tokens Typically the statement or expression terminators 29

30 Syntax Error Recovery: Panic Mode (Cont.) Consider the erroneous expression ( ) + 3 Panic-mode recovery: Skip ahead to next integer and then continue Bison: use the special terminal error to describe how much input to skip E int E + E ( E ) error int ( error ) 30

31 Syntax Error Recovery: Error Productions Idea: specify in the grammar known common mistakes Essentially promotes common errors to alternative syntax Example: Write 5 x instead of 5 * x Add the production E E E Disadvantage Complicates the grammar 31

32 Error Recovery: Local and Global Correction Idea: find a correct nearby program Try token insertions and deletions Exhaustive search Disadvantages: Hard to implement Slows down parsing of correct programs Nearby is not necessarily the intended program Not all tools support it 32

33 Syntax Error Recovery: Past and Present Past Slow recompilation cycle (even once a day) Find as many errors in one cycle as possible Researchers could not let go of the topic Present Quick recompilation cycle Users tend to correct one error/cycle Complex error recovery is less compelling Panic-mode seems enough 33

34 Abstract Syntax Trees So far a parser traces the derivation of a sequence of tokens The rest of the compiler needs a structural representation of the program Abstract syntax trees Like parse trees but ignore some details Abbreviated as AST 34

35 Abstract Syntax Tree. (Cont.) Consider the grammar E int ( E ) E + E And the string 5 + (2 + 3) After lexical analysis (a list of tokens) int 5 + ( int 2 + int 3 ) During parsing we build a parse tree 35

36 Example of Parse Tree E E + E Traces the operation of the parser int 5 ( E ) Does capture the nesting structure E + int 2 E int 3 But too much info Parentheses Single-successor nodes 36

37 Example of Abstract Syntax Tree PLUS PLUS Also captures the nesting structure But abstracts from the concrete syntax => more compact and easier to use An important data structure in a compiler 37

38 Semantic Actions This is what we ll use to construct ASTs Each grammar symbol may have attributes For terminal symbols (lexical tokens) attributes can be calculated by the lexer Each production may have an action Written as: X Y 1 Y n { action } That can refer to or compute symbol attributes 38

39 Semantic Actions: An Example Consider the grammar E int E + E ( E ) For each symbol X define an attribute X.val For terminals, val is the associated lexeme For non-terminals, val is the expression s value (and is computed from values of subexpressions) We annotate the grammar with actions: E int { E.val = int.val } E 1 + E 2 { E.val = E 1.val + E 2.val } ( E 1 ) { E.val = E 1.val } 39

40 Semantic Actions: An Example (Cont.) String: 5 + (2 + 3) Tokens: int 5 + ( int 2 + int 3 ) Productions Equations E E 1 + E 2 E.val = E 1.val + E 2.val E 1 int 5 E 1.val = int 5.val = 5 E 2 ( E 3 ) E 2.val = E 3.val E 3 E 4 + E 5 E 3.val = E 4.val + E 5.val E 4 int 2 E 4.val = int 2.val = 2 E 5 int 3 E 5.val = int 3.val = 3 40

41 Semantic Actions: Notes Semantic actions specify a system of equations Order of resolution is not specified Example: E 3.val = E 4.val + E 5.val Must compute E 4.val and E 5.val before E 3.val We say that E 3.val depends on E 4.val and E 5.val The parser must find the order of evaluation 41

42 Dependency Graph E + E 1 + E 2 Each node labeled E has one slot for the val attribute Note the dependencies int 5 5 ( E 3 + ) E 4 + E 5 int 2 2 int

43 Evaluating Attributes An attribute must be computed after all its successors in the dependency graph have been computed In previous example attributes can be computed bottom-up Such an order exists when there are no cycles Cyclically defined attributes are not legal 43

44 Dependency Graph E 10 E E 2 5 int 5 5 ( E 3 5 ) E E 5 3 int 2 2 int

45 Semantic Actions: Notes (Cont.) Synthesized attributes Calculated from attributes of descendents in the parse tree E.val is a synthesized attribute Can always be calculated in a bottom-up order Grammars with only synthesized attributes are called S-attributed grammars Most common case 45

46 Inherited Attributes Another kind of attribute Calculated from attributes of parent and/or siblings in the parse tree Example: a line calculator 46

47 A Line Calculator Each line contains an expression E int E + E Each line is terminated with the = sign L E = + E = In second form the value of previous line is used as starting value A program is a sequence of lines P ε P L 47

48 Attributes for the Line Calculator Each E has a synthesized attribute val Calculated as before Each L has an attribute val L E = { L.val = E.val } + E = { L.val = E.val + L.prev } We need the value of the previous line We use an inherited attribute L.prev 48

49 Attributes for the Line Calculator (Cont.) Each P has a synthesized attribute val The value of its last line P ε { P.val = 0 } P 1 L { P.val = L.val; L.prev = P 1.val } Each L has an inherited attribute prev L.prev is inherited from sibling P 1.val Example 49

50 Example of Inherited Attributes P val synthesized P ε 0 L + E = prev inherited E + 4 int 2 2 E 5 int 3 3 All can be computed in depth-first order 50

51 Example of Inherited Attributes P 5 val synthesized P ε L E = prev inherited E int 2 2 E 5 int All can be computed in depth-first order 51

52 Semantic Actions: Notes (Cont.) Semantic actions can be used to build ASTs And many other things as well Also used for type checking, code generation, Process is called syntax-directed translation Substantial generalization over CFGs 52

53 Constructing An AST We first define the AST data type Supplied by us for the project Consider an abstract tree type with two constructors: mkleaf(n) = n mkplus(, ) = PLUS T 1 T 2 T 1 T 2 53

54 Constructing a Parse Tree We define a synthesized attribute ast Values of ast values are ASTs We assume that int.lexval is the value of the integer lexeme Computed using semantic actions E int E.ast = mkleaf(int.lexval) E 1 + E 2 E.ast = mkplus(e 1.ast, E 2.ast) ( E 1 ) E.ast = E 1.ast 54

55 Parse Tree Example Consider the string int 5 + ( int 2 + int 3 ) A bottom-up evaluation of the ast attribute: E.ast = mkplus(mkleaf(5), mkplus(mkleaf(2), mkleaf(3)) PLUS PLUS

56 Summary We can specify language syntax using CFG A parser will answer whether s L(G) and will build a parse tree which we convert to an AST and pass on to the rest of the compiler 56

57 Intro to Top-Down Parsing: The Idea The parse tree is constructed From the top From left to right 1 t 2 3 t 9 Terminals are seen in order of appearance in the token stream: t 5 4 t 6 7 t 8 t 2 t 5 t 6 t 8 t 9 57

58 Recursive Descent Parsing Consider the grammar E T T + E T int int * T ( E ) Token stream is: ( int 5 ) Start with top-level non-terminal E Try the rules for E in order 58