#include <bits/stdc++.h>

#include "symbol.h"

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

using namespace std;

int linecount = 0;

int cnt =0;

vector<funcNameTable> functionTable;

int activeFunc = 0;

int level;

vector<symTab>symbolTable;

vector<int>freet(8,0);

vector<string>quadruple;

int nextquad=0;

void yyerror(char *s)

{

fprintf(stderr,"Invalid Syntax\n");

exit(1);

}

int yywrap(){return 1;}

int yylex();

%union{

char idName[100];

struct Node *n;

int val;

float data;

}

int insert_symtab(char *id_name);

void patch_type2(int type, vector<int>v);

int getfreet();

void freeit(int i);

int search_func(string name);

int enter_func(int type , string name);

int search_param(string name);

void enter_param(string name,int type);

int search_var(string name,int flag);

int enter_var(string name,int flag,vector<int> dim);

void patch_type1(int type , vector<int> list);

int get_var_type(string name);

int get_param_type(string name);

int get_ele_type(string name);

int get_dim(string name);

int get_level(string name);

/*void call_func(struct node n,char *a1);

%type<data>DECIMAL;

%type <n> T;

%type <n> L;

%type <idName> ID;

%type <n> E;

%type <n> E2;

%type <n> E22;

%type <n> M_E0;

%type <n> M_E1;

%type <n> F;

%type <n> F3;

%type <n> T2;

%type <n> E_MAIN;

%type <n> OPT;

%type <n> LHS;

%type <n> WHILEXEP;

%type <n> M_WHILE;

%type <n> M_STMT;

%type <n> M_FOR1;

%type <n> M_FOR2;

%type <n> STMT_LIST;

%type <n> STMT;

%type <n> FOREXP;

%type <n> IFEXP;

%type <n> ASG;

%type <val> NUM;

%type <n> M;

%type <n> N;

%type <n> FUNC_DECL;

%type <n> CALL_PARAM;

%type <n> constant_expr;

%type <n> cases;

%type <n> default;

%type <n> case;

%type <n> case_end;

%type <n> case_exp;

%type <n> RESULT;

%type <n> List;

%type <n> DIMList;

%type <n> ID_ARR;

%token MUL

%token PROJECT

%token CARTESIAN_PRODUCT

%token EQUI_JOIN

%token AND

%token OR

%token NOT

%token LP

%token RP

%token LE

%token GE

%token LT

%token GT

%token EQ

%token SEMI

%token NUM

%token QUO

%token ID

%token DOT

%token STRING

%token COMMA

%token STAR

%token MINUS

%token PLUS

%token DIV

%token INT

%token FLOAT

%token WHILE

%token LC

%token RC

%token FOR

%token EE

%token DECIMAL

%token DIVIDE

%token IF

%token ELSE

%token RETURN

%token LB

%token RB

%token SWITCH

%token BREAK

%token COLON

%token CASE

%token DEFAULT

START : STMT_LIST

{

for(int i=0;i<$1->nextlist.size();i++)

{

//quadruple[$1->nextlist[i]] += to_string(nextquad);

quadruple[$1->nextlist[i]] += to_string(nextquad-1);

}

};

STMT : FUNC_DECL

{

/*for(int i=0;i<$1->nextlist.size();i++)

$$ = new Node;

$$->nextlist = $1->nextlist;

level = 0;

activeFunc = 0;

};

STMT : RETURN F SEMI

{

$$ = new Node;

string str = quadruple[quadruple.size()-1];

//cout<<"fvb"<<str<<"fjds";

string temp="";

string reg="";

for(int i=str.size()-1;i>=0;i--)

{

if(str[i]==' ')

break;

temp = str[i]+temp;

}

for(int i=0;i<str.size();i++)

{

if(str[i]==' ')

break;

reg = reg + str[i];

}

/*temp = "return " + temp;

char arr[100];

int parSize = functionTable[activeFunc].parList.size()+1;

sprintf(arr,"#%d = %s",parSize,reg.c_str());

quadruple.resize(nextquad+1);

quadruple[nextquad] = arr;

nextquad++;

char arr22[100];

sprintf(arr22,"goto 1%s_end",functionTable[activeFunc].name.c_str());

quadruple.resize(nextquad+1);

quadruple[nextquad] = arr22;

nextquad++;

};

FUNC_DECL : FUNC_HEAD LC STMT_LIST RC

{

quadruple.push_back("func end");

nextquad++;

$$ = new Node;

$$->nextlist = $3->nextlist;

};

FUNC_HEAD : RES_ID LP DECL_PLIST RP

{

level = 2;

};

RES_ID : T ID

{

int found = search_func($2);

if(found)

printf("Line %d : Function %s() already declared\n",lineno,$2);

else

{

int index = enter_func($1->type,$2);

activeFunc = index;

//cout<<activeFunc<<" ";

level = 1;

char temp[100];

sprintf(temp , "func begin %s",$2);

quadruple.push_back(temp);

nextquad++;

}

};

DECL_PLIST : DECL_PL ;

DECL_PLIST : ;

DECL_PL : DECL_PL COMMA DECL_PARAM ;

DECL_PL : DECL_PARAM;

DECL_PARAM : T ID

{

int found = search_param($2);

if(found)

printf("Line %d : Parameter %s already Declared\n",lineno,$2);

else{

enter_param($2,$1->type);

}

};

STMT_LIST : STMT_LIST M_STMT STMT

{

$$ = new Node;

$$->nextlist.insert($$->nextlist.end(),$3->nextlist.begin(),$3->nextlist.end());

for(int i=0;i<$1->nextlist.size();i++)

{

char temp[100];

//cout<<$2->quad<<endl;

sprintf(temp,"%d",$2->quad);

// printf("==%s===",temp);

quadruple[$1->nextlist[i]] += temp;

}

};

STMT_LIST : STMT

{

$$ = new Node;

$$->nextlist.insert($$->nextlist.end(),$1->nextlist.begin(),$1->nextlist.end());

};

M_STMT :

{

$$ = new Node;

$$->quad = nextquad;

};

STMT : ASG SEMI

{

vector<string>list = $1->idlist;

vector<int> eletypelist = $1->eletypelist;

int dimSize = $1->dim.size();

for(int i=0;i<list.size();i++)

{

int found = search_var(list[i],1);

if(!found)

{

found = search_param(list[i]);

if(!found)

printf("Line %d : Variable %s Not declared\n",lineno,list[i].c_str());

else

{

int eletype = get_ele_type(list[i]);

if(eletype!=eletypelist[i])

printf("Line %d : %s Element Type Mismatch",lineno,list[i].c_str());

}

}

else

{

int eletype = get_ele_type(list[i]);

if(eletype!=eletypelist[i])

printf("Line %d : %s Element Type Mismatch",lineno,list[i].c_str());

int d = get_dim(list[i]);

if(d!=dimSize)

printf("Line %d : %s Dimension Mismmatch\n",lineno,list[i].c_str() );

}

}

/*if($1->sem_type!=-1)

};

STMT : D SEMI;

STMT : FOREXP LC STMT_LIST RC

{

$$ = new Node;

quadruple.resize(nextquad+1);

char arr[500];

sprintf(arr,"goto %d",$1->end);

quadruple[nextquad] = arr;

nextquad++;

/* backpatch */

