Presentation is loading. Please wait.

Presentation is loading. Please wait.

LR(1) Languages An Introduction Professor Yihjia Tsai Tamkang University.

Published by Modified over 8 years ago

Similar presentations

Presentation on theme: "LR(1) Languages An Introduction Professor Yihjia Tsai Tamkang University."— Presentation transcript:

1 LR(1) Languages An Introduction Professor Yihjia Tsai Tamkang University

2 2 Predictive Parsing Summary First and Follow sets are used to construct predictive tables –For non-terminal A and input t, use a production A  a where t  First( a ) –For non-terminal A and input t, if e  First(A) and t  Follow( a ), then use a production A  a where e  First( a ) We ’ ll see First and Follow sets again...

3 3 Bottom-Up Parsing Bottom-up parsing is more general than top-down parsing –And just as efficient –Builds on ideas in top-down parsing Bottom-up is the preferred method in practice Concepts today, algorithms next time

4 4 An Introductory Example Bottom-up parsers don ’ t need left- factored grammars Hence we can revert to the “ natural ” grammar for our example: E  T + E | T T  int * T | int | (E) Consider the string: int * int + int

5 5 The Idea Bottom-up parsing reduces a string to the start symbol by inverting productions: int * int + int T  int int * T + int T  int * T T + int T  int T + T E  T T + E E  T + E E

6 6 Terminology Derivation Sequence starting with the start symbol S and proceeding through a sequence of derivation steps Derivation step A non-terminal on the left side of a derivation is replaced by the right hand side of a production rule in the next step of the derivation  A  if A  is a production, and ,  are arbitrary strings of grammar symbols Sentential Form Any derivation step Sentence Sentential form with no non-terminals

7 7 Grammar E  E + E | E * E | ( E ) | - E | id Simple derivatiozn E  - E Derivation of -(id+id) E  -E  -(E)  -(E+E)  -(id+E)  -(id+id) E -(id+id) derives it  1   2  …   n or simply   Select a nonterminal to replace and an alternative at each step of a derivation Derivation example        

8 8 Leftmost Derivation The derivation E  -E  -(E)  -(E+E)  -(id+E)  -(id+id) is leftmost which we designate as E  lm -E  lm -(E)  lm -(E+E)  lm -(id+E)  lm -(id+id) A sentential form is a derivation step. A leftmost derivation step is a left sentential form, for example: ( Denoted  * lm for typographical convenience)

9 9 Leftmost Derivation A derivation in which only the leftmost non-terminal in any sentential form is replaced at each step. Unique derivation for a string most of the time

10 10 Rightmost Derivation The rightmost non-terminal is replaced in the derivation process in each step. Also referred to as Canonical Derivation Right sentential form: a sentential form produced via a rightmost derivation –If S  * , then  is a sentential form of the CFG –If S  * rm , then  is a right sentential form

11 11 Right Sentential Form Grammar: S  aABe A  Abc | b B  d Reduce abbcde to S by four steps abbcde aAbcde aAde aABe S Why not chose d here?

12 12 TEST YOURSELF #1 Question: find the rightmost derivation of the string int * int + int

13 13 Observation Read the productions found by bottom-up parse in reverse (i.e., from bottom to top) This is a rightmost derivation! int * int + int T  int int * T + int T  int * T T + int T  int T + T E  T T + E E  T + E E

14 14 Important Fact #1 Important Fact #1 about bottom-up parsing: A bottom-up parser traces a rightmost derivation in reverse

15 15 A Bottom-up Parse int * int + int int * T + int T + int T + T T + E E E TE + int * T T

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

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

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

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

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

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

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

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

24 24 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 right-most derivation

25 25 Notation Idea: Split string into two substrings –Right substring is as yet unexamined by parsing (a string of terminals) –Left substring has terminals and non- terminals 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

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

27 27 Shift Shift: Move | one place to the right –Shifts a terminal to the left string ABC|xyz  ABCx|yz

28 28 Reduce Apply an inverse production at the right end of the left string –If A  xy is a production, then Cbxy|ijk  CbA|ijk

29 29 The Example with Reductions Only int * int | + int reduce T  int int * T | + int reduce T  int * T T + int | reduce T  int T + T | reduce E  T T + E | reduce E  T + E E |

