Syntactic Analysis and Context-Free Grammars

Transcription

1 Syntactic Analysis and Context-Free Grammars CSCI 3136 Principles of Programming Languages Faculty of Computer Science Dalhousie University Winter 2012 Reading: Chapter 2

2 Motivation Source program (character stream) Scanner (lexical analysis) Front end Parse tree Parser (syntactic analysis) Token stream Back end Modified intermediate form Modified target language Semantic analysis and code generation Machine-independent code improvement Target code generation Machine-specific code improvement Abstract syntax tree or other intermediate form Target language (e.g., assembly) Symbol table

3 Grammars Describe Languages A grammar for a subset of natural language: S Phrase Verb Phrase Phrase Noun Phrase Adjective Phrase Adjective big green Noun cheese Jim Verb ate Sentences in the language described by this grammar: big Jim ate green cheese green Jim ate green cheese Jim ate cheese cheese at Jim

4 Another Example A grammar for simple arithmetic expressions: Expr ( Expr ) Expr Expr + Expr Expr ++ Expr Expr number Expr identifier

5 Context-Free Grammars A context-free grammar is a 4-tuple (V, Σ, P, S), where V is a set of non-terminals or variables, Σ is a set of terminals, P is a set of rules or productions in the form N (V Σ), where N V, S V is the start symbol. Expr ( Expr ) Expr Expr + Expr Expr ++ Expr Expr number Expr identifier Non-terminals: Expr Terminals: (, ), +, ++, number, identifier Rules: the rules on the left Start symbol: Expr

6 Notational Variations in Productions Merging alternatives using Phrase Noun Phrase Adjective Phrase Phrase Noun Adjective Phrase Backus-Naur form Phrase Noun Adjective Phrase Phrase ::= Noun Adjective Phrase Optional components FunctionDef DeclarationSpecifiers opt Declarator DeclarationList opt CompoundStatement Regular expression form of RHS Expression Term ( op Term )

7 Derivations A derivation is a sequence of rewriting operations that starts with the string σ = S and then repeats the following until σ contains only terminals: Choose a non-terminal X in σ and a production X α in the grammar and replace X with α in σ. As a picture σ = λx ρ σ = λαρ An example S Phrase Verb Phrase Phrase Verb Phrase Noun Verb Phrase Noun Verb Phrase Noun Verb Noun Noun Verb Noun Jim Verb Noun Jim Verb Noun Jim ate Noun Jim ate Noun Jim ate cheese Intermediate strings are called sentential forms.

8 Language Defined By a Context-Free Grammar We write S σ if there exists a sequence S σ 1 σ 2 σ Every grammar G defines a language (G) = {σ Σ S σ} If G is a context-free grammar, (G) is a context-free language. Example: The language defined by the Jim-ate-cheese grammar is (G) = {Jim ate cheese,jim ate Jim,big Jim ate cheese, }

9 Context-Free Languages: Examples What is the language defined by the following grammar? S ɛ S 0 S 0 S 1 S 1

10 Context-Free Languages: Examples What is the language defined by the following grammar? σ R is σ written backwards. S ɛ S 0 S 0 S 1 S 1 (G) = {σσ R σ Σ }

11 Context-Free Languages: Examples What is the language defined by the following grammar? σ R is σ written backwards. S ɛ S 0 S 0 S 1 S 1 (G) = {σσ R σ Σ } What is the language defined by the following grammar? S ɛ S 0 S 1

12 Context-Free Languages: Examples What is the language defined by the following grammar? σ R is σ written backwards. S ɛ S 0 S 0 S 1 S 1 (G) = {σσ R σ Σ } What is the language defined by the following grammar? S ɛ S 0 S 1 (G) = {0 n 1 n n 0}

13 Context-Free Languages: Examples What is the language defined by the following grammar? σ R is σ written backwards. S ɛ S 0 S 0 S 1 S 1 (G) = {σσ R σ Σ } What is the language defined by the following grammar? S ɛ S 0 S 1 (G) = {0 n 1 n n 0} Neither of these two languages is regular.

14 Context-Free Languages: Examples What is the language defined by the following grammar? σ R is σ written backwards. S ɛ S 0 S 0 S 1 S 1 (G) = {σσ R σ Σ } What is the language defined by the following grammar? S ɛ S 0 S 1 (G) = {0 n 1 n n 0} Neither of these two languages is regular. There are more context-free languages than regular ones.

15 Parse Trees Every derivation can be represented by a parse tree: The root is S. The children of each node are the symbols (terminals and non-terminals) it is replaced with. S Phrase Verb Phrase Noun Verb Phrase S Noun Verb Noun Phrase Verb Phrase Jim Verb Noun Jim ate Noun Jim ate cheese Noun Jim ate Noun cheese The internal nodes are non-terminals. The leaves called the yield of the parse-tree are terminals.

16 Parse Trees: Examples (1) S Phrase Verb Phrase Phrase Noun Phrase Adjective Phrase Adjective big green Noun cheese Jim Verb ate S Phrase Verb Phrase Adjective Phrase ate Noun big Noun cheese Jim

17 Parse Trees: Examples (2) S Phrase Verb Phrase Phrase Noun Phrase Adjective Phrase Adjective big green Noun cheese Jim Verb ate S Phrase Verb Phrase Adjective Phrase ate Adjective Phrase big Adjective Phrase green Noun big Noun cheese Jim

18 Ambiguity There are infinitely many context-free grammars generating a given context-free language. Just add arbitrary non-terminals to the right-hand sides of productions and then add ɛ-productions for these non-terminals.