for(int i=0;i<$3->nextlist.size();i++)

{

char temp[100];

sprintf(temp,"%d",$1->end);

quadruple[$3->nextlist[i]] += temp;

}

/* S.next = falselist*/

$$->nextlist.insert($$->nextlist.end(),$1->falselist.begin(),$1->falselist.end());

int i=0;

for(i=0;i<functionTable[activeFunc].varList.size();i++)

{

if(functionTable[activeFunc].varList[i].level==level)

{

functionTable[activeFunc].varList.erase(functionTable[activeFunc].varList.begin()+i);

i=0;

}

}

level--;

};

FOREXP : FOR LP F1 SEMI M_FOR1 E_MAIN SEMI M_FOR2 F3 RP

{

$$ = new Node;

quadruple.resize(nextquad+1);

char arr2[500];

sprintf(arr2,"goto ");

$9->nextlist.push_back(nextquad);

quadruple[nextquad] = arr2;

nextquad++;

$$->falselist.push_back(nextquad);

quadruple.resize(nextquad+1);

char we = 't';

if ($6->type==1)

we='f';

char arr[500];

sprintf(arr,"if %c%d <=0 goto ",we,$6->reg);

quadruple[nextquad] = arr;

for(int i=0;i<$8->nextlist.size();i++)

{

char temp[100];

sprintf(temp,"%d",nextquad);

quadruple[$8->nextlist[i]] += temp;

}

for(int i=0;i<$6->nextlist.size();i++)

{

char temp[100];

sprintf(temp,"%d",nextquad);

quadruple[$6->nextlist[i]] += temp;

}

nextquad++;

$$->begin = $5->quad;

$$->end = $8->quad;

for(int i=0;i<$9->nextlist.size();i++)

{

char temp[100];

sprintf(temp,"%d",$$->begin);

quadruple[$9->nextlist[i]] += temp;

}

level++;

freeit($6->reg);

};

