Source Language

Lexical Analyzer

Syntax Analyzer Front

End
Semantic Analyzer
Structure
Int. Code Generator
of a
Compiler Intermediate Code

Code Optimizer Back

Target Code Generator End

Target Language
Copyright@Mudassar
1 Zaidi,University of Sargodha
 Source Language

Lexical Analyzer
Now!
Syntax Analyzer Front
End
Semantic Analyzer

Int. Code Generator

Intermediate Code

Code Optimizer Back

Target Code Generator End

Target Language
Copyright@Mudassar
2 Zaidi,University of Sargodha
 THE ROLE OF THE PARSER

Read Character Token

Lexical Parser
input
Analyzer
Push back Get Next Token

character
Symbol
Table

Copyright@Mudassar
3 Zaidi,University of Sargodha
 Where is Syntax Analysis?
if (idx == 0) idx = 750;

Lexical Analysis or Scanner

if ( idx == 0 ) idx = 750 ;

Syntax Analysis or Parsing

if
== = Abstract syntax tree
idx 0 idx 750 or parse tree
Copyright@Mudassar
4 Zaidi,University of Sargodha
 Parsing Analogy

Syntax analysis for natural languages

- Identify the function of each word
- Recognize if a sentence is grammatically correct

Example: I gave Ali the card.

Copyright@Mudassar
5 Zaidi,University of Sargodha
 Parsing Analogy
- Syntax analysis for natural languages
-Identify the function of each word
- Recognize if a sentence is grammatically correct
sentence

(subject) (action) (object)

verb phrase
(indirect noun phrase
object)
pronoun verb proper noun article noun
I gave Ali the card

Copyright@Mudassar
6 Zaidi,University of Sargodha
 Syntax Analysis Overview

 Goal: we must determine if the input token stream

satisfies the syntax of the program
 What do we need to do this?
– An expressive way to describe the syntax
– A mechanism that determines if the input token stream
satisfies the syntax description
 For lexical analysis
– Regular expressions describe tokens
– Finite automata = mechanisms to generate tokens from input
stream

Copyright@Mudassar
7 Zaidi,University of Sargodha
 Syntax Analysis(Parsing)

Parsing is the task of determining the syntax of a

program.For this reason,it is also called syntax
analysis.The syntax of a programming language is
usually given by the grammar rules of a context-free
grammar,in a manner similar to the way the lexical
structure of the tokens recognized by the scanner is
given by the regular expression.Indeed ,a context free
grammar uses naming conventions and operations
very similar to those of regular expression.

8 Copyright@Mudassar
 Syntax Analysis(Parsing)
(cont’d)

The algorithms used to recognize these

structures are also quite different from
scanning algorithms.The basic structure used
is usually some kind of tree ,called a parse tree
or syntax tree.

9 Copyright@Mudassar
 The Parsing Process

It is the task 0f the parser to determine the

syntactic structure of a programme from the
tokens produced by the scanner and either
explicitly or implicitly ,to construct a parse tree
or syntax tree that represents this
structure.Thus the parser may be viewed as a
function that takes as its input the sequence
of tokens produced by the scanner and
produces as its output the syntax tree.
Copyright@Mudassar
10 Zaidi,University of Sargodha
 The Parsing Process(cont’d)
Parser
Sequence of tokens Syntax Tree

Usually the sequence of tokens is not an explicit input

parameter,but the parser calls a scanner procedure such as
getToken to fetch the next token from the input as it is needed
during the parsing process.

Copyright@Mudassar
11 Zaidi,University of Sargodha
 Context-Free Grammar

We introduce a notion , called a context – free

grammar (or grammar) , for specifying the
syntax of a language. A grammar naturally
describes the hierarchical structure of many
programming language constructs. For
example , as if – else statement in C has the
form if (expression) statement else statement.

12
 Context-Free Grammar(Cont’d)

That is the statement is concatenation of the

key word an opening parenthesis , an
expression , a closing parenthesis , a
statement , the keyword else , and another
statement. Using the variable expr to denote
an expression and the variable stmt to denote
a statement , this structuring rule can be
expressed as :

13
 Context-Free Grammar(Cont’d)

Stmt if (expr) stmt else stmt

