1

Compilers

2

Compiler

Program

v = 5;

if (v>5)

x = 12 + v;

while (x !=3) {

x = x - 3;

v = 10;

}

......

Add v,v,0

cmp v,5

jmplt ELSE

THEN:

add x, 12,v

ELSE:

WHILE:

cmp x,3

...

Machine Code

3

Lexical

analyzer parser

Compiler

programmachine

code

input output

4

A parser knows the grammar

of the programming language

5

ParserPROGRAM STMT_LIST

STMT_LIST STMT; STMT_LIST | STMT;

STMT EXPR | IF_STMT | WHILE_STMT

| { STMT_LIST }

EXPR EXPR + EXPR | EXPR - EXPR | ID

IF_STMT if (EXPR) then STMT

| if (EXPR) then STMT else STMT

WHILE_STMT while (EXPR) do STMT

6

The parser finds the derivation

of a particular input

10 + 2 * 5

Parser

E -> E + E

| E * E

| INT

E => E + E

=> E + E * E

=> 10 + E*E

=> 10 + 2 * E

=> 10 + 2 * 5

input

derivation

7

10

E

2 5

E => E + E

=> E + E * E

=> 10 + E*E

=> 10 + 2 * E

=> 10 + 2 * 5

derivation

derivation tree

E E

E E

+

*

8

10

E

2 5

derivation tree

E E

E E

+

*

mult a, 2, 5

add b, 10, a

machine code

9

Parsing

10

grammar

Parserinput

stringderivation

11

Example:

Parser

derivation

S

bSaS

aSbS

SSSinput

?aabb

12

Exhaustive Search

||| bSaaSbSSS

Phase 1:

S

bSaS

aSbS

SSSaabb

All possible derivations of length 1

Find derivation of

13

S

bSaS

aSbS

SSS aabb

14

Phase 2

aSbS

SSS

aabb

SSSS

bSaSSSS

aSbSSSS

SSSSSS

Phase 1

abaSbS

abSabaSbS

aaSbbaSbS

aSSbaSbS

||| bSaaSbSSS

15

Phase 2

SSSS

aSbSSSS

SSSSSS

aaSbbaSbS

aSSbaSbS

Phase 3

aabbaaSbbaSbS

||| bSaaSbSSS

aabb

16

Final result of exhaustive search

Parser

derivation

S

bSaS

aSbS

SSSinput

aabb

aabbaaSbbaSbS

(top-down parsing)

17

Time complexity of exhaustive search

Suppose there are no productions of the form

A

BA

Number of phases for string : w ||2 w

18

Time for phase 1: k

k possible derivations

For grammar with rules k

19

Time for phase 2: 2k

possible derivations2k

20

Time for phase : ||2wk

possible derivations||2wk

||2 w

21

Total time needed for string :w

||22 wkkk

Extremely bad!!!

phase 1 phase 2 phase 2|w|

22

There exist faster algorithms

for specialized grammars

S-grammar: axA

symbol string

of variables

),( aA appears oncePair

23

S-grammar example:

cS

bSSS

aSS

abccabcSabSSaSS

Each string has a unique derivation

24

In the exhaustive search parsing

there is only one choice in each phase

For S-grammars:

Total time for parsing string :w || w

Time for a phase: 1

25

For general context-free grammars:

There exists a parsing algorithm

that parses a string

in time

|| w3|| w

26

Simplifications of

Context-Free Grammars

27

A Substitution Rule

bB

abbAB

abBcA

aaAA

aA

abbcA

ababbAcA

aaAA

aA

Substitute B

Equivalent

grammar

28

In general:

nyyyB

xBzA

||| 21

Substitute B

zxyzxyzxyA n||| 21 equivalent

grammar

29

Useless Productions

aAA

AS

S

aSbS

aAaaaaAaAAS

Some derivations never terminate...

Useless Production

30

bAB

A

aAA

AS

Another grammar:

Not reachable from S

Useless Production

31

In general:

If wxAyS

Then variable is usefulA

Otherwise, variable is uselessA

)(GLw

32

A production is useful

if all its variables are useful

xA

33

Removing Useless Productions

Example Grammar:

aCbC

aaB

aA

CAaSS

||

34

First: find all variables that produce

strings with only terminals

aCbC

aaB

aA

CAaSS

|| },{ BA

},,{ SBA

Round 1:

Round 2:

35

Keep only the variables

that produce terminal symbols

aCbC

aaB

aA

CAaSS

||

},,{ SBA

aaB

aA

AaSS

|

36

Second: Find all variables

reachable from

aaB

aA

AaSS

|

S A B

Dependency Graph

not

reachable

S

37

Keep only the variables

reachable from S

aaB

aA

AaSS

|

aA

AaSS

|

Final Grammar

38

Nullable Variables

:production A

Nullable Variable: A

39

Removing Nullable Variables

Example Grammar:

M

aMbM

aMbS

Nullable variable

40

M

M

aMbM

aMbSSubstitute

abM

aMbM

abS

aMbS

Final Grammar

41

Unit-Productions

BAUnit Production:

42

Removing Unit Productions

Observation:

AA

Is removed immediately

43

Example Grammar:

bbB

AB

BA

aA

aAS

44

bbB

AB

BA

aA

aAS

SubstituteBA

bbB

BAB

aA

aBaAS

|

|

45

Remove

bbB

BAB

aA

aBaAS

|

|

bbB

AB

aA

aBaAS

|

BB

46

SubstituteAB

bbB

aA

aAaBaAS

||

bbB

AB

aA

aBaAS

|

47

Remove repeated productions

bbB

aA

aBaAS

|

bbB

aA

aAaBaAS

||

Final grammar

48

Removing All

Step 1: Remove Nullable Variables

Step 2: Remove Unit-Productions

Step 3: Remove Useless Variables