Implementation of Three address code generation

Contents of tac.l file 



%{
#include "y.tab.h"
#include <string.h>
char * split(char* s,char* delimeter);
%}


relop >=|<=|>|<|==|!=
number [0-9]+

%%

[\n\t ]+ {;}
"if" {return IF;}
"while" {return WHILE;}
"for" {return FOR;}
"else" {return ELSE;}
"int"|"string"|"char"|"double" { return TYPE;}
[a-z]([a-z]|[0-9])* { yylval.tuple.result = strdup(yytext); return identifier; }
[0-9]+  {yylval.tuple.num= atoi(yytext); return number;}
{relop} { yylval.tuple.arg1 =strdup(yytext); return RELOP;}
 [-+*=/;] {return yytext[0];}
[(){}]               {return yytext[0];}
%%

int yywrap(void)
{
return 1;
}


Contents of tac.y file 


%{
    int yylex();
    void yyerror(char* s);
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    char* symbols[1000];
    int symbolValues[1000];
    int symbolCounter = 0;
    int labelCounter = 0;
    int flagNum = 0;
    int symbolVal(char* symbol);
    char* numToString;
    char* numToString2;
    char* labels;
    void updateTable(char* symbol,int value);
    char* split(char* s, char delimeter);
    char* split2(char* s, char delimeter);
    int relopHandler(int n,int n2,int n3);
    char* Temp();
    int tempForExp;
    char* Label();
    char* idSplit;
    char* whileLabel;
     FILE* yyout; 
     FILE* yyin;
   
%}

%union {
    struct quadruple
    {
        int num;
        int isnum;
        char *arg1;
        char *arg2;
        char * result;
    } tuple;
    }
%start line
%token <tuple> number
%token TYPE
%token IF
%token ELSE
%token <tuple> incDec
%token <tuple> FOR
%token <tuple> WHILE
%token <tuple> identifier
%token <tuple> RELOP
%type <tuple> line exp factor assignment term C
%left '*' '/'
%left '+' '-'
%nonassoc 'then'
%nonassoc ELSE

%%


line :  assignment ';' {;}
     | line assignment ';'{;}
     | line TYPE identifier ';' {;}
     | line exp ';' {;}
     | line FOR  '(' assignment {labels = Label(); $2.arg1 = labels; printf("%s:\n",$2.arg1);} ';' C {labels = Label(); $7.arg1 = labels; labels = Label(); $2.arg2= labels; printf("if %s Goto %s\n Goto %s\n",$7.result,$7.arg1,$2.arg2);} ';' {labels = Label(); $7.arg2 = labels; printf("%s:\n",$7.arg2);} exp {printf("Goto %s\n",$2.arg1);}')' '{'{printf("%s:\n",$7.arg1);} line {printf("goto %s\n %s:\n",$7.arg2,$2.arg2);} '}' 
     |  FOR  '(' assignment {labels = Label(); $1.arg1 = labels; printf("%s:\n",$1.arg1);} ';' C {labels = Label(); $6.arg1 = labels; labels = Label(); $1.arg2= labels; printf("if %s Goto %s\n Goto %s\n",$6.result,$6.arg1,$1.arg2);} ';' {labels = Label(); $6.arg2 = labels; printf("%s:\n",$6.arg2);} exp {printf("Goto %s\n",$1.arg1);}')' '{'{printf("%s:\n",$6.arg1);} line {printf("goto %s\n %s:\n",$6.arg2,$1.arg2);} '}' 
     | line WHILE {labels = Label(); $2.arg1 = labels; printf("%s:\n",$2.arg1);} '(' C { labels = Label(); $5.arg2 = labels; printf("if %s Goto %s\n",$5.result,$5.arg2);} ')' '{' line '}' { printf("Goto %s\n %s:\n",$2.arg1,$2.arg2);}
     | WHILE {labels = Label(); $1.arg1 = labels; printf("%s:\n",$1.arg1);} '(' C { labels = Label(); $1.arg2 = labels; printf("if %s Goto %s\n",$4.result,$1.arg2);} ')' '{' line '}' { printf("Goto %s\n %s:\n",$1.arg1,$1.arg2);}
     | line IF '(' C { labels = Label(); $4.arg2 = labels; printf("If %s Goto %s \n",$4.result,labels);    }   ')' '{' line '}' { printf("%s :\n",$4.arg2);}
     | IF '(' C { labels = Label(); $3.arg2 = labels; printf("If %s Goto %s \n",$3.result,labels);    }   ')' '{' line '}' { printf("%s :\n",$3.arg2);}
    ;
assignment : TYPE identifier '=' exp { printf("%s = %s\n",$2.result,$4.result);}
           | identifier '=' exp { fprintf(yyout,"%s = %s\n",$1.result,$3.result);}          
           ;
exp : term {;}
    | '-' '-' exp   { printf("--%s\n",$3.result); }       
    | '+' '+' exp {printf("++%s\n",$3.result);}
    | exp '-' '-'    { printf("%s--\n",$1.result); }       
    | exp '+' '+'  {printf("%s++\n",$1.result);}
    | exp '+' term { $$.arg1 = $1.result; $$.arg2 = $3.result; $$.result = Temp(); $$.isnum = 0;  if($1.isnum == 1){  printf("%s = %d + %s\n",$$.result,$1.num,$3.result);}else { printf("%s = %s + %s\n",$$.result,$$.arg1,$$.arg2);}}
    | exp '-' term { $$.arg1 = $1.result; $$.arg2 = $3.result; $$.result = Temp(); $$.isnum = 0;  if($1.isnum == 1){  printf("%s = %d - %s\n",$$.result,$1.num,$3.result);}else { printf("%s = %s - %s\n",$$.result,$$.arg1,$$.arg2);}}
    ;

