scarlett/compiler-the-translators
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Quick formatting updates

Browse Source
This commit is contained in:
Scarlett
2025-03-25 17:02:14 -04:00
parent d817ceaf7d
commit 94b80b024d
5 changed files with 532 additions and 505 deletions
Download Patch File Download Diff File Expand all files Collapse all files

694
src/symbol_table.c
View File

@ -6,42 +6,43 @@
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
char * typey = "type";
char * funy = "function";
TableNode* funprime;
TableNode* arrayprim;
extern SymbolTable* cur;
TableNode* integ;
TableNode* addr;
TableNode* chara;
TableNode* stri;
TableNode* boo;
TableNode* recprime;
TableNode* funtypeprime;
char *typey = "type";
char *funy = "function";
TableNode *funprime;
TableNode *arrayprim;
extern SymbolTable *cur;
TableNode *integ;
TableNode *addr;
TableNode *chara;
TableNode *stri;
TableNode *boo;
TableNode *recprime;
TableNode *funtypeprime;
typedef enum {
//First 4 below are primitive types that are all encapsulated in primitive type
//TYPE_INTEGER,
//TYPE_CHARACTER,
//TYPE_BOOLEAN,
//TYPE_ADDRESS,
//Type String is an array of char enclosed in double quotes per lexer
TYPE_STRING,
//Array can be multidimensional. Information should be stored here
TYPE_ARRAY,
//Record is user defined types
TYPE_RECORD,
//Declaring what type a particular function is without as
TYPE_FUNCTION_DECLARATION,
//Declaring what type a particular function is with as
//TYPE_AS_FUNCTION_DECLARATION,
//Declaring what type a function is (what the parameters and output are)
TYPE_FUNCTION_TYPE,
//The Type being pointed to by the first 4 above that only stores the size
TYPE_PRIMITIVE
// First 4 below are primitive types that are all encapsulated in
// primitive type
// TYPE_INTEGER,
// TYPE_CHARACTER,
// TYPE_BOOLEAN,
// TYPE_ADDRESS,
// Type String is an array of char enclosed in double quotes per lexer
TYPE_STRING,
// Array can be multidimensional. Information should be stored here
TYPE_ARRAY,
// Record is user defined types
TYPE_RECORD,
// Declaring what type a particular function is without as
TYPE_FUNCTION_DECLARATION,
// Declaring what type a particular function is with as
// TYPE_AS_FUNCTION_DECLARATION,
// Declaring what type a function is (what the parameters and output
// are)
TYPE_FUNCTION_TYPE,
// The Type being pointed to by the first 4 above that only stores the
// size
TYPE_PRIMITIVE
} types;
/* put in symbol_table.h
@ -56,13 +57,14 @@ typedef struct{
typedef struct{
int numofdimensions;
//the above value tells you how long the below array is. For example if num of dimensions is 5, I can store 1,3,2,5,9 to define >
int* sizesofdimensions;
//the above value tells you how long the below array is. For example if num
of dimensions is 5, I can store 1,3,2,5,9 to define > int* sizesofdimensions;
TableNode* typeofarray;
}array_info;
typedef struct{
//similar to above we define a record to hold the number of elements and an array of tablenodes (types) that it contains in the order specified by the user
//similar to above we define a record to hold the number of elements and an
array of tablenodes (types) that it contains in the order specified by the user
int numofelements;
TableNode* listoftypes;
}record_info;
@ -77,145 +79,167 @@ typedef struct{
TableNode* returntype;
}function_type_info;
typedef union {
typedef union {
PrimAdInfo* primitive_info;
ArrayAdInfo* array_info;
RecAdInfo* record_info;
StringAdInfo* string_info;
StringAdInfo* string_info;
FunDecAdInfo* func_dec_info;
FunTypeAdInfo* func_type_info;
}AdInfo;
*/
//primitive additional info only stores the size of that type
AdInfo* CreatePrimitiveInfo(int size){
// primitive additional info only stores the size of that type
AdInfo *CreatePrimitiveInfo(int size) {
AdInfo* info = (AdInfo*)malloc(sizeof(AdInfo));
info->PrimAdInfo = (primitive_info*)malloc(sizeof(primitive_info));
info->PrimAdInfo->size=size;
return info;
AdInfo *info = (AdInfo *)malloc(sizeof(AdInfo));
info->PrimAdInfo = (primitive_info *)malloc(sizeof(primitive_info));
info->PrimAdInfo->size = size;
return info;
}
//only gets the size of a primitive type
int getPrimSize(TableNode* definition){
if(strcmp(getType(definition),"primitive")!=0){
printf("not checking the size of a primitive -- invalid op\n");
return 0;}
return definition->additionalinfo->PrimAdInfo->size;
// only gets the size of a primitive type
int getPrimSize(TableNode *definition) {
if (strcmp(getType(definition), "primitive") != 0) {
printf("not checking the size of a primitive -- invalid op\n");
return 0;
}
return definition->additionalinfo->PrimAdInfo->size;
}
//probably don't need the below structure since can create from an array
// probably don't need the below structure since can create from an array
/*string_info* CreateStringInfo(int length, char* loc){
string_info* stringy = (string_info*)malloc(sizeof(string_info));
stringy.length=length;
char* location = loc;
char* location = loc;
return stringy;
}
*/
//Only information stored in array info is the number of dimensions and the type stored in the array
//per professor, the actual size of the array is calculated at runtime so bounds checking only needs to be done then
AdInfo* CreateArrayInfo(int dim, /*int* sizes,*/ TableNode* type){
AdInfo* info = (AdInfo*)malloc(sizeof(AdInfo));
info->ArrayAdInfo = (array_info*)malloc(sizeof(array_info));
info->ArrayAdInfo->numofdimensions=dim;
info->ArrayAdInfo->typeofarray=type;
//avoiding storing any types like below
//int* dimensionsizes = loc;
// Only information stored in array info is the number of dimensions and the
// type stored in the array per professor, the actual size of the array is
// calculated at runtime so bounds checking only needs to be done then
AdInfo *CreateArrayInfo(int dim, /*int* sizes,*/ TableNode *type) {
AdInfo *info = (AdInfo *)malloc(sizeof(AdInfo));
info->ArrayAdInfo = (array_info *)malloc(sizeof(array_info));
info->ArrayAdInfo->numofdimensions = dim;
info->ArrayAdInfo->typeofarray = type;
// avoiding storing any types like below
// int* dimensionsizes = loc;
return info;
}
//This gets the number of dimensions from array info
int getNumArrDim(TableNode* definition){
if(strcmp(getType(definition),"array")!=0){
// This gets the number of dimensions from array info
int getNumArrDim(TableNode *definition) {
if (strcmp(getType(definition), "array") != 0) {
printf("not checking the dim of an array -- invalid op\n");
return 0;}
return 0;
}
return definition->additionalinfo->ArrayAdInfo->numofdimensions;
}
//This gets the type stored in an array from arrtype. It returns a reference to the entry of that type
TableNode* getArrType(TableNode* definition){
if(strcmp(getType(definition),"array")!=0){
// This gets the type stored in an array from arrtype. It returns a reference to
// the entry of that type
TableNode *getArrType(TableNode *definition) {
if (strcmp(getType(definition), "array") != 0) {
printf("not checking the type of an array -- invalid op\n");
return NULL;}
return NULL;
}
return definition->additionalinfo->ArrayAdInfo->typeofarray;
}
//Record type currently stores the number of elements as well as the types, in order, of what make up that type in an array.
//Unfortunately this second part should probably instead be replaced by a reference to a scope in which those elements are found.
AdInfo* CreateRecordInfo(int length, TableNode* typesarray){
AdInfo* info = (AdInfo*)malloc(sizeof(AdInfo));
info->RecAdInfo = (record_info*)malloc(sizeof(record_info));
info->RecAdInfo->numofelements=length;
//replace below with reference to a scope, not an array
// Record type currently stores the number of elements as well as the types, in
// order, of what make up that type in an array. Unfortunately this second part
// should probably instead be replaced by a reference to a scope in which those
// elements are found.
AdInfo *CreateRecordInfo(int length, TableNode *typesarray) {
AdInfo *info = (AdInfo *)malloc(sizeof(AdInfo));
info->RecAdInfo = (record_info *)malloc(sizeof(record_info));
info->RecAdInfo->numofelements = length;
// replace below with reference to a scope, not an array
info->RecAdInfo->listoftypes = typesarray;
return info;
}
//This gets the number of elements that make up a record.
//Perhaps this may not be needed since we need to iterate over all elements anyways.
int getRecLength(TableNode* definition){
if(strcmp(getType(definition),"record")!=0){
// This gets the number of elements that make up a record.
// Perhaps this may not be needed since we need to iterate over all elements
// anyways.
int getRecLength(TableNode *definition) {
if (strcmp(getType(definition), "record") != 0) {
printf("not checking the length of an record -- invalid op\n");
return 0;}
return 0;
}
return definition->additionalinfo->RecAdInfo->numofelements;
}
//This gets the array. Needs to up be updated to get the scope instead
TableNode* getRecList(TableNode* definition){
if(strcmp(getType(definition),"record")!=0){
printf("not checking the list of types of a record -- invalid op\n");
return NULL;}
// This gets the array. Needs to up be updated to get the scope instead
TableNode *getRecList(TableNode *definition) {
if (strcmp(getType(definition), "record") != 0) {
printf("not checking the list of types of a record -- invalid "
"op\n");
return NULL;
}
return definition->additionalinfo->RecAdInfo->listoftypes;
}
//below function takes a bool to see if parameter should be decomposed or not
//note that functions only take one input and have one output
//using "as" the input record can be decomposed to give the illusion of multiple inputs
//Below function also has the line number where the function is first defined
AdInfo* CreateFunctionDeclarationInfo(int line, bool asorregular){
AdInfo* info = (AdInfo*)malloc(sizeof(AdInfo));
info->FunDecAdInfo = (function_declaration_info*)malloc(sizeof(function_declaration_info));
info->FunDecAdInfo->startlinenumber=line;
// below function takes a bool to see if parameter should be decomposed or not
// note that functions only take one input and have one output
// using "as" the input record can be decomposed to give the illusion of
// multiple inputs Below function also has the line number where the function is
// first defined
AdInfo *CreateFunctionDeclarationInfo(int line, bool asorregular) {
AdInfo *info = (AdInfo *)malloc(sizeof(AdInfo));
info->FunDecAdInfo = (function_declaration_info *)malloc(
sizeof(function_declaration_info));
info->FunDecAdInfo->startlinenumber = line;
info->FunDecAdInfo->regularoras = asorregular;
return info;
}
//gets the line at which the function was first defined. (Can be used to print out in table if needed)
int getStartLine(TableNode* definition){
if(strcmp(getType(definition),"function primitive")!=0){
printf("not checking the start line of a function -- invalid op\n");
return 0;}
// gets the line at which the function was first defined. (Can be used to print
// out in table if needed)
int getStartLine(TableNode *definition) {
if (strcmp(getType(definition), "function primitive") != 0) {
printf("not checking the start line of a function -- invalid "
"op\n");
return 0;
}
return definition->additionalinfo->FunDecAdInfo->startlinenumber;
}
//checks if "as" keyword was used for function definition. Either 0 or 1 for not used or used.
bool getAsKeyword(TableNode* definition){
if(strcmp(getType(definition),"function primitive")!=0){
printf("not checking if a function is called with as or not -- invalid op\n");
return NULL;}
// checks if "as" keyword was used for function definition. Either 0 or 1 for
// not used or used.
bool getAsKeyword(TableNode *definition) {
if (strcmp(getType(definition), "function primitive") != 0) {
printf("not checking if a function is called with as or not -- "
"invalid op\n");
return NULL;
}
return definition->additionalinfo->FunDecAdInfo->regularoras;
}
//stores the type of a function (parameter type and return type)
AdInfo* CreateFunctionTypeInfo(TableNode* parameter, TableNode* returntype){
AdInfo* info = (AdInfo*)malloc(sizeof(AdInfo));
info->FunTypeAdInfo = (function_type_info*)malloc(sizeof(function_type_info));
info->FunTypeAdInfo->parameter=parameter;
// stores the type of a function (parameter type and return type)
AdInfo *CreateFunctionTypeInfo(TableNode *parameter, TableNode *returntype) {
AdInfo *info = (AdInfo *)malloc(sizeof(AdInfo));
info->FunTypeAdInfo =
(function_type_info *)malloc(sizeof(function_type_info));
info->FunTypeAdInfo->parameter = parameter;
info->FunTypeAdInfo->returntype = returntype;
return info;
}
//returns parameter type of a function
TableNode* getParameter(TableNode* definition){
if(strcmp(getType(definition),"function type primitive")!=0){
printf("not checking the parameter of a function -- invalid op\n");
return NULL;}
// returns parameter type of a function
TableNode *getParameter(TableNode *definition) {
if (strcmp(getType(definition), "function type primitive") != 0) {
printf(
"not checking the parameter of a function -- invalid op\n");
return NULL;
}
return definition->additionalinfo->FunTypeAdInfo->parameter;
}
//returns return type of a function
TableNode* getReturn(TableNode* definition){
if(strcmp(getType(definition),"function type primitive")!=0){
// returns return type of a function
TableNode *getReturn(TableNode *definition) {
if (strcmp(getType(definition), "function type primitive") != 0) {
printf("not checking the return of a function -- invalid op\n");
return NULL;}
return NULL;
}
return definition->additionalinfo->FunTypeAdInfo->returntype;
}
//creates a new scope (not the top scope though)
SymbolTable* CreateScope(SymbolTable* ParentScope, int Line, int Column) {
SymbolTable* table = (SymbolTable*)malloc(sizeof(SymbolTable));
// creates a new scope (not the top scope though)
SymbolTable *CreateScope(SymbolTable *ParentScope, int Line, int Column) {
SymbolTable *table = (SymbolTable *)malloc(sizeof(SymbolTable));
table->Line_Number = Line;
table->Column_Number = Column;
table->Parent_Scope = ParentScope;
@ -223,16 +247,18 @@ SymbolTable* CreateScope(SymbolTable* ParentScope, int Line, int Column) {
table->entries = NULL;
if (ParentScope != NULL) {
if (ParentScope->Children_Scope == NULL) {
ListOfTable* newEntry = (ListOfTable*)malloc(sizeof(ListOfTable));
ListOfTable *newEntry =
(ListOfTable *)malloc(sizeof(ListOfTable));
newEntry->next = NULL;
// newEntry->prev = NULL;
newEntry->table = table;
ParentScope->Children_Scope = newEntry;
} else {
ListOfTable* newEntry = (ListOfTable*)malloc(sizeof(ListOfTable));
ListOfTable *newEntry =
(ListOfTable *)malloc(sizeof(ListOfTable));
// newEntry->prev = NULL;
newEntry->table = table;
ListOfTable* oldEntry = ParentScope->Children_Scope;
ListOfTable *oldEntry = ParentScope->Children_Scope;
ParentScope->Children_Scope = newEntry;
newEntry->next = oldEntry;
}
@ -240,143 +266,150 @@ SymbolTable* CreateScope(SymbolTable* ParentScope, int Line, int Column) {
return table;
}
//create entry just for things below top level scope
//This function defines the integer, address, character, and bool primitive types
SymbolTable* init(SymbolTable* start){
if(start->Parent_Scope != NULL){
printf("Cannot initialize a scope that is not the parent scope\n");
return NULL;
}
integ = (TableNode*)malloc(sizeof(TableNode));
addr = (TableNode*)malloc(sizeof(TableNode));
chara = (TableNode*)malloc(sizeof(TableNode));
stri = (TableNode*)malloc(sizeof(TableNode));
boo = (TableNode*)malloc(sizeof(TableNode));
//TableNode* arr = (TableNode*)malloc(sizeof(SymbolTable));
start->entries = integ;
integ->next = addr;
addr->next = chara;
chara->next = stri;
stri->next = boo;
//boo->next = arr;
boo->next = NULL;
// create entry just for things below top level scope
// This function defines the integer, address, character, and bool primitive
// types
SymbolTable *init(SymbolTable *start) {
if (start->Parent_Scope != NULL) {
printf(
"Cannot initialize a scope that is not the parent scope\n");
return NULL;
}
integ = (TableNode *)malloc(sizeof(TableNode));
addr = (TableNode *)malloc(sizeof(TableNode));
chara = (TableNode *)malloc(sizeof(TableNode));
stri = (TableNode *)malloc(sizeof(TableNode));
boo = (TableNode *)malloc(sizeof(TableNode));
// TableNode* arr = (TableNode*)malloc(sizeof(SymbolTable));
start->entries = integ;
integ->next = addr;
addr->next = chara;
chara->next = stri;
stri->next = boo;
// boo->next = arr;
boo->next = NULL;
integ->theName= "integer";
addr->theName= "address";
chara->theName= "character";
boo->theName= "Boolean";
stri->theName= "string";
//arr->theName= "array"
//root TableNode that all are pointing to but not in table
//This is only to solve the issue that all entries must have a name and a type
//and the type must point to an actual table entry
//Again, this primitive table entry isn't in the top scope. It is outside the top scope and is only there
//to facilitate the fact that these are primitive
TableNode* prime = (TableNode*)malloc(sizeof(TableNode));
prime->theName= "primitive";
prime->theType=NULL;
prime->additionalinfo = NULL;
prime->next = NULL;
//not sure exatly how to get array types to look right so using a dummy Table Node below and updating the print symbol table function to access the additional information to print for array types, similar to function types
//when printing symbol table, if array is seen
arrayprim = (TableNode*)malloc(sizeof(TableNode));
arrayprim->theName= "array";
arrayprim->theType=NULL;
integ->theName = "integer";
addr->theName = "address";
chara->theName = "character";
boo->theName = "Boolean";
stri->theName = "string";
// arr->theName= "array"
// root TableNode that all are pointing to but not in table
// This is only to solve the issue that all entries must have a name and
// a type and the type must point to an actual table entry Again, this
// primitive table entry isn't in the top scope. It is outside the top
// scope and is only there to facilitate the fact that these are
// primitive
TableNode *prime = (TableNode *)malloc(sizeof(TableNode));
prime->theName = "primitive";
prime->theType = NULL;
prime->additionalinfo = NULL;
prime->next = NULL;
// not sure exatly how to get array types to look right so using a dummy
// Table Node below and updating the print symbol table function to
// access the additional information to print for array types, similar
// to function types when printing symbol table, if array is seen
arrayprim = (TableNode *)malloc(sizeof(TableNode));
arrayprim->theName = "array";
arrayprim->theType = NULL;
arrayprim->additionalinfo = NULL;
prime->next = NULL;
//funprime = CreateEntry(NULL,NULL,strdup("function primitive"),NULL);
//similar workaround to arrays above
funprime = (TableNode*)malloc(sizeof(TableNode));
funprime->theName= "primitive function";
funprime->theType=NULL;
// funprime = CreateEntry(NULL,NULL,strdup("function primitive"),NULL);
// similar workaround to arrays above
funprime = (TableNode *)malloc(sizeof(TableNode));
funprime->theName = "primitive function";
funprime->theType = NULL;
funprime->additionalinfo = NULL;
funprime->next = NULL;
//record
recprime = (TableNode*)malloc(sizeof(TableNode));
recprime->theName= "record";
recprime->theType=NULL;
// record
recprime = (TableNode *)malloc(sizeof(TableNode));
recprime->theName = "record";
recprime->theType = NULL;
recprime->additionalinfo = NULL;
recprime->next = NULL;
funtypeprime = (TableNode*)malloc(sizeof(TableNode));
funtypeprime->theName= "primitive function type";
funtypeprime->theType=NULL;
funtypeprime = (TableNode *)malloc(sizeof(TableNode));
funtypeprime->theName = "primitive function type";
funtypeprime->theType = NULL;
funtypeprime->additionalinfo = NULL;
funtypeprime->next = NULL;
integ->theType=prime;
addr->theType=prime;
chara->theType=prime;
stri->theType=arrayprim;
boo->theType=prime;
//arr->theType=arrayprim;
//filling in all the values for the additional info for initial types
//These numbers below for create primitive specifically are supposed to be the size
//of these primitive types. We can change these if needed to not be hard coded numbers
//as a reminder, stri below is defined as a one dimensional array of characters
integ->additionalinfo = CreatePrimitiveInfo(4);
addr->additionalinfo = CreatePrimitiveInfo(8);
integ->theType = prime;
addr->theType = prime;
chara->theType = prime;
stri->theType = arrayprim;
boo->theType = prime;
// arr->theType=arrayprim;
// filling in all the values for the additional info for initial types
// These numbers below for create primitive specifically are supposed to
// be the size of these primitive types. We can change these if needed
// to not be hard coded numbers as a reminder, stri below is defined as
// a one dimensional array of characters
integ->additionalinfo = CreatePrimitiveInfo(4);
addr->additionalinfo = CreatePrimitiveInfo(8);
chara->additionalinfo = CreatePrimitiveInfo(1);
stri->additionalinfo = CreateArrayInfo(1,chara);
stri->additionalinfo = CreateArrayInfo(1, chara);
boo->additionalinfo = CreatePrimitiveInfo(1);
//addr->additionalinfo = CreatePrimitiveInfo(8);
// addr->additionalinfo = CreatePrimitiveInfo(8);
start->Line_Number = 1;
start->Column_Number = 1;
start->Parent_Scope = NULL;
start->Children_Scope = NULL;
return start;
}
TableNode* CreateEntry(SymbolTable* table, TableNode* typeOf, char* id, AdInfo* ad) {
if(table ==NULL){
printf("Null reference to table");
return NULL;
}
/*
TableNode* topDef = (table_lookup(getAncestor(table),typeOf));
if(topDef == NULL){
printf("This type is not defined at the top level\n");
return NULL;
}
*/
if(typeOf == NULL){
printf("This is not pointing to a proper definition\n");
return NULL;
}
TableNode* newEntry = (TableNode*)malloc(sizeof(TableNode));
newEntry->theType = typeOf/*topDef*/;
newEntry->theName = id;
newEntry->additionalinfo = ad;
if (table->entries == NULL) {
table->entries = newEntry;
return newEntry;
} else {
TableNode* oldEntry = table->entries;
table->entries = newEntry;
newEntry->next = oldEntry;
return newEntry;
}
return start;
}
char* getType(TableNode* tn) { return tn->theType->theName; }
char* getName(TableNode* tn) { return tn->theName; }
int getLine(SymbolTable* st) { return st->Line_Number; }
int getColumn(SymbolTable* st) { return st->Column_Number; }
TableNode *CreateEntry(SymbolTable *table, TableNode *typeOf, char *id,
AdInfo *ad) {
if (table == NULL) {
printf("Null reference to table");
return NULL;
}
/*
TableNode* topDef = (table_lookup(getAncestor(table),typeOf));
if(topDef == NULL){
printf("This type is not defined at the top level\n");
return NULL;
}
*/
if (typeOf == NULL) {
printf("This is not pointing to a proper definition\n");
return NULL;
}
TableNode *newEntry = (TableNode *)malloc(sizeof(TableNode));
newEntry->theType = typeOf /*topDef*/;
newEntry->theName = id;
newEntry->additionalinfo = ad;
if (table->entries == NULL) {
table->entries = newEntry;
return newEntry;
} else {
TableNode *oldEntry = table->entries;
table->entries = newEntry;
newEntry->next = oldEntry;
return newEntry;
}
}
char *getType(TableNode *tn) { return tn->theType->theName; }
char *getName(TableNode *tn) { return tn->theName; }
int getLine(SymbolTable *st) { return st->Line_Number; }
int getColumn(SymbolTable *st) { return st->Column_Number; }
/*
//we use false for type defs and true for functions for parameter of typeOf
TableNode* Define(SymbolTable* table, bool typeOf, char* id) {
if(table ==NULL || table->Parent_Scope != NULL){
printf("No valid table given for header defs\n");
return NULL;
printf("No valid table given for header defs\n");
return NULL;
}
@ -384,14 +417,14 @@ if(table ==NULL || table->Parent_Scope != NULL){
//possible issues with referencing text instead of heap
if(typeOf == 0){
newEntry->theType = typey;
newEntry->theType = typey;
}
if (typeOf == 1){
newEntry->theType = funy;
newEntry->theType = funy;
}
if(table_lookup(table,id) != NULL){
printf("already defined at the top level, can't define duplicate names\n");
return NULL;
printf("already defined at the top level, can't define duplicate
names\n"); return NULL;
}
newEntry->theName = id;
if (table->entries == NULL) {
@ -406,8 +439,8 @@ if(table_lookup(table,id) != NULL){
}
*/
TableNode* table_lookup(SymbolTable* table, char* x) {
TableNode* entrie = table->entries;
TableNode *table_lookup(SymbolTable *table, char *x) {
TableNode *entrie = table->entries;
for (; entrie != NULL; entrie = entrie->next) {
if (!strcmp(entrie->theName, x)) {
return entrie;
@ -415,65 +448,71 @@ TableNode* table_lookup(SymbolTable* table, char* x) {
}
return NULL;
}
TableNode* look_up(SymbolTable* table, char* x) {
TableNode *look_up(SymbolTable *table, char *x) {
if (table == NULL) {
return NULL;
}
TableNode* ret = table_lookup(table, x);
TableNode *ret = table_lookup(table, x);
if (ret != NULL) {
return ret;
}
return look_up(table->Parent_Scope, x);
}
void print_symbol_table(SymbolTable* table, FILE* file_ptr) {
void print_symbol_table(SymbolTable *table, FILE *file_ptr) {
if (table->Parent_Scope == NULL) {
fprintf(file_ptr, "%-17s: %-6s : %-6s : %-21s: %-28s\n", "NAME", "SCOPE",
"PARENT", "TYPE", "Extra annotation");
fprintf(file_ptr, "%-17s: %-6s : %-6s : %-21s: %-28s\n", "NAME",
"SCOPE", "PARENT", "TYPE", "Extra annotation");
}
TableNode* entrie = table->entries;
fprintf(file_ptr,
"-----------------:--------:--------:----------------------:---------"
"--------------------\n");
TableNode *entrie = table->entries;
fprintf(file_ptr, "-----------------:--------:--------:----------------"
"------:---------"
"--------------------\n");
int parant_scope = 0;
int current_scope = 0;
if (table->Parent_Scope != NULL) {
parant_scope = table->Parent_Scope->Line_Number * 1000 +
table->Parent_Scope->Column_Number;
current_scope = table->Line_Number * 1000 + table->Column_Number;
table->Parent_Scope->Column_Number;
current_scope =
table->Line_Number * 1000 + table->Column_Number;
} else {
current_scope = 1001;
}
if ( entrie == NULL ) {
fprintf(file_ptr, "%-17s: %06d : %06d : %-21s: %-28s\n", "",
current_scope, parant_scope, "", "Empty Scope");
if (entrie == NULL) {
fprintf(file_ptr, "%-17s: %06d : %06d : %-21s: %-28s\n", "",
current_scope, parant_scope, "", "Empty Scope");
}
for (; entrie != NULL; entrie = entrie->next) {
if (parant_scope == 0) {
/*have to update*/ if(strcmp(entrie->theType->theName,"function primitive")|| strcmp(entrie->theType->theName,"array")){
}
fprintf(file_ptr, "%-17s: %06d : : %-21s: %-28s\n",
entrie->theName, current_scope, entrie->theType->theName,
"Extra annotation");
/*have to update*/ if (strcmp(entrie->theType->theName,
"function primitive") ||
strcmp(entrie->theType->theName,
"array")) {
}
fprintf(file_ptr,
"%-17s: %06d : : %-21s: %-28s\n",
entrie->theName, current_scope,
entrie->theType->theName, "Extra annotation");
} else {
fprintf(file_ptr, "%-17s: %06d : %06d : %-21s: %-28s\n", entrie->theName,
current_scope, parant_scope, entrie->theType->theName, "Extra annotation");
fprintf(file_ptr, "%-17s: %06d : %06d : %-21s: %-28s\n",
entrie->theName, current_scope, parant_scope,
entrie->theType->theName, "Extra annotation");
}
}
if (table->Children_Scope != NULL) {
ListOfTable* node = table->Children_Scope;
ListOfTable *node = table->Children_Scope;
for (; node != NULL; node = node->next) {
print_symbol_table(node->table, file_ptr);
}
}
if (table->Parent_Scope == NULL) {
fprintf(file_ptr,
"-----------------:--------:--------:----------------------:-------"
"----------------------\n");
fprintf(file_ptr, "-----------------:--------:--------:--------"
"--------------:-------"
"----------------------\n");
}
}
SymbolTable* getAncestor(SymbolTable* table) {
SymbolTable *getAncestor(SymbolTable *table) {
if (table->Parent_Scope == NULL) {
// if table has no parent, return itself
return table;
@ -483,73 +522,78 @@ SymbolTable* getAncestor(SymbolTable* table) {
}
}
SymbolTable* removeEntry(SymbolTable* scope, char* search){
SymbolTable *removeEntry(SymbolTable *scope, char *search) {
if(scope == NULL){
return NULL;
}
if(scope->entries == NULL){
return scope;
if (scope == NULL) {
return NULL;
}
if (scope->entries == NULL) {
return scope;
}
TableNode *prev = NULL;
TableNode *now = scope->entries;
while (now != NULL) {
if (strcmp(getName(now), search) == 0) {
if (prev == NULL) {
scope->entries = getNextEntry(now);
return scope;
} else {
prev->next = now->next;
return scope;
}
}
prev = now;
now = now->next;
}
return scope;
}
TableNode* prev = NULL;
TableNode* now = scope->entries;
bool typeCheck(char *firstID, char *secondID) {
while(now != NULL){
if(strcmp(getName(now),search)==0){
if(prev == NULL){
scope->entries = getNextEntry(now);
return scope;
} else{
prev->next = now->next;
return scope;
}
}
prev = now;
now = now->next;
}
return scope;
}
bool typeCheck(char* firstID, char* secondID){
TableNode* entry1 = look_up(cur,firstID);
TableNode* entry2 = look_up(cur,secondID);
if(entry1==NULL){
printf("first type not defined\n");
return false;
}
if(entry2==NULL){
TableNode *entry1 = look_up(cur, firstID);
TableNode *entry2 = look_up(cur, secondID);
if (entry1 == NULL) {
printf("first type not defined\n");
return false;
}
if (entry2 == NULL) {
printf("second type not defined\n");
return false;
}
if(table_lookup(getAncestor(cur),getType(look_up(cur,firstID))) ==
table_lookup(getAncestor(cur),getType(look_up(cur,secondID)))){
if(strcmp(getType(look_up(cur,firstID)),"array")==0){
if(look_up(cur,firstID)->additionalinfo->ArrayAdInfo->numofdimensions ==
look_up(cur,secondID)->additionalinfo->ArrayAdInfo->numofdimensions &&
look_up(cur,firstID)->additionalinfo->ArrayAdInfo->typeofarray ==
look_up(cur,secondID)->additionalinfo->ArrayAdInfo->typeofarray){
return true;}
else{
return false;}
if (table_lookup(getAncestor(cur), getType(look_up(cur, firstID))) ==
table_lookup(getAncestor(cur), getType(look_up(cur, secondID)))) {
if (strcmp(getType(look_up(cur, firstID)), "array") == 0) {
if (look_up(cur, firstID)
->additionalinfo->ArrayAdInfo
->numofdimensions ==
look_up(cur, secondID)
->additionalinfo->ArrayAdInfo
->numofdimensions &&
look_up(cur, firstID)
->additionalinfo->ArrayAdInfo
->typeofarray ==
look_up(cur, secondID)
->additionalinfo->ArrayAdInfo
->typeofarray) {
return true;
} else {
return false;
}
}
return true;
}
return false;
return true;
}
return false;
}
SymbolTable *getParent(SymbolTable *st) { return st->Parent_Scope; }
SymbolTable* getParent(SymbolTable* st) { return st->Parent_Scope; }
ListOfTable* getChildren(SymbolTable* st) { return st->Children_Scope; }
SymbolTable* getFirstChild(ListOfTable* lt) { return lt->table; }
ListOfTable* getRestOfChildren(ListOfTable* lt) { return lt->next; }
TableNode* getFirstEntry(SymbolTable* st) { return st->entries; }
TableNode* getNextEntry(TableNode* tn) { return tn->next; }
ListOfTable *getChildren(SymbolTable *st) { return st->Children_Scope; }
SymbolTable *getFirstChild(ListOfTable *lt) { return lt->table; }
ListOfTable *getRestOfChildren(ListOfTable *lt) { return lt->next; }
TableNode *getFirstEntry(SymbolTable *st) { return st->entries; }
TableNode *getNextEntry(TableNode *tn) { return tn->next; }
// uncomment the below main function along with the headers above for a simple
// standalone test of table and entry creation