Lex and Yacc Program for Practice
Program 1 :- Lex program to implement validate tokens using regular expression.
Lex Program
digit [0-9]
alpha [a-zA-Z_]
%%
{alpha}({alpha}|{digit})* { printf("Identifier=%s",yytext); }
({digit})+ { printf("Number=%s",yytext); }
%%
int yywrap(void)
{ return 1; }
int main()
{
yylex();
return 0;
}
Program 2:- Lex program to implement to count valid tokens using regular expression.
Lex Programm
%{
int count1,count2;
%}
digit [0-9]
alpha [a-zA-Z_]
%%
{alpha}({alpha}|{digit})* { count1++; }
({digit})+ { count2++; }
%%
int yywrap(void)
{ return 1; }
int main(int argc,char* argv[])
{
yyin=fopen(argv[1],"r");
yylex();
printf("Number of Identifier=%d,Number of Numeric=%d",count1,count2);
return 0;
}
Program 3:- Yacc program to implement syntax analyzer for declaration statement using context
free grammar.
S -> D V
D -> INT
| FLOAT
V : ID ;
| ID , V
Lex Program
%{
#include "y.tab.h"
void yyerror(char*);
%}
alpha [a-zA-Z_]
digit [0-9]
%%
"float" { return FLOAT; }
"int" { return INT; }
{alpha}({alpha}|{digit})* { return ID; }
[,;\n] { return *yytext; }
[ \t] { ; }
. { yyerror("invalid character"); exit(0); }
%%
int yywrap(void)
{ return 1; }
Yacc Program
%{
#include<stdlib.h>
#include<stdio.h>
int yylex(void);
void yyerror(char*);
%}
%token ID
%token FLOAT INT
%%
S : D V '\n' { printf("Valid statement"); }
;
D : INT { }
| FLOAT { }
;
V : ID ';' { }
| ID ',' V { }
;
%%
void yyerror(char* s)
{
fprintf(stderr,"%s",s);
}
int main()
{
yyparse();
return 0;
}
Program 4:-Yacc program to implement syntax analyzer for while statement using context free
grammar.
stmt -> stmt S
| stmt '\n'
S -> While C ExpStmt End While
C -> ID Rel ID
ExpStmt -> ExpStmt Exp
Exp-> ID '=' Exp
| Exp '+' Exp
| Exp '-' Exp
| ID
Lex Program
%{
#include "y.tab.h"
void yyerror(char *);
%}
%%
[\t ]+ /* ignore */ ;
while { return While; }
End { return End; }
"<" { yylval.string_value=strdup(yytext);
return Rel; }
[-=+*\n,;] { return *yytext; }
int { return INT; }
float { return FLOAT; }
[a-zA-Z0-9]+ {
yylval.string_value = strdup(yytext );
return ID;
};
. { yyerror("Invalid Tokens"); }
%%
Yacc Program
%{
#include<stdio.h>
#include<string.h>
void yyerror(char*);
void Gen(char*);
int i,j,f,k=0,count=0,l=0;
char *Array[50][50],temp[50];
char *prev="t0";
extern FILE *yyin;
%}
%union {
char *string_value;
}
%token <string_value> ID
%token <string_value> Rel
%type <string_value> stmt S ExpStmt Exp
%type <string_value> C
%token INT FLOAT While End
%%
stmt : stmt S { printf("Valid While"); }
| stmt '\n' { }
| { }
;
S : While C ExpStmt End While '\n' { }
;
C : ID Rel ID '\n' { }
;
ExpStmt : ExpStmt Exp '\n' { }
| { }
;
Exp: ID '=' Exp { }
| Exp '+' Exp { }
| Exp '-' Exp { }
| ID { }
;
%%
int yywrap() { return 1; }
void yyerror(char *s)
{
fprintf(stderr,"%s",s);
}
int main( int argc, char **argv ) {
yyin=fopen(argv[1],"r");
yyparse();
return 1;
}
Program 5:- Yacc program to implement semantic analyzer for given context free grammar.
S -> E
E -> E + E
|E–E
| id
| num
Lex Program
%{
#include "y.tab.h"
void yyerror(char*);
%}
alpha [a-zA-Z_]
digit [0-9]
%%
{alpha}({alpha}|{digit})* { return ID; }
{digit}+ { return NUM }
[,;\n] { return *yytext; }
[ \t] { ; }
. { yyerror("invalid character"); exit(0); }
%%
int yywrap(void)
{ return 1; }
Yacc Program
%{
#include<stdlib.h>
#include<stdio.h>
int yylex(void);
void yyerror(char*);
%}
%token ID
%token FLOAT INT
%%
S : E '\n' { printf(" Value of Expression is = %d”,$1); }
;
E : E ‘+’ E { $$=$1 + $3; }
| E ‘-’ E { $$=$1 - $3; }
| id { $$=$1; }
| num { $$=$1; }
;
%%
void yyerror(char* s)
{
fprintf(stderr,"%s",s);
}
int main()
{
yyparse();
return 0;
}
Program 6:- Yacc program to validate syntax of Declaration and For statement using context free
grammar.
S -> D V NL
| FOR ob1 ass SC cond SC itr cb1 ob2 stmt cb2
ass -> ID EQ ID | ID EQ INTEGER
cond -> ID OP ID | ID OP INTEGER
itr -> ID EQ exp
exp -> exp '+' exp
| exp '-' exp
| exp '*' exp
| ID
| INTEGER
stmt -> S
|ID EQ exp SC stmt
D -> BUILTIN
V -> ID N
N -> ob INTEGER cb N | SC
Lex Program
%{
#include<stdio.h>
#include "y.tab.h"
%}
%%
for return FOR;
int|float|char return BUILTIN;
"," return COMMA;
";" return SC;
"[" return ob;
"]" return cb;
"(" return ob1;
")" return cb1;
"{" return ob2;
"}" return cb2;
"=" return EQ;
">"|"<"|">="|"<="|"!="|"==" return OP;
[a-zA-Z]+[a-zA-Z0-9]* return ID;
[0-9]+ return INTEGER;
\n return NL;
[-+*\n] return *yytext;
%%
Yacc Program
%{
#include<stdio.h>
%}
%token ID BUILTIN SC NL COMMA ob cb INTEGER FOR ob1 cb1 ob2 cb2 EQ OP
%%
s :D V NL {printf("Valid\n"); return 0;}
|FOR ob1 ass SC cond SC itr cb1 ob2 stmt cb2 {printf("Valid\n"); return 0;}
ass :ID EQ ID | ID EQ INTEGER
cond :ID OP ID | ID OP INTEGER
itr :ID EQ exp
exp : exp '+' exp
| exp '-' exp
| exp '*' exp
| ID
| INTEGER
;
stmt :s
|ID EQ exp SC stmt
|
;
D:BUILTIN
V:ID N
N:ob INTEGER cb N | SC
%%
void yyerror()
{
printf("Error\n");
}
int yywrap()
{
return 1;
}
main()
{
yyparse();
}
Program 7: - Yacc program for Intermediate Code Generation
s1 -> s1 s NL
s -> INT V1
| FLOAT V2
| CHAR V3
V1 -> ID SC
|ID COMMA V1
V2 -> ID SC
| ID COMMA V2
V3 -> ID SC
| ID COMMA V3
Lex Program
%{
#include<stdio.h>
#include "y.tab.h"
int yyval;
int c;
%}
%%
int return INT;
float return FLOAT;
char return CHAR;
"," return COMMA;
";" return SC;
[a-z]+ {c = yytext[0]; yylval = c; return ID;}
\n return NL;
%%
Yacc Program
%{
#include<stdio.h>
#include<string.h>
char* temp[50];
%}
%token ID INT FLOAT CHAR SC NL COMMA
%%
s1: |s1 s NL {printf("Valid\n");}
s: INT V1
|FLOAT V2
|CHAR V3
V1: ID SC { sprintf(temp,"\n%c\tint\t%d",$1,sizeof(int));Gen(temp); }
|ID COMMA V1 { sprintf(temp,"\n%c\tint\t%d",$1,sizeof(int));Gen(temp);
}
V2: ID SC { sprintf(temp,"\n%c\tfloat\t%d",$1,sizeof(float));Gen(temp); }
| ID COMMA V2 { sprintf(temp,"\n%c\tfloat\t%d",
$1,sizeof(float));Gen(temp); }
V3: ID SC { sprintf(temp,"\n%c\tchar\t%d",$1,sizeof(char));Gen(temp); }
| ID COMMA V3 { sprintf(temp,"\n%c\tchar\t%d",
$1,sizeof(char));Gen(temp); }
%%
void yyerror()
{
printf("Error\n");
}
int yywrap()
{
return 1;
}
void Gen(char *val)
{
FILE *fo ;
fo=fopen("output.txt","a");
fputs(val,fo);
fclose(fo);
}
main()
{
yyparse();
}
Program 8:- Yacc program for Intermediate Code Generation
S -> IF ob1 COND cb1 ob2 stmt cb2
stmt -> S
| ID EQ exp SC stmt
exp -> exp '+' exp
| exp '-' exp
| exp '*' exp
| ID
COND -> ID OP ID
Lex program
%{
#include "y.tab.h"
#include<stdio.h>
%}
%%
if {return IF;}
"(" return ob1;
")" return cb1;
"{" return ob2;
"}" return cb2;
";" return SC;
[\t ]+
[-+*\n] {return *yytext;}
"=" return EQ;
[a-zA-Z0-9]+ {yylval.string_value = strdup(yytext );return ID;}
">"|"<"|">="|"<="|"!="|"==" {yylval.string_value = strdup(yytext );return OP;}
%%
Yacc Program
%{
#include<stdio.h>
#include<string.h>
void yyerror(char*);
void Gen(char*);
char temp2[50];
%}
%union
{
char *string_value;
}
%type <string_value> exp
%type <string_value> COND
%type <string_value> s
%type <string_value> stmt
%token <string_value> ID
%token <string_value> OP
%token IF ob1 cb1 ob2 cb2 EQ SC
%%
s : IF ob1 COND cb1 ob2 stmt cb2 { sprintf(temp2,"\nt=if(%s){%s}",$3,$6);$
$="t"; Gen(temp2); }
;
stmt :s
|ID EQ exp SC stmt { sprintf(temp2,"\nt=%s=%s",$1,$3); $$="t"; Gen(temp2); }
|
;
exp : exp '+' exp { sprintf(temp2,"\nt=%s+%s",$1,$3); $$="t"; Gen(temp2); }
| exp '-' exp { sprintf(temp2,"\nt=%s-%s",$1,$3); $$="t"; Gen(temp2); }
| exp '*' exp { sprintf(temp2,"\nt=%s*%s",$1,$3); $$="t"; Gen(temp2); }
| ID { $$=$1; }
;
COND :ID OP ID { sprintf(temp2,"\nt=%s %s %s",
$1,$2,$3); $$="t"; Gen(temp2); }
;
%%
void Gen(char *val)
{
FILE *f;
f=fopen("output.txt","a");
fputs(val,f);
fclose(f);
}
int yywrap() { return 1; }
void yyerror(char *s)
{
return;
}
int main( int argc, char **argv ) {
yyparse();
return 1;
}
Program 9:- Yacc program for Code Optimization
st -> ID = exp
exp-> exp + exp
| exp - exp
| exp / exp
| exp * exp
| ( exp )
| NUMBER
| ID
Lex Program
%{
#include"y.tab.h"
extern char yyval;
%}
%%
[0-9]+ {yylval.symbol = (char)yytext[0];return NUMBER;}
[a-zA-Z]+ {yylval.symbol =(char) yytext[0];return ID;}
. {return yytext[0];}
\n {return 0;}
%%
Yacc Program
%{
#include"y.tab.h"
#include<stdio.h>
#include<stdlib.h>
char temp ='A'-1;
int index1=0;
char addtotable(char, char, char);
struct expr{
char operand1;
char operand2;
char operator;
char result;
};
%}
%union{
char symbol;
}
%left '+''-'
%left '*''/'
%token <symbol> NUMBER ID
%type <symbol> exp
%%
st: ID '=' exp ';' {addtotable((char)$1,(char)$3,'=');};
exp: exp '+' exp {$$ = addtotable((char)$1,(char)$3,'+');}
|exp '-' exp {$$ = addtotable((char)$1,(char)$3,'-');}
|exp '/' exp {$$ = addtotable((char)$1,(char)$3,'/');}
|exp '*' exp {$$ = addtotable((char)$1,(char)$3,'*');}
|'(' exp ')' {$$ = (char)$2;}
|NUMBER {$$ = (char)$1;}
|ID {$$=(char)$1;};
%%
struct expr arr[20];
void quad(){
int i;
FILE *f;
f=fopen("output.txt","a");
for(i=0;i<index1;i++){
if(arr[i].operator=='!') continue;
printf("%c:=\t",arr[i].result);
printf("%c\t",arr[i].operand1);
printf("%c\t",arr[i].operand2);
printf("%c\n",arr[i].operator);
fprintf(f,"%c:=\t",arr[i].result);
fprintf(f,"%c\t",arr[i].operand1);
fprintf(f,"%c\t",arr[i].operand2);
fprintf(f,"%c\n",arr[i].operator);
}
fprintf(f,"\n\n\n");
fclose(f);
}
int main(){
temp='A'-1;
FILE *f;
f=fopen("output.txt","a");
printf("Enter the expression\n");
yyparse();
quad();
opt();
printf("After Optimization\n");
quad();
fclose(f);
int yywrap(){
return 1;
}
void yyerror(char *s){
printf("Error %s",s);
}
char addtotable(char a, char b, char c){
temp++;
arr[index1].operand1=a;
arr[index1].operand2=b;
arr[index1].operator=c;
arr[index1].result=temp;
index1++;
return temp;
}
void opt(){
int i,j;
for(i=0;i<index1;i++)
for(int j=i+1;j<index1;j++){
if(arr[i].operator==arr[j].operator && arr[i].operand1 ==arr[j].operand1 && arr[i].operand2 ==
arr[j].operand2){
int z;
for(int z=j+1;z<index1;z++){
if(arr[z].operand1==arr[j].result)
arr[z].operand1=arr[i].result;
if(arr[z].operand2==arr[j].result)
arr[z].operand2=arr[i].result;
}
arr[j].operator='!';
}
}
}
Program 10:- Yacc program for code generation
stmt -> stmt exp1
exp1 -> ID = exp
exp -> exp + exp
| exp '-' exp
| exp '*' exp
| ID
| INTEGER
Lex Program
%{
#include "y.tab.h"
#include<stdio.h>
%}
%%
[\t ]+ /* ignore the blank spaces */ ;
[-+*=\n,;(){}] { return *yytext; }
[a-zA-Z]+ { // return valid tokens to yacc program
yylval.string_value = strdup(yytext );
return ID;
};
[0-9]+ { // return valid tokens to yacc program
yylval.string_value = strdup(yytext );
return INTEGER;
};
%%
Yacc Program
%{
#include<stdio.h>
#include<string.h>
void yyerror(char*);
void Gen(char*);
int i=1,c=0,j,f,count=0,prev,label=100;
char *Array[10][10],*temp,temp1[50],temp2[50];
extern FILE *yyin;
%}
%union {
char *string_value;
}
%type <string_value> exp exp1
%token <string_value> ID
%token <string_value> INTEGER
%%
stmt : stmt exp1 { }
|
;
exp1 :ID '=' exp { sprintf(temp2,"\n%s=%s",$1,$3); $$="t"; Gen(temp2); sprintf(temp2,"\tmov
%s, %s",$1,$3); Gen(temp2); }
exp : exp '+' exp {sprintf(temp2,"\nt=%s+%s",$1,$3); $$="t"; Gen(temp2);sprintf(temp2,"\tmov
A, %s add A, %s mov t, A",$1,$3);Gen(temp2);}
| exp '-' exp {sprintf(temp2,"\nt=%s-%s",$1,$3); $$="t"; Gen(temp2);sprintf(temp2,"\tmov A,
%s sub A, %s mov t, A",$1,$3);Gen(temp2);}
| exp '*' exp {sprintf(temp2,"\nt=%s*%s",$1,$3); $$="t"; Gen(temp2);sprintf(temp2,"\tmov A,
%s mul A, %s mov t, A",$1,$3);Gen(temp2);}
| ID { $$=$1; }
| INTEGER { $$=$1; }
;
%%
void Gen(char *val)
{
FILE *f;
f=fopen("output.txt","a");
fputs(val,f);
fclose(f);
}
int yywrap() { return 1; }
void yyerror(char *s)
{
}
int main( int argc, char **argv ) {
yyparse();
return 1;
}
Command to execute Lex program ( On Linux Platform)
1) lex file.l
2) gcc lex.yyc.
3) ./a.out
Command to execute Yacc program ( On Linux Platform)
1) lex file1.l
2) yacc –d file2.y
3) gcc lex.yy.c y.tab.h
4) ./a.out