30 30 The Example with Shift-Reduce Parsing |int * int + intshift int | * int + intshift int * | int + intshift int * int | + int reduce T  int int * T | + int reduce T  int * T T | + intshift T + | intshift T + int | reduce T  int T + T | reduce E  T T + E | reduce E  T + E E |

31 31 A Shift-Reduce Parse in Detail (1) + int *  |int * int + int

32 32 A Shift-Reduce Parse in Detail (2) + int *  |int * int + int int | * int + int

33 33 A Shift-Reduce Parse in Detail (3) + int *  |int * int + int int | * int + int int * | int + int

34 34 A Shift-Reduce Parse in Detail (4) + int *  |int * int + int int | * int + int int * | int + int int * int | + int

35 35 A Shift-Reduce Parse in Detail (5) + int * T |int * int + int int | * int + int int * | int + int int * int | + int int * T | + int 

36 36 A Shift-Reduce Parse in Detail (6) T + int * T |int * int + int int | * int + int int * | int + int int * int | + int int * T | + int T | + int 

37 37 A Shift-Reduce Parse in Detail (7) T + int * T |int * int + int int | * int + int int * | int + int int * int | + int int * T | + int T | + int T + | int 

38 38 A Shift-Reduce Parse in Detail (8) T + int * T |int * int + int int | * int + int int * | int + int int * int | + int int * T | + int T | + int T + | int T + int | 

39 39 A Shift-Reduce Parse in Detail (9) T + int * T T |int * int + int int | * int + int int * | int + int int * int | + int int * T | + int T | + int T + | int T + int | T + T | 

40 40 A Shift-Reduce Parse in Detail (10) TE + int * T T |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 | 

41 41 A Shift-Reduce Parse in Detail (11) E TE + int * T T |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 | 

42 42 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 non-terminal on the stack (production lhs)

43 43 Key Issue (will be resolved by algorithms) How do we decide when to shift or reduce? –Consider step int | * int + int –We could reduce by T  int giving T | * int + int –A fatal mistake: No way to reduce to the start symbol E

44 44 Conflicts Generic shift-reduce strategy: –If there is a handle on top of the stack, reduce –Otherwise, shift But what if there is a choice? –If it is legal to shift or reduce, there is a shift-reduce conflict –If it is legal to reduce by two different productions, there is a reduce-reduce conflict

45 45 Source of Conflicts Ambiguous grammars always cause conflicts But beware, so do many non- ambiguous grammars

46 46 Conflict Example Consider everybody's favorite ambiguous grammar: E  E + E |E * E |(E) |int

47 47 One Shift-Reduce Parse |int * int + intshift... E * E | + int reduce E  E * E E | + intshift E + | intshift E + int| reduce E  int E + E | reduce E  E + E E |

48 48 Another Shift-Reduce Parse |int * int + intshift... E * E | + intshift E * E + | intshift E * E + int | reduce E  int E * E + E| reduce E  E + E E * E | reduce E  E * E E |

49 49 Example Notes In the second step E * E | + int we can either shift or reduce by E  E * E Choice determines associativity of + and * As noted previously, grammar can be rewritten to enforce precedence Precedence declarations are an alternative

50 50 Precedence Declarations Revisited Precedence declarations cause shift- reduce parsers to resolve conflicts in certain ways Declaring “ * has greater precedence than + ” causes parser to reduce at E * E | + int More precisely, precedence declaration is used to resolve conflict between reducing a * and shifting a +

51 51 References Aho, A.V., R. Sethi, and J.D. Ullman, Compilers Principles, Techniques and Tools, Addison-Wesley, 1988. ISBN 0-201-10088-6. Chapters 2/3

Download ppt "LR(1) Languages An Introduction Professor Yihjia Tsai Tamkang University."

Similar presentations

Parsing V: Bottom-up Parsing

Parsing V: Bottom-up Parsing
A question from last class: construct the predictive parsing table for this grammar: S->i E t S e S | i E t S | a E -> B.

A question from last class: construct the predictive parsing table for this grammar: S->i E t S e S | i E t S | a E -> B.
Lesson 8 CDT301 – Compiler Theory, Spring 2011 Teacher: Linus Källberg.

