870 lines
31 KiB
C
870 lines
31 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;
|
|
TableNode *undefined;
|
|
|
|
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 = 1,
|
|
// Array can be multidimensional. Information should be stored here
|
|
TYPE_ARRAY = 2,
|
|
// Record is user defined types
|
|
TYPE_RECORD = 3,
|
|
// Declaring what type a particular function is without as
|
|
TYPE_FUNCTION_DECLARATION = 4,
|
|
// 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 = 5,
|
|
// The Type being pointed to by the first 4 above that only stores the
|
|
// size
|
|
TYPE_PRIMITIVE = 6,
|
|
//likely NULL
|
|
TYPE_ALL_ELSE = 7,
|
|
TYPE_UNDEFINED = 8
|
|
|
|
} types;
|
|
|
|
/* put in symbol_table.h
|
|
typedef struct{
|
|
int size; if(strcmp(getType(tn),getName(integ))==0){
|
|
return
|
|
}
|
|
}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;
|
|
*/
|
|
// 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;
|
|
}
|
|
|
|
// only gets the size of a primitive type
|
|
int getPrimSize(TableNode *definition) {
|
|
if (definition == NULL){
|
|
printf("passed an NULL entry to getPrimSize function. Invalid.\n");
|
|
return -1;
|
|
}
|
|
if (definition->additionalinfo == NULL){
|
|
printf("node has NULL additionalinfo. Invalid.\n");
|
|
return -1;
|
|
}
|
|
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;
|
|
}
|
|
*/
|
|
|
|
// 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 (definition == NULL){
|
|
printf("passed an NULL entry to getNumArrDim function. Invalid.\n");
|
|
return -1;
|
|
}
|
|
if (strcmp(getType(definition), "array") != 0) {
|
|
printf("not checking the dim of an array -- invalid op\n");
|
|
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) {
|
|
printf("not checking the type of an array -- invalid op\n");
|
|
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, SymbolTable *recordScope) {
|
|
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->recordScope = recordScope;
|
|
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) {
|
|
printf("not checking the length of an record -- invalid op\n");
|
|
return 0;
|
|
}
|
|
return definition->additionalinfo->RecAdInfo->numofelements;
|
|
}
|
|
// This gets the array. Needs to up be updated to get the scope instead
|
|
SymbolTable *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->recordScope;
|
|
}
|
|
|
|
TableNode* setRecSize(TableNode* tn, int n){
|
|
if(tn == NULL){
|
|
printf("passed in NULL entry for setRecSize. Invalid\n");
|
|
return NULL;
|
|
}
|
|
tn->additionalinfo->RecAdInfo->numofelements = n;
|
|
return tn;
|
|
}
|
|
|
|
int getRecSize(SymbolTable* tn){
|
|
int s = 0;
|
|
TableNode* cur = getFirstEntry(tn);
|
|
while(getNextEntry(cur) != NULL){
|
|
s++;
|
|
cur = getNextEntry(cur);
|
|
}
|
|
return s;
|
|
}
|
|
|
|
// below function takes a bool to see if parameter should be decomposed or not
|
|
assignable:
|
|
ID {$$ = $1; }
|
|
| assignable ablock {$$ = getName(getReturn(look_up(cur, $1)));}
|
|
| assignable rec_op ID {TableNode * tn; if(NULL != (tn = table_lookup(getRecList(look_up(cur, $1)), $3)))
|
|
{$$ = getType(tn);}
|
|
}
|
|
;// 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), "primitive function") != 0) {
|
|
printf("not checking the start line of a function -- invalid "
|
|
"op\n");
|
|
return 0;
|
|
}
|
|
return definition->additionalinfo->FunDecAdInfo->startlinenumber;
|
|
}
|
|
|
|
TableNode* setStartLine(TableNode* tn, int start){
|
|
if(tn == NULL){
|
|
printf("passing in a NULL entry to setStartLine. invalid\n");
|
|
return NULL;
|
|
}
|
|
tn->additionalinfo->FunDecAdInfo->startlinenumber = start;
|
|
return tn;
|
|
}
|
|
// 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), "primitive function") != 0) {
|
|
printf("not checking if a function is called with as or not -- "
|
|
"invalid op\n");
|
|
return NULL;
|
|
}
|
|
return definition->additionalinfo->FunDecAdInfo->regularoras;
|
|
}
|
|
|
|
TableNode* setAsKeyword(TableNode* tn, bool as){
|
|
if(tn == NULL){
|
|
printf("passing in a NULL entry to setAsKeyword. invalid\n");
|
|
return NULL;
|
|
}
|
|
tn->additionalinfo->FunDecAdInfo->regularoras = as;
|
|
return tn;
|
|
}
|
|
|
|
// 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), "primitive function type") != 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), "primitive function type") != 0) {
|
|
printf("not checking the return of a function -- invalid op\n");
|
|
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));
|
|
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
|
|
// 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;
|
|
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;
|
|
|
|
undefined = (TableNode *)malloc(sizeof(TableNode));
|
|
undefined->theName = "undefined";
|
|
undefined->theType = NULL;
|
|
undefined->additionalinfo = NULL;
|
|
undefined->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);
|
|
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* integ;
|
|
TableNode* addr;
|
|
TableNode* chara;
|
|
TableNode* stri;
|
|
TableNode* boo;
|
|
TableNode* recprime;
|
|
TableNode* funtypeprime;
|
|
*/
|
|
TableNode* populateTypeAndInfo(TableNode* tn, TableNode* type, AdInfo* info){
|
|
if(tn == NULL){
|
|
printf("passed in an invalid table node to modify (NULL).\n");
|
|
return NULL;
|
|
}
|
|
if(type == NULL){
|
|
printf("passed in a NULL type reference to populate a table node. Invalid.\n");
|
|
return NULL;
|
|
}
|
|
if(info == NULL){
|
|
printf("passed in a NULL info reference to populate a table node. Invalid.\n");
|
|
return NULL;
|
|
}
|
|
tn->theType = type;
|
|
tn->additionalinfo = info;
|
|
//returning reference to modified table node
|
|
return tn;
|
|
}
|
|
|
|
int getAdInfoType(TableNode* tn){
|
|
if(tn == NULL){
|
|
printf("passing in NULL table entry. Invalid\n");
|
|
return -1;
|
|
}
|
|
if(tn->theType == NULL){
|
|
printf("Entry being passed in has a null reference for theType. Invalid.\n");
|
|
return -1;
|
|
}
|
|
if(strcmp(getType(tn),getName(integ))==0){
|
|
return TYPE_PRIMITIVE;
|
|
}
|
|
if(strcmp(getType(tn),getName(addr))==0){
|
|
return TYPE_PRIMITIVE;
|
|
}
|
|
if(strcmp(getType(tn),getName(chara))==0){
|
|
return TYPE_PRIMITIVE;
|
|
}
|
|
if(strcmp(getType(tn),getName(stri))==0){
|
|
return TYPE_ARRAY;
|
|
}
|
|
if(strcmp(getType(tn),getName(boo))==0){
|
|
return TYPE_PRIMITIVE;
|
|
}
|
|
if(strcmp(getType(tn),getName(recprime))==0){
|
|
return TYPE_RECORD;
|
|
}
|
|
if(strcmp(getType(tn),getName(funtypeprime))==0){
|
|
return TYPE_FUNCTION_TYPE;
|
|
}
|
|
if(strcmp(getType(tn),getName(arrayprim))==0){
|
|
return TYPE_ARRAY;
|
|
}
|
|
if(strcmp(getType(tn),getName(undefined))==0){
|
|
return TYPE_UNDEFINED;
|
|
}
|
|
else{
|
|
return TYPE_FUNCTION_DECLARATION;
|
|
}
|
|
}
|
|
|
|
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) {
|
|
if(tn == NULL){
|
|
printf("passed a NULL table entry to getType\n");
|
|
return getName(undefined);
|
|
}
|
|
if(tn->theType == NULL){
|
|
printf("type of entry is currently NULL, undefined type \n");
|
|
return getName(undefined);
|
|
}
|
|
return tn->theType->theName; }
|
|
|
|
char *getName(TableNode *tn) {
|
|
if(tn == NULL){
|
|
printf("passed a NULL table entry to getName\n");
|
|
return undefined->theName;
|
|
}
|
|
if(tn->theName == NULL){
|
|
printf("name of entry is currently NULL, undefined \n");
|
|
return undefined->theName;
|
|
}
|
|
return tn->theName;
|
|
}
|
|
|
|
int getLine(SymbolTable *st) { return st->Line_Number; }
|
|
int getColumn(SymbolTable *st) { return st->Column_Number; }
|
|
TableNode* addName(TableNode *tn, char* str){
|
|
if(tn == NULL){
|
|
printf("passed a Null table node to the addName function. Invalid./n");
|
|
return tn;
|
|
}
|
|
}
|
|
|
|
SymbolTable* setLineNumber(SymbolTable *st,int line){
|
|
if(st == NULL){
|
|
printf("passed a Null Symbol Table to the setLineNumber function. Invalid./n");
|
|
return st;
|
|
}
|
|
st->Line_Number = line;
|
|
return st;
|
|
}
|
|
|
|
SymbolTable* setColumnNumber(SymbolTable *st,int column){
|
|
if(st == NULL){
|
|
printf("passed a Null Symbol Table to the setColumnNumber function. Invalid./n");
|
|
return st;
|
|
}
|
|
st->Line_Number = column;
|
|
return st;
|
|
}
|
|
/*
|
|
//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;
|
|
}
|
|
|
|
}
|
|
*/
|
|
//only check table that is given
|
|
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 undefined;
|
|
}
|
|
//check current table and all parents
|
|
TableNode *look_up(SymbolTable *table, char *x) {
|
|
if (table == NULL) {
|
|
printf("passed in empty scope. error.\n");
|
|
return undefined;
|
|
}
|
|
TableNode *ret = table_lookup(table, x);
|
|
if (ret != NULL && ret != undefined) {
|
|
return ret;
|
|
}
|
|
printf("could not find %s in scope that started at line %d and column %d so moving up a scope\n"
|
|
,x,getLine(table),getColumn(table));
|
|
return look_up(table->Parent_Scope, x);
|
|
}
|
|
|
|
void print_symbol_table(SymbolTable *table, FILE *file_ptr) {
|
|
|
|
return;
|
|
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 (getAdInfoType(entrie) == TYPE_ARRAY){
|
|
if (parant_scope == 0) {
|
|
|
|
fprintf(file_ptr,
|
|
"%-17s: %06d : : %-21d -> %-21s: %-28s\n",
|
|
entrie->theName, current_scope,
|
|
entrie->additionalinfo->ArrayAdInfo->numofdimensions,
|
|
entrie->additionalinfo->ArrayAdInfo->typeofarray->theName,
|
|
"Type of Array");
|
|
} else {
|
|
fprintf(file_ptr, "%-17s: %06d : %06d : %-21d -> %-21s: %-28s\n",
|
|
entrie->theName, current_scope, parant_scope,
|
|
entrie->additionalinfo->ArrayAdInfo->numofdimensions,
|
|
entrie->additionalinfo->ArrayAdInfo->typeofarray->theName,
|
|
"Type of Array");
|
|
}
|
|
}
|
|
if (getAdInfoType(entrie) == TYPE_RECORD){
|
|
if (parant_scope == 0) {
|
|
|
|
fprintf(file_ptr,
|
|
"%-17s: %06d : :%-21s: elements-%-28d\n",
|
|
entrie->theName, current_scope,
|
|
"record",
|
|
entrie->additionalinfo->RecAdInfo->numofelements);
|
|
} else {
|
|
fprintf(file_ptr, "%-17s: %06d : %06d : %-21s: elements-%-28d\n",
|
|
entrie->theName, current_scope, parant_scope,
|
|
"record",
|
|
entrie->additionalinfo->RecAdInfo->numofelements);
|
|
}
|
|
}
|
|
if (getAdInfoType(entrie) == TYPE_PRIMITIVE){
|
|
if (parant_scope == 0) {
|
|
|
|
fprintf(file_ptr,
|
|
"%-17s: %06d : :%-21s: size-%-28d bytes\n",
|
|
entrie->theName, current_scope,
|
|
"Primitive",
|
|
entrie->additionalinfo->PrimAdInfo->size);
|
|
} else {
|
|
fprintf(file_ptr, "%-17s: %06d : %06d : %-21s: size-%-28d bytes\n",
|
|
entrie->theName, current_scope, parant_scope,
|
|
"Primitive",
|
|
entrie->additionalinfo->PrimAdInfo->size);
|
|
}
|
|
}
|
|
if (getAdInfoType(entrie) == TYPE_FUNCTION_TYPE){
|
|
if (parant_scope == 0) {
|
|
|
|
fprintf(file_ptr,
|
|
"%-17s: %06d : : %-21s -> %-21s: %-28s\n",
|
|
entrie->theName, current_scope,
|
|
entrie->additionalinfo->FunTypeAdInfo->parameter->theName,
|
|
entrie->additionalinfo->FunTypeAdInfo->returntype->theName,
|
|
"Type of Function");
|
|
} else {
|
|
fprintf(file_ptr, "%-17s: %06d : %06d : %-21s -> %-21s: %-28s\n",
|
|
entrie->theName, current_scope, parant_scope,
|
|
entrie->additionalinfo->FunTypeAdInfo->parameter->theName,
|
|
entrie->additionalinfo->FunTypeAdInfo->returntype->theName,
|
|
"Type of Function");
|
|
}
|
|
}
|
|
if (getAdInfoType(entrie) == TYPE_FUNCTION_DECLARATION){
|
|
if (parant_scope == 0) {
|
|
|
|
fprintf(file_ptr,
|
|
"%-17s: %06d : :%-21s: %-28s\n",
|
|
entrie->theName, current_scope,
|
|
getType(entrie),
|
|
"Function");
|
|
} else {
|
|
fprintf(file_ptr, "%-17s: %06d : %06d : %-21s: %-28s\n",
|
|
entrie->theName, current_scope, parant_scope,
|
|
getType(entrie),
|
|
"Function");
|
|
}
|
|
}
|
|
}
|
|
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");
|
|
}
|
|
}
|
|
//get top most symbol table
|
|
SymbolTable *getAncestor(SymbolTable *table) {
|
|
if(table == NULL){
|
|
printf("passing a NULL reference to getAncestor. Invalid.\n");
|
|
return NULL;
|
|
}
|
|
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;
|
|
}
|
|
|
|
//almost certainly don't need to use the below function since type checking happens by passing types up the grammar
|
|
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;
|
|
}
|
|
*/
|