19 Ambiguity There are infinitely many context-free grammars generating a given context-free language. Just add arbitrary non-terminals to the right-hand sides of productions and then add ɛ-productions for these non-terminals. There may be more than one parse tree for the same sentence generated by a grammar G. If this is the case, we call G ambiguous. To allow parsing of programming languages, their grammars have to be unambiguous.

20 Ambiguity There are infinitely many context-free grammars generating a given context-free language. Just add arbitrary non-terminals to the right-hand sides of productions and then add ɛ-productions for these non-terminals. There may be more than one parse tree for the same sentence generated by a grammar G. If this is the case, we call G ambiguous. To allow parsing of programming languages, their grammars have to be unambiguous. Some context-free languages are inherently ambiguous, that is, do not have unambiguous grammars. Usually, this is not the case for programming languages.

21 Ambiguity: Example (1) Expr number Expr identifier Expr Expr + Expr Expr Expr - Expr Expr Expr * Expr Expr Expr / Expr Expr ( Expr ) 2 + E E 3 * 4 E E *

22 Ambiguity: Example (1) Expr number Expr identifier Expr Expr + Expr Expr Expr - Expr Expr Expr * Expr Expr Expr / Expr Expr ( Expr ) 2 + E E 3 * 4 E E * Violates precedence rules.

23 Ambiguity: Example (2) An unambiguous grammar for the same language Expr Term Expr Expr + Term E Expr Expr - Term Term Factor E + T Term Term * Factor T T * F Term Term / Factor Factor number F F 4 Factor identifier Factor ( Expr ) 2 3

24 Ambiguity: Example (2) An unambiguous grammar for the same language Expr Term Expr Expr + Term E Expr Expr - Term Term Factor E + T Term Term * Factor T T * F Term Term / Factor Factor number F F 4 Factor identifier Factor ( Expr ) 2 3 This grammar respects precedence rules.

25 Ambiguity: Example (3) An unambiguous grammar for the same language Expr Term Expr Expr + Term Expr Expr - Term Term Factor Term Term * Factor Term Term / Factor Factor number Factor identifier Factor ( Expr ) E F 2 E E - T - T T F 3 2 F This grammar respects precedence rules. It also respects left-associativity.

26 Leftmost and Rightmost Derivations For every sentence in a language defined by an unambiguous grammar, there is only one parse tree that generates this sentence. There are many different derivations corresponding to this parse tree.

27 Leftmost and Rightmost Derivations For every sentence in a language defined by an unambiguous grammar, there is only one parse tree that generates this sentence. There are many different derivations corresponding to this parse tree. Leftmost derivation: Replaces the leftmost non-terminal in each step. E E + T T + T F + T E E + T 2 + T 2 + T * F T T * F 2 + F * F * F F F * 4 2 3

28 Leftmost and Rightmost Derivations For every sentence in a language defined by an unambiguous grammar, there is only one parse tree that generates this sentence. There are many different derivations corresponding to this parse tree. Leftmost derivation: Replaces the leftmost non-terminal in each step. Rightmost derivation: Replaces the rightmost non-terminal in each step. E E + T E E E + T T + T F + T 2 + T 2 + T * F 2 + F * F * F * 4 E T F 2 + T T F 3 * F 4 E + T * F E + T * 4 E + F * 4 E + 3 * 4 T + 3 * 4 F + 3 * * 4

29 Context-Free Grammars for Programming Languages Context-free grammars are used to formally describe the syntax of programming languages. Parsing a program involves finding the parse tree of the program.

30 Context-Free Grammars for Programming Languages Context-free grammars are used to formally describe the syntax of programming languages. Parsing a program involves finding the parse tree of the program. Context-free grammars for programming languages must be unambiguous and must capture the program structure.

31 Context-Free Grammars for Programming Languages Context-free grammars are used to formally describe the syntax of programming languages. Parsing a program involves finding the parse tree of the program. Context-free grammars for programming languages must be unambiguous and must capture the program structure. The parser should be efficient: Any context-free grammar can be used to derive a parser that runs in O(n 3 ) time. We want linear time.

32 Regular Grammars A context-free grammar is right-linear if all productions are of the form A σb or A σ, where σ is a (possibly empty) string of terminals.

33 Regular Grammars A context-free grammar is right-linear if all productions are of the form A σb or A σ, where σ is a (possibly empty) string of terminals. A context-free grammar is left-linear if all productions are of the form A Bσ or A σ, where σ is a (possibly empty) string of terminals.

34 Regular Grammars A context-free grammar is right-linear if all productions are of the form A σb or A σ, where σ is a (possibly empty) string of terminals. A context-free grammar is left-linear if all productions are of the form A Bσ or A σ, where σ is a (possibly empty) string of terminals. A context-free grammar is regular if it is right-linear or left-linear.

35 Regular Grammars A context-free grammar is right-linear if all productions are of the form A σb or A σ, where σ is a (possibly empty) string of terminals. A context-free grammar is left-linear if all productions are of the form A Bσ or A σ, where σ is a (possibly empty) string of terminals. A context-free grammar is regular if it is right-linear or left-linear. The set of languages expressed by regular grammars is exactly the set of regular languages. Regular grammars are too weak to express programming languages.

36 LL and LR Grammars Two kinds of grammars that can be parsed efficiently and guarantee unambiguousness:

37 LL and LR Grammars Two kinds of grammars that can be parsed efficiently and guarantee unambiguousness: An LL(k)-grammar can be scanned Left-to-right and generates a Leftmost derivation. If the first letter in the current sentential form is a non-terminal, k tokens look-ahead in the input suffice to decide which production to use to expand it.