C : exp RELOP exp {  if($3.isnum == 1){ $$.arg1 = Temp(); $$.result = Temp(); printf("%s = %d\n",$$.arg1,$3.num);  printf("%s = %s %s %s\n",$$.result,$1.result,$2.arg1,$$.arg1);}else {  $$.result = Temp(); printf("%s = %s %s %s\n",$$.result,$1.result,$2.arg1,$3.result);}}
  ;
term : factor {;}
     | term '*' factor {  $$.arg1 = $1.result; $$.arg2 = $3.result; $$.result = Temp(); $$.isnum = 0;  if($1.isnum == 1){  printf("%s = %d * %s\n",$$.result,$1.num,$3.result);}else { printf("%s = %s * %s\n",$$.result,$$.arg1,$$.arg2);}}
     | term '/' factor { $$.arg1 = $1.result; $$.arg2 = $3.result; $$.result = Temp(); $$.isnum = 0;  if($1.isnum == 1){  printf("%s = %d / %s\n",$$.result,$1.num,$3.result);}else { printf("%s = %s / %s\n",$$.result,$$.arg1,$$.arg2);}}
     ;
factor : number { sprintf(numToString,"%d",$1.num); $1.isnum = 1; $1.arg1 = numToString; $1.result = numToString; $$ =$1;}
       | '(' exp ')' { $2.isnum=0;  $$ = $2; } 
       | identifier {  $$.result = $1.result; }
       ;
%%

char * Temp(){
    
    symbolCounter++;
    char *temp=(char *)malloc(sizeof(5*sizeof(char)));
    sprintf(temp,"t%d",symbolCounter);
    return temp;
    
    
    
}
char * Label(){
    
    labelCounter++;
    char *temp=(char *)malloc(sizeof(5*sizeof(char)));
    sprintf(temp,"L%d",labelCounter);
    return temp;
    
    
    
}

int main() {
  
    FILE* yyout;
    numToString = malloc(11 * sizeof(char));
    numToString2 = malloc(10 * sizeof(char));
    labels = malloc(10 * sizeof(char));
    idSplit = malloc(10 * sizeof(char));
    whileLabel = malloc(10 * sizeof(char));
 
   yyout = fopen("out.txt","w");
  yyin = fopen("ip1.txt", "r");
   yyparse();
   fclose(yyout);
  }
void yyerror (char *s) {fprintf (stderr, "%s\n", s);} 





Input for the code ip1.txt

if(a<b){a=b;}
for(i=0 ; i<a ; i++){a=b;}



Popular posts from this blog

DDL DML DCL and TCL

DML (Data Manipulation Language) 2.  DDL (Data Definition Language) 3.  DCL (Data Control Language) 4.  TCL (Transaction Control Language)   DML (Data Manipulation Language) DML statements affect records in a table. These are basic operations we perform on data such as selecting a few records from a table, inserting new records, deleting unnecessary records, and updating/modifying existing records. DML statements include the following: SELECT  – select records from a table INSERT  – insert new records UPDATE  – update/Modify existing records DELETE  – delete existing records DDL (Data Definition Language) DDL statements are used to alter/modify a database or table structure and schema. These statements handle the design and storage of database objects. CREATE  – create a new Table, database, schema ALTER  – alter existing table, column description DROP  – delete existing objects from database DCL (Data
Read more

Implementation of Calculator using lex and yacc

file name Cal.l  %{ #include<stdio.h> #include "y.tab.h" //extern int yylval; %} %% [0-9]+ { yylval=atoi(yytext); return NUMBER; } [\n] return 0; . return yytext[0]; %% int yywrap() { return 1; } file name  cal.y %{ #include<stdio.h> int flag=0; %} %token NUMBER %left '+' '-' %left '*' '/' '%' %left '(' ')' %% ArithmeticExpression: E{          printf("\nResult=%d\n",$$);          return 0;         }; E:E'+'E {$$=$1+$3;}  |E'-'E {$$=$1-$3;}  |E'*'E {$$=$1*$3;}  |E'/'E {$$=$1/$3;}  |E'%'E {$$=$1%$3;}  |'('E')' {$$=$2;}  | NUMBER {$$=$1;} ; %% int main() {   yyparse();   if(flag==0)    printf("\nEntered arithmetic expression is Valid\n\n");   return 0; } int yyerror() {    printf("\nEntered arithmetic expression is Invalid\n\n");    flag=1;    return 0; }
Read more

A Register Allocation algorithm that translates the given code into one with a fixed number of registers.

//C code for  A Register Allocation algorithm that translates the given code into one with a fixed number of registers. #include<stdlib.h> #include<stdio.h> /* We will implement DAG as Strictly Binary Tree where each node has zero or two children */ struct bin_tree { char data; int label; struct bin_tree *right, *left; }; typedef struct bin_tree node; /* R is stack for storing registers */ int R[10]; int top; /* op will be used for opcode name w.r.t. arithmetic operator e.g. ADD for + */ char *op; /* insertnode() and insert() functions are for adding nodes to tree(DAG) */void insertnode(node **tree,char val) { node *temp = NULL; if(!(*tree)) { temp = (node *)malloc(sizeof(node)); temp->left = temp->right = NULL; temp->data = val; temp->label=-1; *tree = temp; } } void insert(node **tree,char val) { char l,r; int numofchildren; insertnode(tree, val); printf("\nEnter number of children of %c:",val); scanf("%d&quo
Read more