Download presentation

Presentation is loading. Please wait.

1
**Simplifications of Context-Free Grammars**

2
A Substitution Rule Equivalent grammar Substitute

3
A Substitution Rule Substitute Equivalent grammar

4
In general: Substitute equivalent grammar

5
Nullable Variables Nullable Variable:

6
**Removing Nullable Variables**

Example Grammar: Nullable variable

7
Final Grammar Substitute

8
Unit-Productions Unit Production: (a single variable in both sides)

9
**Removing Unit Productions**

Observation: Is removed immediately

10
Example Grammar:

11
Substitute

12
Remove

13
Substitute

14
**Remove repeated productions**

Final grammar

15
**Useless Productions Useless Production**

Some derivations never terminate...

16
Another grammar: Useless Production Not reachable from S

17
**then variable is useful**

In general: contains only terminals if then variable is useful otherwise, variable is useless

18
**A production is useless**

if any of its variables is useless Productions useless Variables useless

19
**Removing Useless Productions**

Example Grammar:

20
**First: find all variables that can produce strings with only terminals**

Round 1: Round 2:

21
**Keep only the variables that produce terminal symbols:**

(the rest variables are useless) Remove useless productions

22
**Second: Find all variables reachable from Use a Dependency Graph not**

23
**Keep only the variables reachable from S**

(the rest variables are useless) Final Grammar Remove useless productions

24
Removing All Step 1: Remove Nullable Variables Step 2: Remove Unit-Productions Step 3: Remove Useless Variables

25
**Normal Forms for Context-free Grammars**

26
**Chomsky Normal Form Each productions has form: or variable variable**

terminal

27
Examples: Chomsky Normal Form Not Chomsky Normal Form

28
**Convertion to Chomsky Normal Form**

Example: Not Chomsky Normal Form

29
**Introduce variables for terminals:**

30
**Introduce intermediate variable:**

31
**Introduce intermediate variable:**

32
**Final grammar in Chomsky Normal Form:**

Initial grammar

33
In general: From any context-free grammar (which doesn’t produce ) not in Chomsky Normal Form we can obtain: An equivalent grammar in Chomsky Normal Form

34
The Procedure First remove: Nullable variables Unit productions

35
Then, for every symbol : Add production In productions: replace with New variable:

36
**Replace any production**

with New intermediate variables:

37
**Theorem: For any context-free grammar (which doesn’t produce )**

there is an equivalent grammar in Chomsky Normal Form

38
**Observations Chomsky normal forms are good**

for parsing and proving theorems It is very easy to find the Chomsky normal form for any context-free grammar

39
Greinbach Normal Form All productions have form: symbol variables

40
**Observations Greinbach normal forms are very good for parsing**

It is hard to find the Greinbach normal form of any context-free grammar

41
Compilers

42
Machine Code Program Add v,v,0 cmp v,5 jmplt ELSE THEN: add x, 12,v ELSE: WHILE: cmp x,3 ... v = 5; if (v>5) x = 12 + v; while (x !=3) { x = x - 3; v = 10; } ...... Compiler

43
Compiler Lexical analyzer parser input output machine code program

44
**A parser knows the grammar**

of the programming language

45
**Parser PROGRAM 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

46
**The parser finds the derivation**

of a particular input derivation Parser input E => E + E => E + E * E => 10 + E*E => * E => * 5 E -> E + E | E * E | INT * 5

47
derivation tree derivation E E => E + E => E + E * E => 10 + E*E => * E => * 5 E + E 10 E E * 2 5

48
derivation tree E machine code E + E mult a, 2, 5 add b, 10, a 10 E E * 2 5

49
Parsing

50
Parser input string derivation grammar

51
Example: Parser derivation input ?

52
**Exhaustive Search Phase 1: Find derivation of**

All possible derivations of length 1

54
Phase 2 Phase 1

55
Phase 2 Phase 3

56
**Final result of exhaustive search**

(top-down parsing) Parser input derivation

57
**Time complexity of exhaustive search**

Suppose there are no productions of the form Number of phases for string : approx. |w|

58
For grammar with rules Time for phase 1: possible derivations

59
Time for phase 2: possible derivations

60
**Time for phase |w| is 2|w|:**

A total of 2|w| possible derivations

61
**Extremely bad!!! Total time needed for string : phase 1 phase |w|**

62
**For general context-free grammars:**

There exists a parsing algorithm that parses a string in time The CYK parser

Similar presentations

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google