# Top-Down Parsing and Intro to Bottom-Up Parsing. Lecture 7

Size: px
Start display at page:

Transcription

1 Top-Down Parsing and Intro to Bottom-Up Parsing Lecture 7 1

2 Predictive Parsers Like recursive-descent but parser can predict which production to use Predictive parsers are never wrong Always able to guess correctly which production will lead to a successful parse, provided a string is in L(G). Two strategies allow this: By looking at next few tokens Lookahead By restricting the form of the grammar 2

3 Predictive Parsers Advantage: No backtracking So parsing is completely deterministic Predictive parsers accept LL(k) grammars L means left-to-right scan of input We always do this, so all our techniques would have L in first position L means leftmost derivation k means predict based on k tokens of lookahead Theory is developed for arbitrary k, but In practice, LL(1) is used 3

4 LL(1) vs. Recursive Descent In recursive-descent, At each step, many choices of production to use Backtracking used to undo bad choices In LL(1), At each step, only one choice of production That is When a non-terminal A is leftmost non-terminal in a derivation And the next input symbol is token t There is a unique production A α to use Or no production to use (an error state) Any other production is guaranteed to be incorrect But even the single production A α might not end up succeeding Put another way, in LL(1), there is AT MOST one production to be used in a given situation 4

5 LL(1) vs. Recursive Descent In recursive-descent, At each step, many choices of production to use Backtracking used to undo bad choices In LL(1), At each step, only one choice of production That is When a non-terminal A is leftmost non-terminal in a derivation And the next input symbol is token t There is a unique production A α to use Or no production to use (an error state) LL(1) is a recursive descent variant without backtracking 5

6 Predictive Parsing and Left Factoring Recall our favorite grammar E T + E T T int int * T ( E ) Hard to predict because For T two productions start with int With lookahead 1, can t choose which production For E it is not clear how to predict What s more T is a non-terminal so how do we even do the prediction? Regardless T starts both productions of E, so with single token of lookahead, not going to be easy to know what to do

7 Predictive Parsing and Left Factoring Recall our favorite grammar E T + E T T int int * T ( E ) This grammar is unacceptable for LL(1) parsing Hard to predict because For T two productions start with int With lookahead 1, can t choose which production For E it is not clear how to predict What s more T is a non-terminal so how do we even do the prediction? We need to left-factor the grammar 7

8 The Idea Behind Left Factoring Eliminate the common prefixes of multiple productions for a given non-terminal Ex: In English: If for some non-terminal there are multiple productions that have the same prefix, we want to get rid of that (somehow) E T + E T T int int * T ( E ) E has two productions with prefix T T has two productions with prefix int 8

9 Left-Factoring Example Recall the grammar E T + E T T int int * T ( E ) Factor out common prefixes of productions So the prefix appears in only one production E T X X + E ε T ( E ) int Y Y * T ε But multiple suffixes! New nonterminals X and Y handle suffixes 9

10 Left-Factoring Example Recall the grammar E T + E T T int int * T ( E ) Factor out common prefixes of productions So the prefix appears in only one production E T X X + E ε T ( E ) int Y Y * T ε Effectively delays the decision about which production we re using 10

11 LL(1) Parsing Table Example Left-factored grammar E T X 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 11

12 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 can generate an int in the first position 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 ε 12

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

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

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

16 LL(1) Parsing Algorithm \$ marks bottom of stack initialize stack = <S \$> and next repeat case stack of For non-terminal X on top of stack, lookup production <X, rest> : if T[X,*next] = Y 1 Y n then stack <Y 1 Y n rest>; else error (); <t, rest> : if t == *next ++ For terminal t on top of stack, check t matches next input token. until stack == < > then stack <rest>; else error (); Pop X, push production rhs on stack. Note leftmost symbol of rhs is on top of the stack. 16

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

18 Our Short Term Goal How do we construct LL(1) parse tables? What are the conditions necessary for constructing LL(1) parse tables? 18

19 Constructing Parsing Tables: The Intuition Consider non-terminal A, production A α, & token t The question: Given A and t, under what conditions will we make the move A α? That is, under what conditions is T[A,t] = α? 19

20 Constructing Parsing Tables: The Intuition Consider non-terminal A, production A α, & token t T[A,t] = α in two cases: Note this is * If α * t β α can derive a t in the first position We say that t First(α) 20

21 Constructing Parsing Tables: The Intuition Consider non-terminal A, production A α, & token t T[A,t] = α in two cases: note β and δ Now, assume t First(α) can be anything Doesn t sound very promising to use α But it turns out it may not be hopeless to use A α 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) I.e., t is one of the things that can come after A in the grammar

22 Often A Point of Confusion We are NOT talking about A deriving t A does not produce t We ARE talking about t appearing in a derivation directly after A So this has nothing to do with what A produces Has to do with where A can appear in derivations But for right now, let s concentrate on First sets (We ll get to Follow sets in a bit) 22

23 Computing First Sets Definition First(X) = { t X * tα} {ε X * ε} Note: X can be a single terminal, it could be a single non-terminal, or it could be a string of grammar symbols t however, must be a terminal For technical reasons, ε needs to be in First(X) if it s the case that X can go to ε in zero or more steps Need to keep track of this in order to compute all of the terminals that are in the first set of a given grammar symbol

24 Computing First Sets Definition First(X) = { t X * tα} {ε X * ε} Algorithm sketch: 1. For t a terminal, First(t) = { t } 2. For X a non-terminal ε First(X) if X ε if X A 1 A n and ε First(A i ) for 1 i n Note this can only happen if all of the A i are non-terminals, since if there are any terminals on the R.H.S. then it can never completely go to ε 24

25 Computing First Sets Definition First(X) = { t X * tα} {ε X * ε} Algorithm sketch: 1. For t a terminal, First(t) = { t } 2. For X a non-terminal ε 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 Make sure it s clear to you why (3) is true 25

