June 2011 ~ ●.. My B.Tech ..● 2K8618.blogspot.com

Intermediate Code Generator for While - Yacc Program - Compiler Lab

Program:

(Lex Program: intwh.l)

ALPHA [A-Za-z]
DIGIT [0-9]
%%
while               return WHILE;
{ALPHA}({ALPHA}|{DIGIT})*   return ID;
{DIGIT}+            {yylval=atoi(yytext); return NUM;}
[ \t]                ;
\n               yyterminate();
.                return yytext[0];
%%

(Yacc Program: intwh.y)

%token ID NUM WHILE
%right '='
%left '+' '-'
%left '*' '/'
%left UMINUS
%%

S : WHILE{lab1();} '(' E ')'{lab2();} E ';'{lab3();}
;
E :V '='{push();} E{codegen_assign();}
| E '+'{push();} E{codegen();}
| E '-'{push();} E{codegen();}
| E '*'{push();} E{codegen();}
| E '/'{push();} E{codegen();}
| '(' E ')'
| '-'{push();} E{codegen_umin();} %prec UMINUS
| V
| NUM{push();}
;
V : ID {push();}
;
%%

#include "lex.yy.c"
#include<ctype.h>
char st[100][10];
int top=0;
char i_[2]="0";
char temp[2]="t";

int lnum=1;
int start=1;
main()
{
printf("Enter the expression : ");
yyparse();
}

push()
{
strcpy(st[++top],yytext);
}

codegen()
{
strcpy(temp,"t");
strcat(temp,i_);
printf("%s = %s %s %s\n",temp,st[top-2],st[top-1],st[top]);
top-=2;
strcpy(st[top],temp);
i_[0]++;
}

codegen_umin()
{
strcpy(temp,"t");
strcat(temp,i_);
printf("%s = -%s\n",temp,st[top]);
top--;
strcpy(st[top],temp);
i_[0]++;
}

codegen_assign()
{
printf("%s = %s\n",st[top-2],st[top]);
top-=2;
}

lab1()
{
printf("L%d: \n",lnum++);
}

lab2()
{
strcpy(temp,"t");
strcat(temp,i_);
printf("%s = not %s\n",temp,st[top]);
printf("if %s goto L%d\n",temp,lnum);
i_[0]++;
}

lab3()
{
printf("goto L%d \n",start);
printf("L%d: \n",lnum);
}

Output :
nn@linuxmint ~ $ lex intwh.l
nn@linuxmint ~ $ yacc intwh.y
nn@linuxmint ~ $ gcc y.tab.c -ll -ly
nn@linuxm./a.out
Enter the expression : while(k=c/s)k=k*c+d;
L1:
t0 = c / s
k = t0
t1 = not k
if t1 goto L0
t2 = k * c
t3 = t2 + d
k = t3
goto L1
L0:
nn@linuxmint ~ $

Intermediate Code Generator for If then else - Yacc Program - Compiler Lab

Program :

(lex Program : intif.l)

ALPHA [A-Za-z]
DIGIT [0-9]
%%
if                 return IF;
then                 return THEN;
else                 return ELSE;
{ALPHA}({ALPHA}|{DIGIT})*    return ID;
{DIGIT}+             {yylval=atoi(yytext); return NUM;}
[ \t]                 ;
\n                yyterminate();
.                 return yytext[0];
%%

(Yacc Program : intif.y)

%token ID NUM IF THEN ELSE
%right '='
%left '+' '-'
%left '*' '/'
%left UMINUS
%%

S : IF '(' E ')'{lab1();} THEN E ';'{lab2();} ELSE E ';'{lab3();}
;
E :V '='{push();} E{codegen_assign();}
| E '+'{push();} E{codegen();}
| E '-'{push();} E{codegen();}
| E '*'{push();} E{codegen();}
| E '/'{push();} E{codegen();}
| '(' E ')'
| '-'{push();} E{codegen_umin();} %prec UMINUS
| V
| NUM{push();}
;
V : ID {push();}
;
%%

#include "lex.yy.c"
#include<ctype.h>
char st[100][10];
int top=0;
char i_[2]="0";
char temp[2]="t";

int label[20];
int lnum=0;
int ltop=0;

main()
{
printf("Enter the expression : ");
yyparse();
}

push()
{
strcpy(st[++top],yytext);
}

codegen()
{
strcpy(temp,"t");
strcat(temp,i_);
printf("%s = %s %s %s\n",temp,st[top-2],st[top-1],st[top]);
top-=2;
strcpy(st[top],temp);
i_[0]++;
}