In which the arrow may be reads, a “can have
the form “. Such a rule is called production.
In a production lexical elements like the
keyword if and the parenthesis are called
tokens.

14
 Context-Free Grammar(Cont’d)

Variables like “expr” and “stmt” represent

,sequences of tokens and called
Nonterminals.
A context free grammar has four components;

15
 Context-Free Grammar(con’t)
 Consist of 4 components (Backus-Naur Form or
BNF):
1) A set of tokens , known as terminal symbol
2) A set of non terminals.
3) A set of productions where each production
consists of non-terminals , called the left side of the
production , an arrow and a sequence of tokens and
for non-terminals called right side of the production.
4) A designation of one of the non-terminals as the
starts symbol.

Copyright@Mudassar
16 Zaidi,University of Sargodha
 Context-Free Grammar(con’t)

EXAMPLE:
expr expr op expr
expr ( expr )
expr id
op +
op -
op *
Copyright@Mudassar
17 Zaidi,University of Sargodha
 Context-Free Grammar(cont’d)

 Terminal Symbols :
id , + , -, *, ( , )
 Non-Terminal Symbols:
expr,op
 Start Symbol
expr
 Production
expr expr op expr
Copyright@Mudassar
18 Zaidi,University of Sargodha
 Example 1

We use expressions consisting of digits and

plus and minus signs, e.g. 9 – 5+2, since a
plus or minus sign appear between two digits.
We refer to such expressions as lists of digits
separated by plus or minus sign expressions.
The following grammar describe the syntax of
these expressions.

Copyright@Mudassar
19 Zaidi,University of Sargodha
 Example 1(Cont’d)
The productions are:
List list + digits (1)
List list – digits (2)
List digit (3)
Digit 0,1,2,3,4,5,6,7,8,9

Copyright@Mudassar
20 Zaidi,University of Sargodha
 Example 1(Cont’d)

The right sides of the productions with non terminals list

on the left side can equivalently be grouped;
List list + digit|list – digit | digit
The token of the grammar are the symbol are the
symbols + - 0123456789.
The non terminals are list and digit, with list being the
starting non terminals because its production are given
first .

Copyright@Mudassar
21 Zaidi,University of Sargodha
 Example 1(Cont’d)

We say a production is for a non terminal if the

non terminals appears on the left side of the
production . A string of tokens is sequence of
zero or more tokens. The string containing zero
tokens , written as “ε” is called the empty
string.

Copyright@Mudassar
22 Zaidi,University of Sargodha
 Example 1(Cont’d)

The language defined by the grammar of

example 1, consists list of digits separated by
plus and minus signs. We can deduce that
9-5+2 is a list as follows.

Copyright@Mudassar
23 Zaidi,University of Sargodha
 Example 1(Cont’d)

 9 is a list by production (3), since 9 is

a digit
 9-5 is a list by production (2) , since 9
is a list and 2 is a digit
 9-5 +2 is a list by production (1) ,
since 9-5 is a list and 2 is a digit.

Copyright@Mudassar
24 Zaidi,University of Sargodha
 Example 1(Cont’d)

This reasoning is shown by the tree in next slide . Each

node in the tree is labeled by a grammar symbol .An
interior node and its children correspond to a production
: the interior node corresponds to the left side of the
production ,the children to the right side.
Such trees are called parse trees.
List = list + digit

Interior node Children

Copyright@Mudassar
25 Zaidi,University of Sargodha
 Example 1(Cont’d)

List

List Digit

List Digit

Digit

9 - 5 + 2
Copyright@Mudassar
26 Zaidi,University of Sargodha
 Parse Tree

A parse tree shows how the start symbol of a

grammar derives a string in the language. If
non terminal A has production A XYZ, then
a parse tree may have an interior node labeled
A with three children labeled X, Y and Z, from
left to right.

Copyright@Mudassar
27 Zaidi,University of Sargodha
 Parse Tree(Cont’d)

X Y Z
Formally , given a context free grammar , a parse
tree is a tree with the following properties;

Copyright@Mudassar
28 Zaidi,University of Sargodha
 Defining a Parse Tree

 More Formally, a Parse Tree for a CFG Has