26 Computing First Sets Definition First(X) = { t X * tα} {ε X * ε} Algorithm sketch: 1. For t a terminal, First(t) = { t } 2. For X a non-terminal ε 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 Note: Rule (1) covers terminals; (2) and (3) cover nonterminals

27 First Sets. Example Recall the grammar E T X T ( E ) int Y X + E ε Y * T ε First sets First( ( ) = { ( } First( T ) = {int, ( } First( ) ) = { ) } First( E ) = {int, ( } First( int) = { int } First( X ) = {+, ε } First( + ) = { + } First( Y ) = {*, ε } First( * ) = { * } 27

28 Computing Follow Sets Definition: Follow(X) = { t S * β X t δ } Recall that the definition of the Follow set for a given symbol in the grammar is not about what that symbol can generate, but on where that symbol can appear In words, t is in Follow(X) if there is some derivation where terminal t can appear immediately after the symbol X 28

29 Computing 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) Recall that \$ is special symbol marking end of input

30 Computing 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) That is, \$ is in the Follow of the start symbol Always added as an initial condition

31 Computing Follow Sets (Cont.) 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(β) 31

32 When is \$ in Follow(α)? Students are often confused about \$, so let s discuss exactly when \$ is in Follow(α) (This is important, since we ll be using Follow sets to build the parse table) 32

33 First, Some New Language If S is the start symbol of a grammar G, and α is such that S * α, then α is a sentential form of G Note α may contain both terminals and nonterminals A sentence of G is a sentential form that contains no nonterminals. Technically speaking, the language of G, L(G), is the set of sentences of G 33

34 So, the rule: \$ is in Follow(α) if and only if α can appear at the end of a sentential form EX: Consider the following grammar E TX X Ta Cb T Tc ε C a b Note that neither B nor C can end a sentential form (why?), so \$ is not in Follow(B) or Follow(C). But \$ is in Follow(X).

35 Follow Sets. Example Recall the grammar E T X T ( E ) int Y X + E ε Y * T ε Follow sets Follow( + ) = { int, ( } Follow( * ) = { int, ( } Follow( ( ) = { int, ( } Follow( E ) = {), \$} Follow( X ) = {\$, ) } Follow( T ) = {+, ), \$} Follow( ) ) = {+, ), \$} Follow( Y ) = {+, ), \$} Follow( int) = {*, +, ), \$} Note, unlike with First sets, Follow sets for terminals can actually be interesting.

36 Follow Sets. Example Recall the grammar E T X T ( E ) int Y X + E ε Y * T ε Follow sets Follow( + ) = { int, ( } Follow( * ) = { int, ( } Follow( ( ) = { int, ( } Follow( E ) = {), \$} Follow( X ) = {\$, ) } Follow( T ) = {+, ), \$} Follow( ) ) = {+, ), \$} Follow( Y ) = {+, ), \$} Follow( int) = {*, +, ), \$} Note Follow( ( ). It makes sense: what can follow an ( in the language? A nested ( or an int

37 Follow Sets. Example Recall the grammar E T X T ( E ) int Y X + E ε Y * T ε Follow sets Follow( + ) = { int, ( } Follow( * ) = { int, ( } Follow( ( ) = { int, ( } Follow( E ) = {), \$} Follow( X ) = {\$, ) } Follow( T ) = {+, ), \$} Follow( ) ) = {+, ), \$} Follow( Y ) = {+, ), \$} Follow( int) = {*, +, ), \$} Similarly, Follow( + ). What can follow + in the language? A new ( or an int. Can t be \$ (end input)

38 So Now We re going to pull together what we know about first and follow sets to construct LL(1) parsing tables. This is done one production at a time, eventually considering every production in the grammar Recall: First(X) = { t X * tα} {ε X * ε} Follow(X) = { t S * β X t δ } 38

39 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(A) do T[A, t] = α If ε First(α), for each t Follow(A) do T[A, t] = α If ε First(α) and \$ Follow(A) do T[A, \$] = α (note this is a special case, since \$ is technically not a terminal symbol) 39

40 Constructing LL(1) Parsing Tables Construct a parsing table T for CFG G Note: α might be ε For each production A α in G do: For each terminal t First(A) do T[A, t] = α If ε First(α), for each t Follow(A) do T[A, t] = α If ε First(α) and \$ Follow(A) do T[A, \$] = α (note this is a special case, since \$ is technically not a terminal symbol) This is the algorithm for building LL(1) tables!

41 LL(1) Parsing Table Example Left-factored grammar E T X 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 41

42 Reference First( ( ) = { ( } First( T ) = {int, ( } First( ) ) = { ) } First( E ) = {int, ( } First( int) = { int } First( X ) = {+, ε } First( + ) = { + } First( Y ) = {*, ε } First( * ) = { * } Follow( + ) = { int, ( } Follow( * ) = { int, ( } Follow( ( ) = { int, ( } Follow( E ) = {), \$} Follow( X ) = {\$, ) } Follow( T ) = {+, ), \$} Follow( ) ) = {+, ), \$} Follow( Y ) = {+, ), \$} Follow( int) = {*, +, ), \$}

43 Another Example S Sa b First(S) = {b}, Follow(S) = {\$, a} The LL(1) parsing table: S a b \$ b Sa ε The problem: both productions can produce a b in the first position, giving entry with multiple moves 43

44 Notes on 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 These amount to quick checks for NOT LL(1)-ness In fact, definition of LL(1) is that a grammar is NOT LL(1) iff the built LL(1) table has a multiply defined entry Most programming language CFGs are not LL(1) 44

45 Bottom Line on LL(1) Parsing Most programming language CFGs are not LL(1) LL(1) grammars are just too weak to capture all of the interesting and important structures in realworld programming languages There are more powerful formalisms for describing practical grammars So, why bother with LL(1)? Well, it turns out that these formalisms build on everything we ve learned here for LL(1) grammars, so our effort is not wasted. Ideas just assembled in a more sophisticated way to build more powerful parts 45