38 LL and LR Grammars Two kinds of grammars that can be parsed efficiently and guarantee unambiguousness: An LL(k)-grammar can be scanned Left-to-right and generates a Leftmost derivation. If the first letter in the current sentential form is a non-terminal, k tokens look-ahead in the input suffice to decide which production to use to expand it. An LR(k)-grammar can be scanned Left-to-right and generates a Rightmost derivation. The next k tokens in the input suffice to choose the next step the parser should perform. (We ll see what these steps are.)

39 LL and LR Grammars Two kinds of grammars that can be parsed efficiently and guarantee unambiguousness: An LL(k)-grammar can be scanned Left-to-right and generates a Leftmost derivation. If the first letter in the current sentential form is a non-terminal, k tokens look-ahead in the input suffice to decide which production to use to expand it. An LR(k)-grammar can be scanned Left-to-right and generates a Rightmost derivation. The next k tokens in the input suffice to choose the next step the parser should perform. (We ll see what these steps are.) Almost every programming language can be described by an LL(1)- or LR(1)-grammar.

40 S-Grammars An S-grammar or simple grammar is a special case of an LL(1)-grammar. A context-free grammar is an S-grammar if Every production starts with a terminal and The productions for the same LHS start with different terminals. An S-grammar A a A A A b A A non-simple context-free grammar A a A A A a A

41 LL Parsing: An Example An S-grammar for arithmetic expressions in Polish notation S + S S S - S S S * S S S / S S S neg S S integer (2 + 3) * *

42 LL Parsing: An Example An S-grammar for arithmetic expressions in Polish notation S S + S S S - S S S * S S S / S S S neg S S integer (2 + 3) * * S

43 LL Parsing: An Example An S-grammar for arithmetic expressions in Polish notation S + S S S - S S S * S S S / S S S neg S S integer (2 + 3) * * S + S S S + S S

44 LL Parsing: An Example An S-grammar for arithmetic expressions in Polish notation S + S S S - S S S * S S S / S S S neg S S integer (2 + 3) * * S + S S S + S S

45 LL Parsing: An Example An S-grammar for arithmetic expressions in Polish notation S + S S S - S S S * S S S / S S S neg S S integer (2 + 3) * * S + S S * S S S + S S * S S S

46 LL Parsing: An Example An S-grammar for arithmetic expressions in Polish notation S + S S S - S S S * S S S / S S S neg S S integer (2 + 3) * * S + S S * S S S + S S * S S S

47 LL Parsing: An Example An S-grammar for arithmetic expressions in Polish notation S + S S S - S S S * S S S / S S S neg S S integer (2 + 3) * * S + S S * S S + S S + S S * S S S + S S S S S

48 LL Parsing: An Example An S-grammar for arithmetic expressions in Polish notation S + S S S - S S S * S S S / S S S neg S S integer (2 + 3) * * S + S S * S S + S S + S S * S S S + S S S S S

49 LL Parsing: An Example An S-grammar for arithmetic expressions in Polish notation S + S S S - S S S * S S S / S S S neg S S integer (2 + 3) * * int S + S S * S S + S S S + S S * S S S + S S S S integer S S S

50 LL Parsing: An Example An S-grammar for arithmetic expressions in Polish notation S + S S S - S S S * S S S / S S S neg S S integer (2 + 3) * * int S + S S * S S + S S S + S S * S S S + S S S S integer S S S

51 LL Parsing: An Example An S-grammar for arithmetic expressions in Polish notation S + S S S - S S S * S S S / S S S neg S S integer (2 + 3) * * int S + S S * S S + S S int S + S S * S S S + S S S S integer S S S integer S S

52 LL Parsing: An Example An S-grammar for arithmetic expressions in Polish notation S + S S S - S S S * S S S / S S S neg S S integer (2 + 3) * * int S + S S * S S + S S int S + S S * S S S + S S S S integer S S S integer S S

53 LL Parsing: An Example An S-grammar for arithmetic expressions in Polish notation S + S S S - S S S * S S S / S S S neg S S integer (2 + 3) * * int S + S S * S S + S S int S + S S * S S S + S S S S integer S S S integer S S integer S int

54 LL Parsing: An Example An S-grammar for arithmetic expressions in Polish notation S + S S S - S S S * S S S / S S S neg S S integer (2 + 3) * * int S + S S * S S + S S int S + S S * S S S + S S S S integer S S S integer S S integer S int

55 LL Parsing: An Example An S-grammar for arithmetic expressions in Polish notation S + S S S - S S S * S S S / S S S neg S S integer (2 + 3) * * int S + S S * S S + S S int S + S S * S S S + S S S S integer S S S integer S S integer S integer int int

56 LL Parsing: An Example An S-grammar for arithmetic expressions in Polish notation S + S S S - S S S * S S S / S S S neg S S integer (2 + 3) * * int S + S S * S S + S S int S + S S * S S S + S S S S integer S S S integer S S integer S integer int int

57 LL Parsing: An Example An S-grammar for arithmetic expressions in Polish notation S + S S S - S S S * S S S / S S S neg S S integer (2 + 3) * * This process is called recursive descent parsing. int S + S S * S S + S S int S + S S * S S S + S S S S integer S S S integer S S integer S integer int int

58 LR Parsing: An Example A grammar for arithmetic expressions in reverse Polish notation S S S + S S S - S S S * S S S / S S neg S integer (2 + 3) * * 5 +

59 LR Parsing: An Example A grammar for arithmetic expressions in reverse Polish notation S S S + S S S - S S S * S S S / S S neg S integer (2 + 3) * * 5 +

60 LR Parsing: An Example A grammar for arithmetic expressions in reverse Polish notation S S S + S S S - S S S * S S S / S S neg S integer int (2 + 3) * * 5 + integer

