Scribd
Upload
18 views4 pages

Experiment No: 7: Name: Abhishek Subhash Tekalkar Roll - No: 124 Div: B

The document discusses operator precedence parsing. It defines an operator precedence grammar as one where no production has an empty right-hand side or two adjacent non-terminals. An operator precedence parser interprets such grammars using three precedence relations: yield, take precedence over, and same precedence as. It encodes the precedence relations into precedence functions that map symbols to integers for comparison rather than storing a precedence table. An example C program demonstrates implementing operator precedence by evaluating expressions with different operator groupings.

Uploaded by

Abhishek Tekalkar
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
18 views4 pages

Experiment No: 7: Name: Abhishek Subhash Tekalkar Roll - No: 124 Div: B

The document discusses operator precedence parsing. It defines an operator precedence grammar as one where no production has an empty right-hand side or two adjacent non-terminals. An operator precedence parser interprets such grammars using three precedence relations: yield, take precedence over, and same precedence as. It encodes the precedence relations into precedence functions that map symbols to integers for comparison rather than storing a precedence table. An example C program demonstrates implementing operator precedence by evaluating expressions with different operator groupings.

Uploaded by

Abhishek Tekalkar
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 4

Name: Abhishek Subhash Tekalkar Roll.

no: 124 Div: B


Experiment No: 7

Aim: Write a program to implement operator precedence parser.

Theory:
A grammar that is used to define mathematical operators is called an operator grammar or
operator precedence grammar. Such grammars have the restriction that no production has either
an empty right-hand side (null productions) or two adjacent non-terminals in its right-hand side.

Examples –
This is an example of operator grammar:

E->E+E/E*E/id
However, the grammar given below is not an operator grammar because two non-terminals are
adjacent to each other:

S->SAS/a
A->bSb/b
We can convert it into an operator grammar, though:
S->SbSbS/SbS/a
A->bSb/b
Operator precedence parser –
An operator precedence parser is a bottom-up parser that interprets an operator grammar. This
parser is only used for operator grammars. Ambiguous grammars are not allowed in any parser
except operator precedence parser.
There are two methods for determining what precedence relations should hold between a pair of
terminals:

Use the conventional associativity and precedence of operator.


The second method of selecting operator-precedence relations is first to construct an
unambiguous grammar for the language, a grammar that reflects the correct associativity and
precedence in its parse trees.
This parser relies on the following three precedence relations: ⋖, ≐, ⋗
a ⋖ b This means a “yields precedence to” b. a ⋗ b This means a
“takes precedence over” b.
a ≐ b This means a “has same precedence as” b.
Figure – Operator precedence relation table for grammar E->E+E/E*E/id

There is not given any relation between id and id as id will not be compared and two variables
can not come side by side. There is also a disadvantage of this table – if we have n operators then
size of table will be n*n and complexity will be 0(n2). In order to decrease the size of table, we
use operator function table.

Operator precedence parsers usually do not store the precedence table with the relations; rather
they are implemented in a special way. Operator precedence parsers use precedence functions
that map terminal symbols to integers, and the precedence relations between the symbols are
implemented by numerical comparison. The parsing table can be encoded by two precedence
functions f and g that map terminal symbols to integers. We select f and g such that:

f(a) < g(b) whenever a yields precedence to b f(a) =


g(b) whenever a and b have the same precedence f(a) >
g(b) whenever a takes precedence over b Example –
Consider the following grammar:

E -> E + E/E * E/( E )/id


This is the directed graph representing the precedence function:
Since there is no cycle in the graph, we can make this function table:

fid -> g* -> f+ ->g+ -> f$ gid -


> f* -> g* ->f+ -> g+ ->f$
Code:
Operator.c

#include <stdio.h>
main()
{ int a =
20; int b =
10; int c =
15; int d =
5;
int e;
e = (a + b) * c / d; // ( 30 * 15 ) / 5
printf("Value of (a + b) * c / d is : %d\n", e ); e
= ((a + b) * c) / d; // (30 * 15 ) / 5 printf("Value
of ((a + b) * c) / d is : %d\n" , e ); e = (a + b) *
(c / d); // (30) * (15/5) printf("Value of (a + b)
* (c / d) is : %d\n", e ); e = a + (b * c) / d; // 20
+ (150/5) printf("Value of a + (b * c) / d is :
%d\n" , e );

return 0;
}

Output:

Conclusion:-
Hence we understood how operator precedence parser and successfully implemented it

You might also like