M_FOR1 :

{

$$ = new Node;

$$->quad = nextquad;

};

M_FOR2 :

{

$$ = new Node;

quadruple.resize(nextquad+1);

char arr[500];

sprintf(arr,"goto ");

quadruple[nextquad] = arr;

$$->nextlist.push_back(nextquad);

nextquad++;

$$->quad = nextquad;

};

F1 : ASG ;

F3 : ASG {$$ = new Node;};

STMT : WHILEXEP LC STMT_LIST RC

{

//printf("ok");

$$ = new Node;

quadruple.resize(nextquad+1);

char arr[500];

sprintf(arr,"goto %d",$1->begin);

quadruple[nextquad] = arr;

nextquad++;

/* backpatch */

for(int i=0;i<$3->nextlist.size();i++)

{

char temp[100];

sprintf(temp,"%d",$1->begin);

quadruple[$3->nextlist[i]] += temp;

}

/* S.next = falselist*/

$$->nextlist.insert($$->nextlist.end(),$1->falselist.begin(),$1->falselist.end());

int i=0;

for(i=0;i<functionTable[activeFunc].varList.size();i++)

{

if(functionTable[activeFunc].varList[i].level==level)

{

functionTable[activeFunc].varList.erase(functionTable[activeFunc].varList.begin()+i);

i=0;

}

}

level--;

};