61 LR Parsing: An Example A grammar for arithmetic expressions in reverse Polish notation S S S + S S S - S S S * S S S / S S neg S integer S int (2 + 3) * * 5 + integer S integer

62 LR Parsing: An Example A grammar for arithmetic expressions in reverse Polish notation S S S + S S S - S S S * S S S / S S neg S integer S int int (2 + 3) * * 5 + integer S integer

63 LR Parsing: An Example A grammar for arithmetic expressions in reverse Polish notation S S S + S S S - S S S * S S S / S S neg S integer S int S int (2 + 3) * * 5 + integer S integer S S +

64 LR Parsing: An Example A grammar for arithmetic expressions in reverse Polish notation S S S + S S S - S S S * S S S / S S neg S integer S int S int + (2 + 3) * * 5 + integer S integer S S +

65 LR Parsing: An Example A grammar for arithmetic expressions in reverse Polish notation S S S + S S S - S S S * S S S / S S neg S integer S int S S int + (2 + 3) * * 5 + integer S integer S S + S integer

66 LR Parsing: An Example A grammar for arithmetic expressions in reverse Polish notation S S S + S S S - S S S * S S S / S S neg S integer S int S S int + int (2 + 3) * * 5 + integer S integer S S + S integer

67 LR Parsing: An Example A grammar for arithmetic expressions in reverse Polish notation S S S + S S S - S S S * S S S / S S neg S integer S int S S int + S int (2 + 3) * * 5 + integer S integer S S + S integer S S *

68 LR Parsing: An Example A grammar for arithmetic expressions in reverse Polish notation S S S + S S S - S S S * S S S / S S neg S integer S int S S int + S int * (2 + 3) * * 5 + integer S integer S S + S integer S S *

69 LR Parsing: An Example A grammar for arithmetic expressions in reverse Polish notation S S S + S S S - S S S * S S S / S S neg S integer S int S S int S + S int * (2 + 3) * * 5 + integer S integer S S + S integer S S * S integer

70 LR Parsing: An Example A grammar for arithmetic expressions in reverse Polish notation S S S + S S S - S S S * S S S / S S neg S integer (2 + 3) * * 5 + S int S * S S int S int + int integer S integer S S + S integer S S * S integer

71 LR Parsing: An Example A grammar for arithmetic expressions in reverse Polish notation S S S + S S S - S S S * S S S / S S neg S integer (2 + 3) * * 5 + S int S integer S integer S S + S integer S S * S integer S S + S * S S int S int + int

72 LR Parsing: An Example A grammar for arithmetic expressions in reverse Polish notation S S S + S S S - S S S * S S S / S S neg S integer S int S S * S S int S int + int + (2 + 3) * * 5 + integer S integer S S + S integer S S * S integer S S +

73 LR Parsing: An Example A grammar for arithmetic expressions in reverse Polish notation S S S S + S S S - S S S * S S S / S S neg S integer S int S S * S S int S int + int + (2 + 3) * * 5 + integer S integer S S + S integer S S * S integer S S + S

74 LR Parsing: An Example A grammar for arithmetic expressions in reverse Polish notation S S S S + S S S - S S S * S S S / S S neg S integer S int S S * S S int S int + int + (2 + 3) * * 5 + This process is called shift-reduce parsing. integer S integer S S + S integer S S * S integer S S + S

75 Parsing Using LL(1) Grammars The crux with parsing deterministically using an LL(1) grammar is to decide which production to apply when the next symbol in the current sentential form is a non-terminal: Input: a Sentential form: A Production: A α?

76 Parsing Using LL(1) Grammars The crux with parsing deterministically using an LL(1) grammar is to decide which production to apply when the next symbol in the current sentential form is a non-terminal: Input: a Sentential form: A Production: A α? Two cases A α aβ A α ɛ and a derivation of A can be succeeded by a.

77 Parsing Using LL(1) Grammars The crux with parsing deterministically using an LL(1) grammar is to decide which production to apply when the next symbol in the current sentential form is a non-terminal: Input: a Sentential form: A Production: A α? Two cases A α aβ A α ɛ and a derivation of A can be succeeded by a. Intuitively (but formally not quite correctly), a terminal a is in the predictor set of production A α if Aβ αβ aγ, for some β, γ Σ.

78 Parsing Using LL(1) Grammars The crux with parsing deterministically using an LL(1) grammar is to decide which production to apply when the next symbol in the current sentential form is a non-terminal: Input: a Sentential form: A Production: A α? Two cases A α aβ A α ɛ and a derivation of A can be succeeded by a. Intuitively (but formally not quite correctly), a terminal a is in the predictor set of production A α if Aβ αβ aγ, for some β, γ Σ. A grammar is LL(1) if the predictor sets of all productions with the same LHS are disjoint.

79 Parsing Using LL(1) Grammars The crux with parsing deterministically using an LL(1) grammar is to decide which production to apply when the next symbol in the current sentential form is a non-terminal: Input: a Sentential form: A Production: A α? Two cases A α aβ A α ɛ and a derivation of A can be succeeded by a. Intuitively (but formally not quite correctly), a terminal a is in the predictor set of production A α if Aβ αβ aγ, for some β, γ Σ. A grammar is LL(1) if the predictor sets of all productions with the same LHS are disjoint. Rule Predictor set S + S S {+} S - S S {-} S * S S {*} S / S S {/} S neg S {neg} S integer {integer}

80 Computing Predictor Sets Compute three kinds of sets: FIRST(σ), for all σ (V Σ) : For a Σ, a FIRST(σ) if σ aβ. ɛ FIRST(σ) if σ ɛ. (We compute FIRST(X ) only for X V Σ and generate FIRST(σ), for some strings σ (V Σ), on the fly when needed.)

