# Syntax-Directed Translation. Lecture 14

Size: px
Start display at page:

Transcription

1 Syntax-Directed Translation Lecture 14 (adapted from slides by R. Bodik) 9/27/2006 Prof. Hilfinger, Lecture 14 1

2 Motivation: parser as a translator syntax-directed translation stream of tokens parser ASTs, or assembly code syntax + translation rules (typically hardcoded in the parser) 9/27/2006 Prof. Hilfinger, Lecture 14 2

3 Outline Syntax-directed translation: specification translate parse tree to its value, or to an AST type check the parse tree Syntax-directed translation: implementation during LR parsing during recursive-descent parsing 9/27/2006 Prof. Hilfinger, Lecture 14 3

4 Mechanism of syntax-directed translation syntax-directed translation is done by extending the CFG a translation rule is defined for each production given X d A B c the translation of X is defined recursively using translation of nonterminals A, B values of attributes of terminals d, c constants 9/27/2006 Prof. Hilfinger, Lecture 14 4

5 To translate an input string: 1. Build the parse tree. 2. Working bottom-up Use the translation rules to compute the translation of each nonterminal in the tree Result: the translation of the string is the translation of the parse tree's root nonterminal. Why bottom up? a nonterminal's value may depend on the value of the symbols on the right-hand side, so translate a non-terminal node only after children translations are available. 9/27/2006 Prof. Hilfinger, Lecture 14 5

6 Example 1: Arithmetic expression to value Syntax-directed translation rules: E E + T E 1.trans = E 2.trans + T.trans E T E.trans = T.trans T T * F T 1.trans = T 2.trans * F.trans T F T.trans = F.trans F int F.trans = int.value F ( E ) F.trans = E.trans 9/27/2006 Prof. Hilfinger, Lecture 14 6

7 Example 1: Bison/Yacc Notation E : E + T { \$\$ = \$1 + \$3; } T : T * F { \$\$ = \$1 * \$3; } F : int { \$\$ = \$1; } F : ( E ) { \$\$ = \$2; } KEY: \$\$ : Semantic value of left-hand side \$n : Semantic value of n th symbol on right-hand side 9/27/2006 Prof. Hilfinger, Lecture 14 7

8 Example 1 (cont): Annotated Parse Tree Input: 2 * (4 + 5) E (18) T (18) T (2) * F (9) F (2) ( E (9) ) int (2) E (4) * T (5) T (4) F (4) F (5) 9/27/2006 Prof. Hilfinger, Lecture 14 8 int (4) int (5)

9 Example 2: Compute the type of an expression E -> E + E if \$1 == INT and \$3 == INT: \$\$ = INT else: \$\$ = ERROR E -> E and E if \$1 == BOOL and \$3 == BOOL: \$\$ = BOOL else: \$\$ = ERROR E -> E == E if \$1 == \$3 and \$2!= ERROR: \$\$ = BOOL else: \$\$ = ERROR E -> true \$\$ = BOOL E -> false \$\$ = BOOL E -> int \$\$ = INT E -> ( E ) \$\$ = \$2 9/27/2006 Prof. Hilfinger, Lecture 14 9

10 Example 2 (cont) Input: (2 + 2) == 4 E (BOOL) E (INT) == E (INT) ( E (INT) ) int (INT) E (INT) + E (INT) int (INT) int (INT) 9/27/2006 Prof. Hilfinger, Lecture 14 10

11 Building Abstract Syntax Trees Examples so far, streams of tokens translated into integer values, or types Translating into ASTs is not very different 9/27/2006 Prof. Hilfinger, Lecture 14 11

12 AST vs. Parse Tree AST is condensed form of a parse tree operators appear at internal nodes, not at leaves. "Chains" of single productions are collapsed. Lists are "flattened". Syntactic details are omitted e.g., parentheses, commas, semi-colons AST is a better structure for later compiler stages omits details having to do with the source language, only contains information about the essential structure of the program. 9/27/2006 Prof. Hilfinger, Lecture 14 12

13 Example: 2 * (4 + 5) Parse tree vs. AST E T * T * F 2 + F ( E ) 4 5 int (2) E T * T F F int (5) int (4) 9/27/2006 Prof. Hilfinger, Lecture 14 13

