Akankshya (#10)

* IC

* Finished

* Lab test

Intermediate.h

@@ -0,0 +1,11 @@
+#include "IntermediateDef.h"
+TEMP newTemp();
+LABEL newLabel();
+result *newResult(int flag, TEMP t, LABEL l);
+arg* newArg(int flag, hash_ele* h, TEMP t, LABEL L, int num, float rnum, int width);
+op* newOp(int flag, TAG tag, TOKEN tkname);
+label* returnLabel(int flag, LABEL l, char* dataDef);
+quadruple* newQuad(arg *a1, arg *a2, op* op, LABEL *l, result *res);
+quadruple* generateIntermediateCode(ASTNodeIt* root);
+char* concat(const char *s1, const char *s2);
+arg* getArg(ASTNodeIt* ast);

IntermediateDef.h

@@ -4,19 +4,24 @@
 // KARABEE BATTA 2016A7PS0052P
 // AASTHA KATARIA 2016A7PS0062P
 
+#ifndef SYM_INCLUDED
 #include "SymbolTable.h"
+#define SYM_INCLUDED
+#endif
 typedef int LABEL;
 typedef int TEMP;
 typedef struct IntermediateDef IntermediateDef;
 
+typedef struct label label;
 typedef struct arg{
     int flag;
     union{
         hash_ele* hElem;
         TEMP t;
-        LABEL L; //TRUE is stored in arg1, FALSE in arg2
+        label *L; //TRUE is stored in arg1, FALSE in arg2
         int num;
         float rnum;
+        int width;
     }u;
 }arg;
 
@@ -36,11 +41,19 @@ typedef struct{
     }u;
 }result;
 
+typedef struct label{
+    int flag;
+    union{
+        LABEL l;
+        char *dataDef;
+    }u;    
+}label;
+
 typedef struct quadruple{
     arg* a1;
     arg* a2;
     op* operand;
     result *res;
-    LABEL l;
+    label *L;
     struct quadruple* next;  
 }quadruple;

SymbolTable.c

