FILE NO - rgpvonline.com · Web viewIT 704 Elective –I (IT- 713- Automata and Compiler Design) Unit I: Introduction: Alphabets, Strings and Languages; Automata and Grammars, Deterministic

FILE NO

COLLEGE NAME, BHOPAL

DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING

COURSE FILE

Program

: B.E.

Semester

: VII

Course Code

:

Subject Name : Automata and Compiler Design

Prepared By:

Approved By

Index

S.No. Contents

Page No.

1. Scheme

2. Syllabus

3. Time Table

4. Lecture Plan

5. List of Books

6. Mid Semester Exam Question Papers

7. RGPV Question Paper

8. Tutorial Questions

9. Assignment Questions

10. Hand-Written Notes

11. Transparencies/PPT Slides

12. Mid Semester Exam Result

13. Attendance Sheet

PROGRAMME: B.E. Information Technology VII Semester

IT 704 Elective –I (IT- 713- Automata and Compiler Design)

Unit I: Introduction: Alphabets, Strings and Languages; Automata and Grammars, Deterministic finite Automata (DFA)-Formal Definition, Simplified notation: State transition graph, Transition table, Language of DFA, Nondeterministic finite Automata (NFA), Equivalence of NFA and DFA, Minimization of Finite Automata, Regular Expressions, Arden’s theorem.

Unit II: Compiler Structure: Compilers and Translators, Various Phases of Compiler, Pass Structure of Compiler, Bootstrapping of Compiler. Lexical Analysis: The role of Lexical Analyzer, A simple approach to the design of Lexical Analyzer, Implementation of Lexical Analyzer. The Syntactic Specification of Programming Languages: CFG, Derivation and Parse tree, Ambiguity, Capabilities of CFG. Basic Parsing Techniques: Top-Down parsers with backtracking, Recursive Descent Parsers, Predictive Parsers,

Unit III: Bottom–up Parsers, Shift-Reduce Parsing, Operator Precedence Parsers, LR parsers (SLR, Canonical LR, LALR) Syntax Analyzer Generator: YACC, Intermediate Code Generation: Different Intermediate forms: three address code, Quadruples & Triples. Syntax Directed translation mechanism and attributed definition. Translation of Declaration, Assignment, Control flow, Boolean expression, Array References in arithmetic expressions, procedure calls, case statements, postfix translation.

Unit IV: Run Time Memory Management: Static and Dynamic storage allocation, stack based memory allocation schemes, Symbol Table management Error Detection and Recovery: Lexical phase errors, Syntactic phase errors, Semantic errors.

Unit V: Code Optimization and Code Generation: Local optimization, Loop optimization, Peephole optimization, Basic blocks and flow graphs, DAG, Data flow analyzer, Machine Model, Order of evaluation, Register allocation and code selection

References:

1.Louden, “Compiler construction”, Cengage learning .

2. Alfred V Aho, Jeffrey D. Ullman, “Principles of Compiler Design”, Narosa.

3. A.V. Aho, R. Sethi and J.D Ullman, “Compiler: principle, Techniques and Tools”, AW.

4. Michal Sipser, “Theory of Computation”, Cengage learning.

5. H.C. Holub, “Compiler Design in C”, Prentice Hall Inc.

6. Hopcroft, Ullman, “Introduction to Automata Theory, Languages and Computation”, Pearson

Education.

Time Table

Department

Information Technology

Session :

2014

Name of Teacher

Sem

VII

Subject

Compiler Design

Sub. Code

IT-713

(B) TIME SCHEDULE : Total expected periods:___, Extra periods (if required)_____

Lecture Plan

Day

Mon

Tue

Wed

Thu

Fri

Sat

Max. available

No. of

Periods

01

01

01

01

01

01

Lecture.

Topics to be covered

Planned

Date of Completion

Remarks

UNIT-I

1

Alphabets, Strings and Languages

R1:1, R2:1

2

Automata and Grammars

R1:3, R2:1

3

Deterministic finite Automata (DFA)

R1:10 , R2:5

4

State transition graph, Transition table

R1:84,88,R2:74

5