Lesson 8 CDT301 – Compiler Theory, Spring 2011 Teacher: Linus Källberg.
Bottom up Parsing Bottom up parsing trys to transform the input string into the start symbol. Moves through a sequence of sentential forms (sequence of.

Bottom up Parsing Bottom up parsing trys to transform the input string into the start symbol. Moves through a sequence of sentential forms (sequence of.
Bottom-up Parsing A general style of bottom-up syntax analysis, known as shift-reduce parsing. Two types of bottom-up parsing: Operator-Precedence parsing.

Bottom-up Parsing A general style of bottom-up syntax analysis, known as shift-reduce parsing. Two types of bottom-up parsing: Operator-Precedence parsing.
Predictive Parsing l Find derivation for an input string, l Build a abstract syntax tree (AST) –a representation of the parsed program l Build a symbol.

Predictive Parsing l Find derivation for an input string, l Build a abstract syntax tree (AST) –a representation of the parsed program l Build a symbol.
6/12/2015Prof. Hilfinger CS164 Lecture 111 Bottom-Up Parsing Lecture 11-12 (From slides by G. Necula & R. Bodik)

6/12/2015Prof. Hilfinger CS164 Lecture 111 Bottom-Up Parsing Lecture (From slides by G. Necula & R. Bodik)
1 Chapter 5: Bottom-Up Parsing (Shift-Reduce). 2 - attempts to construct a parse tree for an input string beginning at the leaves (the bottom) and working.

1 Chapter 5: Bottom-Up Parsing (Shift-Reduce). 2 - attempts to construct a parse tree for an input string beginning at the leaves (the bottom) and working.
1 Bottom Up Parsing. 2 Bottom-Up Parsing l Bottom-up parsing is more general than top-down parsing »And just as efficient »Builds on ideas in top-down.

1 Bottom Up Parsing. 2 Bottom-Up Parsing l Bottom-up parsing is more general than top-down parsing »And just as efficient »Builds on ideas in top-down.
By Neng-Fa Zhou Syntax Analysis lexical analyzer syntax analyzer semantic analyzer source program tokens parse tree parser tree.

By Neng-Fa Zhou Syntax Analysis lexical analyzer syntax analyzer semantic analyzer source program tokens parse tree parser tree.
CS 536 Spring 20011 Introduction to Bottom-Up Parsing Lecture 11.

CS 536 Spring Introduction to Bottom-Up Parsing Lecture 11.
CH4.1 CSE244 Sections 4.5,4.6 Aggelos Kiayias Computer Science & Engineering Department The University of Connecticut 371 Fairfield Road, Box U-155 Storrs,

CH4.1 CSE244 Sections 4.5,4.6 Aggelos Kiayias Computer Science & Engineering Department The University of Connecticut 371 Fairfield Road, Box U-155 Storrs,
Bottom Up Parsing.

Bottom Up Parsing.
Parsing — Part II (Ambiguity, Top-down parsing, Left-recursion Removal)

Parsing — Part II (Ambiguity, Top-down parsing, Left-recursion Removal)
Prof. Fateman CS 164 Lecture 91 Bottom-Up Parsing Lecture 9.

Prof. Fateman CS 164 Lecture 91 Bottom-Up Parsing Lecture 9.
CS 330 Programming Languages 09 / 23 / 2008 Instructor: Michael Eckmann.

CS 330 Programming Languages 09 / 23 / 2008 Instructor: Michael Eckmann.
Professor Yihjia Tsai Tamkang University

Professor Yihjia Tsai Tamkang University
1 Bottom-up parsing Goal of parser : build a derivation –top-down parser : build a derivation by working from the start symbol towards the input. builds.

1 Bottom-up parsing Goal of parser : build a derivation –top-down parser : build a derivation by working from the start symbol towards the input. builds.
– 1 – CSCE 531 Spring 2006 Lecture 8 Bottom Up Parsing Topics Overview Bottom-Up Parsing Handles Shift-reduce parsing Operator precedence parsing Readings:

– 1 – CSCE 531 Spring 2006 Lecture 8 Bottom Up Parsing Topics Overview Bottom-Up Parsing Handles Shift-reduce parsing Operator precedence parsing Readings:
Parsing IV Bottom-up Parsing Copyright 2003, Keith D. Cooper, Ken Kennedy & Linda Torczon, all rights reserved. Students enrolled in Comp 412 at Rice University.

Parsing IV Bottom-up Parsing Copyright 2003, Keith D. Cooper, Ken Kennedy & Linda Torczon, all rights reserved. Students enrolled in Comp 412 at Rice University.

Similar presentations

Ads by Google