@@ -180,7 +180,7 @@ void populate_type(hash_ele* hashEle_identifier,ASTNodeIt* temp)
         else if(temp->node->u.n->children->node->u.l->leaf_symbol->tokenName==TK_REAL)
         {
             hashEle_identifier->ele->u.g->u.t->is_record=0;
-            hashEle_identifier->ele->u.g->u.t->u.pri_type=false;
+            hashEle_identifier->ele->u.g->u.t->u.pri_type=true;
         }
         else
         {

SymbolTable.h

@@ -4,6 +4,7 @@
 // KARABEE BATTA 2016A7PS0052P
 // AASTHA KATARIA 2016A7PS0062P
 #include "SymbolTableDef.h"
+#define SYM_INCLUDED
 //hashtable functions
 char *TypeString(int index);
 int hashEle(char *str);

SymbolTableDef.h

@@ -58,7 +58,7 @@ typedef struct globalTableElem{
     bool is_record;
     union{
         type* t;
-        rec* rec_type_list;    
+        rec* rec_type_list;
     }u;
     int offset;
 }globalTableElem;

codegen.c

@@ -0,0 +1,58 @@
+#include "Intermediate.h"
+
+quadruple *writeDataDefs(quadruple *code, FILE *fp){
+    while(code->operand->flag==0 && code->operand->u.tag==TAG_DECLARE){
+        if(code->a1->u.width==2) fprintf(fp, "%s\tdw\tdup(?)", code->L->u.dataDef);
+        else fprintf(fp, "%s\tdd\tdup(?)", code->L->u.dataDef);
+        code=code->next;
+    }
+    return code;
+}
+
+void writeCode(quadruple *code, FILE *fp){
+    while(code!=NULL){
+        if(code->operand->flag==0 && code->operand->u.tag==TAG_READ){
+            fprintf(fp, "\tMOV\tEDX, %d", (code->a2->u.width==2)? 3:5);
+            fprintf(fp, "\tMOV\tECX, %s", code->a1->u.L->u.dataDef);
+            fprintf(fp, "\tMOV\tEAX, 3");
+            fprintf(fp, "\tMOV\tEBX, EAX");
+            fprintf(fp, "\tINT\t80H");
+        }
+        else if(code->operand->flag==0 && code->operand->u.tag==TAG_WRITE){
+            fprintf(fp, "\tMOV\tEDX, %d", (code->a2->u.width==2)? 3:5);
+            fprintf(fp, "\tMOV\tECX, %s", code->a1->u.L->u.dataDef);
+            fprintf(fp, "\tMOV\tEBX, 1");
+            fprintf(fp, "\tMOV\tEAX, 4");
+            fprintf(fp, "\tINT\t80H");
+        }
+        else if(code->operand->flag==1 && (code->operand->u.tkname==TK_PLUS || code->operand->u.tkname==TK_MINUS || code->operand->u.tkname==TK_DIV || code->operand->u.tkname==TK_MUL)){
+            if(code->operand->u.tkname==TK_PLUS){
+
+            }
+            else if(code->operand->u.tkname==TK_MINUS){
+
+            }
+            else if(code->operand->u.tkname==TK_DIV){
+
+            }
+            else if(code->operand->u.tkname==TK_MUL){
+
+            }
+        }
+        code = code->next;
+    }
+    fprintf(fp, "\tMOV\tEAX, 1");
+    fprintf(fp, "\tMOV\tEBX, 0");
+    fprintf(fp, "\tINT\t80H");
+}
+
+void generateCode(ASTNodeIt *ast, char *filename){
+	FILE *fp = fopen(filename, "w");
+    quadruple *fullcode = generateIntermediateCode(ast);
+    fprintf(fp,"SECTION .bss\n");
+    fprintf(fp,"\tlpBuffer: resb 18\n\tBuf_Len: equ $-lpBuffer\n");
+    fprintf(fp,"lft: RESW 8\nFOR_CTRL: RESW 8\nOUT: RESW 10\ntemp: RESW 1\nrgt: RESW 1\n");
+    quadruple *stmts = writeDataDefs(fullcode, fp);
+    fprintf(fp,"SECTION .text\nglobal _start\n\n_start:\n");
+    writeCode(stmts, fp);
+}

codegen.h

@@ -0,0 +1,5 @@
+#include "Intermediate.h"
+
+quadruple *writeDataDefs(quadruple *code, FILE *fp);
+void writeCode(quadruple *code, FILE *fp);
+void generateCode(ASTNodeIt *ast, char *filename);

driver.c

@@ -12,6 +12,7 @@
 #include "parser.h"
 #include "grammar.h"
 #include "semantic.h"
+#include "codegen.h"
 extern parse_table T;
 extern int semantic_correct;
 // extern int parse_correct;
@@ -111,19 +112,17 @@ int main(int argc, char *argv[]){
 			int i;
 			printf("Please enter whether code is free of syntactic, semantic or type mismatch errors(0 for no, 1 for yes)\n");
 			printf("To check, use option=9 first\n");
-			scanf("%d\n", &i);
-			if(i){
-				treeNodeIt* t = parseInputSourceCode(argv[1]);
-				ASTNodeIt *ast;
-				if(parse_correct){
-					ast = semanticAnalyzer(t);
-				}
-				if(!semantic_correct){
-					printf("Code compiles successfully...\n");
-				}
-				else printf("\n");
-				// constructASMcode(ast, argv[2]);
+			treeNodeIt* t = parseInputSourceCode(argv[1]);
+			ASTNodeIt *ast;
+			if(parse_correct){
+				ast = semanticAnalyzer(t);
+			}
+			if(!semantic_correct){
+				printf("Code compiles successfully...\n");
+				continue;
 			}
+			else printf("\n");
+			generateCode(ast, argv[2]);
 		}
 		else{
 			printf("Enter correct option\n");

makefile

@@ -3,12 +3,16 @@
 # // NARAPAREDDY BHAVANA 2016A7PS0034P
 # // KARABEE BATTA 2016A7PS0052P
 # // AASTHA KATARIA 2016A7PS0062P
-compile: keyhead lexhead parshead stackhead grammarhead ASThead symbolTablehead semantichead SymbolTable.o semantic.o key.o DFA.o AST.o grammar.o stack.o lexer.o parser.o driver.o
-	gcc driver.o AST.o SymbolTable.o semantic.o DFA.o grammar.o stack.o lexer.o parser.o key.o -o compiler
+compile: keyhead lexhead parshead stackhead grammarhead ASThead symbolTablehead semantichead inthead codehead Intermediate.o codegen.o SymbolTable.o semantic.o key.o DFA.o AST.o grammar.o stack.o lexer.o parser.o driver.o
+	gcc driver.o AST.o Intermediate.o codegen.o SymbolTable.o semantic.o DFA.o grammar.o stack.o lexer.o parser.o key.o -o compiler
 driver.o: driver.c 
 	gcc -c -g driver.c
 AST.o: AST.c
 	gcc -c -g AST.c
+Intermediate.o: Intermediate.c
+	gcc -c -g Intermediate.c
+codegen.o: codegen.c
+	gcc -c -g codegen.c
 SymbolTable.o: SymbolTable.c
 	gcc -c -g SymbolTable.c 
 semantic.o: semantic.c
@@ -47,4 +51,9 @@ symbolTablehead:
 	gcc SymbolTableDef.h
 	gcc SymbolTable.h
 semantichead:
-	gcc semantic.h
+	gcc semantic.h
+inthead:
+	gcc Intermediate.h
+	gcc IntermediateDef.h
+codehead:
+	gcc codegen.h

parser.c

@@ -188,6 +188,10 @@ treeNodeIt* parseInputSourceCode(char *testcaseFile){
 				printf("Line %d: The token %s for lexeme %.2f does not match with expected token %s\n", ti->line_no, TerminalString(ti->tokenName), ti->u.value_of_real, nonTerminalStringTable[e->elem.nonterminal]->nonterminal);
 			}
 			do{
+				if(ti->tokenName==EOS){
+					 e_flag=1;
+					 break;
+				}
 				ti = getNextToken(fp);
 				// printf("%s\n", TerminalString(ti->tokenName));
 				if((T[e->elem.nonterminal][ti->tokenName].is_error==0)){
@@ -468,4 +472,4 @@ size_t printParseTreeNodes(treeNodeIt *root){
 		}
 		temp = temp->next;
 	}
-}
+}