Nondeterministic finite Automata (NFA

R1:105, R2:103

6

Equivalence of NFA and DFA,

R2:20

7

Minimization of Finite

Automata

R1:725 ,R2:24

8

Regular Expressions, Arden’s theorem

NOTES

Unit-II

9

Compilers and Translators

R2:126

10

Various Phases of Compiler

R2-147

11

Pass Structure of

Compiler, Bootstrapping of Compiler

R1:215,193, R2:158

12

The role of Lexical Analyzer

R1:215,193, R2:158

13

A simple approach to the design of Lexical Analyzer,

R1:215,193, R2:158

14

CFG, Derivation and Parse tree,

R1:52,207, R2:146

15

Ambiguity, Capabilities of CFG. Basic Parsing

R1:215,193, R2:158

16

Top-Down parsers with backtracking

R1:227,233,R3:148

17

Recursive Descent Parsers

R1:257

18

Predictive Parsers

R1:299,R5:154

Unit-III

24

Bottom–up Parsers

R1:360,R4:83-89

25

Shift-Reduce Parsing

R1:-350

26

Operator Precedence Parsers

R1-366

27

LR parsers

NOTES

28

Syntax Analyzer Generator

R1:408,R5:252

29

YACC, Intermediate Code Generation

R1:413,R5:278

30

three address code

R2:328, R2:336

31

Quadruples & Triples.

R1:478,R2:254

32

. Translation of Declaration, Assignment

R1:500,R2:271

33

Control flow, Boolean expression

NOTES

34

Array References in arithmetic expressions

R1:526,R2:521

35

procedure calls

R1:28

36

case statements

R1:526,

37

postfix translation

NOTES

Unit –IV

39

Run Time Memory Management

R2-408

40

Static and Dynamic storage allocation

R1:608,R2:410

41

stack based memory

allocation schemes

R1:608,R2:410

42

Symbol Table management Error Detection and Recovery

R2-408

43

Lexical phase errors

R3:661

44

Syntactic phase errors, Semantic errors

R2-408

Unit –V

45

Code Optimization and Code Generation

R2-408

46

Local optimization

R1:608,R2:410

47

Loop optimization

R1:608,R2:410

48

Peephole

optimization

R2-408

49

Basic blocks and flow graphs

R3:661

50

DAG

R2-408

51

Data flow analyzer

R1:608,R2:410

52

Machine Model

R1:608,R2:410

53

Order of evaluation

R2-408

54

Register allocation and code selection

R3:661

REFERENCE BOOKS

R1: Compilers Principles, Techniques, and Tools by Aho,Ullman & Sethi, Pearson Education

R2: Principles of Compiler Design by Aho & Ullman, Narosa Publishing House

R3:Compiler Construction 2/e: Dhamdhere

R4: Compiler Design by Santanu Chattopadhyay, PHI

R5: Compilers Construction & Design by Rajni Jindal, Umesh Publications

R6: Compiler Design by O. G. Kakde, Laxmi Publications (p) LTD

Websites:

1. www.cs.uccs.edu/~abudjen/classsnotes.doc

2. www.os.iitb.ac.in/~sri/notes/lexical.pdf

3. www.iitb.ac.in/~sri/notes/compiler/regex.pdf

List of Books

1. A. V. Aho, R. Sethi, and J. D. Ullman. Compilers: Principles, Techniques and

Tools , Pearson Education

2 Raghavan, Compiler Design, TMH Pub.

3. Louden. Compiler Construction: Principles and Practice, Cengage Learning

4. A. C. Holub. Compiler Design in C , Prentice-Hall Inc., 1993.

5. Mak, writing compiler & Interpreters, Willey Pub.

COLLEGE NAME

MID SEMESTER I

BRANCH- IT

SEMESTER: VII

SUBJECT: COMPILER DESIGN

SUBJECT CODE: IT-713

Max. Marks: 40 Time: 2 Hours

Note: All questions are compulsory carry equal marks.

1. (a) What is Ad hoc network and how it differs from other network?

(b) Explain various challenges of mobile Ad hoc network.

2. What is Source and Receiver oriented MAC Routing Protocol?

3. Write the difference between-

a. Cellular and Mobile Ad hoc Network

b. Proactive and Reactive Routing protocol

4. Explain various design issues of Ad hoc Network in brief.

5. Explain the Working of DSDV Routing protocol

COLLEGE NAME

MID SEMESTER II

BRANCH- IT

SEMESTER: VII

SUBJECT: COMPILER DESIGN

SUBJECT CODE: IT-713

Max. Marks: 40 Time: 2 Hours

Note: Attempt any four questions.

1.

(a)

(b)

Explain dynamic source routing (DSR) protocols with its advantages and disadvantages.

Evaluate the route discovery (RD) time parameter in the communication performance of ad-hoc network.

5

5

2.

(a)

(b)

Describe the power management at various layers.

What are smart batteries? What are its characteristics ?

5

5

3.

(a)

(b)

Explain the ATM cell header at UNI and at NNI.

What are the advantages and disadvantages of packet switching over circuit switching?

5

5

4.

(a)

(b)

Draw and discuss the ATM protocol architecture model.

With neat sketch, explain architecture of 802.11 LAN. Also, explain its MAC logic.

5

5

5.

Write short note on (any two)

i) ZRP protocol