codegen_umin()
{
strcpy(temp,"t");
strcat(temp,i_);
printf("%s = -%s\n",temp,st[top]);
top--;
strcpy(st[top],temp);
i_[0]++;
}

codegen_assign()
{
printf("%s = %s\n",st[top-2],st[top]);
top-=2;
}

lab1()
{
lnum++;
strcpy(temp,"t");
strcat(temp,i_);
printf("%s = not %s\n",temp,st[top]);
printf("if %s goto L%d\n",temp,lnum);
i_[0]++;
label[++ltop]=lnum;
}

lab2()
{
int x;
lnum++;
x=label[ltop--];
printf("goto L%d\n",lnum);
printf("L%d: \n",x);
label[++ltop]=lnum;
}

lab3()
{
int y;
y=label[ltop--];
printf("L%d: \n",y);
}

Output:

nn@linuxmint ~ $ lex intif.l
nn@linuxmint ~ $ yacc intif.y
nn@linuxmint ~ $ gcc y.tab.c -ll -ly
nn@linuxmint ~ $ ./a.out
Enter the expression : if(k+8) then k=18;else c=s;
t0 = k + 8
t1 = not t0
if t1 goto L1
k = 18
goto L2
L1:
c = s
L2:
nn@linuxmint ~ $

Intermediate Code Generator for Arithmetic Expression - Yacc Program - Compiler Lab

Program:

(Lex Program : intar.l)

ALPHA [A-Za-z]
DIGIT [0-9]
%%

{ALPHA}({ALPHA}|{DIGIT})* return ID;
{DIGIT}+ {yylval=atoi(yytext); return NUM;}
[\n\t] yyterminate();
. return yytext[0];
%%

(Yacc Program : intar.y)

%token ID NUM
%right '='
%left '+' '-'
%left '*' '/'
%left UMINUS
%%

S : ID{push();} '='{push();} E{codegen_assign();}
   ;
E : E '+'{push();} T{codegen();}
   | E '-'{push();} T{codegen();}
   | T
   ;
T : T '*'{push();} F{codegen();}
   | T '/'{push();} F{codegen();}
   | F
   ;
F : '(' E ')'
   | '-'{push();} F{codegen_umin();} %prec UMINUS
   | ID{push();}
   | NUM{push();}
   ;
%%

#include "lex.yy.c"
#include<ctype.h>
char st[100][10];
int top=0;
char i_[2]="0";
char temp[2]="t";

main()
{
printf("Enter the expression : ");
yyparse();
}

push()
{
strcpy(st[++top],yytext);
}

codegen()
{
strcpy(temp,"t");
strcat(temp,i_);
printf("%s = %s %s %s\n",temp,st[top-2],st[top-1],st[top]);
top-=2;
strcpy(st[top],temp);
i_[0]++;
}

codegen_umin()
{
strcpy(temp,"t");
strcat(temp,i_);
printf("%s = -%s\n",temp,st[top]);
top--;
strcpy(st[top],temp);
i_[0]++;
}

codegen_assign()
{
printf("%s = %s\n",st[top-2],st[top]);
top-=2;
}

Output:

nn@linuxmint ~ $ lex intar.l
nn@linuxmint ~ $ yacc intar.y
nn@linuxmint ~ $ gcc y.tab.c -ll -ly
nn@linuxmint ~ $ ./a.out
Enter the expression : a=(k+8)*(c-s)
t0 = k + 8
t1 = c - s
t2 = t0 * t1
a = t2
nn@linuxmint ~ $

Parser for Function Definition - YACC Program - Compiler Lab

Program :

(Lex Program : fundf.l)

alpha [A-Za-z]
digit [0-9]

%%

[\t \n]            ;
int|float|void|char        return TYPE;
return                return RETURN;
{digit}+            return NUM;
{alpha}({alpha}|{digit})*    return ID;
.                return yytext[0];

%%

(Yacc Program : fundf.y)

%{
#include <stdio.h>
#include <stdlib.h>
%}
%token TYPE RETURN ID NUM
%right "="
%left '+' '-'
%left '*' '/'
%right UMINUS
%left '!'

%%

S    : FUN {printf("Input accepted\n"); exit(0);}
FUN    : TYPE ID '(' PARAM ')' '{' BODY '}'
    ;
PARAM    : PARAM ',' TYPE ID
    | TYPE ID
    |
    ;
BODY    : BODY BODY
    | PARAM ';'
    | E ';'
        | RETURN E ';'
        |
    ;