81 Computing Predictor Sets Compute three kinds of sets: FIRST(σ), for all σ (V Σ) : For a Σ, a FIRST(σ) if σ aβ. ɛ FIRST(σ) if σ ɛ. (We compute FIRST(X ) only for X V Σ and generate FIRST(σ), for some strings σ (V Σ), on the fly when needed.) FOLLOW(X), for all X V : For a Σ, a FOLLOW(X ) if S αx aβ. ɛ FOLLOW(X ) if S αx.

82 Computing Predictor Sets Compute three kinds of sets: FIRST(σ), for all σ (V Σ) : For a Σ, a FIRST(σ) if σ aβ. ɛ FIRST(σ) if σ ɛ. (We compute FIRST(X ) only for X V Σ and generate FIRST(σ), for some strings σ (V Σ), on the fly when needed.) FOLLOW(X), for all X V : For a Σ, a FOLLOW(X ) if S αx aβ. ɛ FOLLOW(X ) if S αx. PREDICT(A α): For a Σ {ɛ}, a PREDICT(A α) if a FIRST(α) \ {ɛ} or ɛ FIRST(α) and a FOLLOW(A).

83 Computing Predictor Sets Compute three kinds of sets: FIRST(σ), for all σ (V Σ) : For a Σ, a FIRST(σ) if σ aβ. ɛ FIRST(σ) if σ ɛ. (We compute FIRST(X ) only for X V Σ and generate FIRST(σ), for some strings σ (V Σ), on the fly when needed.) FOLLOW(X), for all X V : For a Σ, a FOLLOW(X ) if S αx aβ. ɛ FOLLOW(X ) if S αx. PREDICT(A α): For a Σ {ɛ}, a PREDICT(A α) if a FIRST(α) \ {ɛ} or ɛ FIRST(α) and a FOLLOW(A).

84 Computing FIRST Computing FIRST(X), for X V Σ: For a Σ, FIRST(a) := {a}. For X V, FIRST(X ) :=. Repeat until no FIRST(X ) set changes any more: FIRST(X ) := FIRST(X ) FIRST(Y 1 Y 2 Y k ), for each production X Y 1 Y 2 Y k. Computing FIRST(Y 1 Y 2 Y k ) on the fly when needed: FIRST(Y 1 Y 2 Y k ) := For i := 1, 2,, k: FIRST(Y 1 Y 2 Y k ) := FIRST(Y 1 Y 2 Y k ) (FIRST(Y i ) \ {ɛ}) If ɛ / FIRST(Y i ), then return. FIRST(Y 1 Y 2 Y k ) := FIRST(Y 1 Y 2 Y k ) {ɛ}

85 Computing FIRST: Example Is the following grammar LL(1)? T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f

86 Computing FIRST: Example Is the following grammar LL(1)? T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f Symbol X p q b e c f T A P Q B C FIRST(X) It. 1 It. 2 It. 3 It. 4

87 Computing FIRST: Example Is the following grammar LL(1)? T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f Symbol X p q b e c f T A P Q B C It. 1 {p} {q} {b} {e} {c} {f } FIRST(X) It. 2 It. 3 It. 4

88 Computing FIRST: Example Is the following grammar LL(1)? T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f Symbol X p q b e c f T A P Q B C It. 1 {p} {q} {b} {e} {c} {f } FIRST(X) It. 2 It. 3 It. 4

89 Computing FIRST: Example Is the following grammar LL(1)? T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f Symbol X p q b e c f T A P Q B C It. 1 {p} {q} {b} {e} {c} {f } It. 2 FIRST(X) It. 3 It. 4

90 Computing FIRST: Example Is the following grammar LL(1)? T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f Symbol X p q b e c f T A P Q B C It. 1 {p} {q} {b} {e} {c} {f } It. 2 {p, ɛ} {q, ɛ} {b, e} {c, f } FIRST(X) It. 3 It. 4

91 Computing FIRST: Example Is the following grammar LL(1)? T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f Symbol X p q b e c f T A P Q B C It. 1 {p} {q} {b} {e} {c} {f } It. 2 {p, ɛ} {q, ɛ} {b, e} {c, f } FIRST(X) It. 3 It. 4

92 Computing FIRST: Example Is the following grammar LL(1)? T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f Symbol X p q b e c f T A P Q B C It. 1 {p} {q} {b} {e} {c} {f } It. 2 {p, ɛ} {q, ɛ} {b, e} {c, f } FIRST(X) It. 3 {p, q, ɛ, b, e} It. 4

93 Computing FIRST: Example Is the following grammar LL(1)? T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f Symbol X p q b e c f T A P Q B C It. 1 {p} {q} {b} {e} {c} {f } It. 2 {p, ɛ} {q, ɛ} {b, e} {c, f } FIRST(X) It. 3 {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } It. 4

94 Computing FIRST: Example Is the following grammar LL(1)? T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f Symbol X p q b e c f T A P Q B C It. 1 {p} {q} {b} {e} {c} {f } It. 2 {p, ɛ} {q, ɛ} {b, e} {c, f } FIRST(X) It. 3 {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } It. 4 {p, q, b, e}

95 Computing FIRST: Example Is the following grammar LL(1)? T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f Symbol X p q b e c f T A P Q B C It. 1 {p} {q} {b} {e} {c} {f } It. 2 {p, ɛ} {q, ɛ} {b, e} {c, f } FIRST(X) It. 3 {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } It. 4 {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f }