ii) EED performance in ad-hoc network

iii) X.25

iv) AAL

------------------------------------------------

10

COLLEGE NAME, Bhopal

Department of Information Technology

Assignment-1

Subject: Compiler Design

Subject Code: IT-713

Unit-1

1. Give the reasons for the separation of scanner and parser in separate phases of compiler.

2. Describe the role of lexical analyzer in recognizing tokens.

3. Explain the concept of input buffering.

4. Explain how tokens are recognized.

5. What is simple approach to design of lexical analyzer for an identifier.

6. What’s LEX? Describe auxiliary definitions and translation rules for LEX with suitable example.

7. What are the tasks performed by the compiler in lexical and syntax analysis phases. Explain with help of examples.

8. Explain role of symbol table in various phases of compiler



Assignment-2



Unit-2

1. Write in brief about the error recovery procedure in LL and LR parsing.

2. Write short note on automatic parser generator.

3. Describe the function of LALR parser generator YACC.

4. What is meant by syntax directed translation?

5. Explain. Give the parse tree and translation for expression 23* 5+4 according to the syntax directed translation scheme.

6. Differentiate between synthesized translation and inherited translations.

7. Let the synthesized attribute “val”, give the integer value associated with non terminals in following grammar-

L→ E

E →E +T | T

T→ T*F | F

F→(E)| digit

8. Write a brief note on syntax tree.

9. For the following grammar find FIRST and FOLLOW sets for each non terminal-

S→aAB |bA|€

A→aAb|€

B→bB|€

Where € is Null string.