E    : ID '=' E
    | E '+' E
    | E '-' E
    | E '*' E
    | E '/' E
    | ID
    | NUM
    ;

%%

#include "lex.yy.c"
main()
{
    printf("Enter the expression:\n");
    yyparse();
}



Output :
nn@linuxmint ~ $ lex fund.l
nn@linuxmint ~ $ yacc fund.y
conflicts: 17 shift/reduce, 11 reduce/reduce
nn@linuxmint ~ $ gcc y.tab.c -ll -ly
nn@linuxmint ~ $ ./a.out
Enter the expression:
float sum(int term)
{
   float result;
   result=result+term;
   return result;
}
Input accepted
nn@linuxmint ~ $

UDP Chat - User Datagram Protocol - Networks & DBMS Lab - C Program

Program :

// Server Program : udps.c

#include<stdio.h>
#include<string.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
main()
{
    struct sockaddr_in client,server;
    int s,n;
    char b1[100],b2[100];
    s=socket(AF_INET,SOCK_DGRAM,0);
    server.sin_family=AF_INET;
    server.sin_port=2000;
    server.sin_addr.s_addr=inet_addr("127.0.0.1");
    bind(s,(struct sockaddr *)&server,sizeof(server));
    printf("\nServer ready,waiting for client....\n");
    n=sizeof(client);
    while(1)
    {
        recvfrom(s,b1,sizeof(b1),0,(struct sockaddr *) &client,&n);
        if(!(strcmp(b1,"end")))
            break;
        printf("\nClient:%s",b1);
        printf("\nServer:");
        gets(b2);
        sendto(s,b2,sizeof(b2),0,(struct sockaddr *) &client,n);

    }

}

//Client Program : udpc.c

#include<stdio.h>
#include<string.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
main()
{
    struct sockaddr_in client,server;
    int s,n;
    char b1[100],b2[100];
    s=socket(AF_INET,SOCK_DGRAM,0);
    server.sin_family=AF_INET;
    server.sin_port=2000;
    server.sin_addr.s_addr=inet_addr("127.0.0.1");
    printf("\nClient ready....\n");
    n=sizeof(server);
    while(1)
    {
        printf("\nClient:");
        gets(b2);
        sendto(s,b2,sizeof(b2),0,(struct sockaddr *) &server,n);
        if(strcmp(b2,"end")==0)
            break;
        recvfrom(s,b1,sizeof(b1),0,NULL,NULL);
        printf("\nServer:%s",b1);
    }

}

Output:

Terminal 1: (Server)

student@cselab-desktop:~$ gcc udps.c -o server
/tmp/cc30up4j.o: In function `main':
udps.c:(.text+0x129): warning: the `gets' function is dangerous and should not be used.
student@cselab-desktop:~$ ./server

Server ready,waiting for client....

Client:hi...
Server:hi.. hw r u?

Client:fine.u?
Server:ok.bye...

Client:bye...
Server:end
student@cselab-desktop:~$

Terminal 2 :(Client)
student@cselab-desktop:~$ gcc udpc.c -o client
/tmp/ccfz7pFY.o: In function `main':
udpc.c:(.text+0x8b): warning: the `gets' function is dangerous and should not be used.
student@cselab-desktop:~$ ./client

Client ready....

Client:hi...

Server:hi.. hw r u?
Client:fine.u?

Server:ok.bye...
Client:bye...


Server:end
Client:student@cselab-desktop:~$

Echo Server - UDP - Networks & DBMS Lab - C Program

Program :

//Server program : echos.c

#include<stdio.h>
#include<string.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
main()
{
    struct sockaddr_in client,server;
    int s,n;
    char b1[100],b2[100];
    s=socket(AF_INET,SOCK_DGRAM,0);
    server.sin_family=AF_INET;
    server.sin_port=2000;
    server.sin_addr.s_addr=inet_addr("127.0.0.1");
    bind(s,(struct sockaddr *)&server,sizeof(server));
    printf("\nEcho Server ready,waiting for client....\n");
    n=sizeof(client);
    while(1)
    {
        recvfrom(s,b1,sizeof(b1),0,(struct sockaddr *) &client,&n);
    if(!(strcmp(b1,"end")))
            break;
        sendto(s,b1,sizeof(b1),0,(struct sockaddr *) &client,n);

    }

}

// Client Program : (echoc.c)

