The document discusses compiler theory and provides code examples. It covers: 1. Lex theory - how regular expressions are used to specify patterns for tokenization and how these are implemented as finite state automata. 2. Yacc theory - how context-free grammars are specified in BNF and parsed using shift-reduce parsing. Issues like shift-reduce conflicts and reduce-reduce conflicts are explained. 3. Code examples of stack implementations using arrays and linked lists, and a program to check if a string is a keyword.

1. INDEX
S.No. Program Date Signature
1 Practice of LEX/YACC of compiler writing.
2 Write a program to implement stack opeartions
using array.
3 Write a program to show all the operations of a
stack using Link list.
4 Write a program to find whether string is a
keyword or not.
5 Write a program is to find out whether a given
string is an Identifier or not.
6 Write a program to find whether the string is
constant or not.
7 Write a program to check whether string belongs
to a grammar or not.
8 Write a program to find the FIRST of a variable.
9 Write a program to compute FOLLOW of non-
terminals.
10 Write a program to find the Trailing Terminals
in the String.

2. Program 1: Practice of LEX/YACC of compiler writing
Lex Theory
The first phase in a compiler reads the input source and converts strings in the
source to tokens. Using regular expressions, we can specify patterns to lex that
allow it to scan and match strings in the input. Each pattern in lex has an associated
action. Typically an action returns a token, representing the matched string, for
subsequent use by the parser. To begin with, however, we will simply print the
matched string rather than return a token value. We may scan for identifiers using
the regular expression.
letter(letter|digit)*
This pattern matches a string of characters that begins with a single letter, and is
followed by zero or more letters or digits. This example nicely illustrates
operations allowed in regular expressions:
 repetition, expressed by the “*” operator
 alternation, expressed by the “|” operator
 concatenation
Any regular expression expressions may be expressed as a finite state automaton
(FSA). We can represent an FSA using states, and transitions between states. There
is one start state, and one or more final or accepting states.
Figure 1: Finite State Automaton
In Figure1, state 0 is the start state, and state 2 is the accepting state. As characters
are read, we make a transition from one state to another. When the first letter is
read, we transition to state 1. We remain in state 1 as more letters or digits are read.

3. When we read a character other than a letter or digit, we transition to state 2, the
accepting state. Any FSA may be expressed as a computer program. For example,
our 3-state machine is easily programmed:
start : goto state0
state0: read c
if c = letter goto state1
goto state0
state1: read c
if c = letter goto state1
if c = digit goto state1
goto state2
state2: accept string
This is the technique used by lex. Regular expressions are translated by lex to a
computer program that mimics an FSA. Using the next input character, and current
state, the next state is easily determined by indexing into a computer-generated
state table.
Now we can easily understand some of lex’s limitations. For example, lex cannot
be used to recognize nested structures such as parentheses. Nested structures are
handled by incorporating a stack. Whenever we encounter a “(”, we push it on the
stack. When a “)” is encountered, we match it with the top of the stack, and pop the
stack. Lex, however, only has states and transitions between states. Since it has no
stack, it is not well suited for parsing nested structures. Yacc augments an FSA
with a stack, and can process constructs such as parentheses with ease. The
important thing is to use the right tool for the job. Lex is good at pattern matching.
Yacc is appropriate for more challenging tasks.

4. Yacc Theory
Grammars for yacc are described using a variant of Backus Naur Form (BNF).
This technique was pioneered by John Backus and Peter Naur, and used to describe
ALGOL60. A BNF grammar can be used to express context-free languages. Most
constructs in modern programming languages can be represented in BNF. For
example, the grammar for an expression that multiplies and adds numbers is
1 E -> E + E
2 E -> E * E
3 E -> id
Three productions have been specified. Terms that appear on the left-hand side
(lhs) of a production, such as E (expression) are non-terminals. Terms such as id
(identifier) are terminals (tokens returned by lex) and only appear on the right-hand
side (rhs) of a production. This grammar specifies that an expression may be the
sum of two expressions, the product of two expressions, or an identifier. We can
use this grammar to generate expressions:
E -> E * E (r2)
-> E * z (r3)
-> E + E * z (r1)
-> E + y * z (r3)
-> x + y * z (r3)
At each step we expanded a term, replacing the lhs of a production with the
corresponding rhs. The numbers on the right indicate which rule applied. To parse
an expression, we actually need to do the reverse operation. Instead of starting with
a single nonterminal (start symbol) and generating an expression from a grammar,
we need to reduce an expression to a single nonterminal. This is known as bottom-
up or shift-reduce parsing, and uses a stack for storing terms. Here is the same
derivation, but in reverse order:

5. 1 . x + y * z shift
2 x . + y * z reduce(r3)
3 E . + y * z shift
4 E + . y * z shift
5 E + y . * z reduce(r3)
6 E + E . * z shift
7 E + E * . z shift
8 E + E * z . reduce(r3)
9 E + E * E . reduce(r2) emit multiply
10 E + E . reduce(r1) emit add
11 E . accept
Terms to the left of the dot are on the stack, while remaining input is to the right of
the dot. We start by shifting tokens onto the stack. When the top of the stack
matches the rhs of a production, we replace the matched tokens on the stack with
the lhs of the production. Conceptually, the matched tokens of the rhs are popped
off the stack, and the lhs of the production is pushed on the stack. The matched
tokens are known as a handle, and we are reducing the handle to the lhs of the
production. This process continues until we have shifted all input to the stack, and
only the starting nonterminal remains on the stack. In step 1 we shift the x to the
stack. Step 2 applies rule r3 to the stack, changing x to E. We continue shifting and
reducing, until a single nonterminal, the start symbol, remains in the stack. In step
9, when we reduce rule r2, we emit the multiply instruction. Similarly, the add
instruction is emitted in step 10. Thus, multiply has a higher precedence than
addition.
Consider, however, the shift at step 6. Instead of shifting, we could have reduced,
applying rule r1. This would result in addition having a higher precedence than
multiplication. This is known as a shift-reduce conflict. Our grammar is ambguous,

6. as there is more than one possible derivation that will yield the expression. In this
case, operator precedence is affected. As another example, associativity in the rule
E -> E + E
is ambiguous, for we may recurse on the left or the right. To remedy the situation,
we could rewrite the grammar, or supply yacc with directives that indicate which
operator has precedence. The latter method is simpler, and will be demonstrated in
the practice section.
The following grammar has a reduce-reduce conflict. With an id on the stack, we
may reduce to T, or reduce to E.
E -> T
E -> id
T -> id
Yacc takes a default action when there is a conflict. For shift-reduce conflicts, yacc
will shift. For reduce-reduce conflicts, it will use the first rule in the listing. It also
issues a warning message whenever a conflict exists. The warnings may be
suppressed by making the grammar unambiguous. Several methods for removing
ambiguity will be presented in subsequent sections.

7. Program 2: - Write a program to implement stack operations using an
array.
#define MAX 4 //you can take any number to limit your stack size
#include<stdio.h>
#include<conio.h>
int stack[MAX];
int top;
void push(int token)
{
char a;
do
{
if(top==MAX-1)
{
printf("Stack full");
return;
}
printf("nEnter the token to be inserted:");
scanf("%d",&token);
top=top+1;
stack[top]=token;
printf("do you want to continue insertion Y/N");
a=getch();

8. }
while(a=='y');
}
int pop()
{
int t;
if(top==-1)
{
printf("Stack empty");
return -1;
}
t=stack[top];
top=top-1;
return t;
}
void show()
{
int i;
printf("nThe Stack elements are:");
for(i=0;i<=top;i++)
{
printf("%d",stack[i]);
}

9. }
int main()
{
char ch , a='y';
int choice, token;
top=-1;
printf("1.Insert");
printf("n2.Delete");
printf("n3.show or display");
do
{
printf("nEnter your choice for the operation: ");
scanf("%d",&choice);
switch(choice)
{
case 1:
{
push(token);
show();
break;
}
case 2:
{

10. token=pop();
printf("nThe token deleted is %d",token);
show();
break;
}
case 3:
{
show();
break;
}
default:printf("Wrong choice");
break;
}
printf("nDo you want to continue(y/n):");
ch=getch();
}
while(ch=='y'||ch=='Y');
getch();
}