10. What is Shift-Reduce and Reduce-Reduce conflict? How these can be resolved? With examples explain in which condition S-R and R-R conflict can occur in SLR, Canonical LR and LALR parsers. (Make use of LR(0), LR(1) items.



Assignment-3



Unit-3

1. What do you mean by heap allocation? Explain the following terms related to heap allocation-

(i) Fragmentation

(ii) Free list

(iii) Reference counts

2. Explain the difference between static, stack and heap allocation.

3. What is the difference between dynamic and static storage management?

4. What are different parameter passing mechanisms?

5. Explain with a suitable example, mechanisms, used by the compiler to handle procedure parameters.

6. Write short note on symbol table organization.

7. Explain various symbol table management techniques.

8. Explain various data structures used for implementing the symbol table and compare them.

9. What is hashing? What are different types of hashing techniques available?



Assignment-4



Unit-4

1. Define Leaders.

2. Explain DAG construction.

3. What are applications of DAGs?

4. Write advantages of DAG.

5. Write short note on application of DAG in code generation.

6. Discuss the various methods of translating Boolean expression.

7. Construct DAG of basic block after converting code in 3-address representation-

Begin

Prod:=0;

i :=1;

do

begin

prod:= prod+a[i]*b[i];

i:=i+1;

end

while i<=20

end

8. Translate the following expression into quadruples, triples and indirect triples.



Assignment-5



Unit-5

1. What is global data flow analysis? What is its use in code optimization?

2. Describe global data flow analysis.

3. Write the criteria for code improving transformations. Explain the principal sources of optimization.

4. Define dominators and write short note on loops in flow graph.



Tutorial-1



Topic to be covered: Unit-1

9. Explain why one should study about the compilers.

10. Explain working of compilers drawing its block diagram.

11. What are the features of good compiler?

12. Compare and contrast the features of single pass compiler with multi pass compiler.

13. Write short note on bootstrapping.

14. Compiler uses two passes scheme of compilation, performing analysis, in first pass and synthesis in second pass. Explain what use is made of the symbol table in two passes of compiler.

15. Draw and explain various phases of compiler

16. Draw the block diagram of lexical and syntax analyzer and state clearly input , output and task performed by them.



Tutorial-2



Unit-2

1. Write short note on grammar. What do you mean by ambiguity of grammar?

2. What is top down parsing? What are the difficulties encountered in this and how they overcome?

3. Write short note on recursive decent parser.

4. What is predictive parser? How a parser is controlled by a program?

5. Differentiate top down and bottom up parsing. Give examples of method of each type.

6. What is operator precedence grammar?

7. What Describe operator precedence parsing algorithm.

8. What are the limitations of operator precedence parsing?

9. What do you understand by LR(k) grammar?

10. Write the Algo/ Procedure for construction of canonical LR parsing table.



Tutorial-3



Unit-3

1. Give a brief description of type checking.

2. Give the difference between implicit type conversion and explicit type conversion with help of an example.

3. Differentiate between static and dynamic binding.

4. Explain the importance of run time storage management in compiler.

5. What do you mean by activation record? Why this record is maintained by the compiler?

6. Explain various fields of activation record.

7. Describe storage allocation strategies.

8. What do you mean by static allocation? What are its drawback?



Tutorial-4



Unit-4

9. Write a translation scheme to generate intermediate code for assignment statement with array references.

10. Write syntax directed definition to translate ‘switch’ statement. With a suitable example, show translation of the source language ‘switch’ statement.

11. Write short note on back patching.

12. Write short note on code generation.

13. What are general issues in designing a code generator?

14. Explain code generation algorithm.

15. What is basic block? With suitable example discuss various transformations on the basic blocks.

16. What are the different types of intermediate codes? Explain in brief.



Tutorial-5



Unit-5

1. Explain why code optimization is called optional phase?

2. Explain the principal sources of optimization with suitable example.

3. Describe the necessary and sufficient condition performing constant propagation and dead code eliminations.

4. Explain the following optimizing transformations with suitable examples-

(i) Code movement

(ii) Common sub-expression elimination

5. Define dominators.

Unit wise blow- Up

UNIT – I

A language translator is a program which translates programs from source language in an equivalent program in an object language. The source language is usually a high-level programming language and the object language is usually the machine language of an actual computer. A compiler is a translator whose source language is a high-level language and whose object language is close the machine language of an actual computer. The typical compiler consists of an analysis phase and a synthesis phase. In contrast with compilers an interpreter is a program which simulates the execution of programs written in a source language. Interpreters may be used either at the source program level or an interpreter may be used it interpret an object code for an idealized machine. The typical compiler consists of several phases each of which passes its output the next phase

(i) The lexical phase (scanner) groups characters in lexical units or kens. The input the lexical phase is a character stream. The output is a stream of kens. Regular expressions are used define the kens recognized by a scanner (or lexical analyzer). The scanner is implemented as a finite state machine.

(ii) The parser groups kens in syntactical units. The output of the parser is a parse tree representation of the program. Context-free grammars are used define the program structure recognized by a parser. The parser is implemented as a push-down automata.

(iii) The contextual analysis phase analyzes the parse tree for context-sensitive information often called the static semantics. The output of the contextual analysis phase is an annotated parse tree. Attribute grammars are used describe the static semantics of a program.

(iv) The optimizer applies semantics preserving transformation the annotated parse tree simplify the structure of the tree and facilitate the generation of more efficient code.

(v) The code general transforms the simplified annotated parse tree in object code using rules which denote the semantics of the source language.

(vi) The peephole optimizer examines the object code, a few instructions at a time, and attempts do machine dependent code improvements.

Types of Compiler-

1. One-pass compiler

2. Multi-pass Compiler

3. Load & Go Compiler

4. Optimized Compiler

A one-pass compiler reads the program only once, and translates it at the same time as it is reading. A multi-pass compiler reads the program several times, each time transforming it in a different form and usually in a different data structure.

· Cross Compiler-A cross compiler compiles a target language different from the language of the machine it runs on

· Bootstrapping- Bootstrapping describe the techniques involved in writing a compiler or assembler) in the target programming language which it is intended compile.