#include<stdio.h>
#include<string.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
main()
{
    struct sockaddr_in server,client;
    int s,n;
    char b1[100],b2[100];
    s=socket(AF_INET,SOCK_DGRAM,0);
    server.sin_family=AF_INET;
    server.sin_port=2000;
    server.sin_addr.s_addr=inet_addr("127.0.0.1");
    printf("\nClient ready....\n");
    n=sizeof(server);
    while(1)
    {
        printf("\nClient:");
        gets(b2);
        sendto(s,b2,sizeof(b2),0,(struct sockaddr *) &server,n);
        if(strcmp(b2,"end")==0)
            break;
        recvfrom(s,b1,sizeof(b1),0,NULL,NULL);
        printf("\nServer:%s",b1);
    }

}

Output :

Terminal 1: (Server)
student@cselab-desktop:~$ gcc echos.c -o server
student@cselab-desktop:~$ ./server

Echo Server ready,waiting for client....
student@cselab-desktop:~$

Terminal 2: (Client)
student@cselab-desktop:~$ gcc echoc.c -o client
/tmp/cc0rsfpG.o: In function `main':
echoc.c:(.text+0x8b): warning: the `gets' function is dangerous and should not be used.
student@cselab-desktop:~$ ./client

Client ready....

Client:hi,2k8618...

Server:hi,2k8618...
Client:www.2k8cs.tk

Server:www.2k8cs.tk
Client:end
student@cselab-desktop:~$

TCP Chat - Transmission Control Protocol - Networks & DBMS Lab - C Program

Program:

(tcpserver.c)

// TCP Chat : Server

#include<stdio.h>
#include<string.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
main()
{
    struct sockaddr_in client,server;
    int s,n,sock;
    char b1[100]="",b2[100]="2k8cs.tk";
    s=socket(AF_INET,SOCK_STREAM,0);
    server.sin_family=AF_INET;
    server.sin_port=2000;
    server.sin_addr.s_addr=inet_addr("127.0.0.1");
    bind(s,(struct sockaddr *)&server,sizeof server);
    listen(s,1);
    printf("\nServer ready,waiting for client....\n");
    n=sizeof client;
    sock=accept(s,(struct sockaddr *)&client,&n);

    for(;;)
    {
        recv(sock,b1,sizeof b1,0);
        if(strcmp(b1,"end")==0)
            break;
        printf("\nClient:%s",b1);
        printf("\nServer:");
        gets(b2);
        send(sock,b2,sizeof b2,0);
        if(strcmp(b2,"end")==0)
            break;

    }
    close(sock);
    close(s);
}

(tcpclient.c)

// TCP Chat : Client

#include<stdio.h>
#include<string.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
main()
{
    struct sockaddr_in client,server;
    int s,sock;
    char b1[100]="",b2[100]="2k8cs.tk";
    s=socket(AF_INET,SOCK_STREAM,0);
    server.sin_family=AF_INET;
    server.sin_port=2000;
    server.sin_addr.s_addr=inet_addr("127.0.0.1");
    printf("\nClient ready....\n");
    connect(s,(struct sockaddr *)&server,sizeof server);
    for(;;)
    {
        printf("\nClient:");
        gets(b2);
        send(s,b2,sizeof b2,0);
        if(strcmp(b2,"end")==0)
            break;
        recv(s,b1,sizeof b1,0);
        if(strcmp(b1,"end")==0)
            break;
        printf("\nServer:%s",b1);
    }
    close(s);
}
Output:

Terminal 1: (Server)

nn@linuxmint ~ $ gcc tcps.c -o server
/tmp/cch4cSzA.o: In function `main':
tcps.c:(.text+0x18e): warning: the `gets' function is dangerous and should not be used.
nn@linuxmint ~ $ ./server

Server ready,waiting for client....

Client:hi,2k8618...
Server:hi...

Client:your site is helpful...
Server:thanks

Client:ok.bye...
Server:bye
nn@linuxmint ~ $

Terminal 2: (Client)

nn@linuxmint ~ $ gcc tcpc.c -o client
/tmp/cc73fkiv.o: In function `main':
tcpc.c:(.text+0xf2): warning: the `gets' function is dangerous and should not be used.
nn@linuxmint ~ $ ./client

Client ready....

Client:hi,2k8618...

Server:hi...
Client:your site is helpful...

Server:thanks
Client:ok.bye...

Server:bye
Client:end
nn@linuxmint ~ $

Parser for SWITCH Statements - YACC Program - Compiler Design