the Following Properties:
– Root Is Labeled With the Start Symbol
– Leaf Node Is a Token or 
– Interior Node (Now Leaf) Is a Non-Terminal
– If A  x1x2…xn, Then A Is an Interior; x1x2…xn
Are Children of A and May Be Non-Terminals or
Tokens

Copyright@Mudassar
29 Zaidi,University of Sargodha
 Ambiguity

If a grammar can have more than one parse tree

generating a given string of tokens , then such a
grammar is said to be ambiguous to show that a
grammar is ambiguous all we need to do is find a
token string that has more then one parse tree. Since
a string with more then one parse tree usually has
more than one meaning for compiling applications we
need to design unambiguous grammars.

Copyright@Mudassar
30 Zaidi,University of Sargodha
 Ambiguity (Cont’d)

Suppose we did not distinguish between digits and lists

as in example (1). We could have written the grammar.
List list + list
List list – list
List 0|1|2|3|4|5|6|7|8|9

Copyright@Mudassar
31 Zaidi,University of Sargodha
 Ambiguity (Cont’d)

List

List
List

List List

9 - 5 + 2
Copyright@Mudassar
32 Zaidi,University of Sargodha
 Ambiguity (Cont’d)

List

List List

List
List

9 - 5 + 2
Copyright@Mudassar
33 Zaidi,University of Sargodha
 True Derivation

Op = '+'|'-'|'*'|'/' 1) Start  Expr

Int = [0-9]+ 2) Expr  Expr Op Expr
Open = (
Close = ) 3) Expr  Int
Start
4) Expr  Open Expr Close
Expr
Expr Op Expr
Open Expr Close Op Expr
Open Expr Op Expr Close Op Expr
Open Int Op Int Close Op Int
(2 - 1) + 1
Copyright@Mudassar
34 Zaidi,University of Sargodha
 Parse Tree Construction

1) Start  Expr Start

2) Expr  Expr Op Expr
3) Expr  Int
4) Expr  Open Expr Close
Start
Expr
Expr Op Expr
Open Expr Close Op Expr
Open Expr Op Expr Close Op Expr
Open Int Op Int Close Op Int
(2 - 1) + 1

Copyright@Mudassar
35 Zaidi,University of Sargodha
 Parse Tree Construction

1) Start  Expr Start

2) Expr  Expr Op Expr
3) Expr  Int
4) Expr  Open Expr Close

Start
Expr
Expr Op Expr
Open Expr Close Op Expr
Open Expr Op Expr Close Op Expr
Open Int Op Int Close Op Int
(2 - 1) + 1
Copyright@Mudassar
36 Zaidi,University of Sargodha
 Parse Tree Construction

1) Start  Expr Start

2) Expr  Expr Op Expr
3) Expr  Int
Expr
4) Expr  Open Expr Close

Start
Expr
Expr Op Expr
Open Expr Close Op Expr
Open Expr Op Expr Close Op Expr
Open Int Op Int Close Op Int
(2 - 1) + 1

Copyright@Mudassar
37 Zaidi,University of Sargodha
 Parse Tree Construction

Start
1) Start  Expr
2) Expr  Expr Op Expr
3) Expr  Int Expr
4) Expr  Open Expr Close

Start
Expr
Expr Op Expr
Open Expr Close Op Expr
Open Expr Op Expr Close Op Expr
Open Int Op Int Close Op Int
(2 - 1) + 1
Copyright@Mudassar
38 Zaidi,University of Sargodha
 Parse Tree Construction

1) Start  Expr Start

2) Expr  Expr Op Expr
3) Expr  Int Expr
4) Expr  Open Expr Close
Start Expr Op Expr
Expr
Expr Op Expr
Open Expr Close Op Expr
Open Expr Op Expr Close Op Expr
Open Int Op Int Close Op Int
(2 - 1) + 1
Copyright@Mudassar
39 Zaidi,University of Sargodha
 Parse Tree Construction

1) Start  Expr
2) Expr  Expr Op Expr Start
3) Expr  Int
4) Expr  Open Expr Close Expr
Start
Expr Expr Op Expr
Expr Op Expr
Open Expr Close Op Expr
Open Expr Op Expr Close Op Expr
Open Int Op Int Close Op Int
(2 - 1) + 1