14 AST-building translation rules E E + T \$\$ = new PlusNode(\$1, \$3) E T \$\$ = \$1 T T * F \$\$ = new TimesNode(\$1, \$3) T F \$\$ = \$1 F int \$\$ = new IntLitNode(\$1) F ( E ) \$\$ = \$2 9/27/2006 Prof. Hilfinger, Lecture 14 14

15 Example: 2 * (4 + 5): Steps in Creating AST E * T T F * ( F E ) (Only some of the semantic values are shown) int (2) E T * T F F int (5) int (4) 9/27/2006 Prof. Hilfinger, Lecture 14 15

16 Syntax-Directed Translation and LR Parsing add semantic stack, parallel to the parsing stack: each symbol (terminal or non-terminal) on the parsing stack stores its value on the semantic stack holds terminals attributes, and holds nonterminals' translations when the parse is finished, the semantic stack will hold just one value: the translation of the root non-terminal (which is the translation of the whole input). 9/27/2006 Prof. Hilfinger, Lecture 14 16

17 Semantic actions during parsing when shifting push the value of the terminal on the semantic stack when reducing pop k values from the semantic stack, where k is the number of symbols on production s RHS push the production s value on the semantic stack 9/27/2006 Prof. Hilfinger, Lecture 14 17

18 An LR example Grammar + translation rules: E E + ( E ) \$\$ = \$1 + \$4 E int \$\$ = \$1 Input: 2 + ( 3 ) + ( 4 ) 9/27/2006 Prof. Hilfinger, Lecture 14 18

19 Shift-Reduce Example with evaluations parsing stack I int + (int) + (int)\$ shift semantic stack I 9/27/2006 Prof. Hilfinger, Lecture 14 19

20 Shift-Reduce Example with evaluations I int + (int) + (int)\$ shift int I + (int) + (int)\$ red. E int I 2 I 9/27/2006 Prof. Hilfinger, Lecture 14 20

21 Shift-Reduce Example with evaluations I int + (int) + (int)\$ shift I int I + (int) + (int)\$ red. E int 2 I E I + (int) + (int)\$ shift 3 times 2 I 9/27/2006 Prof. Hilfinger, Lecture 14 21