96 Computing FIRST: Example Is the following grammar LL(1)? T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f Symbol X p q b e c f T A P Q B C It. 1 {p} {q} {b} {e} {c} {f } It. 2 {p, ɛ} {q, ɛ} {b, e} {c, f } FIRST(X) It. 3 {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } It. 4 {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f }

97 Computing Predictor Sets Compute three kinds of sets: FIRST(σ), for all σ (V Σ) : For a Σ, a FIRST(σ) if σ aβ. ɛ FIRST(σ) if σ ɛ. (We compute FIRST(X ) only for X V Σ and generate FIRST(σ), for some strings σ (V Σ), on the fly when needed.) FOLLOW(X), for all X V : For a Σ, a FOLLOW(X ) if S αx aβ. ɛ FOLLOW(X ) if S αx. PREDICT(A α): For a Σ {ɛ}, a PREDICT(A α) if a FIRST(α) \ {ɛ} or ɛ FIRST(α) and a FOLLOW(A).

98 Computing FOLLOW FOLLOW(S) := {ɛ} FOLLOW(X ) :=, for all X V \ {S} Repeat until no FOLLOW(X ) set changes any more: For each production A αbβ: FOLLOW(B) := FOLLOW(B) (FIRST(β) \ {ɛ}) If ɛ FIRST(β), then FOLLOW(B) := FOLLOW(B) FOLLOW(A)

99 Computing FOLLOW: Example T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f X p q b e c f T A P Q B C FIRST(X) {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } V T A P Q B C FOLLOW(V) It. 1 It. 2 It. 3

100 Computing FOLLOW: Example T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f X p q b e c f T A P Q B C FIRST(X) {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } V T A P Q B C It. 1 {ɛ} FOLLOW(V) It. 2 It. 3

101 Computing FOLLOW: Example T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f X p q b e c f T A P Q B C FIRST(X) {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } V T A P Q B C It. 1 {ɛ} FOLLOW(V) It. 2 It. 3 {ɛ}

102 Computing FOLLOW: Example T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f X p q b e c f T A P Q B C FIRST(X) {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } V T A P Q B C It. 1 {ɛ} FOLLOW(V) It. 2 It. 3 {ɛ} {b, e}

103 Computing FOLLOW: Example T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f X p q b e c f T A P Q B C FIRST(X) {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } V T A P Q B C It. 1 {ɛ} FOLLOW(V) It. 2 It. 3 {ɛ} {b, e} {q}

104 Computing FOLLOW: Example T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f X p q b e c f T A P Q B C FIRST(X) {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } V T A P Q B C It. 1 {ɛ} FOLLOW(V) It. 2 It. 3 {ɛ} {b, e} {q}

105 Computing FOLLOW: Example T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f X p q b e c f T A P Q B C FIRST(X) {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } V T A P Q B C It. 1 {ɛ} FOLLOW(V) It. 2 It. 3 {ɛ} {b, e} {q} {ɛ, c, f }

106 Computing FOLLOW: Example T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f X p q b e c f T A P Q B C FIRST(X) {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } V T A P Q B C It. 1 {ɛ} FOLLOW(V) It. 2 It. 3 {ɛ} {b, e} {q} {ɛ, c, f }

107 Computing FOLLOW: Example T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f X p q b e c f T A P Q B C FIRST(X) {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } V T A P Q B C It. 1 {ɛ} FOLLOW(V) It. 2 It. 3 {ɛ} {b, e} {q} {ɛ, c, f } {ɛ} {b, e}

108 Computing FOLLOW: Example T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f X p q b e c f T A P Q B C FIRST(X) {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } V T A P Q B C It. 1 {ɛ} FOLLOW(V) It. 2 It. 3 {ɛ} {b, e} {q} {ɛ, c, f } {ɛ} {b, e} {q, b, e}

109 Computing FOLLOW: Example T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f X p q b e c f T A P Q B C FIRST(X) {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } V T A P Q B C It. 1 {ɛ} FOLLOW(V) It. 2 It. 3 {ɛ} {b, e} {q} {ɛ, c, f } {ɛ} {b, e} {q, b, e} {b, e}

110 Computing FOLLOW: Example T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f X p q b e c f T A P Q B C FIRST(X) {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } V T A P Q B C It. 1 {ɛ} FOLLOW(V) It. 2 It. 3 {ɛ} {b, e} {q} {ɛ, c, f } {ɛ} {b, e} {q, b, e} {b, e} {ɛ, c, f }

111 Computing FOLLOW: Example T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f X p q b e c f T A P Q B C FIRST(X) {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } V T A P Q B C It. 1 {ɛ} FOLLOW(V) It. 2 It. 3 {ɛ} {b, e} {q} {ɛ, c, f } {ɛ} {b, e} {q, b, e} {b, e} {ɛ, c, f } {b, e}

112 Computing Predictor Sets Compute three kinds of sets: FIRST(σ), for all σ (V Σ) : For a Σ, a FIRST(σ) if σ aβ. ɛ FIRST(σ) if σ ɛ. (We compute FIRST(X ) only for X V Σ and generate FIRST(σ), for some strings σ (V Σ), on the fly when needed.) FOLLOW(X), for all X V : For a Σ, a FOLLOW(X ) if S αx aβ. ɛ FOLLOW(X ) if S αx. PREDICT(A α): For a Σ {ɛ}, a PREDICT(A α) if a FIRST(α) \ {ɛ} or ɛ FIRST(α) and a FOLLOW(A).

113 Computing PREDICT PREDICT(A α) :=, for every production A α For every production A α: PREDICT(A α) := FIRST(α) \ {ɛ} If ɛ FIRST(α), then PREDICT(A α) := PREDICT(A α) FOLLOW(A)