Copyright@Mudassar
40 Zaidi,University of Sargodha
 Parse Tree Construction

1) Start  Expr
2) Expr  Expr Op Expr
Start
3) Expr  Int
4) Expr  Open Expr Close Expr
Start
Expr Expr Op Expr
Expr Op Expr
Open Expr Close Op Expr Open Expr Close
Open Expr Op Expr Close Op Expr
Open Int Op Int Close Op Int
(2 - 1) + 1
Copyright@Mudassar
41 Zaidi,University of Sargodha
 Parse Tree Construction

1) Start  Expr Start

2) Expr  Expr Op Expr
3) Expr  Int
Expr
4) Expr  Open Expr Close

Start Expr Op Expr

Expr
Expr Op Expr Open Expr Close
Open Expr Close Op Expr
Open Expr Op Expr Close Op Expr
Open Int Op Int Close Op Int
(2 - 1) + 1
Copyright@Mudassar
42 Zaidi,University of Sargodha
 Parse Tree Construction

1) Start  Expr Start

2) Expr  Expr Op Expr
3) Expr  Int
Expr
4) Expr  Open Expr Close

Start Expr Op Expr

Expr
Expr Op Expr Open Expr Close
Open Expr Close Op Expr
Open Expr Op Expr Close Op Expr Expr Op Expr
Open Int Op Int Close Op Int
(2 - 1) + 1
Copyright@Mudassar
43 Zaidi,University of Sargodha
 Parse Tree Construction

Start
1) Start  Expr
2) Expr  Expr Op Expr Expr
3) Expr  Int
4) Expr  Open Expr Close
Expr Op Expr
Start
Expr Open Expr Close
Expr Op Expr
Open Expr Close Op Expr
Expr Op Expr
Open Expr Op Expr Close Op Expr
Open Int Op Int Close Op Int
(2 - 1) + 1 Copyright@Mudassar
44 Zaidi,University of Sargodha
 Parse Tree Construction

1) Start  Expr Start

2) Expr  Expr Op Expr
3) Expr  Int Expr
4) Expr  Open Expr Close
Expr Op Expr
Start
Expr
Open Expr Close Int
Expr Op Expr
Open Expr Close Op Expr
Open Expr Op Expr Close Op Expr
Expr Op Expr
Open Int Op Int Close Op Int
(2 - 1) + 1 Int Int
Copyright@Mudassar
45 Zaidi,University of Sargodha
 Parse Tree Construction

Start
1) Start  Expr
2) Expr  Expr Op Expr Expr
3) Expr  Int
4) Expr  Open Expr Close Expr Op Expr
Start
Expr Open Expr Close Int
Expr Op Expr
Open Expr Close Op Expr Expr Op Expr
Open Expr Op Expr Close Op Expr
Open Int Op Int Close Op Int Int Int
(2 - 1) + 1
46
Copyright@Mudassar DONE!
Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr Op Expr

Open Expr Close Int

Expr Op Expr

Int Int

Copyright@Mudassar
47 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr Op Expr

Open Expr Close Int

Expr Op Expr

Int Int

Copyright@Mudassar
48 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr Op Expr

Open Expr Close Int

Expr Op Expr

Int Int

( 2 - 1 ) + 1
Copyright@Mudassar
49 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr Op Expr

Open Expr Close Int

Expr Op Expr

Int Int

( 2 - 1 ) + 1
Copyright@Mudassar
50 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr Op Expr

Open Expr Close Int

Expr Op Expr

Int Int

( 2 - 1 ) + 1
Copyright@Mudassar
51 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr Op Expr

Open Expr Close Int

Expr Op Expr

Int Int

( 2 - 1 ) + 1
Copyright@Mudassar
52 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr Op Expr

Open Expr Close Int

Expr Op Expr

Int Int

( 2 - 1 ) + 1
Copyright@Mudassar
53 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr Op Expr