46 Bottom-Up Parsing Bottom-up parsing is more general than (deterministic) top-down parsing And just as efficient Builds on ideas in top-down parsing Bottom-up is the preferred method Used in most parser generator tools (including CUP) Concepts today, algorithms next time 46

47 Recall where we are: We talked about Recursive Descent parsing, which is completely general but requires backtracking. Then we talked about LL(1), which is not completely general, but requires no backtracking. We are now embarking on bottom-up parsing. 47

48 An Introductory Example Bottom-up parsers don t need left-factored grammars Recall what left-factored means: (no two productions with the same prefix) Revert to the natural grammar for our example: E T + E T T int * T int (E) natural in quotes because we still have to deal with precedence of + and * 48

49 An Introductory Example Bottom-up parsers don t need left-factored grammars Recall what left-factored means Revert to the natural grammar for our example: E T + E T T int * T int (E) Consider the string: int * int + int 49

50 The Idea Bottom-up parsing reduces a string to the start symbol by inverting productions (running them backwards) int * int + int int * T + int T + int T + T T + E E T int T int * T T int E T E T + E Left column is a sequence of states. right side is productions used. 50

51 Observation Read the productions in reverse (from bottom to top) Read in the order we did them, called reductions This is a rightmost derivation! int * int + int int * T + int T + int T + T T + E E T int T int * T T int E T E T + E 51

52 Important Fact #1 Important Fact #1 about bottom-up parsing: A bottom-up parser traces a rightmost derivation in reverse If you re ever having trouble with bottom-up parsing, it s good to come back to this basic fact 52

53 The Idea A top-down parser begins with the start symbol and produces the tree incrementally by expanding some non-terminal at the frontier A bottom-up parser begins with all ALL the leaves of the parse tree (the entire input) and builds little trees on top of those It pastes all the subtrees that it s built so far together to create the entire parse tree 53

54 A Bottom-up Parse int * int + int E int * T + int T + int T E T + T T + E T T E int * int + int 54

55 A Bottom-up Parse in Detail (1) int * int + int int * int + int 55

56 A Bottom-up Parse in Detail (2) int * int + int int * T + int T int * int + int 56

57 A Bottom-up Parse in Detail (3) int * int + int int * T + int T + int T T int * int + int 57

58 A Bottom-up Parse in Detail (4) int * int + int int * T + int T + int T T + T T T int * int + int 58

59 A Bottom-up Parse in Detail (5) int * int + int int * T + int T + int T E T + T T + E T T int * int + int 59

60 A Bottom-up Parse in Detail (6) int * int + int E int * T + int T + int T E T + T T + E T T E int * int + int 60

61 A Trivial Bottom-Up Parsing Algorithm Let I = input string repeat pick a non-empty substring β of I where X β is a production if no such β, backtrack replace one β by X in I until I = S (the start symbol) or all possibilities are exhausted 61

62 Questions Does this algorithm terminate? How fast is the algorithm? Does the algorithm handle all cases? How do we choose the substring to reduce at each step? 62

63 Where Do Reductions Happen? Important Fact #1 has an interesting consequence: Let αβω be a step of a bottom-up parse Assume the next reduction is by X β Then ω is a string of terminals Why? Because αxω αβω is a step in a rightmost derivation Recall Fact #1: Bottom-up parser traces a rightmost derivation in reverse.

64 Notation Idea: Split string into two substrings Right substring is as yet unexamined by parsing (a string of terminals) Turns out terminal symbols to right of right most nonterminal are exactly the unexamined input in bottom-up parsing Left substring has terminals and non-terminals E.g., if we have αxω, and X is the rightmost nonterminal, then ω is the input we have not read yet 64

65 Notation The dividing point is marked by a The is not part of the string Initially, all input is unexamined x 1 x 2... x n After some input has been examined: x 1 x 2 x 3 x 4... x n processed unprocessed 65

66 Shift-Reduce Parsing Bottom-up parsing uses only two kinds of actions: Shift moves Reduce moves 66

67 Shift Shift: Move one place to the right Shifts a terminal to the left string Equivalently reads one token of input In example below, the shift indicates that token x can now be considered as part of processing y and z remain unprocessed and unread at this point ABC xyz ABCx yz 67

68 Reduce Move Apply an inverse production at the right end of the left string If A xy is a production, then Cbxy ijk CbA ijk 68

69 Previously Seen Example with Reductions Only E T + E T T int * T int (E) int * int + int int * T + int reduce T int reduce T int * T T + int T + T T + E E reduce T int reduce E T reduce E T + E 69

70 The Example with Shift-Reduce Parsing int * int + int int * int + int int * int + int int * int + int int * T + int T + int T + int T + int T + T T + E E shift shift shift reduce T int reduce T int * T shift shift reduce T int reduce E T reduce E T + E E T + E T T int * T int (E) 70

71 Note: In this derivation, and in the details of it that follows, all I m showing is that there exists a sequence of shift and reduce moves that can successfully parse the input string. I do not (yet) explain how we choose whether to perform a shift or reduce move. 71

72 A Shift-Reduce Parse in Detail (1) int * int + int int * int + int 72

73 A Shift-Reduce Parse in Detail (2) int * int + int int * int + int int * int + int 73

74 A Shift-Reduce Parse in Detail (3) int * int + int int * int + int int * int + int int * int + int 74

75 A Shift-Reduce Parse in Detail (4) int * int + int int * int + int int * int + int int * int + int int * int + int 75

76 A Shift-Reduce Parse in Detail (5) int * int + int int * int + int int * int + int int * int + int int * T + int T int * int + int 76

77 A Shift-Reduce Parse in Detail (6) int * int + int int * int + int int * int + int int * int + int int * T + int T + int T T int * int + int 77

78 A Shift-Reduce Parse in Detail (7) int * int + int int * int + int int * int + int int * int + int int * T + int T + int T + int T T int * int + int 78

79 A Shift-Reduce Parse in Detail (8) int * int + int int * int + int int * int + int int * int + int int * T + int T T + int T + int T T + int int * int + int 79

