Ex No:6 Type Checker Using YACC

Date: 13-02-18
Aim:
To write a YACC Program to implement the type checker.
Algorithm:
 typecheck: lex.yy.c y.tab.c types.h types.c
o gcc -o typecheck y.tab.c -ly -ll

 lex.yy.c: check.l
o lex check.l

 y.tab.c: check.y
o yacc check.y

 typecheck2: lex.yy.c y.tab.c types.H type.cpp

o g++ -x c++ -o typecheck2 y.tab.c types.cpp -ly -ll

Program:
type.lex
%%
char {return(CHAR_T);}
integer {return(INT_T);}
array {return(ARRAY_T);}
of {return(OF_T);}
\, {return(',');}
\; {return(';');}
\[ {return('[');}
\] {return(']');}
\( {return('(');}
\) {return(')');}
\: {return(':');}
\^ {return(PTR);}
\+ {return('+');}
X {return(CART);}
\-\> {return(MAP);}
\'[a-z]\' {return(LITERAL);}
[a-z]+ {yylval.name = (char*)malloc(strlen(yytext)+1);
strcpy(yylval.name,yytext); return(ID);}
[0-9]* {yyval.value = atoi(yytext);return(NUM);}
[ \t\n] {}
%%
type.yacc
%{
#include <stdio.h>

typedef enum {CHAR,INT,ARRAY,POINTER,CARTESIAN,MAPPING,UNKNOWN} type_info;

S.MUTHU LAKSHMI 15CSE81

 typedef struct tnode {
type_info info;
struct tnode *p1, *p2;
int array_size;
} typenode, *typeptr;

typeptr new_node(type_info info);

typeptr map(),cartesian();
typeptr lookup();
int typematch();

typedef struct s {
char *name;
typeptr t;
struct s *next;
} typetable;
%}
%token ID CHAR_T INT_T ARRAY_T OF_T
%token PTR CART MAP
%token NUM LITERAL
%union{
int value;
char *name;
typeptr type;
}
%type <name> ID
%type <type> TYPE E
%type <value> NUM
%left MAP
%left CART
%left ','
%left '+'
%right PTR
%left '['

%%
P: DL ';' E
;
DL : DL ';' D
| D
;
D: ID ':' TYPE {add_symbol($1,$3); }
;
TYPE : TYPE MAP TYPE {$$ = map($1,$3); }
| TYPE CART TYPE {$$ = cartesian($1,$3); }
| ARRAY_T '[' NUM ']' OF_T TYPE {$$ = array($6,$3); }
| PTR TYPE {$$ = pointer($2); }
| '(' TYPE ')' {$$ = $2; }

S.MUTHU LAKSHMI 15CSE81

 | CHAR_T {$$ = new_node(CHAR); }
| INT_T {$$ = new_node(INT); }
;

E : LITERAL {$$ = new_node(CHAR); }

| NUM {$$ = new_node(INT);}
| ID {$$ = lookup($1); }
| ID '[' E ']' {typeptr t;
t = lookup($1);
if (t->info == ARRAY)
if ($3->info == INT)
$$ = t->p1;
else type_error("array index must be integer");
else type_error("array expected");
}
| ID '(' E ')' {typeptr t;
t = lookup($1);
if (t->info == MAPPING)
if (typematch($3,t->p1))
$$ = t->p2;
else type_error("incorrect actuals");
else type_error("function expected");
}
| E '+' E {if (($1->info == INT) && ($3->info == INT))
$$ = $1;
else type_error("integers expected for +");
}
| E PTR { if ($1->info == POINTER) $$ = $1->p1;
else type_error("pointer expected");
}
| E ',' E { $$ = cartesian($1,$3); }
;
%%
#include "lex.yy.c"

yyerror(s) {
printf("%s line %d\n",s,yylineno);
}

type_error(char *s) {
printf("type error: %s\n",s); exit(42);
}

typeptr char_node, int_node;

main() {
yyparse();

S.MUTHU LAKSHMI 15CSE81

 }