D : T L {

//patch_type1($1->type,$2->namelist);

//patch_type2($1->type,$2->namelist);

//cout<<"hello";

vector<string> list = $2->idlist;

vector<int> eleList = $2->eletypelist;

for(int i=0;i<list.size();i++)

{

int found = search_var(list[i],0);

if(found)

{

printf("Line %d : Variable %s already declared at same level\n",lineno,list[i].c_str());

}

else if(level==2)

{

int found = search_param(list[i]);

if(found)

printf("Line %d : Redeclaration of Parameter %s as Variable\n",lineno,list[i].c_str());

else

{

int index = enter_var(list[i],eleList[i],$2->dim);

functionTable[activeFunc].varList[index].type = $1->type;

}

}

else

{

int index = enter_var(list[i],eleList[i],$2->dim);

functionTable[activeFunc].varList[index].type = $1->type;

}

if(level<0)

{

;

// sprintf(arr,"#%d = t%d\n",abs(level),$3->reg);

}

else

{

//cout<<"h"<<$2->nextlist2.size();

//cout<<i<<" "<<$2->nextlist2[i]<<"\n";

if(i < $2->nextlist2.size() && $2->nextlist2[i]!=-1)

{

//cout<<i<<" "<<$2->nextlist2[i]<<"\n";

char arr[500];

string temp="";

int f=0;

string res = quadruple[$2->nextlist2[i]];

for(int i=0;i < res.size();i++)

{

if(f==1 || res[i]=='=')

{

temp += res[i];

f=1;

}

}

sprintf(arr,"%s_%d %s",list[i].c_str(),level,temp.c_str());

quadruple[$2->nextlist2[i]] = arr;

//cout<<quadruple[$2->nextlist2[i]]<<" ";

}

}

}

vector<pair<string,int> > comp = $1->comp;

for(int i=0;i<comp.size();i++)

{

if(get_var_type(comp[i].first)!=comp[i].second)

printf("Line %d : Type Mismatch\n",lineno);

}

/*if($2->sem_type!=-1 && $1->type!=$2->sem_type)

};

T : INT {$$ = new Node; $$->type = 0;};

T : FLOAT {$$ = new Node; $$->type = 1;};

///////////////////////////////////////////////////////////////////////////////////////////

L : ASG {

//int i = insert_symtab($1->id);

//cout<<level<<" ";

$$ = new Node;

/*int found = search_var($1->id,0);

$$->idlist = $1->idlist;

$$->eletypelist = $1->eletypelist;

$$->dim = $1->dim;

$$->comp = $1->comp;

$$->nextlist2 = $1->nextlist2;

//$$->sem_type = $1->sem_type;

//$$->namelist.push_back(i);

};

L : L COMMA ASG {

//int i = insert_symtab($3->id);

/*$$ = new Node;

/*int found = search_var($3->id,0);

$$ = new Node;

$$->idlist = $1->idlist;

$$->idlist.insert($$->idlist.end(),$3->idlist.begin(),$3->idlist.end());

$$->eletypelist = $1->eletypelist;

$$->eletypelist.insert($$->eletypelist.end(),$3->eletypelist.begin(),$3->eletypelist.end());

$$->dim = $1->dim;

$$->dim.insert($$->dim.end(),$3->dim.begin(),$3->dim.end());

$$->comp = $1->comp;

$$->comp.insert($$->comp.end(),$3->comp.begin(),$3->comp.end());

$$->nextlist2 = $1->nextlist2;

$$->nextlist2.insert($$->nextlist2.end(),$3->nextlist2.begin(),$3->nextlist2.end());

//$$->sem_type = -1;

};

ID_ARR : ID

{

$$ = new Node;

$$->id = $1;

$$->idlist.push_back($1);

$$->eletypelist.push_back(0);

$$->dim.push_back(-2);

$$->type2 = 4;

};

ID_ARR : ID DIMList

{

$$ = new Node;

$$->id = $1;

$$->idlist.push_back($1);

$$->eletypelist.push_back(1);

$$->type2 =5;

$$->dim = $2->dim;

$$->iddim = $2->iddim;

};

DIMList : LB ID RB

{

$$= new Node;

$$->dim.push_back(-1);

$$->iddim.push_back($2);

};

DIMList : LB ID RB DIMList

{

$$= new Node;

$$->dim.push_back(-1);

$$->iddim.push_back($2);

$$->dim.insert($$->dim.end(),$4->dim.begin(),$4->dim.end());

$$->iddim.insert($$->iddim.end(),$4->iddim.begin(),$4->iddim.end());

};

DIMList : LB NUM RB

{

$$= new Node;

$$->dim.push_back($2);

$$->iddim.push_back("");

};

DIMList : LB NUM RB DIMList

{

$$= new Node;

$$->dim.push_back($2);

$$->iddim.push_back("");

$$->dim.insert($$->dim.end(),$4->dim.begin(),$4->dim.end());

$$->iddim.insert($$->iddim.end(),$4->iddim.begin(),$4->iddim.end());

};

L : ID_ARR {

$$ = new Node;

/*int i = insert_symtab($1);

/*int found = search_var($1,1);

$$->idlist=$1->idlist;

$$->eletypelist = $1->eletypelist;

$$->dim = $1->dim;

//$$->sem_type = -1;

};

L : L COMMA ID_ARR {

$$ = new Node;

/*int i = insert_symtab($3);

/*int found = search_var($3,0);

$$->idlist = $1->idlist;

$$->idlist.insert($$->idlist.end(),$3->idlist.begin(),$3->idlist.end());

$$->eletypelist = $1->eletypelist;

$$->eletypelist.insert($$->eletypelist.end(),$3->eletypelist.begin(),$3->eletypelist.end());

$$->dim = $1->dim;

$$->dim.insert($$->dim.end(),$3->dim.begin(),$3->dim.end());

$$->comp = $1->comp;

$$->nextlist2 = $1->nextlist2;

$$->nextlist2.push_back(-1);

//$$->sem_type = -1;

};

ASG : LHS EQ E_MAIN

{ /* depending on type */

$$ = new Node;

$$->id = $1->id;

char we='t';

if($3->type==1)

{

we='f';

}

int found = search_var($1->id,1);

if(!found)

found = search_param($1->id);

//cout<<$1->id<<" "<<found<<" "<<$1->type<<"\n";

if(found && get_var_type($1->id)!=$3->type)

printf("Line %d : Type Mismatch\n",lineno );

//cout<<$1->type<<" "<<$3->type<<"\n";

//printf("Line %d : Type Mismatch\n",lineno );

if($1->type2 == 4)

{

char arr[500];

if($3->flag==0)

{

int l = get_level($1->id);

if(l<0)

{

sprintf(arr,"#%d = %c%d\n",abs(l),we,$3->reg);

// cout<<

}

else

sprintf(arr,"%s_%d = %c%d\n",$1->id.c_str(),l,we,$3->reg);

}

else

{

/*quadruple[quadruple.size()-2] += $1->id;

string call_func_name = "";

int f=0;

//cout<<quadruple[quadruple.size()-1]<<" ";

for(int i=0;i<quadruple[quadruple.size()-1].size();i++)

{

if(f==1)

call_func_name += quadruple[quadruple.size()-1][i];

if(quadruple[quadruple.size()-1][i]==' ')

f=1;

}

int t;

for(int i=0;i<functionTable.size();i++)

{

if(functionTable[i].name==call_func_name)

{

t = functionTable[i].resultType;

break;

}

}

char we;

if(t==0)

we='t';

else

we='f';

int r = getfreet();

freet[r] = 1;

quadruple[quadruple.size()-2] += we + to_string(r);

//cout<<"\n\n\n"<<call_func_name<<"\n\n\n";

sprintf(arr,"%c%d = v0",we,r);

quadruple.resize(nextquad+1);

quadruple[nextquad] = arr;

nextquad++;

int l = get_level($1->id);

if(l<0)

{

//cout<<"afvdsb<<" ""

sprintf(arr,"#%d = %c%d",abs(l),we,r);

}

else

{

//cout<<"afvdsb<<" "";

sprintf(arr,"%s_%d = %c%d",$1->id.c_str(),l,we,r);

}

for(int i=0;i<$3->regNum.size();i++)

freeit($3->regNum[i]);

freeit(r);

}

//sprintf(arr,"%s = t%d\n",$1->id.c_str(),$3->reg);

$$->nextlist2.push_back(nextquad);

quadruple.resize(nextquad+1);

quadruple[nextquad] = arr;

nextquad++;

}

else

{

char arr[500];

int a1 = getfreet();

freet[a1]=1;

vector<symTab> temp = functionTable[activeFunc].varList;

vector<int> dim;

int type;

for(int i=0;i<temp.size();i++)

{

if(temp[i].name==$1->id)

{

dim = temp[i].dim;

type = temp[i].type;

}

}

int memory = 1;

for(int i=0;i<dim.size();i++)

{

memory = memory * dim[i];

}

sprintf(arr,"t%d = addr(%s) %d\n",a1,$1->id.c_str(),memory);

quadruple.resize(nextquad+1);

quadruple[nextquad] = arr;

nextquad++;

int ans=0;

int final=0;

if(type==0)

{

ans = 4;

}

else

{

ans = 8;

}

int w= getfreet();

freet[w]=1;

int cnt=0;

char temp3[500];

sprintf(temp3,"t%d = 0\n",w);

quadruple.resize(nextquad+1);

quadruple[nextquad] = temp3;

nextquad++;

for(int i=0;i<$1->dim.size();i++)

{

if($1->dim[i]!=-1)

{

int o=1;

for(int j=i+1;j<$1->dim.size();j++)

{

o=o*dim[j];

}

o=o*$1->dim[i]*ans;

final = final + o;

}

else

{

int q=1;

for(int j=i+1;j<$1->dim.size();j++)

{

q = q*dim[j];

}

q= q*ans;

int r = getfreet();

freet[r]=1;

int e = getfreet();

freet[e]=1;

char temp4[500];

int l = get_level($1->id);

sprintf(temp4,"t%d = %s_%d\n",e,$1->iddim[i].c_str(),l);

quadruple.resize(nextquad+1);

quadruple[nextquad] = temp4;

nextquad++;

char temp[500];

sprintf(temp,"t%d = %d*t%d\n",r,q,e);

quadruple.resize(nextquad+1);

quadruple[nextquad] = temp;

nextquad++;

char temp2[500];

sprintf(temp2,"t%d = t%d+t%d\n",w,w,r);

quadruple.resize(nextquad+1);

quadruple[nextquad] = temp2;

nextquad++;

freeit(r);

freeit(e);

cnt++;

}

}

char temp2[500];

sprintf(temp2,"t%d = t%d+%d\n",w,w,final);

quadruple.resize(nextquad+1);

quadruple[nextquad] = temp2;

nextquad++;

char arr2[500];

int a2 = getfreet();

freet[a2]=1;

sprintf(arr2,"t%d = t%d\n",a2,w);

quadruple.resize(nextquad+1);

quadruple[nextquad] = arr2;

nextquad++;

freeit(w);

char arr3[500];

sprintf(arr3,"t%d[t%d] = %c%d\n",a1,a2,we,$3->reg);

quadruple.resize(nextquad+1);

quadruple[nextquad] = arr3;

nextquad++;

freeit(a1);

freeit(a2);

}

/*char arr[500];