114 Computing PREDICT: Example X p q b e c f T A P Q B C FIRST(X) {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } V T A P Q B C FOLLOW(V) {ɛ} {b, e} {q, b, e} {b, e} {ɛ, c, f } {b, e} Rule R T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f PREDICT(R)

115 Computing PREDICT: Example X p q b e c f T A P Q B C FIRST(X) {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } V T A P Q B C FOLLOW(V) {ɛ} {b, e} {q, b, e} {b, e} {ɛ, c, f } {b, e} Rule R T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f PREDICT(R) {p, q, b, e}

116 Computing PREDICT: Example X p q b e c f T A P Q B C FIRST(X) {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } V T A P Q B C FOLLOW(V) {ɛ} {b, e} {q, b, e} {b, e} {ɛ, c, f } {b, e} Rule R T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f PREDICT(R) {p, q, b, e} {p, q, b, e}

117 Computing PREDICT: Example X p q b e c f T A P Q B C FIRST(X) {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } V T A P Q B C FOLLOW(V) {ɛ} {b, e} {q, b, e} {b, e} {ɛ, c, f } {b, e} Rule R T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f PREDICT(R) {p, q, b, e} {p, q, b, e} {b, e}

118 Computing PREDICT: Example X p q b e c f T A P Q B C FIRST(X) {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } V T A P Q B C FOLLOW(V) {ɛ} {b, e} {q, b, e} {b, e} {ɛ, c, f } {b, e} Rule R T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f PREDICT(R) {p, q, b, e} {p, q, b, e} {b, e} {p}

119 Computing PREDICT: Example X p q b e c f T A P Q B C FIRST(X) {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } V T A P Q B C FOLLOW(V) {ɛ} {b, e} {q, b, e} {b, e} {ɛ, c, f } {b, e} Rule R T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f PREDICT(R) {p, q, b, e} {p, q, b, e} {b, e} {p} {q, b, e}

120 Computing PREDICT: Example X p q b e c f T A P Q B C FIRST(X) {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } V T A P Q B C FOLLOW(V) {ɛ} {b, e} {q, b, e} {b, e} {ɛ, c, f } {b, e} Rule R T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f PREDICT(R) {p, q, b, e} {p, q, b, e} {b, e} {p} {q, b, e} {q}

121 Computing PREDICT: Example X p q b e c f T A P Q B C FIRST(X) {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } V T A P Q B C FOLLOW(V) {ɛ} {b, e} {q, b, e} {b, e} {ɛ, c, f } {b, e} Rule R T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f PREDICT(R) {p, q, b, e} {p, q, b, e} {b, e} {p} {q, b, e} {q} {b, e}

122 Computing PREDICT: Example X p q b e c f T A P Q B C FIRST(X) {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } V T A P Q B C FOLLOW(V) {ɛ} {b, e} {q, b, e} {b, e} {ɛ, c, f } {b, e} Rule R T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f PREDICT(R) {p, q, b, e} {p, q, b, e} {b, e} {p} {q, b, e} {q} {b, e} {b}

123 Computing PREDICT: Example X p q b e c f T A P Q B C FIRST(X) {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } V T A P Q B C FOLLOW(V) {ɛ} {b, e} {q, b, e} {b, e} {ɛ, c, f } {b, e} Rule R T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f PREDICT(R) {p, q, b, e} {p, q, b, e} {b, e} {p} {q, b, e} {q} {b, e} {b} {e}

124 Computing PREDICT: Example X p q b e c f T A P Q B C FIRST(X) {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } V T A P Q B C FOLLOW(V) {ɛ} {b, e} {q, b, e} {b, e} {ɛ, c, f } {b, e} Rule R T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f PREDICT(R) {p, q, b, e} {p, q, b, e} {b, e} {p} {q, b, e} {q} {b, e} {b} {e} {c}

125 Computing PREDICT: Example X p q b e c f T A P Q B C FIRST(X) {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } V T A P Q B C FOLLOW(V) {ɛ} {b, e} {q, b, e} {b, e} {ɛ, c, f } {b, e} Rule R T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f PREDICT(R) {p, q, b, e} {p, q, b, e} {b, e} {p} {q, b, e} {q} {b, e} {b} {e} {c} {f }

126 Computing PREDICT: Example X p q b e c f T A P Q B C FIRST(X) {p} {q} {b} {e} {c} {f } {p, q, b, e} {p, q, ɛ, b, e} {p, ɛ} {q, ɛ} {b, e} {c, f } V T A P Q B C FOLLOW(V) {ɛ} {b, e} {q, b, e} {b, e} {ɛ, c, f } {b, e} Rule R T A B A P Q A B C P p P P ɛ Q q Q Q ɛ B b B B e C c C C f PREDICT(R) {p, q, b, e} {p, q, b, e} {b, e} {p} {q, b, e} {q} {b, e} {b} {e} {c} {f } The grammar is not LL(1)!

127 Some Facts About LL(1) Languages There exist context-free languages that do not have LL(1) grammars. There is no known algorithm to determine whether a language is LL(1) (but there is an algorithm to decide whether a grammar is LL(1)). The obvious grammar for most programming languages is usually not LL(1). In many situations, a non-ll(1) grammar can be transformed into an LL(1) grammar for the same language.

128 Converting a Grammar to LL(1) Two common reasons why a grammar is not LL(1) are left recursion and common prefixes, both of which can be eliminated by modifying the grammar. Left recursion A α Aβ Common prefix A αβ αγ Example of a common prefix Expr Term Expr Term + Expr

