544 lines
18 KiB
C
544 lines
18 KiB
C
/* Symbol Table */
|
|
/* The Translators - Spring 2025 */
|
|
|
|
#include "symbol_table.h"
|
|
|
|
#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;
|
|
|
|
|
|
|
|
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
|
|
|
|
} types;
|
|
|
|
/* put in symbol_table.h
|
|
typedef struct{
|
|
int size;
|
|
}primitive_info;
|
|
|
|
typedef struct{
|
|
int length;
|
|
char* location;
|
|
}string_info;
|
|
|
|
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;
|
|
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
|
|
int numofelements;
|
|
TableNode* listoftypes;
|
|
}record_info;
|
|
|
|
typedef struct{
|
|
int startlinenumber;
|
|
bool regularoras;
|
|
}function_declaration_info;
|
|
|
|
typedef struct{
|
|
TableNode* parameter;
|
|
TableNode* returntype;
|
|
}function_type_info;
|
|
|
|
typedef union {
|
|
PrimAdInfo* primitive_info;
|
|
ArrayAdInfo* array_info;
|
|
RecAdInfo* record_info;
|
|
StringAdInfo* string_info;
|
|
FunDecAdInfo* func_dec_info;
|
|
FunTypeAdInfo* func_type_info;
|
|
}AdInfo;
|
|
*/
|
|
|
|
AdInfo* CreatePrimitiveInfo(int size){
|
|
|
|
AdInfo* info = (AdInfo*)malloc(sizeof(AdInfo));
|
|
info->PrimAdInfo = (primitive_info*)malloc(sizeof(primitive_info));
|
|
info->PrimAdInfo->size=size;
|
|
return info;
|
|
}
|
|
|
|
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
|
|
/*string_info* CreateStringInfo(int length, char* loc){
|
|
string_info* stringy = (string_info*)malloc(sizeof(string_info));
|
|
stringy.length=length;
|
|
char* location = loc;
|
|
return stringy;
|
|
}
|
|
*/
|
|
|
|
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;
|
|
}
|
|
|
|
int getNumArrDim(TableNode* definition){
|
|
if(strcmp(getType(definition),"array")!=0){
|
|
printf("not checking the dim of an array -- invalid op\n");
|
|
return 0;}
|
|
return definition->additionalinfo->ArrayAdInfo->numofdimensions;
|
|
}
|
|
|
|
TableNode* getArrType(TableNode* definition){
|
|
if(strcmp(getType(definition),"array")!=0){
|
|
printf("not checking the type of an array -- invalid op\n");
|
|
return NULL;}
|
|
return definition->additionalinfo->ArrayAdInfo->typeofarray;
|
|
}
|
|
|
|
AdInfo* CreateRecordInfo(int length, TableNode* typesarray){
|
|
AdInfo* info = (AdInfo*)malloc(sizeof(AdInfo));
|
|
info->RecAdInfo = (record_info*)malloc(sizeof(record_info));
|
|
info->RecAdInfo->numofelements=length;
|
|
info->RecAdInfo->listoftypes = typesarray;
|
|
return info;
|
|
}
|
|
|
|
int getRecLength(TableNode* definition){
|
|
if(strcmp(getType(definition),"record")!=0){
|
|
printf("not checking the length of an record -- invalid op\n");
|
|
return 0;}
|
|
return definition->additionalinfo->RecAdInfo->numofelements;
|
|
}
|
|
|
|
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
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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 definition->additionalinfo->FunTypeAdInfo->returntype;
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
table->Children_Scope = NULL;
|
|
table->entries = NULL;
|
|
if (ParentScope != NULL) {
|
|
if (ParentScope->Children_Scope == NULL) {
|
|
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));
|
|
// newEntry->prev = NULL;
|
|
newEntry->table = table;
|
|
ListOfTable* oldEntry = ParentScope->Children_Scope;
|
|
ParentScope->Children_Scope = newEntry;
|
|
newEntry->next = oldEntry;
|
|
}
|
|
}
|
|
return table;
|
|
}
|
|
|
|
//create entry just for things below top level scope
|
|
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 primitive";
|
|
//arr->theName= "array"
|
|
|
|
//root TableNode that all are pointing to but not in table
|
|
TableNode* prime = (TableNode*)malloc(sizeof(TableNode));
|
|
prime->theName= "primitive";
|
|
prime->theType=NULL;
|
|
prime->additionalinfo = NULL;
|
|
prime->next = NULL;
|
|
|
|
//note sur 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
|
|
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->additionalinfo = NULL;
|
|
funprime->next = 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->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
|
|
integ->additionalinfo = CreatePrimitiveInfo(4);
|
|
addr->additionalinfo = CreatePrimitiveInfo(8);
|
|
chara->additionalinfo = CreatePrimitiveInfo(1);
|
|
stri->additionalinfo = CreateArrayInfo(1,chara);
|
|
boo->additionalinfo = CreatePrimitiveInfo(1);
|
|
//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, char* 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;
|
|
}
|
|
TableNode* newEntry = (TableNode*)malloc(sizeof(TableNode));
|
|
newEntry->theType = 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;
|
|
}
|
|
|
|
|
|
TableNode* newEntry = (TableNode*)malloc(sizeof(TableNode));
|
|
|
|
//possible issues with referencing text instead of heap
|
|
if(typeOf == 0){
|
|
newEntry->theType = typey;
|
|
}
|
|
if (typeOf == 1){
|
|
newEntry->theType = funy;
|
|
}
|
|
if(table_lookup(table,id) != NULL){
|
|
printf("already defined at the top level, can't define duplicate names\n");
|
|
return NULL;
|
|
}
|
|
newEntry->theName = id;
|
|
if (table->entries == NULL) {
|
|
table->entries = newEntry;
|
|
return newEntry;
|
|
} else {
|
|
TableNode* oldEntry = table->entries;
|
|
table->entries = newEntry;
|
|
newEntry->next = oldEntry;
|
|
return newEntry;
|
|
}
|
|
|
|
}
|
|
*/
|
|
TableNode* table_lookup(SymbolTable* table, char* x) {
|
|
TableNode* entrie = table->entries;
|
|
for (; entrie != NULL; entrie = entrie->next) {
|
|
if (!strcmp(entrie->theName, x)) {
|
|
return entrie;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
TableNode* look_up(SymbolTable* table, char* x) {
|
|
if (table == NULL) {
|
|
return NULL;
|
|
}
|
|
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) {
|
|
if (table->Parent_Scope == NULL) {
|
|
fprintf(file_ptr, "%-17s: %-6s : %-6s : %-21s: %-28s\n", "NAME", "SCOPE",
|
|
"PARENT", "TYPE", "Extra annotation");
|
|
}
|
|
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;
|
|
} else {
|
|
current_scope = 1001;
|
|
}
|
|
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");
|
|
} else {
|
|
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;
|
|
for (; node != NULL; node = node->next) {
|
|
print_symbol_table(node->table, file_ptr);
|
|
}
|
|
}
|
|
if (table->Parent_Scope == NULL) {
|
|
fprintf(file_ptr,
|
|
"-----------------:--------:--------:----------------------:-------"
|
|
"----------------------\n");
|
|
}
|
|
}
|
|
|
|
SymbolTable* getAncestor(SymbolTable* table) {
|
|
if (table->Parent_Scope == NULL) {
|
|
// if table has no parent, return itself
|
|
return table;
|
|
} else {
|
|
// call function recursively to grab ancestor
|
|
return getAncestor(table->Parent_Scope);
|
|
}
|
|
}
|
|
|
|
SymbolTable* removeEntry(SymbolTable* scope, char* search){
|
|
|
|
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;
|
|
}
|
|
|
|
|
|
|
|
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){
|
|
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;}
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
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; }
|
|
// uncomment the below main function along with the headers above for a simple
|
|
// standalone test of table and entry creation
|
|
|
|
/*
|
|
int main(){
|
|
char* String = "STRING";
|
|
char* X = "X";
|
|
SymbolTable* Second = CreateScope(NULL, 2,2);
|
|
printf("Line number is %d, Column number of scope is
|
|
%d\n",Second->Line_Number,Second->Column_Number); TableNode* First_Entry =
|
|
CreateEntry(Second,String,X);
|
|
|
|
printf("The type of the first entry is %s\n",First_Entry->theType);
|
|
return 0;
|
|
}
|
|
*/
|