· LEX- LEX is a program general designed for lexical processing of character input streams. It accepts a high-level, problem oriented specification for character string matching, and produces a program in a general purpose language which recognizes regular expressions. The regular expressions are specified by the user in the source specifications given LEX. The LEX written code recognizes these expressions in an input stream and partitions the input stream in strings matching the expressions

UNIT II

The parsing is a process of finding a parse tree for a string of kens. Equivalently, it is a process of determining whether a string of kens can be generated by a grammar. There are two types of Parsing

· Top-down Parsing (start from start symbol and derive string)A Top-down parser builds a parse tree by starting at the root and working down wards the leaves.

· Easy generate by hand.

· Examples are- Recursive- descent, Predictive.

· Bottom-up Parsing (start from string and reduce start symbol)A bottom- up parser builds a parser tree by starting at the leaves and working up wards the root.

· Not easy handle by hands, usually compiler- generating software generate bottom up parser

· But handles larger class of grammar

· Example is LR parser.

· Operator precedence parsing- Bottom-up parsers for a large class of context-free grammars can be easily developed using operator grammars. Operator grammars have the property that no production right side is empty or has two adjacent non terminals. This property enables the implementation of efficient operator-precedence parsers

· SLR parser - Simple LR parser or SLR parser is an LR parser or which the parsing tables are generated as for an LR(0) parser except that it only performs a reduction with a grammar rule A → w if the next symbol on the input stream is in the follow set of A. Such a parser can prevent certain shift-reduce and reduce-reduce conflicts. That occur in LR (0) parsers and it can therefore deal with more grammars. However, it still cannot parse all grammars that can be parsed by an LR(1) parser. A grammar that can be parsed by an SLR parser is called a SLR grammar.

· Yacc-YACC stands for “Yet Another Compiler-Compiler”. this is because this kind of analysis of text files is normally associated with writing compilers. Yacc provides a general ol for imposing structure on the input a computer program. The Yacc user prepares a specification of the input process; this includes rules describing the input structure, code be invoked when these rules are recognized, and a low-level routine do the basic input. Yacc then generates a function control the input process

UNIT III

A syntax- directed translation is used define the translation of a sequence of kens some other value, based on a CFG for the input. A syntax- directed translation is defined by associating a translation rule with each grammar rule. A translation rule defines the translation of the left- hand -side conterminal as a function of eight-hand- side no terminals' translations, and the values of the right-hand-side terminals. compute the translation of a string, build the parse tree, and use the translation rules compute the translation of each conterminal in the tree, bottom-up; the translation of the string is the translation of the root conterminal. There is no restriction on the type of converted actions that manipulate the parser's semantic stack. Each action must pop all right-hand-side non terminals' translations from the semantic stack, then compute and push the left-hand-side non terminal's translation. Next, the actions are incorporated (as action numbers) in the grammar rules. Finally, the grammar is converted LL (1) form (treating the action numbers just like terminal or conterminal symbols).

· Intermediate Code- The semantic phase of a compiler first translates parse trees in an intermediate representation (IR), which is independent of the underlying computer architecture, and then generates machine code from the IRs. This makes the task of retargeting the compiler another computer architecture easier handle

1. High-Level Intermediate Languages

· Abstract syntax tree. Postfix notation is a linearized representation of an abstract syntax tree.

EXAMPLE- a = b*c + d is a b c * d + assign

· Dependence graphs.

· Medium-Level Intermediate Language

Reflect a range of features in a language-independent way. Represent source variables, temporaries, and registers. Appropriate for most of the optimizations done in compilers such as common-sub expression elimination, code motion, and algebraic simplification.

· Three address code (x = y op z),

· assignment statements x := y op z

· assignment statements x := op y

· copy x := y

· unconditional jump go L

· conditional jump if re loop go L

· param x and call p, n for procedure calls and return y -- where y representing a return value is optional

· indexed statements of the form x:= y[i], x[i] := y

· address and pointer assignments of the form x := &y and x := *y

· Low-Level Intermediate Languages

one--one correspondence target machine instructions, and are usually architecture dependent. Usually deviate only when there are alternatives for the most effective code generate for them. E.g., multiply instruction or more complex addressing modes.

UNIT IV

Activation records

· Created every time a procedure is called

· Must be accessible both the caller and the callee