Open(() Expr Close Int

Expr Op Expr

Int Int

( 2 - 1 ) + 1
Copyright@Mudassar
54 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr Op Expr

Open(() Expr Close Int

Expr Op Expr

Int Int

( 2 - 1 ) + 1
Copyright@Mudassar
55 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr Op Expr

Open(() Expr Close Int

Expr Op Expr

Int Int

( 2 - 1 ) + 1
Copyright@Mudassar
56 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr Op Expr

Open(() Expr Close Int

Expr Op Expr

Int Int

( 2 - 1 ) + 1
Copyright@Mudassar
57 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr Op Expr

Open(() Expr Close Int

Expr Op Expr

Int(2) Int

( 2 - 1 ) + 1
Copyright@Mudassar
58 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr Op Expr

Open(() Expr Close Int

Expr(2) Op Expr

Int(2) Int

( 2 - 1 ) + 1
Copyright@Mudassar
59 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr Op Expr

Open(() Expr Close Int

Expr(2) Op Expr

Int(2) Int

( 2 - 1 ) + 1
Copyright@Mudassar
60 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr Op Expr

Open(() Expr Close Int

Expr(2) Op(-) Expr

Int(2) Int

( 2 - 1 ) + 1
Copyright@Mudassar
61 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr Op Expr

Open(() Expr Close Int

Expr(2) Op(-) Expr

Int(2) Int

( 2 - 1 ) + 1
Copyright@Mudassar
62 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr Op Expr

Open(() Expr Close Int

Expr(2) Op(-) Expr

Int(2) Int

( 2 - 1 ) + 1
Copyright@Mudassar
63 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr Op Expr

Open(() Expr Close Int

Expr(2) Op(-) Expr

Int(2) Int(1)

( 2 - 1 ) + 1
Copyright@Mudassar
64 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr Op Expr

Open(() Expr Close Int

Expr(2) Op(-) Expr(1)

Int(2) Int(1)

( 2 - 1 ) + 1
Copyright@Mudassar
65 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr Op Expr

Open(() Expr(1) Close Int

Expr(2) Op(-) Expr(1)

Int(2) Int(1)

( 2 - 1 ) + 1
Copyright@Mudassar
66 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr Op Expr

Open(() Expr(1) Close Int

Expr(2) Op(-) Expr(1)

Int(2) Int(1)

( 2 - 1 ) + 1
Copyright@Mudassar
67 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr Op Expr

Open(() Expr(1) Close()) Int

Expr(2) Op(-) Expr(1)

Int(2) Int(1)

( 2 - 1 ) + 1
Copyright@Mudassar
68 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr(1) Op Expr

Open(() Expr(1) Close()) Int

Expr(2) Op(-) Expr(1)

Int(2) Int(1)

( 2 - 1 ) + 1
Copyright@Mudassar
69 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr(1) Op Expr

Open(() Expr(1) Close()) Int

Expr(2) Op(-) Expr(1)

Int(2) Int(1)

( 2 - 1 ) + 1
Copyright@Mudassar
70 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr(1) Op(+) Expr

Open(() Expr(1) Close()) Int

Expr(2) Op(-) Expr(1)

Int(2) Int(1)

( 2 - 1 ) + 1
Copyright@Mudassar
71 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr(1) Op(+) Expr

Open(() Expr(1) Close()) Int

Expr(2) Op(-) Expr(1)

Int(2) Int(1)

( 2 - 1 ) + 1
Copyright@Mudassar
72 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr(1) Op(+) Expr

Open(() Expr(1) Close()) Int

Expr(2) Op(-) Expr(1)

Int(2) Int(1)

( 2 - 1 ) + 1
Copyright@Mudassar
73 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr(1) Op(+) Expr

Open(() Expr(1) Close()) Int(1)

Expr(2) Op(-) Expr(1)

Int(2) Int(1)

( 2 - 1 ) + 1
Copyright@Mudassar
74 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr

Expr(1) Op(+) Expr(1)

Open(() Expr(1) Close()) Int(1)

Expr(2) Op(-) Expr(1)

Int(2) Int(1)

( 2 - 1 ) + 1
Copyright@Mudassar
75 Zaidi,University of Sargodha
 Processing the Tree
Start

Expr(2)

Expr(1) Op(+) Expr(1)

Open(() Expr(1) Close()) Int(1)

Expr(2) Op(-) Expr(1)

Int(2) Int(1)

( 2 - 1 ) + 1
Copyright@Mudassar
76 Zaidi,University of Sargodha
 Processing the Tree
Start(2)

Expr(2)

Expr(1) Op(+) Expr(1)

Open(() Expr(1) Close()) Int(1)

Expr(2) Op(-) Expr(1)

Int(2) Int(1)

( 2 - 1 ) + 1
Copyright@Mudassar
77 Zaidi,University of Sargodha
 General Grammar

Exp exp + term

Exp exp - term
Exp term
Term term * Factor
Term term / Factor
Term Factor
Factor digit
Factor (exp)

Copyright@Mudassar
78 Zaidi,University of Sargodha
 CFG - Example
 Grammar for balanced-parentheses language
– S(S)S
– S
 1 non-terminal: S
 3 terminals: “(”, “)”,ε
 Start symbol: S
 2 productions
 If grammar accepts a string, there is a derivation of that
string using the productions
– How do we produce: (())
– S = (S)  = ((S) S)  = (()  )  = (())

Copyright@Mudassar
79 Zaidi,University of Sargodha
 Stack based algorithm

 Push start symbol onto stack

 Replace non-terminal symbol on stack using grammar
rules
 Objective is to have something on stack which will
match input stream
 If top of stack matches input token, both may be
discarded
 If, eventually, both stack and input string are empty
then successful parse

Copyright@Mudassar
80 Zaidi,University of Sargodha
 Demonstration
 Grammar

S  ( S ) S | 

 Generates strings of balanced parentheses

 S
 (S)S
 ((S)S)S
 ((S)S)(S)S
 (( ))()

Copyright@Mudassar
81 Zaidi,University of Sargodha
 Demonstration

The Grammar The Input

S  ( S ) S |  ()$

 We mark the bottom of the stack

with a dollar sign.
 Note also that the input is
terminated with a dollar sign
representing end of input
$
Copyright@Mudassar
82 Zaidi,University of Sargodha
 Demonstration

The Grammar The Input

S  ( S ) S |  ()$

 Start by pushing the start

symbol onto the stack

S
$
Copyright@Mudassar
83 Zaidi,University of Sargodha
 The Grammar The Input
S  ( S ) S |  ()$

(
 Replace it with a rule from the
grammar: S  ( S ) S S
 Note that the rule is pushed )
onto the stack from right to left S
$
Copyright@Mudassar
84 Zaidi,University of Sargodha
 Demonstration

The Grammar The Input

S  ( S ) S |  ()$

 Now we match the top of the (

stack with the next input S
character )
S
$
Copyright@Mudassar
85 Zaidi,University of Sargodha
 Demonstration

The Grammar The Input

S  ( S ) S |  ()$

(
 Characters matched are
S
removed from both stack and
input stream )
S
$
Copyright@Mudassar
86 Zaidi,University of Sargodha
 Demonstration

The Grammar The Input

S  ( S ) S |  )$

 Characters matched are S

removed from both stack and )
input stream
S
$
Copyright@Mudassar
87 Zaidi,University of Sargodha
 Demonstration

The Grammar The Input

S  ( S ) S |  )$

 Now we use the rule: S  

S
)
S
$
Copyright@Mudassar
88 Zaidi,University of Sargodha
 Demonstration

The Grammar The Input

S  ( S ) S |  )$

 Now we use the rule: S  

)
S
$
Copyright@Mudassar
89 Zaidi,University of Sargodha
 Demonstration

The Grammar The Input

S  ( S ) S |  )$

 We can again match )

S
$
Copyright@Mudassar
90 Zaidi,University of Sargodha
 Demonstration

The Grammar The Input

S  ( S ) S |  $

 and remove matches

S
$
Copyright@Mudassar
91 Zaidi,University of Sargodha
 Demonstration

The Grammar The Input

S  ( S ) S |  $

 One more application of the

rule: S   S
$
Copyright@Mudassar
92 Zaidi,University of Sargodha
 Demonstration

The Grammar The Input

S  ( S ) S |  $

 One more application of the

rule: S  
$
Copyright@Mudassar
93 Zaidi,University of Sargodha
 Demonstration

The Grammar The Input

S  ( S ) S |  $

 Now finding both stack and

input are at $ we conclude
successful parse

$
Copyright@Mudassar
94 Zaidi,University of Sargodha
 THANKS
Copyright@Mudassar
95 Zaidi,University of Sargodha