11. Output:-

12. Program 3: - Write a program to implement stack operations using array
#include <stdio.h>
#include <stdlib.h>
struct Node
{
int Data;
struct Node *next;
}*top;
void popStack()
{
struct Node *temp, *var=top;
if(var==top)
{
top = top->next;
free(var);
}
else
printf("nStack Empty");
}
void push(int value)
{
struct Node *temp;
temp=(struct Node *)malloc(sizeof(struct Node));

13. temp->Data=value;
if (top == NULL)
{
top=temp;
top->next=NULL;
}
else
{
temp->next=top;
top=temp;
}
}
void display()
{
struct Node *var=top;
if(var!=NULL)
{
printf("nElements are as:n");
while(var!=NULL)
{
printf("t%dn",var->Data);
var=var->next;
}

14. printf("n");
}
else
printf("nStack is Empty");
}
int main(int argc, char *argv[])
{
int i=0;
top=NULL;
printf(" n1. Push to stack");
printf(" n2. Pop from Stack");
printf(" n3. Display data of Stack");
printf(" n4. Exitn");
while(1)
{
printf(" nChoose Option: ");
scanf("%d",&i);
switch(i)
{
case 1:
{
int value;
printf("nEnter a valueber to push into Stack: ");

15. scanf("%d",&value);
push(value);
display();
break;
}
case 2:
{
popStack();
display();
break;
}
case 3:
{
display();
break;
}
case 4:
{
struct Node *temp;
while(top!=NULL)
{
temp = top->next;
free(top);

16. top=temp;
}
exit(0);
}
default:
{
printf("nwrong choice for operation");
}
}
}
}
Output:

17. Program 4:- Program to find whether string is a keyword or not.
#include<stdio.h>
#include<conio.h>
#include<string.h>
void main()
{
int i,flag=0,m;
char s[5][10]={"if","else","goto","continue","return"},st[10];
clrscr();
printf("n enter the string :");
gets(st);
for(i=0;i<5;i++)
{
m=strcmp(st,s[i]);
if(m==0)
flag=1;
}
if(flag==0)
printf("n it is not a keyword");
else
printf("n it is a keyword");
getch();
}

18. Output:

19. Program 5:- Write a program is to find out whether a given string is a
Identifier or not.
#include<stdio.h>
#include<conio.h>
#include<string.h>
#include<ctype.h>
void main()
{
int i=0,flag=0;
char string[10];
clrscr();
printf("Enter a string :");
gets(string);
/*----Checking the 1st character*----*/
if((string[0]=='_')||(isalpha(string[0])!=0))
{
/*---Checking rest of the characters*---*/
for(i=1;string[i]!='0';i++)
if((isalnum(string[i])==0)&&(string[i]!='_'))
flag=1;
}
else
flag=1;

20. if( flag==0)
printf("n%s is an identifier ",string);
else
printf("n%s is not an identifier ",string);
getch();
}
Output:

21. Program no.6 :- Program to find whether the string is constant or not.
#include<stdio.h>
#include<conio.h>
#include<ctype.h>
#include<string.h>
void main()
{
char str[10];
int len,a;
clrscr();
printf("n Input a string :");
gets(str);
len=strlen(str);
a=0;
while(a<len)
{
if(isdigit(str[a]))
{
a++;
}
else
{
printf(" It is not a Constant");

22. break;
}
}
if(a==len)
{
printf(" It is a Constant");
}
getch();
}
Output:

23. Program 7: Write a program to check whether string belongs to a grammar
or not.
#include<stdio.h>
#include<conio.h>
#include<string.h>
void main()
{
clrscr();
int i,j,k=0;
char x,y,z;
char S[10],A[10],B[10],C[10];
printf("t Enter String S->");
gets(S);
for(i=0;i<=strlen(S)-1;i=i+1)
{
x=S[i];
z=S[i+1];
if(x>='a' && x<='z')
{
printf("n n t First(S)-> %c",x);
break;
}
else

24. {
printf("n n t Enter String for %c-> ",x);
label1:
gets(C);
for(j=0;j<=strlen(C)-1;j++)
{
y=C[j];
if(y>='a' && y<='z')
goto label;
else
{
printf("nt Enter String For %c-> ",y);
goto label1;
}
}
}
}
label:
printf("ntFirst(S)->%c%c",y,z);
getch();
}