80 A Shift-Reduce Parse in Detail (9) int * int + int int * int + int int * int + int int * int + int int * T + int T T + int T + int T T T + int T + T int * int + int 80

81 A Shift-Reduce Parse in Detail (10) int * int + int int * int + int int * int + int int * int + int int * T + int T E T + int T + int T T T + int T + T T + E int * int + int 81

82 A Shift-Reduce Parse in Detail (11) int * int + int int * int + int E int * int + int int * int + int int * T + int T E T + int T + int T T T + int T + T T + E int * int + int E 82

83 The Stack Left string can be implemented by a stack Top of the stack is the Shift pushes a terminal on the stack Reduce pops 0 or more symbols off of the stack (production rhs) and pushes a nonterminal on the stack (production lhs) 83

84 Conflicts In a given state, more than one action (shift or reduce) may lead to a valid parse If both a shift and a reduce are possible at some juncture, there is a shift-reduce conflict If it is legal to reduce by two different productions, there is a reduce-reduce conflict You will see such conflicts in your project! More next time... 84

### Top-Down Parsing and Intro to Bottom-Up Parsing. Lecture 7

Top-Down Parsing and Intro to Bottom-Up Parsing Lecture 7 1 Predictive Parsers Like recursive-descent but parser can predict which production to use Predictive parsers are never wrong Always able to guess

### Introduction to Bottom-Up Parsing

Introduction to Bottom-Up Parsing Lecture 11 CS 536 Spring 2001 1 Outline he strategy: shift-reduce parsing Ambiguity and precedence declarations Next lecture: bottom-up parsing algorithms CS 536 Spring

### Intro to Bottom-up Parsing. Lecture 9

Intro to Bottom-up Parsing Lecture 9 Bottom-Up Parsing Bottom-up parsing is more general than topdown parsing And just as efficient Builds on ideas in top-down parsing Bottom-up is the preferred method

### Review of CFGs and Parsing II Bottom-up Parsers. Lecture 5. Review slides 1

Review of CFGs and Parsing II Bottom-up Parsers Lecture 5 1 Outline Parser Overview op-down Parsers (Covered largely through labs) Bottom-up Parsers 2 he Functionality of the Parser Input: sequence of

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

### Compilers. Predictive Parsing. Alex Aiken

Compilers 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

### Outline. The strategy: shift-reduce parsing. Introduction to Bottom-Up Parsing. A key concept: handles

Outline Introduction to Bottom-Up Parsing Lecture Notes by Profs. Alex Aiken and George Necula (UCB) he strategy: -reduce parsing A key concept: handles Ambiguity and precedence declarations CS780(Prasad)

### Top down vs. bottom up parsing

Parsing A grammar describes the strings that are syntactically legal A recogniser simply accepts or rejects strings A generator produces sentences in the language described by the grammar A parser constructs

### Abstract Syntax Trees & Top-Down Parsing

Abstract Syntax Trees & Top-Down Parsing Review of Parsing Given a language L(G), a parser consumes a sequence of tokens s and produces a parse tree Issues: How do we recognize that s L(G)? A parse tree

### Abstract Syntax Trees & Top-Down Parsing

Review of Parsing Abstract Syntax Trees & Top-Down Parsing Given a language L(G), a parser consumes a sequence of tokens s and produces a parse tree Issues: How do we recognize that s L(G)? A parse tree

### Abstract Syntax Trees & Top-Down Parsing

Review of Parsing Abstract Syntax Trees & Top-Down Parsing Given a language L(G), a parser consumes a sequence of tokens s and produces a parse tree Issues: How do we recognize that s L(G)? A parse tree

### 8 Parsing. Parsing. Top Down Parsing Methods. Parsing complexity. Top down vs. bottom up parsing. Top down vs. bottom up parsing

8 Parsing Parsing A grammar describes syntactically legal strings in a language A recogniser simply accepts or rejects strings A generator produces strings A parser constructs a parse tree for a string

### Ambiguity, Precedence, Associativity & Top-Down Parsing. Lecture 9-10

Ambiguity, Precedence, Associativity & Top-Down Parsing Lecture 9-10 (From slides by G. Necula & R. Bodik) 9/18/06 Prof. Hilfinger CS164 Lecture 9 1 Administrivia Please let me know if there are continued

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

### Bottom-Up Parsing II (Different types of Shift-Reduce Conflicts) Lecture 10. Prof. Aiken (Modified by Professor Vijay Ganesh.

Bottom-Up Parsing II Different types of Shift-Reduce Conflicts) Lecture 10 Ganesh. Lecture 10) 1 Review: Bottom-Up Parsing Bottom-up parsing is more general than topdown parsing And just as efficient Doesn

### 4 (c) parsing. Parsing. Top down vs. bo5om up parsing

4 (c) parsing Parsing A grammar describes syntac2cally legal strings in a language A recogniser simply accepts or rejects strings A generator produces strings A parser constructs a parse tree for a string

### CSCI312 Principles of Programming Languages

Copyright 2006 The McGraw-Hill Companies, Inc. CSCI312 Principles of Programming Languages! LL Parsing!! Xu Liu Derived from Keith Cooper s COMP 412 at Rice University Recap Copyright 2006 The McGraw-Hill

### Syntactic Analysis. Top-Down Parsing

Syntactic Analysis Top-Down Parsing Copyright 2017, Pedro C. Diniz, all rights reserved. Students enrolled in Compilers class at University of Southern California (USC) have explicit permission to make

### Parsing III. CS434 Lecture 8 Spring 2005 Department of Computer Science University of Alabama Joel Jones

Parsing III (Top-down parsing: recursive descent & LL(1) ) (Bottom-up parsing) CS434 Lecture 8 Spring 2005 Department of Computer Science University of Alabama Joel Jones Copyright 2003, Keith D. Cooper,

### Types of parsing. CMSC 430 Lecture 4, Page 1

Types of parsing Top-down parsers start at the root of derivation tree and fill in picks a production and tries to match the input may require backtracking some grammars are backtrack-free (predictive)