#include "types.c"
/* types.h

typedef enum {CHAR,INT,ARRAY,POINTER,CARTESIAN,MAPPING,UNKNOWN} type_info;

typedef struct tnode {
type_info info;
struct tnode *p1, *p2;
int array_size;
} typenode, *typeptr;

typeptr new_node(type_info info);

typeptr map(),cartesian();

typedef struct s {
char *name;
typeptr t;
struct s *next;
} typetable;
*/

typeptr new_node(type_info info) {

typeptr t;
t = (typeptr)malloc(sizeof(typenode));
t->info = info;
t->p1 = NULL;
t->p2 = NULL;
return t;
}

int typematch(typeptr t1, typeptr t2) {

int v;
if (t1 && t2)
if (t1->info == t2->info)
switch (t1->info) {
case CHAR: return 1;
case INT: return 1;
case ARRAY: if (t1->array_size == t2->array_size)
return typematch(t1->p1,t2->p1);
else return 0;
case POINTER: return typematch(t1->p1, t2->p1);
case CARTESIAN: v = typematch(t1->p1, t2->p1);
if (v) return typematch(t1->p2,t2->p2);
else return 0;
case MAPPING: v = typematch(t1->p1, t2->p1);
if (v) return typematch(t1->p2,t2->p2);

S.MUTHU LAKSHMI 15CSE81

 else return 0;
case UNKNOWN: return 0;
} /* switch */
else return 0;
else if (!t1 && !t2) return 1;
else return 0;
}

typeptr map(typeptr t1,typeptr t2) {

typeptr t;
t = (typeptr)malloc(sizeof(typenode));
t->info = MAPPING;
t->p1 = t1;
t->p2 = t2;
return t;
}

typeptr cartesian(typeptr t1,typeptr t2) {

typeptr t;
t = (typeptr)malloc(sizeof(typenode));
t->info = CARTESIAN;
t->p1 = t1;
t->p2 = t2;
return t;
}

typeptr array(typeptr t1,int size) {

typeptr t;
t = (typeptr)malloc(sizeof(typenode));
t->info = ARRAY;
t->p1 = t1;
t->p2 = NULL;
t->array_size = size;
return t;
}

typeptr pointer(typeptr t1) {

typeptr t;
t = (typeptr)malloc(sizeof(typenode));
t->info = POINTER;
t->p2 = NULL;
t->p1 = t1;
return t;
}

typetable *type_table = NULL;

add_symbol(char *name,typeptr type) {

S.MUTHU LAKSHMI 15CSE81

 typetable *t;
t = (typetable*)malloc(sizeof(typetable));
t->name = (char*)malloc(strlen(name)+1);
strcpy(t->name,name);
t->t = type;
t->next = type_table;
type_table = t;
}