129 Removing Left Recursion and Common Prefixes Left recursion can be replaced with right recursion: A α Aβ A αa A ɛ βa Side effect: Often, left recursion is used intentionally to capture structure of the language (e.g., associativity of operators in arithmetic expressions). The above conversion removes this information.

130 Removing Left Recursion and Common Prefixes Left recursion can be replaced with right recursion: A α Aβ A αa A ɛ βa Side effect: Often, left recursion is used intentionally to capture structure of the language (e.g., associativity of operators in arithmetic expressions). The above conversion removes this information. Common prefixes can be removed using left factoring: A αβ αγ A αa A β γ

131 Converting a Grammar to LL(1): Example (1) Rule (R) S E$ E EAT E T T T M F T F PREDICT(R) F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} V FOLLOW(V) S {ɛ} E {$,),+,-} A T {$,),+,-,*,/} M F {$,),+,-,*,/} X FIRST(X) $ {$} n {n} ( {(} ) {)} + {+} - {-} * {*} / {/} S E A {+,-} T M {*,/} F

132 Converting a Grammar to LL(1): Example (2) Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} V S E E A T T M F FOLLOW(V) {ɛ} {$,)} {$,)} {+,-, $,)} {+,-, $,)} {*,/,+,-, $, )} X FIRST(X) $ {$} n {n} ( {(} ) {)} + {+} - {-} * {*} / {/} S E E {ɛ,+,-} A {+,-} T T {ɛ,*,/} M {*,/} F

133 Parsing LL(1) Languages LL(1) languages can be parsed using efficient, easy-to-implement parsers. Two approaches Recursive descent method Deterministic push-down automaton (DPDA) Recursive descent parsing For each non-terminal X, write a procedure parse-x: Based on next token, choose production X Y 1 Y 2 Y k If Y 1 is a non-terminal, then parse-y 1, else match Y 1 with next input token. If Y 2 is a non-terminal, then parse-y 2, else match Y 2 with next input token.

134 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $

135 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e

136 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e parse-t If next token is n or (, then parse-f parse-t

137 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e parse-t If next token is n or (, then parse-f parse-t parse-f If next token is n, then Match n

138 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e parse-t If next token is n or (, then parse-f parse-t parse-f If next token is n, then Match n

139 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e parse-t If next token is n or (, then parse-f parse-t

140 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e parse-t If next token is n or (, then parse-f parse-t parse-t If next token is * or /, then parse-m parse-f parse-t

141 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e parse-t If next token is n or (, then parse-f parse-t parse-t If next token is * or /, then parse-m parse-f parse-t parse-m If next token is *, then Match *

142 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e parse-t If next token is n or (, then parse-f parse-t parse-t If next token is * or /, then parse-m parse-f parse-t parse-m If next token is *, then Match *

143 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e parse-t If next token is n or (, then parse-f parse-t parse-t If next token is * or /, then parse-m parse-f parse-t

144 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e parse-t If next token is n or (, then parse-f parse-t parse-t If next token is * or /, then parse-m parse-f parse-t parse-f If next token is n, then Match n

145 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e parse-t If next token is n or (, then parse-f parse-t parse-t If next token is * or /, then parse-m parse-f parse-t parse-f If next token is n, then Match n

146 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e parse-t If next token is n or (, then parse-f parse-t parse-t If next token is * or /, then parse-m parse-f parse-t

147 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e parse-t If next token is n or (, then parse-f parse-t parse-t If next token is * or /, then parse-m parse-f parse-t parse-t If next token is +, -, $ or ), then Do nothing

148 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e parse-t If next token is n or (, then parse-f parse-t parse-t If next token is * or /, then parse-m parse-f parse-t

149 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e parse-t If next token is n or (, then parse-f parse-t

150 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e

151 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e parse-e If next token is + or -, then parse-a parse-t parse-e

152 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e parse-e If next token is + or -, then parse-a parse-t parse-e parse-a If next token is -, then Match -

153 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e parse-e If next token is + or -, then parse-a parse-t parse-e parse-a If next token is -, then Match -

154 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e parse-e If next token is + or -, then parse-a parse-t parse-e

155 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e parse-e If next token is + or -, then parse-a parse-t parse-e parse-t If next token is n or (, then parse-f parse-t

156 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e parse-e If next token is + or -, then parse-a parse-t parse-e parse-t If next token is n or (, then parse-f parse-t parse-f If next token is n, then Match n

157 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e parse-e If next token is + or -, then parse-a parse-t parse-e parse-t If next token is n or (, then parse-f parse-t parse-f If next token is n, then Match n

158 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e parse-e If next token is + or -, then parse-a parse-t parse-e parse-t If next token is n or (, then parse-f parse-t

159 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e parse-e If next token is + or -, then parse-a parse-t parse-e parse-t If next token is n or (, then parse-f parse-t parse-t If next token is * or /, then parse-m parse-f parse-t

160 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e parse-e If next token is + or -, then parse-a parse-t parse-e parse-t If next token is n or (, then parse-f parse-t parse-t If next token is * or /, then parse-m parse-f parse-t parse-m If next token is *, then Match *

161 Recursive Descent Parsing: Example Rule (R) S E$ E T E PREDICT(R) E ɛ {$,)} E AT E {+,-} T F T T ɛ {+,-, $,)} T M F T {*,/} F n {n} F (E) {(} A + {+} A - {-} M * {*} M / {/} 2 * * 3 $ parse-s If next token is n or (, then parse-e Match $ parse-e If next token is n or (, then parse-t parse-e parse-e If next token is + or -, then parse-a parse-t parse-e parse-t If next token is n or (, then parse-f parse-t parse-t If next token is * or /, then parse-m parse-f parse-t parse-m If next token is *, then Match *