### Administrativia. WA1 due on Thu PA2 in a week. Building a Parser III. Slides on the web site. CS164 3:30-5:00 TT 10 Evans.

Administrativia Building a Parser III CS164 3:30-5:00 10 vans WA1 due on hu PA2 in a week Slides on the web site I do my best to have slides ready and posted by the end of the preceding logical day yesterday,

### Bottom-Up Parsing II. Lecture 8

Bottom-Up Parsing II Lecture 8 1 Review: Shift-Reduce Parsing Bottom-up parsing uses two actions: Shift ABC xyz ABCx yz Reduce Cbxy ijk CbA ijk 2 Recall: he Stack Left string can be implemented by a stack

### Review: Shift-Reduce Parsing. Bottom-up parsing uses two actions: Bottom-Up Parsing II. Shift ABC xyz ABCx yz. Lecture 8. Reduce Cbxy ijk CbA ijk

Review: Shift-Reduce Parsing Bottom-up parsing uses two actions: Bottom-Up Parsing II Lecture 8 Shift ABC xyz ABCx yz Reduce Cbxy ijk CbA ijk Prof. Aiken CS 13 Lecture 8 1 Prof. Aiken CS 13 Lecture 8 2

### Note that for recursive descent to work, if A ::= B1 B2 is a grammar rule we need First k (B1) disjoint from First k (B2).

LL(k) Grammars We need a bunch of terminology. For any terminal string a we write First k (a) is the prefix of a of length k (or all of a if its length is less than k) For any string g of terminal and

### Parsing. Roadmap. > Context-free grammars > Derivations and precedence > Top-down parsing > Left-recursion > Look-ahead > Table-driven parsing

Roadmap > Context-free grammars > Derivations and precedence > Top-down parsing > Left-recursion > Look-ahead > Table-driven parsing The role of the parser > performs context-free syntax analysis > guides

### Monday, September 13, Parsers

Parsers Agenda Terminology LL(1) Parsers Overview of LR Parsing Terminology Grammar G = (Vt, Vn, S, P) Vt is the set of terminals Vn is the set of non-terminals S is the start symbol P is the set of productions

### Table-Driven Parsing

Table-Driven Parsing It is possible to build a non-recursive predictive parser by maintaining a stack explicitly, rather than implicitly via recursive calls [1] The non-recursive parser looks up the production

### Parsing III. (Top-down parsing: recursive descent & LL(1) )

Parsing III (Top-down parsing: recursive descent & LL(1) ) Roadmap (Where are we?) Previously We set out to study parsing Specifying syntax Context-free grammars Ambiguity Top-down parsers Algorithm &

### Parsing Part II (Top-down parsing, left-recursion removal)

Parsing Part II (Top-down parsing, left-recursion removal) Copyright 2003, Keith D. Cooper, Ken Kennedy & Linda Torczon, all rights reserved. Students enrolled in Comp 412 at Rice University have explicit

### LL(k) Parsing. Predictive Parsers. LL(k) Parser Structure. Sample Parse Table. LL(1) Parsing Algorithm. Push RHS in Reverse Order 10/17/2012

Predictive Parsers LL(k) Parsing Can we avoid backtracking? es, if for a given input symbol and given nonterminal, we can choose the alternative appropriately. his is possible if the first terminal of

### CA Compiler Construction

CA4003 - Compiler Construction David Sinclair A top-down parser starts with the root of the parse tree, labelled with the goal symbol of the grammar, and repeats the following steps until the fringe of

SYNTAX ANALYSIS 1. Define parser. Hierarchical analysis is one in which the tokens are grouped hierarchically into nested collections with collective meaning. Also termed as Parsing. 2. Mention the basic

### 3. Parsing. Oscar Nierstrasz

3. Parsing Oscar Nierstrasz Thanks to Jens Palsberg and Tony Hosking for their kind permission to reuse and adapt the CS132 and CS502 lecture notes. http://www.cs.ucla.edu/~palsberg/ http://www.cs.purdue.edu/homes/hosking/

### Syntax Analysis. Martin Sulzmann. Martin Sulzmann Syntax Analysis 1 / 38

Syntax Analysis Martin Sulzmann Martin Sulzmann Syntax Analysis 1 / 38 Syntax Analysis Objective Recognize individual tokens as sentences of a language (beyond regular languages). Example 1 (OK) Program

### CS2210: Compiler Construction Syntax Analysis Syntax Analysis

Comparison with Lexical Analysis The second phase of compilation Phase Input Output Lexer string of characters string of tokens Parser string of tokens Parse tree/ast What Parse Tree? CS2210: Compiler

### Ambiguity. Grammar E E + E E * E ( E ) int. The string int * int + int has two parse trees. * int

Administrivia Ambiguity, Precedence, Associativity & op-down Parsing eam assignments this evening for all those not listed as having one. HW#3 is now available, due next uesday morning (Monday is a holiday).

### Prelude COMP 181 Tufts University Computer Science Last time Grammar issues Key structure meaning Tufts University Computer Science

Prelude COMP Lecture Topdown Parsing September, 00 What is the Tufts mascot? Jumbo the elephant Why? P. T. Barnum was an original trustee of Tufts : donated \$0,000 for a natural museum on campus Barnum

### Wednesday, August 31, Parsers

Parsers How do we combine tokens? Combine tokens ( words in a language) to form programs ( sentences in a language) Not all combinations of tokens are correct programs (not all sentences are grammatically

### Lexical and Syntax Analysis. Top-Down Parsing

Lexical and Syntax Analysis Top-Down Parsing Easy for humans to write and understand String of characters Lexemes identified String of tokens Easy for programs to transform Data structure Syntax A syntax

### Wednesday, September 9, 15. Parsers

Parsers What is a parser A parser has two jobs: 1) Determine whether a string (program) is valid (think: grammatically correct) 2) Determine the structure of a program (think: diagramming a sentence) Agenda

### Parsers. What is a parser. Languages. Agenda. Terminology. Languages. A parser has two jobs:

What is a parser Parsers A parser has two jobs: 1) Determine whether a string (program) is valid (think: grammatically correct) 2) Determine the structure of a program (think: diagramming a sentence) Agenda

### Bottom-Up Parsing. Lecture 11-12

Bottom-Up Parsing Lecture 11-12 (From slides by G. Necula & R. Bodik) 9/22/06 Prof. Hilfinger CS164 Lecture 11 1 Bottom-Up Parsing Bottom-up parsing is more general than topdown parsing And just as efficient

### Lexical and Syntax Analysis

Lexical and Syntax Analysis (of Programming Languages) Top-Down Parsing Lexical and Syntax Analysis (of Programming Languages) Top-Down Parsing Easy for humans to write and understand String of characters

### Parsers. Xiaokang Qiu Purdue University. August 31, 2018 ECE 468

Parsers Xiaokang Qiu Purdue University ECE 468 August 31, 2018 What is a parser A parser has two jobs: 1) Determine whether a string (program) is valid (think: grammatically correct) 2) Determine the structure

### More Bottom-Up Parsing

More Bottom-Up Parsing Lecture 7 Dr. Sean Peisert ECS 142 Spring 2009 1 Status Project 1 Back By Wednesday (ish) savior lexer in ~cs142/s09/bin Project 2 Due Friday, Apr. 24, 11:55pm My office hours 3pm

### Bottom-Up Parsing. Lecture 11-12

Bottom-Up Parsing Lecture 11-12 (From slides by G. Necula & R. Bodik) 2/20/08 Prof. Hilfinger CS164 Lecture 11 1 Administrivia Test I during class on 10 March. 2/20/08 Prof. Hilfinger CS164 Lecture 11

### Compilers. Yannis Smaragdakis, U. Athens (original slides by Sam

Compilers Parsing Yannis Smaragdakis, U. Athens (original slides by Sam Guyer@Tufts) Next step text chars Lexical analyzer tokens Parser IR Errors Parsing: Organize tokens into sentences Do tokens conform

### Lecture 8: Deterministic Bottom-Up Parsing

Lecture 8: Deterministic Bottom-Up Parsing (From slides by G. Necula & R. Bodik) Last modified: Fri Feb 12 13:02:57 2010 CS164: Lecture #8 1 Avoiding nondeterministic choice: LR We ve been looking at general

### Extra Credit Question

Top-Down Parsing #1 Extra Credit Question Given this grammar G: E E+T E T T T * int T int T (E) Is the string int * (int + int) in L(G)? Give a derivation or prove that it is not. #2 Revenge of Theory

### CS502: Compilers & Programming Systems

CS502: Compilers & Programming Systems Top-down Parsing Zhiyuan Li Department of Computer Science Purdue University, USA There exist two well-known schemes to construct deterministic top-down parsers:

### Lecture 7: Deterministic Bottom-Up Parsing

Lecture 7: Deterministic Bottom-Up Parsing (From slides by G. Necula & R. Bodik) Last modified: Tue Sep 20 12:50:42 2011 CS164: Lecture #7 1 Avoiding nondeterministic choice: LR We ve been looking at general

### Parsing. Handle, viable prefix, items, closures, goto s LR(k): SLR(1), LR(1), LALR(1)

TD parsing - LL(1) Parsing First and Follow sets Parse table construction BU Parsing Handle, viable prefix, items, closures, goto s LR(k): SLR(1), LR(1), LALR(1) Problems with SLR Aho, Sethi, Ullman, Compilers

### LL Parsing: A piece of cake after LR

LL Parsing: A piece of cake after LR Lecture 11 Dr. Sean Peisert ECS 142 Spring 2009 1 LL Parsing Still specified using a CFG Still reads left-to-right (Lx) Now is leftmost derivation (xl) rather than

### MIT Parse Table Construction. Martin Rinard Laboratory for Computer Science Massachusetts Institute of Technology

MIT 6.035 Parse Table Construction Martin Rinard Laboratory for Computer Science Massachusetts Institute of Technology Parse Tables (Review) ACTION Goto State ( ) \$ X s0 shift to s2 error error goto s1

### Compiler Design 1. Top-Down Parsing. Goutam Biswas. Lect 5

Compiler Design 1 Top-Down Parsing Compiler Design 2 Non-terminal as a Function In a top-down parser a non-terminal may be viewed as a generator of a substring of the input. We may view a non-terminal

### 1 Introduction. 2 Recursive descent parsing. Predicative parsing. Computer Language Implementation Lecture Note 3 February 4, 2004

CMSC 51086 Winter 2004 Computer Language Implementation Lecture Note 3 February 4, 2004 Predicative parsing 1 Introduction This note continues the discussion of parsing based on context free languages.

### Example CFG. Lectures 16 & 17 Bottom-Up Parsing. LL(1) Predictor Table Review. Stacks in LR Parsing 1. Sʹ " S. 2. S " AyB. 3. A " ab. 4.

Example CFG Lectures 16 & 17 Bottom-Up Parsing CS 241: Foundations of Sequential Programs Fall 2016 1. Sʹ " S 2. S " AyB 3. A " ab 4. A " cd Matt Crane University of Waterloo 5. B " z 6. B " wz 2 LL(1)

### Compila(on (Semester A, 2013/14)