Program:
(sw.l)
alpha [A-Za-z]
digit [0-9]
%%
[ \t\n]
switch    return SWITCH;
case return CASE;
break return BREAK;
default return DEFAULT;
{digit}+    return NUM;
{alpha}({alpha}|{digit})*    return ID;
"<="    return LE;
">="    return GE;
"=="    return EQ;
"!="    return NE;
"||"    return OR;
"&&"    return AND;
.    return yytext[0];
%%

(sw.y)
%{
#include <stdio.h>
#include <stdlib.h>
%}
%token ID NUM SWITCH CASE DEFAULT BREAK LE GE EQ NE OR AND ELSE
%right '='
%left AND OR
%left '<' '>' LE GE EQ NE
%left '+''-'
%left '*''/'
%right UMINUS
%left '!'
%%

S       : ST {printf("Input accepted.\n");exit(0);}
         ;
ST    :    SWITCH '(' ID ')' '{' B '}'
   ;

B :    C
   |    C    D
;

C :    C    C
|    CASE NUM ':' E ';'
      | BREAK ';'
      ;

D :    DEFAULT    ':' E ';' BREAK ';'
;

E    : ID'='E
    | E'+'E
    | E'-'E
    | E'*'E
    | E'/'E
    | E'<'E
    | E'>'E
    | E LE E
    | E GE E
    | E EQ E
    | E NE E
    | E OR E
    | E AND E
    | ID
    | NUM
    ;

%%

#include "lex.yy.c"

main()
{
printf("Enter the exp: ");
yyparse();
}

Output:
students@cselab-desktop:~$ lex sw.l
students@cselab-desktop:~$ yacc sw.y
conflicts: 2 shift/reduce
students@cselab-desktop:~$ gcc y.tab.c -ll -ly
students@cselab-desktop:~$ ./a.out
Enter the exp: switch(a)
{
case 1: a=1;
    break;
case 2: a=2;
    break;
default:a=0;
break;
}
Input accepted.
students@cselab-desktop:~$

Parser for DO WHILE Statements - YACC Program - Compiler Design

Program:

(dowh.l)
alpha [A-Za-z]
digit [0-9]
%%
[ \t\n]
do    return DO;
while    return WHILE;
{digit}+    return NUM;
{alpha}({alpha}|{digit})*    return ID;
"<="    return LE;
">="    return GE;
"=="    return EQ;
"!="    return NE;
"||"    return OR;
"&&"    return AND;
.    return yytext[0];
%%

(dowh.y)
%{
#include <stdio.h>
#include <stdlib.h>
%}
%token ID NUM DO WHILE LE GE EQ NE OR AND
%right '='
%left AND OR
%left '<' '>' LE GE EQ NE
%left '+''-'
%left '*''/'
%right UMINUS
%left '!'

%%

S : ST1 {printf("Input accepted.\n");exit(0);};
ST1    :    DO '{' ST '}' WHILE'(' E2 ')'';';
ST    :     ST ST
        | E';'
          ;
E : ID'='E
   | E'+'E
   | E'-'E
   | E'*'E
   | E'/'E
   | E'<'E
   | E'>'E
   | E LE E
   | E GE E
   | E EQ E
   | E NE E
   | E OR E
       | E AND E
   | ID
   | NUM
   ;
E2 : E'<'E
   | E'>'E
   | E LE E
   | E GE E
   | E EQ E
   | E NE E
   | E OR E
   | E AND E
   | ID
   | NUM
   ;

%%

#include "lex.yy.c"

main()
{
   printf("Enter the exp: ");
   yyparse();
}

Output:

students@ccflab-desktop:~$ lex dowh.l
students@ccflab-desktop:~$ yacc dowh.y
conflicts: 2 shift/reduce
students@ccflab-desktop:~$ gcc y.tab.c -ll -ly
students@ccflab-desktop:~$ ./a.out
Enter the exp: do{a=b+1;}while(a<10);
Input accepted.
students@ccflab-desktop:~$

Parser for WHILE Statements - YACC Program - Compiler Design

Program:

(wh.l)

alpha [A-Za-z]
digit [0-9]
%%
[ \t\n]
while    return WHILE;
{digit}+    return NUM;
{alpha}({alpha}|{digit})*    return ID;
"<="    return LE;
">="    return GE;
"=="    return EQ;
"!="    return NE;
"||"    return OR;
"&&"    return AND;
.    return yytext[0];
%%

(wh.y)