22 Shift-Reduce Example with evaluations I int + (int) + (int)\$ shift I int I + (int) + (int)\$ red. E int 2 I E I + (int) + (int)\$ shift 3 times 2 I E + (int I ) + (int)\$ red. E int 2 + ( 3 I 9/27/2006 Prof. Hilfinger, Lecture 14 22

23 Shift-Reduce Example with evaluations I int + (int) + (int)\$ shift I int I + (int) + (int)\$ red. E int 2 I E I + (int) + (int)\$ shift 3 times 2 I E + (int I ) + (int)\$ red. E int 2 + ( 3 I E + (E I ) + (int)\$ shift 2 + ( 3 I 9/27/2006 Prof. Hilfinger, Lecture 14 23

24 Shift-Reduce Example with evaluations I int + (int) + (int)\$ shift I int I + (int) + (int)\$ red. E int 2 I E I + (int) + (int)\$ shift 3 times 2 I E + (int I ) + (int)\$ red. E int 2 + ( 3 I E + (E I ) + (int)\$ shift 2 + ( 3 I E + (E) I + (int)\$ red. E E + (E) 2 + ( 3 ) I 9/27/2006 Prof. Hilfinger, Lecture 14 24

25 Shift-Reduce Example with evaluations I int + (int) + (int)\$ shift I int I + (int) + (int)\$ red. E int 2 I E I + (int) + (int)\$ shift 3 times 2 I E + (int I ) + (int)\$ red. E int 2 + ( 3 I E + (E I ) + (int)\$ shift 2 + ( 3 I E + (E) I + (int)\$ red. E E + (E) 2 + ( 3 ) I E I + (int)\$ shift 3 times 5 I 9/27/2006 Prof. Hilfinger, Lecture 14 25

26 Shift-Reduce Example with evaluations I int + (int) + (int)\$ shift I int I + (int) + (int)\$ red. E int 2 I E I + (int) + (int)\$ shift 3 times 2 I E + (int I ) + (int)\$ red. E int 2 + ( 3 I E + (E I ) + (int)\$ shift 2 + ( 3 I E + (E) I + (int)\$ red. E E + (E) 2 + ( 3 ) I E I + (int)\$ shift 3 times 5 I E + (int I )\$ red. E int 5 + ( 4 I 9/27/2006 Prof. Hilfinger, Lecture 14 26

27 Shift-Reduce Example with evaluations I int + (int) + (int)\$ shift I int I + (int) + (int)\$ red. E int 2 I E I + (int) + (int)\$ shift 3 times 2 I E + (int I ) + (int)\$ red. E int 2 + ( 3 I E + (E I ) + (int)\$ shift 2 + ( 3 I E + (E) I + (int)\$ red. E E + (E) 2 + ( 3 ) I E I + (int)\$ shift 3 times 5 I E + (int I )\$ red. E int 5 + ( 4 I E + (E I )\$ shift 5 + ( 4 I 9/27/2006 Prof. Hilfinger, Lecture 14 27

28 Shift-Reduce Example with Evaluations I int + (int) + (int)\$ shift I int I + (int) + (int)\$ red. E int 2 I E I + (int) + (int)\$ shift 3 times 2 I E + (int I ) + (int)\$ red. E int 2 + ( 3 I E + (E I ) + (int)\$ shift 2 + ( 3 I E + (E) I + (int)\$ red. E E + (E) 2 + ( 3 ) I E I + (int)\$ shift 3 times 5 I E + (int I )\$ red. E int 5 + ( 4 I E + (E I )\$ shift 5 + ( 4 I E + (E) I \$ red. E E + (E) 5 + ( 4 ) I 9/27/2006 Prof. Hilfinger, Lecture 14 28

29 Shift-Reduce Example with evaluations I int + (int) + (int)\$ shift I int I + (int) + (int)\$ red. E int 2 I E I + (int) + (int)\$ shift 3 times 2 I E + (int I ) + (int)\$ red. E int 2 + ( 3 I E + (E I ) + (int)\$ shift 2 + ( 3 I E + (E) I + (int)\$ red. E E + (E) 2 + ( 3 ) I E I + (int)\$ shift 3 times 5 I E + (int I )\$ red. E int 5 + ( 4 I E + (E I )\$ shift 5 + ( 4 I E + (E) I \$ red. E E + (E) 5 + ( 4 ) I E I \$ accept 9 I 9/27/2006 Prof. Hilfinger, Lecture 14 29

30 Taking Advantage of Derivation Order So far, rules have been functional; no side effects except to define (once) value of LHS. LR parsing produces reverse rightmost derivation. Can use the ordering to do control semantic actions with side effects. 9/27/2006 Prof. Hilfinger, Lecture 14 30

31 Example of Actions with Side Effects E E + T print +, E T pass T T * F print *, T F pass F int print \$1, F ( E ) pass We know that reduction taken after all the reductions that form the nonterminals on right-hand side. So what does this print for 3+4*(7+1)? * + 9/27/2006 Prof. Hilfinger, Lecture 14 31

32 Recursive-Descent Translation Translating with recursive descent is also easy. The semantic values (what Bison calls \$\$, \$1, etc.), become return values of the parsing functions We ll also assume that the lexer has a way to return lexical values (e.g., the scan function introduced in Lecture 9 might do so). 9/27/2006 Prof. Hilfinger, Lecture 14 32

33 Example of Recursive-Descent Translation E T E+T T P T*P P int ( E ) def E(): T () while next() == + : scan( + ); T() def T(): P() while next() == * : scan( * ); P() def P(): if next()==int: scan (int) elif next()== ( : scan( ( ) E() scan( ) ) else: ERROR() (we ve cheated and used loops; see end of lecture 9) 9/27/2006 Prof. Hilfinger, Lecture 14 33

34 Example contd.: Add Semantic Values E T E+T T P T*P P int ( E ) def E(): v = T () while next() == + : scan( + ); v += T() return v def T(): v = P() while next() == * : scan( * ); v *= P() return v def P(): if next()==int: v = scan (int) elif next()== ( : scan( ( ) v = E() scan( ) ) else: ERROR() return v 9/27/2006 Prof. Hilfinger, Lecture 14 34

35 Table-Driven LL(1) We can automate all this, and add to the LL(1) parser method from Lecture 9. However, this gets a little involved, and I m not sure it s worth it. (That is, let s leave it to the LL(1) parser generators for now!) 9/27/2006 Prof. Hilfinger, Lecture 14 35

### Outline. Limitations of regular languages Parser overview Context-free grammars (CFG s) Derivations Syntax-Directed Translation

Outline Introduction to Parsing Lecture 8 Adapted from slides by G. Necula and R. Bodik Limitations of regular languages Parser overview Context-free grammars (CG s) Derivations Syntax-Directed ranslation

### Outline. Parser overview Context-free grammars (CFG s) Derivations Syntax-Directed Translation

Outline Introduction to Parsing (adapted from CS 164 at Berkeley) Parser overview Context-free grammars (CFG s) Derivations Syntax-Directed ranslation he Functionality of the Parser Input: sequence of

### Introduction to Parsing. Lecture 8

Introduction to Parsing Lecture 8 Adapted from slides by G. Necula Outline Limitations of regular languages Parser overview Context-free grammars (CFG s) Derivations Languages and Automata Formal languages

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

### Outline. Limitations of regular languages. Introduction to Parsing. Parser overview. Context-free grammars (CFG s)

Outline Limitations of regular languages Introduction to Parsing Parser overview Lecture 8 Adapted from slides by G. Necula Context-free grammars (CFG s) Derivations Languages and Automata Formal languages

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

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

### RYERSON POLYTECHNIC UNIVERSITY DEPARTMENT OF MATH, PHYSICS, AND COMPUTER SCIENCE CPS 710 FINAL EXAM FALL 96 INSTRUCTIONS

RYERSON POLYTECHNIC UNIVERSITY DEPARTMENT OF MATH, PHYSICS, AND COMPUTER SCIENCE CPS 710 FINAL EXAM FALL 96 STUDENT ID: INSTRUCTIONS Please write your student ID on this page. Do not write it or your name

### Syntax and Grammars 1 / 21

Syntax and Grammars 1 / 21 Outline What is a language? Abstract syntax and grammars Abstract syntax vs. concrete syntax Encoding grammars as Haskell data types What is a language? 2 / 21 What is a language?

### Derivations vs Parses. Example. Parse Tree. Ambiguity. Different Parse Trees. Context Free Grammars 9/18/2012

Derivations vs Parses Grammar is used to derive string or construct parser Context ree Grammars A derivation is a sequence of applications of rules Starting from the start symbol S......... (sentence)

### Syntax Analysis: Context-free Grammars, Pushdown Automata and Parsing Part - 4. Y.N. Srikant

Syntax Analysis: Context-free Grammars, Pushdown Automata and Part - 4 Department of Computer Science and Automation Indian Institute of Science Bangalore 560 012 NPTEL Course on Principles of Compiler

### Recursive Descent Parsers

Recursive Descent Parsers Lecture 7 Robb T. Koether Hampden-Sydney College Wed, Jan 28, 2015 Robb T. Koether (Hampden-Sydney College) Recursive Descent Parsers Wed, Jan 28, 2015 1 / 18 1 Parsing 2 LL Parsers

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

### Programming Languages & Translators PARSING. Baishakhi Ray. Fall These slides are motivated from Prof. Alex Aiken: Compilers (Stanford)

Programming Languages & Translators PARSING Baishakhi Ray Fall 2018 These slides are motivated from Prof. Alex Aiken: Compilers (Stanford) Languages and Automata Formal languages are very important in

### Syntax Errors; Static Semantics

Dealing with Syntax Errors Syntax Errors; Static Semantics Lecture 14 (from notes by R. Bodik) One purpose of the parser is to filter out errors that show up in parsing Later stages should not have to

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

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

### EDAN65: Compilers, Lecture 06 A LR parsing. Görel Hedin Revised:

EDAN65: Compilers, Lecture 06 A LR parsing Görel Hedin Revised: 2017-09-11 This lecture Regular expressions Context-free grammar Attribute grammar Lexical analyzer (scanner) Syntactic analyzer (parser)

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

### Review main idea syntax-directed evaluation and translation. Recall syntax-directed interpretation in recursive descent parsers

Plan for Today Review main idea syntax-directed evaluation and translation Recall syntax-directed interpretation in recursive descent parsers Syntax-directed evaluation and translation in shift-reduce

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

### COMP-421 Compiler Design. Presented by Dr Ioanna Dionysiou

COMP-421 Compiler Design Presented by Dr Ioanna Dionysiou Administrative! Any questions about the syllabus?! Course Material available at www.cs.unic.ac.cy/ioanna! Next time reading assignment [ALSU07]

### Parsing CSCI-400. Principles of Programming Languages.

Parsing Principles of Programming Languages https://lambda.mines.edu Activity & Overview Review the learning group activity with your group. Compare your solutions to the practice problems. Did anyone

### CSE450 Translation of Programming Languages. Lecture 4: Syntax Analysis

CSE450 Translation of Programming Languages Lecture 4: Syntax Analysis http://xkcd.com/859 Structure of a Today! Compiler Source Language Lexical Analyzer Syntax Analyzer Semantic Analyzer Int. Code Generator

### Section A. A grammar that produces more than one parse tree for some sentences is said to be ambiguous.

Section A 1. What do you meant by parser and its types? A parser for grammar G is a program that takes as input a string w and produces as output either a parse tree for w, if w is a sentence of G, or

### CS 406: Syntax Directed Translation

CS 406: Syntax Directed Translation Stefan D. Bruda Winter 2015 SYNTAX DIRECTED TRANSLATION Syntax-directed translation the source language translation is completely driven by the parser The parsing process

### CMSC 330: Organization of Programming Languages

CMSC 330: Organization of Programming Languages Context Free Grammars and Parsing 1 Recall: Architecture of Compilers, Interpreters Source Parser Static Analyzer Intermediate Representation Front End Back

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

### CSE 130 Programming Language Principles & Paradigms Lecture # 5. Chapter 4 Lexical and Syntax Analysis

Chapter 4 Lexical and Syntax Analysis Introduction - Language implementation systems must analyze source code, regardless of the specific implementation approach - Nearly all syntax analysis is based on

### Context-Free Grammar. Concepts Introduced in Chapter 2. Parse Trees. Example Grammar and Derivation

Concepts Introduced in Chapter 2 A more detailed overview of the compilation process. Parsing Scanning Semantic Analysis Syntax-Directed Translation Intermediate Code Generation Context-Free Grammar A

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

### COMPILER CONSTRUCTION LAB 2 THE SYMBOL TABLE. Tutorial 2 LABS. PHASES OF A COMPILER Source Program. Lab 2 Symbol table

COMPILER CONSTRUCTION Lab 2 Symbol table LABS Lab 3 LR parsing and abstract syntax tree construction using ''bison' Lab 4 Semantic analysis (type checking) PHASES OF A COMPILER Source Program Lab 2 Symtab

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

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

### Introduction to Syntax Analysis Recursive-Descent Parsing

Introduction to Syntax Analysis Recursive-Descent Parsing CS F331 Programming Languages CSCE A331 Programming Language Concepts Lecture Slides Friday, February 10, 2017 Glenn G. Chappell Department of

### Static Semantics. Lecture 15. (Notes by P. N. Hilfinger and R. Bodik) 2/29/08 Prof. Hilfinger, CS164 Lecture 15 1

Static Semantics Lecture 15 (Notes by P. N. Hilfinger and R. Bodik) 2/29/08 Prof. Hilfinger, CS164 Lecture 15 1 Current Status Lexical analysis Produces tokens Detects & eliminates illegal tokens Parsing

### The Parsing Problem (cont d) Recursive-Descent Parsing. Recursive-Descent Parsing (cont d) ICOM 4036 Programming Languages. The Complexity of Parsing

ICOM 4036 Programming Languages Lexical and Syntax Analysis Lexical Analysis The Parsing Problem Recursive-Descent Parsing Bottom-Up Parsing This lecture covers review questions 14-27 This lecture covers

### CSE 401 Midterm Exam Sample Solution 2/11/15

Question 1. (10 points) Regular expression warmup. For regular expression questions, you must restrict yourself to the basic regular expression operations covered in class and on homework assignments:

### Chapter 4. Lexical and Syntax Analysis

Chapter 4 Lexical and Syntax Analysis Chapter 4 Topics Introduction Lexical Analysis The Parsing Problem Recursive-Descent Parsing Bottom-Up Parsing Copyright 2012 Addison-Wesley. All rights reserved.

### LECTURE 3. Compiler Phases

LECTURE 3 Compiler Phases COMPILER PHASES Compilation of a program proceeds through a fixed series of phases. Each phase uses an (intermediate) form of the program produced by an earlier phase. Subsequent

### A programming language requires two major definitions A simple one pass compiler

A programming language requires two major definitions A simple one pass compiler [Syntax: what the language looks like A context-free grammar written in BNF (Backus-Naur Form) usually suffices. [Semantics:

### Context-Free Grammars

Context-Free Grammars Lecture 7 http://webwitch.dreamhost.com/grammar.girl/ Outline Scanner vs. parser Why regular expressions are not enough Grammars (context-free grammars) grammar rules derivations

### CS 4120 Introduction to Compilers

CS 4120 Introduction to Compilers Andrew Myers Cornell University Lecture 6: Bottom-Up Parsing 9/9/09 Bottom-up parsing A more powerful parsing technology LR grammars -- more expressive than LL can handle

### Introduction to Parsing. Lecture 5

Introduction to Parsing Lecture 5 1 Outline Regular languages revisited Parser overview Context-free grammars (CFG s) Derivations Ambiguity 2 Languages and Automata Formal languages are very important

### A Simple Syntax-Directed Translator

Chapter 2 A Simple Syntax-Directed Translator 1-1 Introduction The analysis phase of a compiler breaks up a source program into constituent pieces and produces an internal representation for it, called

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

### COP 3402 Systems Software Syntax Analysis (Parser)

COP 3402 Systems Software Syntax Analysis (Parser) Syntax Analysis 1 Outline 1. Definition of Parsing 2. Context Free Grammars 3. Ambiguous/Unambiguous Grammars Syntax Analysis 2 Lexical and Syntax Analysis

### Alternatives for semantic processing

Semantic Processing Copyright c 2000 by Antony L. Hosking. Permission to make digital or hard copies of part or all of this work for personal or classroom use is granted without fee provided that copies

### Project Compiler. CS031 TA Help Session November 28, 2011

Project Compiler CS031 TA Help Session November 28, 2011 Motivation Generally, it s easier to program in higher-level languages than in assembly. Our goal is to automate the conversion from a higher-level

### Syntax Analysis. Chapter 4

Syntax Analysis Chapter 4 Check (Important) http://www.engineersgarage.com/contributio n/difference-between-compiler-andinterpreter Introduction covers the major parsing methods that are typically used

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

### Downloaded from Page 1. LR Parsing

Downloaded from http://himadri.cmsdu.org Page 1 LR Parsing We first understand Context Free Grammars. Consider the input string: x+2*y When scanned by a scanner, it produces the following stream of tokens:

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

### Last Time. What do we want? When do we want it? An AST. Now!

Java CUP 1 Last Time What do we want? An AST When do we want it? Now! 2 This Time A little review of ASTs The philosophy and use of a Parser Generator 3 Translating Lists CFG IdList -> id IdList comma

### 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 Parsing. Lecture 5

Introduction to Parsing Lecture 5 1 Outline Regular languages revisited Parser overview Context-free grammars (CFG s) Derivations Ambiguity 2 Languages and Automata Formal languages are very important

### Syntax Analysis Part I

Syntax Analysis Part I Chapter 4: Context-Free Grammars Slides adapted from : Robert van Engelen, Florida State University Position of a Parser in the Compiler Model Source Program Lexical Analyzer Token,

### Syntax-Directed Translation. Introduction

Syntax-Directed Translation Introduction Translation of languages guided by context-free grammars Attach attributes to the grammar symbols Values of the attributes are computed by semantic rules associated

### CS 406/534 Compiler Construction Putting It All Together

CS 406/534 Compiler Construction Putting It All Together 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

### Lecture 14 Sections Mon, Mar 2, 2009

Lecture 14 Sections 5.1-5.4 Hampden-Sydney College Mon, Mar 2, 2009 Outline 1 2 3 4 5 Parse A parse tree shows the grammatical structure of a statement. It includes all of the grammar symbols (terminals

### CSE P 501 Exam 8/5/04

Name There are 7 questions worth a total of 65 points. Please budget your time so you get to all of the questions. Keep your answers brief and to the point. You may refer to the following references: Course

### Announcements. Working in pairs is only allowed for programming assignments and not for homework problems. H3 has been posted

Announcements Working in pairs is only allowed for programming assignments and not for homework problems H3 has been posted 1 Syntax Directed Transla@on 2 CFGs so Far CFGs for Language Defini&on The CFGs

### ( ) i 0. Outline. Regular languages revisited. Introduction to Parsing. Parser overview. Context-free grammars (CFG s) Lecture 5.

Outline Regular languages revisited Introduction to Parsing Lecture 5 Parser overview Context-free grammars (CFG s) Derivations Prof. Aiken CS 143 Lecture 5 1 Ambiguity Prof. Aiken CS 143 Lecture 5 2 Languages

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

### EDAN65: Compilers, Lecture 04 Grammar transformations: Eliminating ambiguities, adapting to LL parsing. Görel Hedin Revised:

EDAN65: Compilers, Lecture 04 Grammar transformations: Eliminating ambiguities, adapting to LL parsing Görel Hedin Revised: 2017-09-04 This lecture Regular expressions Context-free grammar Attribute grammar

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

### 10/4/18. Lexical and Syntactic Analysis. Lexical and Syntax Analysis. Tokenizing Source. Scanner. Reasons to Separate Lexical and Syntactic Analysis

Lexical and Syntactic Analysis Lexical and Syntax Analysis In Text: Chapter 4 Two steps to discover the syntactic structure of a program Lexical analysis (Scanner): to read the input characters and output

### 10/5/17. Lexical and Syntactic Analysis. Lexical and Syntax Analysis. Tokenizing Source. Scanner. Reasons to Separate Lexical and Syntax Analysis

Lexical and Syntactic Analysis Lexical and Syntax Analysis In Text: Chapter 4 Two steps to discover the syntactic structure of a program Lexical analysis (Scanner): to read the input characters and output

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

### CSE 3302 Programming Languages Lecture 2: Syntax

CSE 3302 Programming Languages Lecture 2: Syntax (based on slides by Chengkai Li) Leonidas Fegaras University of Texas at Arlington CSE 3302 L2 Spring 2011 1 How do we define a PL? Specifying a PL: Syntax:

### 4. Lexical and Syntax Analysis

4. Lexical and Syntax Analysis 4.1 Introduction Language implementation systems must analyze source code, regardless of the specific implementation approach Nearly all syntax analysis is based on a formal

### Outline. Regular languages revisited. Introduction to Parsing. Parser overview. Context-free grammars (CFG s) Lecture 5. Derivations.

Outline Regular languages revisited Introduction to Parsing Lecture 5 Parser overview Context-free grammars (CFG s) Derivations Prof. Aiken CS 143 Lecture 5 1 Ambiguity Prof. Aiken CS 143 Lecture 5 2 Languages

### Context-free grammars (CFG s)

Syntax Analysis/Parsing Purpose: determine if tokens have the right form for the language (right syntactic structure) stream of tokens abstract syntax tree (AST) AST: captures hierarchical structure of

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

### CSE 401 Compilers. LR Parsing Hal Perkins Autumn /10/ Hal Perkins & UW CSE D-1

CSE 401 Compilers LR Parsing Hal Perkins Autumn 2011 10/10/2011 2002-11 Hal Perkins & UW CSE D-1 Agenda LR Parsing Table-driven Parsers Parser States Shift-Reduce and Reduce-Reduce conflicts 10/10/2011

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

### How do LL(1) Parsers Build Syntax Trees?

How do LL(1) Parsers Build Syntax Trees? So far our LL(1) parser has acted like a recognizer. It verifies that input token are syntactically correct, but it produces no output. Building complete (concrete)

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

### Semantic actions for declarations and expressions

Semantic actions for declarations and expressions Semantic actions Semantic actions are routines called as productions (or parts of productions) are recognized Actions work together to build up intermediate

### 4. Lexical and Syntax Analysis

4. Lexical and Syntax Analysis 4.1 Introduction Language implementation systems must analyze source code, regardless of the specific implementation approach Nearly all syntax analysis is based on a formal

### Error Handling Syntax-Directed Translation Recursive Descent Parsing

Error Handling Syntax-Directed Translation Recursive Descent Parsing Lecture 6 by Professor Vijay Ganesh) 1 Outline Recursive descent Extensions of CFG for parsing Precedence declarations Error handling

### Today. Assignments. Lecture Notes CPSC 326 (Spring 2019) Quiz 5. Exam 1 overview. Type checking basics. HW4 due. HW5 out, due in 2 Tuesdays

Today Quiz 5 Exam 1 overview Type checking basics Assignments HW4 due HW5 out, due in 2 Tuesdays S. Bowers 1 of 11 Exam Overview Basics closed notes, book, etc. 4 multi-part questions worth 15% of final

### Outline CS412/413. Administrivia. Review. Grammars. Left vs. Right Recursion. More tips forll(1) grammars Bottom-up parsing LR(0) parser construction

C12/1 Introduction to Compilers and Translators pring 00 Outline More tips forll1) grammars Bottom-up parsing LR0) parser construction Lecture 5: Bottom-up parsing Lecture 5 C 12/1 pring '00 Andrew Myers

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

### Semantic actions for declarations and expressions. Monday, September 28, 15

Semantic actions for declarations and expressions Semantic actions Semantic actions are routines called as productions (or parts of productions) are recognized Actions work together to build up intermediate

### MIDTERM EXAM (Solutions)

MIDTERM EXAM (Solutions) Total Score: 100, Max. Score: 83, Min. Score: 26, Avg. Score: 57.3 1. (10 pts.) List all major categories of programming languages, outline their definitive characteristics and

### Lexical and Syntax Analysis

Lexical and Syntax Analysis In Text: Chapter 4 N. Meng, F. Poursardar Lexical and Syntactic Analysis Two steps to discover the syntactic structure of a program Lexical analysis (Scanner): to read the input

### Syntax Analysis/Parsing. Context-free grammars (CFG s) Context-free grammars vs. Regular Expressions. BNF description of PL/0 syntax

Susan Eggers 1 CSE 401 Syntax Analysis/Parsing Context-free grammars (CFG s) Purpose: determine if tokens have the right form for the language (right syntactic structure) stream of tokens abstract syntax

### CS 164, Spring 2010 CS 164: Test #1 Solutions P. N. Hilfinger DO NOT. Copyright (c) 2010 by P. N. Hilfinger. Copying and reproduction prohibited.

S 164, Spring 2010 S 164: P. N. Hilfinger 1. [2 points] onsider the following very simple grammar: p : s s : /* Empty */ s : ( s ) Suppose that we have a shift-reduce parser for this grammar. Write a regular

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

### Programming Language Syntax and Analysis

Programming Language Syntax and Analysis 2017 Kwangman Ko (http://compiler.sangji.ac.kr, kkman@sangji.ac.kr) Dept. of Computer Engineering, Sangji University Introduction Syntax the form or structure of

### CS 2210 Sample Midterm. 1. Determine if each of the following claims is true (T) or false (F).

CS 2210 Sample Midterm 1. Determine if each of the following claims is true (T) or false (F). F A language consists of a set of strings, its grammar structure, and a set of operations. (Note: a language

### Compiler construction lecture 3

Compiler construction in4303 lecture 3 Top-down parsing Chapter 2.2-2.2.4 Overview syntax analysis: tokens AST language grammar parser generator program text lexical analysis tokens syntax analysis AST

### Lexical and Syntax Analysis. Bottom-Up Parsing

Lexical and Syntax Analysis Bottom-Up Parsing Parsing There are two ways to construct derivation of a grammar. Top-Down: begin with start symbol; repeatedly replace an instance of a production s LHS with

### Comp 411 Principles of Programming Languages Lecture 3 Parsing. Corky Cartwright January 11, 2019

Comp 411 Principles of Programming Languages Lecture 3 Parsing Corky Cartwright January 11, 2019 Top Down Parsing What is a context-free grammar (CFG)? A recursive definition of a set of strings; it is

### UNIVERSITY OF CALIFORNIA

UNIVERSITY OF CALIFORNIA Department of Electrical Engineering and Computer Sciences Computer Science Division CS164 Fall 1997 P. N. Hilfinger CS 164: Midterm Name: Please do not discuss the contents of

### LR Parsing. Leftmost and Rightmost Derivations. Compiler Design CSE 504. Derivations for id + id: T id = id+id. 1 Shift-Reduce Parsing.

LR Parsing Compiler Design CSE 504 1 Shift-Reduce Parsing 2 LR Parsers 3 SLR and LR(1) Parsers Last modifled: Fri Mar 06 2015 at 13:50:06 EST Version: 1.7 16:58:46 2016/01/29 Compiled at 12:57 on 2016/02/26