· Allocates space for

· Parameters

· Local variables

· Return address

· Other links and pointers provide access non-local data

· Other issues

· Initializing local variables

· Stack vs. heap allocated

· Optimizing activation records by coalescing

Symbol Table

· keeps track of scope and other attributes of named program entities

· key operations

· void insert(symbol s);

· symbol lookup(string name);

· void enter_scope(void);

· void exit_scope(void);

· implementations

· list

· hash table

· stack of tables

· for some languages, the symbol table must handle overloading

· each identifier contains a list of symbols

· when entering new scope, chain symbols with same name in previous scope

UNIT V

Directed Acyclic Graph (DAG)– Directed acyclic graph DAG-

• Contraction of AST that avoids duplication- identical

sub trees are reused.

• exposes redundancies- changes (assignments, calls) ?

• smaller memory footprint

· Example- a x (a-b) + c x (a-b)

· Code optimization together with code generation form the back end of the compiler. In compilers with a very extensive optimization, the optimization phase is distinguished as a middle end.

· The goal of the compiler's optimizer is transform the IR program created by the front end in an IR program that computes the same results in a better way. Here "better" can take on many meanings. It usually implies faster code, but it might imply more compact code, less power when it runs or costs less run under some model.

· Ideally, compilers should produce target code that is as good as can be written by hand. The reality is that this goal is achieved only in limited cases, and with difficulty. However, the code produced by straightforward compiling algorithms can often be made run faster or take less space, or both. This improvement is achieved by program transformations that are traditionally called optimizations, although the term "optimization" is a misnomer because is rarely a guarantee that the resulting code is the best possible. Most of the compilers involve some optimization. Compilers that apply code-improving transformations are called optimizing compilers.

· Code generation is the final phase in compilation. It takes as input an intermediate representation of the source program and produces as output an equivalent target program. The code generation techniques can be used whether or not an optimization phase occurs before code generation.

· The requirements traditionally imposed on a code generar are severe. The output code must be correct and of high quality, meaning that it should make effective use of the resources of the target machine. Moreover, the code generar itself should run efficiently.

· Mathematically, the problem of generating optimal target code is (TM) undecidable!

· In practice, we must be content with heuristic techniques that generate good, but not necessarily optimal, code. The choice of heuristics is important, because a carefully designed code generation algorithm can easily produce code that is several times faster that produced with ad hoc code generation techniques.

· As code generation begins, the program exists in IR form. The code generar must convert the IR program (perhaps, already optimized) in code that can run on the target machine.

· The code generation is performed typically as a sequence- instruction selection, instruction scheduling and register allocation-

· Instruction selection - selecting a sequence of target-machine operations that implement the IR operations.

· Instruction scheduling - choosing an order in which the operations should execute.

· Register allocation - deciding which values should reside in registers at each point in the program

· Most compilers handle each of these three processes separately. The term code generation is often used refer instruction selection only.

· When the level of abstraction of the IR and the target machine differ significantly, or the underlying computation models differ, instruction selection can play a critical role in bridging the gap. The extent which instruction selection can map the computation in the IR program efficiently the target machine will often determine the efficiency of the generated code. For example, consider three scenarios for generating code from an IR-

· A simple, scalar RISC machine - the mapping from IR assembly is straightforward. The code generar might consider only one or two assembly-language sequences for each IR operation.

· A CISC processor - make effective use of a CISC's instruction set, the compiler may need aggregate several IR operations in a single target-machine operation.

· A stack machine - the code generar must translate from the register--register computational style of IR a stack based style with its implicit names and, in some cases, destructive operations.

· As the gap in abstraction between the IR and the target ISA grows, so does the need for ols help build code generars.

· While instruction selection can play an important role in determining code quality, the compiler writer must keep in mind the enormous size of the search space that the instruction select might explore. As we shall see, even moderately sized instruction sets can produce search spaces that contain hundreds of millions of states. Clearly, the compiler cannot afford explore such spaces in either a careless or an exhaustive way.

Previous Univ. Exam Paper

CS – 701

B.E. (Seventh Semester ) EXAMINATION , June, 2009

(Common for CS & IT Engg.)

COMPILER DESIGN

Time - Three Hours

Maximum Marks - 100

Minimum Pass Marks - 35

Note - Attempt all questions. All question carry equal marks.

1. (a) Consider the following LEX program -

Auxiliary Definitions

(none)

Translation Rules

Token Pattern

Action

Key word

Identifier

Constant

Operator

{Return KW}

(Return id}

{Return const.}

{Return OP}

Implement the LEX program as DFA.

(b) Describe the role of a lexical analyzer and also explain the concept of Input Buffering.

OR

2. (a) Consider a finite – state automata in which -

S = {q0, q1, q2, q3}, Σ = {0, 1} S0 = q0 F = {q0}

And the transition function δ is given in the following table -

State

0

1

q0

q1

q2

q3

q2

q3

q0

q1

q1

q0

q3

q2

a) Give the entire sequence of states for the input string 101101.

b) Find out the string among the following string which are accepted by the given finite- state automation -

c) 101101

d) 11111

e) 000000

(b) Explain why should one study about compilers.

3. (a) What do you mean by ambiguous and unambiguous grammar? Explain with example.

(b) Construct the parsing table for the following grammar.

S( aXYb

X( c/ €

Y( d/€

OR

4. (a) Consider the grammar -

S ( ACB/ C b B/ B a

A( da /BC

B( g / €

C( h / €

Calculate FIRST and Follow.

(b) Show that the following grammar is U (1), by constructing its parse table-

S ( a AB / b A / €

A( a A b / €

B( b B / €

5. (a) Translate the following statement to quadruple -

If a > b then x = a + b

else x = a - b

(b) Translate the following expression to quadruple, triple-

- (x + y) * (z + c) – (x + y + z)

OR

6. Write short notes on the following -

7. S- attributed definitions

8. L- Attributed definition

9. Dependency graph

10. (a) Explain the role of symbol table in various phases of compiler.

(b) What do you mean by heap allocation? Explain the following terms related to heap allocation-

11. Fragmentation

12. Free list

13. Bit map

14. Reference counts

OR

15. (a) Explain various storage allocation strategies. Which storage allocation model is to be used if a language permits recursion ?

(b) Describe parameter passing mechanisms for a procedure call.

16. (a) Describe the necessary and sufficient conditions for performing constant propagation and dead code eliminations.

(b) Write and explain data flow equations.

OR

17. Explain the following -

18. Loop invariant conditionals

19. Conditional depending on loop index

20. Independent loop conditionals

21. Reduction loops

***********************************************************************

Model Paper

CS-701

COMPILER DESIGN

Time - 3 Hrs

Max. Marks-100

Minimum Pass Marks - 35

Note - Solve any five questions. All questions carry equal marks.

1.(a) What is the basic task of scanning. What are the difficulties faced in delimeter oriented scanning. How can this be removed.

(b) What is the structure of a compiler. Discuss phases of a compiler briefly.

2. (a) What are errors can be encountered by virtually all the phases of a compiler.

(b) Explain the concept of transition diagram and its use in building a lexical analyzer.

3 (a) Why are multiple passes required in a compiler. Describe strategies for reducing the number of passes.

(b) What are data structures used for symbol tables management. Explain each of them in brief.

4(a) Comment on the need for indirection in symbol table.

(b) What is p-down parsing. What are the difficulties encountered in it and how are they overcome.

5(a) Write the quadruples, triples and indirection triples for the expression -

A ( B + C*D | E

(b) Why is the dynamic srage allocation strategy particularly amendable the run-time usage requirements of block structured languages. Write the procedure for run-time address calculation in our dynamic srage allocation mode.

6. (a) Describe Global Data Flow analysis. How is it useful in code optimization.

(b) Define the ambiguity of grammer. Suggest some possible solutions remove the ambiguity of a grammer.

7. Given a grammer with the following productions. -

S ( E

E ( T | E – T

T ( F | T * F

F ( i | (E)

· Generate the sets of LR (1) items

· Give a trtace of the Parse of the following input string (i – i) * i.

8. What is operar precedence grammer? For given the grammer:

E ( E + T | T

T ( T * F | F

F ( (E) | id

Obtain the following -

· Operator precedence matrix

· The parse for input string id + id

Documents

FILE NO - rgpvonline.com · Web viewIT 704 Elective –I (IT- 713- Automata and Compiler Design) Unit I: Introduction: Alphabets, Strings and Languages; Automata and Grammars, Deterministic