%{
#include <stdio.h>
#include <stdlib.h>
%}
%token ID NUM WHILE LE GE EQ NE OR AND
%right '='
%left AND OR
%left '<' '>' LE GE EQ NE
%left '+''-'
%left '*''/'
%right UMINUS
%left '!'
%%
S    : ST1 {printf("Input accepted.\n");exit(0);};
ST1    :    WHILE'(' E2 ')' '{' ST '}'
ST    :     ST ST
        | E';'
          ;
E : ID'='E
| E'+'E
| E'-'E
      | E'*'E
| E'/'E
| E'<'E
      | E'>'E
| E LE E
      | E GE E
| E EQ E
| E NE E
      | E OR E
| E AND E
      | ID
| NUM
;
E2 : E'<'E
      | E'>'E
| E LE E
| E GE E
| E EQ E
| E NE E
| E OR E
      | E AND E
      | ID
      | NUM
      ;

%%

#include "lex.yy.c"

main()
{
   printf("Enter the exp: ");
   yyparse();
}

Output:

students@ccflab-desktop:~$ lex wh.l
students@ccflab-desktop:~$ yacc wh.y
conflicts: 2 shift/reduce
students@ccflab-desktop:~$ gcc y.tab.c -ll -ly
students@ccflab-desktop:~$ ./a.out
Enter the exp: while(a>1){ b=1;}
Input accepted.

Parser for IF-THEN-ELSE Statements - YACC Program - Compiler Design

Program:

(Lex Program: ift.l)
alpha [A-Za-z]
digit [0-9]
%%
[ \t\n]
if    return IF;
then    return THEN;
else    return ELSE;
{digit}+    return NUM;
{alpha}({alpha}|{digit})*    return ID;
"<="    return LE;
">="    return GE;
"=="    return EQ;
"!="    return NE;
"||"    return OR;
"&&"    return AND;
.    return yytext[0];
%%

(Yacc Program: ift.y)

%{
#include <stdio.h>
#include <stdlib.h>
%}
%token ID NUM IF THEN LE GE EQ NE OR AND ELSE
%right '='
%left AND OR
%left '<' '>' LE GE EQ NE
%left '+''-'
%left '*''/'
%right UMINUS
%left '!'
%%

S    : ST {printf("Input accepted.\n");exit(0);};
ST    : IF '(' E2 ')' THEN ST1';' ELSE ST1';'
        | IF '(' E2 ')' THEN ST1';'
      ;
ST1 : ST
        | E
        ;
E    : ID'='E
      | E'+'E
      | E'-'E
      | E'*'E
      | E'/'E
      | E'<'E
      | E'>'E
      | E LE E
      | E GE E
      | E EQ E
      | E NE E
      | E OR E
      | E AND E
      | ID
      | NUM
      ;
E2 : E'<'E
      | E'>'E
      | E LE E
      | E GE E
      | E EQ E
      | E NE E
      | E OR E
      | E AND E
      | ID
      | NUM
      ;

%%

#include "lex.yy.c"

main()
{
printf("Enter the exp: ");
yyparse();
}

Output:

students@cselab-desktop:~$ lex ift.lex
students@cselab-desktop:~$ yacc ift.y
students@cselab-desktop:~$ gcc y.tab.c -ll -ly
students@cselab-desktop:~$ ./a.out
Enter the exp: if(a==1) then b=1; else b=2;
Input accepted.
students@cselab-desktop:~$

Expression Evaluation - Yacc Program - Compiler Design

Program:

// Yacc Program: expr.y

%{
#include"stdio.h"
%}
%token DIGIT
%%
S       : E '\n' {printf("%d\n",$1);return 1;}
        ;
E       : E '+' T { $$ = $1 + $3 ;}
        | T
        ;
T       :T '-' FF { $$ = $1 - $3 ;}
        | FF
        ;
FF      :FF '/' FFF { $$ = $1 / $3 ;}
        |FFF;
FFF     :FFF '*' F { $$ =$1*$3 ;}
        |F
        ;
F       : '(' E ')' { $$ = $2 ;}
        |DIGIT
        ;
%%
yylex()
{
int c;
c=getchar();
if(isdigit(c))
{
        yylval=c-'0';
        return DIGIT;
}
return c;
}

main()
{
printf("Enter the exp:");
yyparse();
}

Output:
nn@linuxmint ~ $ lex io.l
nn@linuxmint ~ $ yacc expr.y
nn@linuxmint ~ $ gcc y.tab.c -ll -ly
nn@linuxmint ~ $ ./a.out
Enter the exp:5*(5+1)-9/2
26
nn@linuxmint ~ $