Compila(on 0368-3133 (Semester A, 2013/14) Lecture 4: Syntax Analysis (Top- Down Parsing) Modern Compiler Design: Chapter 2.2 Noam Rinetzky Slides credit: Roman Manevich, Mooly Sagiv, Jeff Ullman, Eran

### Parsing #1. Leonidas Fegaras. CSE 5317/4305 L3: Parsing #1 1

Parsing #1 Leonidas Fegaras CSE 5317/4305 L3: Parsing #1 1 Parser source file get next character scanner get token parser AST token A parser recognizes sequences of tokens according to some grammar and

### Syntax Analysis, III Comp 412

COMP 412 FALL 2017 Syntax Analysis, III Comp 412 source code IR Front End Optimizer Back End IR target code Copyright 2017, Keith D. Cooper & Linda Torczon, all rights reserved. Students enrolled in Comp

### CS 314 Principles of Programming Languages

CS 314 Principles of Programming Languages Lecture 5: Syntax Analysis (Parsing) Zheng (Eddy) Zhang Rutgers University January 31, 2018 Class Information Homework 1 is being graded now. The sample solution

### Fall Compiler Principles Lecture 2: LL parsing. Roman Manevich Ben-Gurion University of the Negev

Fall 2017-2018 Compiler Principles Lecture 2: LL parsing Roman Manevich Ben-Gurion University of the Negev 1 Books Compilers Principles, Techniques, and Tools Alfred V. Aho, Ravi Sethi, Jeffrey D. Ullman

### Fall Compiler Principles Lecture 3: Parsing part 2. Roman Manevich Ben-Gurion University

Fall 2014-2015 Compiler Principles Lecture 3: Parsing part 2 Roman Manevich Ben-Gurion University Tentative syllabus Front End Intermediate Representation Optimizations Code Generation Scanning Lowering

### Syntax Analysis, III Comp 412

Updated algorithm for removal of indirect left recursion to match EaC3e (3/2018) COMP 412 FALL 2018 Midterm Exam: Thursday October 18, 7PM Herzstein Amphitheater Syntax Analysis, III Comp 412 source code

### Parsing. Note by Baris Aktemur: Our slides are adapted from Cooper and Torczon s slides that they prepared for COMP 412 at Rice.

Parsing Note by Baris Aktemur: Our slides are adapted from Cooper and Torczon s slides that they prepared for COMP 412 at Rice. Copyright 2010, Keith D. Cooper & Linda Torczon, all rights reserved. Students

### Compilation Lecture 3: Syntax Analysis: Top-Down parsing. Noam Rinetzky

Compilation 0368-3133 Lecture 3: Syntax Analysis: Top-Down parsing Noam Rinetzky 1 Recursive descent parsing Define a function for every nonterminal Every function work as follows Find applicable production

### CMSC 330: Organization of Programming Languages

CMSC 330: Organization of Programming Languages Parsing CMSC 330 - Spring 2017 1 Recall: Front End Scanner and Parser Front End Token Source Scanner Parser Stream AST Scanner / lexer / tokenizer converts

### Chapter 4: LR Parsing

Chapter 4: LR Parsing 110 Some definitions Recall For a grammar G, with start symbol S, any string α such that S called a sentential form α is If α Vt, then α is called a sentence in L G Otherwise it is

### Bottom-up parsing. Bottom-Up Parsing. Recall. Goal: For a grammar G, withstartsymbols, any string α such that S α is called a sentential form

Bottom-up parsing Bottom-up parsing Recall Goal: For a grammar G, withstartsymbols, any string α such that S α is called a sentential form If α V t,thenα is called a sentence in L(G) Otherwise it is just

### A left-sentential form is a sentential form that occurs in the leftmost derivation of some sentence.

Bottom-up parsing Recall For a grammar G, with start symbol S, any string α such that S α is a sentential form If α V t, then α is a sentence in L(G) A left-sentential form is a sentential form that occurs

### Chapter 3. Parsing #1

Chapter 3 Parsing #1 Parser source file get next character scanner get token parser AST token A parser recognizes sequences of tokens according to some grammar and generates Abstract Syntax Trees (ASTs)

### Compilers: CS31003 Computer Sc & Engg: IIT Kharagpur 1. Top-Down Parsing. Lect 5. Goutam Biswas

Compilers: CS31003 Computer Sc & Engg: IIT Kharagpur 1 Top-Down Parsing Compilers: CS31003 Computer Sc & Engg: IIT Kharagpur 2 Non-terminal as a Function In a top-down parser a non-terminal may be viewed

### Introduction to Parsing. Comp 412

COMP 412 FALL 2010 Introduction to Parsing Comp 412 Copyright 2010, Keith D. Cooper & Linda Torczon, all rights reserved. Students enrolled in Comp 412 at Rice University have explicit permission to make

### CS 406/534 Compiler Construction Parsing Part I

CS 406/534 Compiler Construction Parsing Part I Prof. Li Xu Dept. of Computer Science UMass Lowell Fall 2004 Part of the course lecture notes are based on Prof. Keith Cooper, Prof. Ken Kennedy and Dr.

### Computer Science 160 Translation of Programming Languages

Computer Science 160 Translation of Programming Languages Instructor: Christopher Kruegel Top-Down Parsing Parsing Techniques Top-down parsers (LL(1), recursive descent parsers) Start at the root of the

### CS 321 Programming Languages and Compilers. VI. Parsing

CS 321 Programming Languages and Compilers VI. Parsing Parsing Calculate grammatical structure of program, like diagramming sentences, where: Tokens = words Programs = sentences For further information,

### Parsing Wrapup. Roadmap (Where are we?) Last lecture Shift-reduce parser LR(1) parsing. This lecture LR(1) parsing

Parsing Wrapup Roadmap (Where are we?) Last lecture Shift-reduce parser LR(1) parsing LR(1) items Computing closure Computing goto LR(1) canonical collection This lecture LR(1) parsing Building ACTION

### COMP 181. Prelude. Next step. Parsing. Study of parsing. Specifying syntax with a grammar

COMP Lecture Parsing September, 00 Prelude What is the common name of the fruit Synsepalum dulcificum? Miracle fruit from West Africa What is special about miracle fruit? Contains a protein called miraculin

### Fall Compiler Principles Lecture 2: LL parsing. Roman Manevich Ben-Gurion University of the Negev

Fall 2016-2017 Compiler Principles Lecture 2: LL parsing Roman Manevich Ben-Gurion University of the Negev 1 Books Compilers Principles, Techniques, and Tools Alfred V. Aho, Ravi Sethi, Jeffrey D. Ullman

### Formal Languages and Compilers Lecture VII Part 3: Syntactic A

Formal Languages and Compilers Lecture VII Part 3: Syntactic Analysis Free University of Bozen-Bolzano Faculty of Computer Science POS Building, Room: 2.03 artale@inf.unibz.it http://www.inf.unibz.it/

VIVA QUESTIONS WITH ANSWERS 1. What is a compiler? A compiler is a program that reads a program written in one language the source language and translates it into an equivalent program in another language-the

### Parsing II Top-down parsing. Comp 412

COMP 412 FALL 2018 Parsing II Top-down parsing Comp 412 source code IR Front End Optimizer Back End IR target code Copyright 2018, Keith D. Cooper & Linda Torczon, all rights reserved. Students enrolled

### Syntax Analysis, V Bottom-up Parsing & The Magic of Handles Comp 412

Midterm Exam: Thursday October 18, 7PM Herzstein Amphitheater Syntax Analysis, V Bottom-up Parsing & The Magic of Handles Comp 412 COMP 412 FALL 2018 source code IR Front End Optimizer Back End IR target

### Context-free grammars

Context-free grammars Section 4.2 Formal way of specifying rules about the structure/syntax of a program terminals - tokens non-terminals - represent higher-level structures of a program start symbol,

### Syntax Analysis. Amitabha Sanyal. (www.cse.iitb.ac.in/ as) Department of Computer Science and Engineering, Indian Institute of Technology, Bombay

Syntax Analysis (www.cse.iitb.ac.in/ as) Department of Computer Science and Engineering, Indian Institute of Technology, Bombay September 2007 College of Engineering, Pune Syntax Analysis: 2/124 Syntax

### Parsing Part II. (Ambiguity, Top-down parsing, Left-recursion Removal)

Parsing Part II (Ambiguity, Top-down parsing, Left-recursion Removal) Ambiguous Grammars Definitions If a grammar has more than one leftmost derivation for a single sentential form, the grammar is ambiguous

### Chapter 4. Lexical and Syntax Analysis. Topics. Compilation. Language Implementation. Issues in Lexical and Syntax Analysis.

Topics Chapter 4 Lexical and Syntax Analysis Introduction Lexical Analysis Syntax Analysis Recursive -Descent Parsing Bottom-Up parsing 2 Language Implementation Compilation There are three possible approaches

### Compiler Construction: Parsing

Compiler Construction: Parsing Mandar Mitra Indian Statistical Institute M. Mitra (ISI) Parsing 1 / 33 Context-free grammars. Reference: Section 4.2 Formal way of specifying rules about the structure/syntax

### Bottom up parsing. The sentential forms happen to be a right most derivation in the reverse order. S a A B e a A d e. a A d e a A B e S.

Bottom up parsing Construct a parse tree for an input string beginning at leaves and going towards root OR Reduce a string w of input to start symbol of grammar Consider a grammar S aabe A Abc b B d And

### CSE P 501 Compilers. LR Parsing Hal Perkins Spring UW CSE P 501 Spring 2018 D-1

CSE P 501 Compilers LR Parsing Hal Perkins Spring 2018 UW CSE P 501 Spring 2018 D-1 Agenda LR Parsing Table-driven Parsers Parser States Shift-Reduce and Reduce-Reduce conflicts UW CSE P 501 Spring 2018

### CS Parsing 1

CS414-20034-03 Parsing 1 03-0: Parsing Once we have broken an input file into a sequence of tokens, the next step is to determine if that sequence of tokens forms a syntactically correct program parsing

### Lecture Notes on Top-Down Predictive LL Parsing

Lecture Notes on Top-Down Predictive LL Parsing 15-411: Compiler Design Frank Pfenning Lecture 8 1 Introduction In this lecture we discuss a parsing algorithm that traverses the input string from l eft

### Parser Generation. Bottom-Up Parsing. Constructing LR Parser. LR Parsing. Construct parse tree bottom-up --- from leaves to the root

Parser Generation Main Problem: given a grammar G, how to build a top-down parser or a bottom-up parser for it? parser : a program that, given a sentence, reconstructs a derivation for that sentence ----

### Compilerconstructie. najaar Rudy van Vliet kamer 140 Snellius, tel rvvliet(at)liacs(dot)nl. college 3, vrijdag 22 september 2017

Compilerconstructie najaar 2017 http://www.liacs.leidenuniv.nl/~vlietrvan1/coco/ Rudy van Vliet kamer 140 Snellius, tel. 071-527 2876 rvvliet(at)liacs(dot)nl college 3, vrijdag 22 september 2017 + werkcollege

### CSC 4181 Compiler Construction. Parsing. Outline. Introduction

CC 4181 Compiler Construction Parsing 1 Outline Top-down v.s. Bottom-up Top-down parsing Recursive-descent parsing LL1) parsing LL1) parsing algorithm First and follow sets Constructing LL1) parsing table

### Syntax Analysis. COMP 524: Programming Language Concepts Björn B. Brandenburg. The University of North Carolina at Chapel Hill

Syntax Analysis Björn B. Brandenburg The University of North Carolina at Chapel Hill Based on slides and notes by S. Olivier, A. Block, N. Fisher, F. Hernandez-Campos, and D. Stotts. The Big Picture Character

### CS 406/534 Compiler Construction Parsing Part II LL(1) and LR(1) Parsing

CS 406/534 Compiler Construction Parsing Part II LL(1) and LR(1) Parsing Prof. Li Xu Dept. of Computer Science UMass Lowell Fall 2004 Part of the course lecture notes are based on Prof. Keith Cooper, Prof.

### Syntax Analysis. The Big Picture. The Big Picture. COMP 524: Programming Languages Srinivas Krishnan January 25, 2011

Syntax Analysis COMP 524: Programming Languages Srinivas Krishnan January 25, 2011 Based in part on slides and notes by Bjoern Brandenburg, S. Olivier and A. Block. 1 The Big Picture Character Stream Token