typeptr
lookup(char *name) {
typetable *t;
t = type_table;
while (t) {
if (strcmp(t->name,name) ==0) return t->t;
t = t->next;
}
return NULL;

typedef enum {CHAR,INT,ARRAY,POINTER,CARTESIAN,MAPPING,UNKNOWN} type_info;

typedef struct tnode {
type_info info;
struct tnode *p1, *p2;
int array_size;
} typenode, *typeptr;

typeptr new_node(type_info info);

typeptr map(),cartesian();
typeptr lookup();
int typematch();

typedef struct s {
char *name;
typeptr t;
struct s *next;
} typetable;

Output:
key: integer ;
a: array [20] of integer;
b: array[40] of ^ integer;
b[a[key]]
Correct
key: ^integer ;
a: integer -> integer;

S.MUTHU LAKSHMI 15CSE81

 a(key) + 4

Type Error

Result:
Thus the YACC Program to implement the type checking was executed successfully.

S.MUTHU LAKSHMI 15CSE81

Ex.No:7 STORAGE ALLOCATION STRATEGIES-STACK
Date:20-02-18

AIM:
To write a program in C to implement the storage allocation strategies using stack data
structure.

ALGORITHM:
1. Declare the structure to store return address, parameter etc.
2. Implement the operation of stck i.e push and pop operation.
3. Track the line no of the source program.
4. Fin the pattern for function call in the input program.
5. Then store the next line for return address and parameter in the function call.
6. Push the activation record in to the stack when it is invoked.
7. Pop the activation record when it leaves the control.
PROGRAM:

#include<stdio.h>
#include<conio.h>
#include<string.h>
char str[100];
int top=0;
typedef struct activate{
int return_addr;
char name[10];
char param[10];
}stack;
stack s[100];
void remove_space(){//program which delete white space in txt file
int count=0,i;
for(i=0;str[i];i++){
if(str[i]!=' ')
str[count++]=str[i];
}
str[count]='\0';
}
void push(int line,char *v,char *tmp){//push data to the stack
if(top<99){
strcpy(s[top].name,v);
strcpy(s[top].param,tmp);
s[top].return_addr=line;

S.MUTHU LAKSHMI 15CSE81

 top++;
}else{
printf("Stack overflow");
}
}
int pop(){//pop data from the stack
--top;
if(top==-1){
return 0;
}
printf("Function name is %s return address %d\n",s[top].name,s[top].return_addr);
printf("function contains %s parameters \n\n",s[top].param);
return 1;
}
void display(){
while(pop());//pop the data until stack is empty
}
void built(int line,int flag){//the function which seperate the function name and parameter
char *v=strtok(str,"("),*tmp=strtok(NULL,")");
if(flag==0){
push(++line,v,"No");
}else{
push(++line,v,tmp);
}
}
void main(){
FILE *fp;
int line=0,f=0,len;
char *re;
clrscr();
fp=fopen("inp.txt","r");
while(fgets(str,100,fp)){
++line;
remove_space();
re = strtok(str,";");
len=strlen(re);
if(f==0){//check for main function
char *v=strtok(re,"(");
if(strcmp(v,"main")==0)
f=1;
}else{//condition for identify function call
if(re[len-1]==')' && re[len-2]=='('){

S.MUTHU LAKSHMI 15CSE81

 built(line,0);
}else{
if(re[len-1]==')')
built(line,1);
}
}
}
display();//call the display fn to pop all elements from stack
getch();
}
InputFile(Inp.txt)
main(){
call();
callp(a,b);
}
OUTPUT:

RESULT:
Thus the program to implement the stack storage allocation strategies in runtime
storage management using c was compiled and executed.

S.MUTHU LAKSHMI 15CSE81

Ex.No.8 SIMPLE CODE OPTIMIZER
DATE: 27-02-18

Aim:
To design a simple code optimizer which performs,

1. Reduction in strength
2. Algebraic expression elimination
3. Constant folding

Algorithm:

1. Get the set of three address codes.

2. Check if there is any possibility of Reduction in strength, Algebraic expression elimination and
Constant folding
3. Perform the necessary optimizations.
4. Display the resultant code.

Program:

#include<stdio.h>
#include<conio.h>
#include<string.h>
#include<math.h>

struct instruction
{
char res[10];
char op1[10];
char oper[10];
char op2[10];
}ins[20];

void main()
{
char s,ass[2],t[10];
FILE *fp;
int len,i,count,j,k,temp,m,n,o1,o2;
clrscr();
fp=fopen("inp.txt","w");
printf("Enter the 3 address codes\n");
scanf("%c",&s);

S.MUTHU LAKSHMI 15CSE81

while(s!='$')
{
fputc(s,fp);
scanf("%c",&s);
}
fclose(fp);
fp=fopen("inp.txt","r");
i=1;
while(!feof(fp))
{
fscanf(fp,"%s%s%s%s%s",ins[i].res,ass,ins[i].op1,ins[i].oper,ins[i].op2);
i++;
}
fclose(fp);
i--;
count=i;
printf("\nUnOptimized Three Address Codes are :: \n");
for(i=1;i<=count;i++)
{
printf("%s=%s%s%s\n",ins[i].res,ins[i].op1,ins[i].oper,ins[i].op2);
}

//Reduction in Strength
for(i=1;i<=count;i++)
{
if(strcmp(ins[i].oper,"**")==0)
{
if(strcmp(ins[i].op2,"2")==0)
{
strcpy(ins[i].oper,"*");
strcpy(ins[i].op2,ins[i].op1);
printf("\nTYPE :: REDUCTION IN STRENGTH\n");
printf("%s=%s%s%s\n\n",ins[i].res,ins[i].op1,ins[i].oper,ins[i].op2);
}
}
}

//Algebaric Expression Elimination

for(i=1;i<=count;i++)
{
if(strcmp(ins[i].oper,"+")==0 || strcmp(ins[i].oper,"-")==0)
{

S.MUTHU LAKSHMI 15CSE81

 if(strcmp(ins[i].op2,"0")==0)
{
strcpy(ins[i].oper,"");
strcpy(ins[i].op2,"");
printf("\nTYPE :: ALGEBARIC EXPRESSION ELIMINATION\n");
printf("%s=%s%s%s\n\n",ins[i].res,ins[i].op1,ins[i].oper,ins[i].op2);
}
}
if(strcmp(ins[i].oper,"/")==0 || strcmp(ins[i].oper,"*")==0)
{
if(strcmp(ins[i].op2,"1")==0)
{
strcpy(ins[i].oper,"");
strcpy(ins[i].op2,"");
printf("\nTYPE :: ALGEBARIC EXPRESSION ELIMINATION\n");
printf("%s=%s%s%s\n\n",ins[i].res,ins[i].op1,ins[i].oper,ins[i].op2);
}
}
}

//Constant Folding
for(i=1;i<=count;i++)
{
j=ins[i].op1[0]-48;
k=ins[i].op2[0]-48;
if(j>=0&&j<=9&&k>=0&&k<=9)
{
len=strlen(ins[i].op1);
n=pow(10,len-1);
temp=0;
for(m=0;m<len;m++)
{
temp+=(ins[i].op1[m]-48)*n;
n/=10;
}
o1=temp;

len=strlen(ins[i].op2);
n=pow(10,len-1);
temp=0;
for(m=0;m<len;m++)
{

S.MUTHU LAKSHMI 15CSE81

 temp+=(ins[i].op2[m]-48)*n;
n/=10;
}
o2=temp;
printf("%d %d",o1,o2);
if(strcmp(ins[i].oper,"+")==0)
{
temp=o1+o2;
sprintf(t,"%d",temp);
strcpy(ins[i].op1,t);
strcpy(ins[i].oper,"");
strcpy(ins[i].op2,"");
}
if(strcmp(ins[i].oper,"-")==0)
{
temp=o1-o2;
sprintf(t,"%d",temp);
strcpy(ins[i].op1,t);
strcpy(ins[i].oper,"");
strcpy(ins[i].op2,"");
}
if(strcmp(ins[i].oper,"/")==0)
{
temp=o1/o2;
sprintf(t,"%d",temp);
strcpy(ins[i].op1,t);
strcpy(ins[i].oper,"");
strcpy(ins[i].op2,"");
}
if(strcmp(ins[i].oper,"*")==0)
{
temp=o1*o2;
sprintf(t,"%d",temp);
strcpy(ins[i].op1,t);
strcpy(ins[i].oper,"");
strcpy(ins[i].op2,"");
}
printf("\nTYPE :: CONSTANT FOLDING\n");
printf("%s=%s%s%s\n\n",ins[i].res,ins[i].op1,ins[i].oper,ins[i].op2);
}
}

S.MUTHU LAKSHMI 15CSE81

 printf("\nOptimized Three Address Codes\n");
for(i=1;i<=count;i++)
{
printf("%s=%s%s%s;\n",ins[i].res,ins[i].op1,ins[i].oper,ins[i].op2);
}
getch();
}

Output:

RESULT:
Thus the C program to implement simple code generator is successfully executed and
the output is verified.

S.MUTHU LAKSHMI 15CSE81

Ex.No:9
Date: 06-03-18 DAG

AIM:
To write a C program to implement DAG.

ALGORITHM:

Step 1: Input the three address code in a file.

Step 2: check the input if it not present interduce it and mark its left and right value,if it is then
append it to the already added one
Step 3: keep doing the second step until the whole tree is constructed

PROGRAM:
#include<stdio.h>
#include<graphics.h>
#include<conio.h>
struct val
{
int op1[10];
int op2[10];
char ope[10];
int num;
}v[10];
void main()
{
FILE *f;
char c,var[20][5],s[5],left[5],op1[5],op2[5],ope[5];
int i,j,tot,k;
clrscr();
f=fopen("inp.c","w");
scanf("%c",&c);
while(c!='$')
{
fputc(c,f);
scanf("%c",&c);
}
fclose(f);
//ASCII VALUES a-->97 z-->122 A-->65 Z-->90
f=fopen("inp.c","r");
tot=0;

S.MUTHU LAKSHMI 15CSE81

while(!feof(f))
{
fscanf(f,"%s",s);
k=s[0];
if((k>=97&&k<=122)||(k>=65&&k<=90))
{
j=0;
for(i=0;i<=tot;i++)
{
if(strcmp(var[i],s)==0)
{
j=1;
}
}
if(j==0)
{
strcpy(var[tot],s);
tot++;
}
}
}
for(i=0;i<tot;i++)
{
v[i].num=0;
}
rewind(f);
while(!feof(f))
{
fscanf(f,"%s%s%s%s%s",left,s,op1,ope,op2);
for(i=0;i<tot;i++)
{
if(strcmp(var[i],left)==0)
{
for(j=0;j<tot;j++)
{
if(strcmp(var[j],op1)==0)
{
v[i].op1[v[i].num]=j;
}
}
for(j=0;j<tot;j++)
{

S.MUTHU LAKSHMI 15CSE81

 if(strcmp(var[j],op2)==0)
{
v[i].op2[v[i].num]=j;
}
}
v[i].ope[v[i].num]=ope[0];
v[i].num++;
}
}
}
printf("\nLOCATION\tVARIABLE\n");
printf("\n~~~~~~~~\t~~~~~~~~\n");
for(i=0;i<tot;i++)
{
printf("%d\t\t%s\n",i,var[i]);
}
printf("\nDAGs\n");
printf("~~~~\n");
for(i=0;i<tot;i++)
{
if(v[i].num>0)
{
for(j=0;j<v[i].num;j++)
{
printf("\t %c,%d\n\n",v[i].ope[j],i);
printf("\t%d\t%d\n\n\n\n\n",v[i].op1[j],v[i].op2[j]);
}
}
}
fclose(f);
getch();
}

S.MUTHU LAKSHMI 15CSE81

Output
~~~~~

RESULT:
Thus the C program to implement DAG is successfully executed and the output is
verified.

S.MUTHU LAKSHMI 15CSE81

Ex:10 Control Flow Analysis
Date:14-03-18
Aim:
To write a program in java to implement the control flow analysis by constructing control flow
graph for three address code statements.

Algorithm:
 Create a text file to store the sequence of three address code statements.
 Next generate the quadruple array using List in Java.
 Track each and every statement in text file in turn and identify the keyword GOTO is
available.
 And track the target of GOTO and generate the Control flow graph.

Program:
import java.beans.Statement;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class lab9 {
public static void writeFile(String filename) throws Exception
{
FileWriter writer = new FileWriter(filename, false);
BufferedWriter bufferedWriter = new BufferedWriter(writer);
Scanner s = new Scanner(System.in);
while(true)
{
String input = s.nextLine();
if(input.contains("end")|input.contains("END"))
break;
bufferedWriter.write(input);
bufferedWriter.newLine();
}
bufferedWriter.close();
}
public static List<String> readFile(String filename) throws Exception
{
FileReader reader = new FileReader(filename);

S.MUTHU LAKSHMI 15CSE81

 BufferedReader bufferedReader = new BufferedReader(reader);
String line;
List<String> statements = new ArrayList<String>();
statements.clear();
int i=1;
while ((line = bufferedReader.readLine()) != null) {
statements.add(line);
System.out.println("("+(i++)+") "+ line);
}
reader.close();
return statements;
}
public static void flowFind(List<String> statements)
{
for(int i=0; i<statements.size();i++)
{
System.out.print(i+1);
if(i!=statements.size()-1)
System.out.print("->");
if(statements.get(i).contains("goto"))
{
System.out.print("-
>"+statements.get(i).substring(statements.get(i).lastIndexOf("goto")+5));
System.out.println();
}
}
}
public static void sttFlowFind(List<String> statements)
{
for(int i=0; i<statements.size();i++)
{
System.out.print(statements.get(i));
if(i!=statements.size()-1)
System.out.print("->");
if(statements.get(i).contains("goto"))
{
System.out.print("->"+statements.get(Integer.parseInt(statements.get(i).substring
(statements.get(i).lastIndexOf ("goto")+5))-1));
System.out.println();
}
}
}

S.MUTHU LAKSHMI 15CSE81

 public static void main(String[] args) throws Exception {
String file = "myfile.txt";
System.out.println("Write Statements");
writeFile(file);
System.out.println("Statements");
List<String> statements = readFile(file);
System.out.println("Flow");
flowFind(statements);
System.out.println("Statements Execution Flow");
sttFlowFind(statements);
}
}

Output:

Result:
Thus the program to construct the control flow graph for the three address quadruple
statement was compiled and executed.

S.MUTHU LAKSHMI 15CSE81

Ex.No:11 DATA FLOW ANALYSIS
Date:14-03-18

AIM:
To write a C program to implement data flow analysis for the three address code.
ALGORITHM:

Step 1: Input the three address code in a file.

Step 2: Separate the left and right side operands and store those as GEN(s) and In(s)
respectively.
Step 3: Find the Out(s) from the Gen(s) and In(s).
PROGRAM:
#include<stdio.h>
#include<conio.h>
int kill[20],k=0,l=0,out[100];
void find_kill(char *a,int l1,char *b,int l2){
int i,j;
for(i=0;i<l1;i++){
for(j=0;j<l2;j++){
if(a[i]==b[j]){
kill[k++]=a[i];
}
}
}
}
void main(){
char gen[100],in[100];
char *g,*asg,*i1,*op,*i2;
int i,p1=0,p2=0,j;
FILE *fp;
clrscr();
fp=fopen("inp.txt","r");
while(!feof(fp)){
fscanf(fp,"%s%s%s%s%s",g,asg,i1,op,i2);
gen[p1++]=g[0];
out[l++]=g[0];
out[l++]=i1[0];
out[l++]=i2[0];
in[p2++]=i1[0];
in[p2++]=i2[0];
}
gen[p1]='\0';
in[p2]='\0';
find_kill(gen,p1,in,p2);
printf("Generator of s is\n");
for(i=0;i<p1;i++){

S.MUTHU LAKSHMI 15CSE81

 printf("\t%c",gen[i]);
}
printf("\nInput of s is \n");
for(i=0;i<p2;i++){
printf("\t%c",in[i]);
}
printf("\nKill of s is \n");
for(i=0;i<k;i++)
printf("\t%c",kill[i]);
printf("\nOut of s is \n");
for(i=0;i<l;i++){
for(j=0;j<k;j++){
if(i==0)
printf("\t%c",kill[j]);
if(kill[j]!=out[i]){
printf("\t%c",out[i]);
}
}
}
getch();
}
Input:

z=a+b
x=u-v
a=i+j

Output:

RESULT:
Thus the C program to implement data flow analysis for the three address code is
successfully executed and the output is verified.

S.MUTHU LAKSHMI 15CSE81

Ex No:12 Type Checker Using YACC
DATE:21-03-18
Aim:
To write a YACC Program to implement the type checker.
Algorithm:
 typecheck: lex.yy.c y.tab.c types.h types.c
o gcc -o typecheck y.tab.c -ly -ll

 lex.yy.c: check.l
o lex check.l

 y.tab.c: check.y
o yacc check.y

 typecheck2: lex.yy.c y.tab.c types.H type.cpp

o g++ -x c++ -o typecheck2 y.tab.c types.cpp -ly -ll

Program:
type.lex
%%
char {return(CHAR_T);}
integer {return(INT_T);}
array {return(ARRAY_T);}
of {return(OF_T);}
\, {return(',');}
\; {return(';');}
\[ {return('[');}
\] {return(']');}
\( {return('(');}
\) {return(')');}
\: {return(':');}
\^ {return(PTR);}
\+ {return('+');}
X {return(CART);}
\-\> {return(MAP);}
\'[a-z]\' {return(LITERAL);}
[a-z]+ {yylval.name = (char*)malloc(strlen(yytext)+1);
strcpy(yylval.name,yytext); return(ID);}
[0-9]* {yyval.value = atoi(yytext);return(NUM);}
[ \t\n] {}
%%
type.yacc
%{
#include <stdio.h>

typedef enum {CHAR,INT,ARRAY,POINTER,CARTESIAN,MAPPING,UNKNOWN} type_info;

S.MUTHU LAKSHMI 15CSE81

 typedef struct tnode {
type_info info;
struct tnode *p1, *p2;
int array_size;
} typenode, *typeptr;

typeptr new_node(type_info info);

typeptr map(),cartesian();
typeptr lookup();
int typematch();

typedef struct s {
char *name;
typeptr t;
struct s *next;
} typetable;
%}
%token ID CHAR_T INT_T ARRAY_T OF_T
%token PTR CART MAP
%token NUM LITERAL
%union{
int value;
char *name;
typeptr type;
}
%type <name> ID
%type <type> TYPE E
%type <value> NUM
%left MAP
%left CART
%left ','
%left '+'
%right PTR
%left '['

%%
P: DL ';' E
;
DL : DL ';' D
| D
;
D: ID ':' TYPE {add_symbol($1,$3); }
;
TYPE : TYPE MAP TYPE {$$ = map($1,$3); }
| TYPE CART TYPE {$$ = cartesian($1,$3); }
| ARRAY_T '[' NUM ']' OF_T TYPE {$$ = array($6,$3); }
| PTR TYPE {$$ = pointer($2); }
| '(' TYPE ')' {$$ = $2; }

S.MUTHU LAKSHMI 15CSE81

 | CHAR_T {$$ = new_node(CHAR); }
| INT_T {$$ = new_node(INT); }
;

E : LITERAL {$$ = new_node(CHAR); }

| NUM {$$ = new_node(INT);}
| ID {$$ = lookup($1); }
| ID '[' E ']' {typeptr t;
t = lookup($1);
if (t->info == ARRAY)
if ($3->info == INT)
$$ = t->p1;
else type_error("array index must be integer");
else type_error("array expected");
}
| ID '(' E ')' {typeptr t;
t = lookup($1);
if (t->info == MAPPING)
if (typematch($3,t->p1))
$$ = t->p2;
else type_error("incorrect actuals");
else type_error("function expected");
}
| E '+' E {if (($1->info == INT) && ($3->info == INT))
$$ = $1;
else type_error("integers expected for +");
}
| E PTR { if ($1->info == POINTER) $$ = $1->p1;
else type_error("pointer expected");
}
| E ',' E { $$ = cartesian($1,$3); }
;
%%
#include "lex.yy.c"

yyerror(s) {
printf("%s line %d\n",s,yylineno);
}

type_error(char *s) {
printf("type error: %s\n",s); exit(42);
}

typeptr char_node, int_node;

main() {
yyparse();

S.MUTHU LAKSHMI 15CSE81

 }

#include "types.c"
/* types.h

typedef enum {CHAR,INT,ARRAY,POINTER,CARTESIAN,MAPPING,UNKNOWN} type_info;

typedef struct tnode {
type_info info;
struct tnode *p1, *p2;
int array_size;
} typenode, *typeptr;

typeptr new_node(type_info info);

typeptr map(),cartesian();

typedef struct s {
char *name;
typeptr t;
struct s *next;
} typetable;
*/

typeptr new_node(type_info info) {

typeptr t;
t = (typeptr)malloc(sizeof(typenode));
t->info = info;
t->p1 = NULL;
t->p2 = NULL;
return t;
}

int typematch(typeptr t1, typeptr t2) {

int v;
if (t1 && t2)
if (t1->info == t2->info)
switch (t1->info) {
case CHAR: return 1;
case INT: return 1;
case ARRAY: if (t1->array_size == t2->array_size)
return typematch(t1->p1,t2->p1);
else return 0;
case POINTER: return typematch(t1->p1, t2->p1);
case CARTESIAN: v = typematch(t1->p1, t2->p1);
if (v) return typematch(t1->p2,t2->p2);
else return 0;
case MAPPING: v = typematch(t1->p1, t2->p1);
if (v) return typematch(t1->p2,t2->p2);

S.MUTHU LAKSHMI 15CSE81

 else return 0;
case UNKNOWN: return 0;
} /* switch */
else return 0;
else if (!t1 && !t2) return 1;
else return 0;
}

typeptr map(typeptr t1,typeptr t2) {

typeptr t;
t = (typeptr)malloc(sizeof(typenode));
t->info = MAPPING;
t->p1 = t1;
t->p2 = t2;
return t;
}

typeptr cartesian(typeptr t1,typeptr t2) {

typeptr t;
t = (typeptr)malloc(sizeof(typenode));
t->info = CARTESIAN;
t->p1 = t1;
t->p2 = t2;
return t;
}

typeptr array(typeptr t1,int size) {

typeptr t;
t = (typeptr)malloc(sizeof(typenode));
t->info = ARRAY;
t->p1 = t1;
t->p2 = NULL;
t->array_size = size;
return t;
}

typeptr pointer(typeptr t1) {

typeptr t;
t = (typeptr)malloc(sizeof(typenode));
t->info = POINTER;
t->p2 = NULL;
t->p1 = t1;
return t;
}

typetable *type_table = NULL;

add_symbol(char *name,typeptr type) {

S.MUTHU LAKSHMI 15CSE81

 typetable *t;
t = (typetable*)malloc(sizeof(typetable));
t->name = (char*)malloc(strlen(name)+1);
strcpy(t->name,name);
t->t = type;
t->next = type_table;
type_table = t;
}

typeptr
lookup(char *name) {
typetable *t;
t = type_table;
while (t) {
if (strcmp(t->name,name) ==0) return t->t;
t = t->next;
}
return NULL;

typedef enum {CHAR,INT,ARRAY,POINTER,CARTESIAN,MAPPING,UNKNOWN} type_info;

typedef struct tnode {
type_info info;
struct tnode *p1, *p2;
int array_size;
} typenode, *typeptr;

typeptr new_node(type_info info);

typeptr map(),cartesian();
typeptr lookup();
int typematch();

typedef struct s {
char *name;
typeptr t;
struct s *next;
} typetable;

Output:
key: integer ;
a: array [20] of integer;
b: array[40] of ^ integer;
b[a[key]]
Correct
key: ^integer ;
a: integer -> integer;

S.MUTHU LAKSHMI 15CSE81

 a(key) + 4

Type Error

Result:
Thus the YACC Program to implement the type checking was executed successfully.

S.MUTHU LAKSHMI 15CSE81

S.MUTHU LAKSHMI 15CSE81