25. Output:

26. Program 8: Write a program to find the FIRST of a variable.
#include<stdio.h>
#include<conio.h>
#include<string.h>
void main()
{
clrscr();
int i,j,k=0;
char x,y,z;
char S[10],A[10],B[10],C[10];
printf("t Enter String S->");
gets(S);
for(i=0;i<=strlen(S)-1;i=i+1)
{
x=S[i];
z=S[i+1];
if(x>='a' && x<='z')
{
printf("n n t First(S)-> %c",x);
break;
}
else

27. {
printf("n n t Enter String for %c-> ",x);
label1:
gets(C);
for(j=0;j<=strlen(C)-1;j++)
{
y=C[j];
if(y>='a' && y<='z')
goto label;
else
{
printf("nt Enter String For %c-> ",y);
goto label1;
}
}
}
}
label:
printf("ntFirst(S)->%c%c",y,z);
getch();
}

28. Output:

29. Program 9: Write a program to find the FOLLOW of a variable.
#include<stdio.h>
#include<conio.h>
#include<math.h>
void first(char ch);
char p[10][10]={"S->aAB","A->Bc","B->d"};
char stk[10];
int top=-1;
int c=0;
int follow(char ch)
{
int i,j,c1,count=0,x;
if(ch=='S')
{
printf("$");
//break;
}
for(i=0;i<3;i++)
{
if(ch==p[i][0])
count++;
for(j=3;p[i][j]!='0';j++)

30. {
if(p[i][j]==ch && p[i][j+1]!='0')
{
if(p[i][j+1]=='a' || p[i][j+1]=='c' || p[i][j+1]=='d')
printf(",%c",p[i][j+1]);
else
first(p[i][j+1]);
}
if(p[i][j]==ch && p[i][j+1]=='0')
x=follow(p[i][0]);
}
}
return count;
}
void first(char ch)
{ int i;
for(i=0;i<3;i++)
{
if(ch==p[i][0])
{
if(p[i][3]=='a' || p[i][3]=='c' || p[i][3]=='d')
printf("%c",p[i][3]);
else

31. {
top++;
stk[top]=p[i][3];
if(p[i][3]=='B')
{
if(p[i][4]=='a' || p[i][4]=='c' ||p[i][4]=='d')
printf("%c",p[i][4]);
else
{
top++;
stk[top]=p[i][4];
}
}
}
}
}
while(top!=-1)
{
char ch1;
ch1=stk[top];
top--;
first(ch1);
}

32. }
void main()
{
int i;
clrscr();
printf("Grammeris-------->S->aAB A->Bc B->d");
for(i=0;i<3;i=i+c)
{
printf("nFollow of %c is:" ,p[i][0]);
c=follow(p[i][0]);
}
getch();
}
Output:

33. Program 10: Write a program to find the Trailing Terminals in the String.
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include<string.h>
#include<iostream.h>
void main()
{
clrscr();
char str1[10],str2[10];
char x,y,z;
int i,j,k;
printf("nEnter String For finding Trailing Terminalt S-> ");
gets(str1);
for(i=strlen(str1)-1;i>=0;i--)
{
x=str1[i];
if(x>='a' && x<='z')
{
printf("nTrailing Terminal of the String t S-> %c",x);
break;
}
else

34. {
printf("nEnter Production for t %c-> ",x);
label1:
gets(str2);
k=strlen(str2)-1;
y=str2[k];
if(str2[k]>='a' && str2[k]<='z')
{
y=str2[k];
goto label2;
}
else
{
printf("nEnter Production for t %c-> ",y);
goto label1;
}
label2:
for(j=i-1;j>=0;j--)
{
z=str1[j];
if(z>='a' && z<='z')
goto label;
}

35. }
}
label:
printf("nnTrailing Terminal of the String tS-> %c%c",y,z);
getch();
}
Output: