From 94b80b024d4ae9ff8ee97d7629603acc57b27964 Mon Sep 17 00:00:00 2001 From: Scarlett Date: Tue, 25 Mar 2025 17:02:14 -0400 Subject: [PATCH] Quick formatting updates --- src/grammar.y | 106 +++---- src/runner.c | 82 +++--- src/runner.h | 20 +- src/symbol_table.c | 694 ++++++++++++++++++++++++--------------------- src/symbol_table.h | 135 ++++----- 5 files changed, 532 insertions(+), 505 deletions(-) diff --git a/src/grammar.y b/src/grammar.y index 6c3cf9f..758b35d 100644 --- a/src/grammar.y +++ b/src/grammar.y @@ -2,30 +2,30 @@ /* The Translators - Spring 2025 */ %{ - #include - #include "../src/symbol_table.c" - #include - extern int yylex(void); - void yyerror(const char *err); - extern char* yytext; - extern int yyleng; - extern int yychar; - extern SymbolTable * cur; - //char* cur_value; - //char* cur_type; - int token_tracker; - extern int line_number; - extern int column_number; - extern FILE * yyin; - extern TableNode* funprime; - extern TableNode* arrayprim; - extern TableNode* recprime; - extern TableNode* funtypeprime; - extern TableNode* integ; - extern TableNode* addr; - extern TableNode* chara; - extern TableNode* stri; - extern TableNode* boo; + #include + #include "../src/symbol_table.c" + #include + extern int yylex(void); + void yyerror(const char *err); + extern char* yytext; + extern int yyleng; + extern int yychar; + extern SymbolTable * cur; + //char* cur_value; + //char* cur_type; + int token_tracker; + extern int line_number; + extern int column_number; + extern FILE * yyin; + extern TableNode* funprime; + extern TableNode* arrayprim; + extern TableNode* recprime; + extern TableNode* funtypeprime; + extern TableNode* integ; + extern TableNode* addr; + extern TableNode* chara; + extern TableNode* stri; + extern TableNode* boo; %} //%define api.location.type {location_t} %locations @@ -123,7 +123,8 @@ definition: | TYPE ID COLON constant ARROW ID | function_declaration | TYPE ID COLON id_or_types ARROW id_or_types { - CreateEntry(cur,funtypeprime,$2,CreateFunctionTypeInfo(table_lookup(cur,$4),table_lookup(cur,$6)));} + CreateEntry(cur,funtypeprime,$2,CreateFunctionTypeInfo(table_lookup(cur,$4),table_lookup(cur,$6))); + } | ID parameter ASSIGN sblock ; @@ -192,15 +193,12 @@ rec_op : DOT expression: - constant {printf("constant expression\n");} {$$ = $1;} | SUB_OR_NEG expression %prec UMINUS {printf("negative expression\n");if(strcmp($2,"integer") != 0) - {printf("cant negate something not an integer at line %d and column %d\n",@2.first_line,@2.first_column); - $$=strdup("undefined");}else{$$=$2;}} - + {printf("cant negate something not an integer at line %d and column %d\n",@2.first_line,@2.first_column); + $$=strdup("undefined");}else{$$=$2;}} | NOT expression {printf("not expression\n"); if(strcmp($2,"Boolean")==0){$$=$2;}else{$$=strdup("undefined"); - printf("mismatch at line %d and column %d\n",@1.first_line,@1.first_column);}} - + printf("mismatch at line %d and column %d\n",@1.first_line,@1.first_column);}} | expression ADD expression {printf("add expression\n");} | expression SUB_OR_NEG expression {printf("subtract expression\n");} | expression MUL expression {printf("multiply expression\n");} @@ -212,16 +210,16 @@ expression: | expression OR expression {printf("or expression\n");} | expression LESS_THAN expression {printf("less than expression\n");if(strcmp($1,$3)==0 && - strcmp($1,"integer")==0){$$=strdup("Boolean");}else{printf("mismatch at line %d and column %d\n",@2.first_line,@2.first_column); - $$=strdup("Boolean");$$=strdup("undefined");}} + strcmp($1,"integer")==0){$$=strdup("Boolean");}else{printf("mismatch at line %d and column %d\n",@2.first_line,@2.first_column); + $$=strdup("Boolean");$$=strdup("undefined");}} | expression EQUAL_TO expression {printf("equals check expression\n"); - if(strcmp($1,$3)==0){$$=strdup("Boolean");}else if((strcmp($1,"array")==0||strcmp($1,"record")==0|| -strcmp($1,"function type primitive")==0) && (strcmp($3,"address")==0)){$$=strdup("Boolean");} -else{printf("mismatch at line %d and column %d\n",@2.first_line,@2.first_column);$$=strdup("undefined");}} + if(strcmp($1,$3)==0){$$=strdup("Boolean");}else if((strcmp($1,"array")==0||strcmp($1,"record")==0|| + strcmp($1,"function type primitive")==0) && (strcmp($3,"address")==0)){$$=strdup("Boolean");} + else{printf("mismatch at line %d and column %d\n",@2.first_line,@2.first_column);$$=strdup("undefined");}} | assignable {printf("assignable expression\n");$$=$1;} | L_PAREN expression R_PAREN {printf("paren expression\n");$$=$2;} | memOp assignable {$$ = strdup("address");} - ; + ; ablock: @@ -250,9 +248,9 @@ constant: ; types: - // Commented out T_String below - // T_STRING {printf("string of T_STRING in types is %s\n",$1);} {$$ = $1;} - T_INTEGER {printf("string of T_INTEGER in types is %s\n",$1);} {$$ = $1;} + // Commented out T_String below + // T_STRING {printf("string of T_STRING in types is %s\n",$1);} {$$ = $1;} + T_INTEGER {printf("string of T_INTEGER in types is %s\n",$1);} {$$ = $1;} | T_ADDRESS {printf("string of T_ADDRESS in types is %s\n",$1);} {$$ = $1;} | T_CHARACTER {printf("string of T_CHARACTER in types is %s\n",$1);} {$$ = $1;} | T_BOOLEAN {printf("string of T_BOOLEAN in types is %s\n",$1);} {$$ = $1;} @@ -261,31 +259,5 @@ types: %% void yyerror(const char *err) { - fprintf(stderr, "ERROR: %s at token %s at line number %d,column number %d\n", err,yytext,yylloc.first_line,yylloc.first_column); + fprintf(stderr, "ERROR: %s at token %s at line number %d,column number %d\n", err,yytext,yylloc.first_line,yylloc.first_column); } -/* -int main(int argc, char * argv[]) { - token_tracker = 1; - cur=CreateScope(NULL,1,1); - //int a; - FILE * fp; - if(argc > 1){ - fp = fopen(argv[1], "r"); - yyin = fp; - } else { - fp = stdin; - yyin = fp; - } - yyparse(); - //while ((a = yyparse() != EOF){ - // token_tracker++; - //printf("%d = a: yytext = %s: yychar = %d, token number: %d\n", a, yytext, yychar,token_tracker); - //if(yytext[0] == '\n'){ - FILE* f = fdopen(1,"w"); - print_symbol_table(getAncestor(cur),f); - fclose(f); - // break; - //} - //} - return 0; -} */ diff --git a/src/runner.c b/src/runner.c index f2a96ef..8722425 100644 --- a/src/runner.c +++ b/src/runner.c @@ -2,13 +2,13 @@ /* The Translators - Spring 2025 */ #include "runner.h" -extern TableNode* funprime; -extern TableNode* arrayprim; -extern TableNode* integ; -extern TableNode* addr; -extern TableNode* chara; -extern TableNode* stri; -extern TableNode* boo; +extern TableNode *funprime; +extern TableNode *arrayprim; +extern TableNode *integ; +extern TableNode *addr; +extern TableNode *chara; +extern TableNode *stri; +extern TableNode *boo; int main(int argc, char *argv[]) { if (argc == 1) { @@ -29,13 +29,16 @@ int main(int argc, char *argv[]) { } else { - if (is_alpha_file(argv[argc - 1], strlen(argv[argc - 1])) != 0) { + if (is_alpha_file(argv[argc - 1], strlen(argv[argc - 1])) != + 0) { fprintf(stderr, INVALID); return -1; } else { for (int i = 1; i < argc - 1; i++) { if (check_flag(argv[i], argv[argc - 1]) != 0) { - fprintf(stderr, "INVALID FLAG(S): Use -help to view valid inputs \n"); + fprintf(stderr, + "INVALID FLAG(S): Use -help to " + "view valid inputs \n"); return -1; } } @@ -64,21 +67,22 @@ int check_flag(char *arg, char *alpha) { } } -void incr(int lnum,int cnum, int tok){ - //if (tok == COMMENT) { - for (int i = 0; i < yyleng; i++) { - if (yytext[i] == '\n') { - line_number++; - column_number = 0; - } - column_number++; - } -// }else{ -// column_number += yyleng; -// } +void incr(int lnum, int cnum, int tok) { + // if (tok == COMMENT) { + for (int i = 0; i < yyleng; i++) { + if (yytext[i] == '\n') { + line_number++; + column_number = 0; + } + column_number++; + } + // }else{ + // column_number += yyleng; + // } } -void print_tok(int tok){ -fprintf(tok_flag, "%d %d %3d \"%s\"\n", line_number, column_number,tok, yytext); +void print_tok(int tok) { + fprintf(tok_flag, "%d %d %3d \"%s\"\n", line_number, column_number, tok, + yytext); } int run(FILE *alpha) { int token; @@ -94,10 +98,11 @@ int run(FILE *alpha) { // TOK FLAG if (tok_flag != NULL) { while (0 != (token = yylex())) { - //if (tok_flag != NULL) { - // fprintf(tok_flag, "%d %d %3d \"%s\"\n", line_number, column_number, - // token, yytext); - //} + // if (tok_flag != NULL) { + // fprintf(tok_flag, "%d %d %3d \"%s\"\n", + // line_number, column_number, + // token, yytext); + // } /*if (token == COMMENT) { for (int i = 0; i < yyleng; i++) { if (yytext[i] == '\n') { @@ -110,9 +115,10 @@ int run(FILE *alpha) { } if (token == 1999) { printf( - "On line number %d and column number %d we have an invalid " - "character:%s\n", - line_number, column_number, yytext); + "On line number %d and column + number %d we have an invalid " "character:%s\n", + line_number, column_number, + yytext); } column_number += yyleng; */ } @@ -172,14 +178,15 @@ int new_file(char *arg, char *alpha) { } else if (strcmp(arg, "-st") == 0) { type_len = ST_LEN; } else { - fprintf(stderr, "INVALID FLAG: Use -help to view valid inputs\n"); + fprintf(stderr, + "INVALID FLAG: Use -help to view valid inputs\n"); return -1; } // calculate lengths int basename_len = strlen(basename); char *file_name = - calloc(basename_len - ALPHA_OFFSET + type_len + 2, sizeof(char)); + calloc(basename_len - ALPHA_OFFSET + type_len + 2, sizeof(char)); // coy filename and add extension strncpy(file_name, basename, basename_len - ALPHA_OFFSET); @@ -195,15 +202,14 @@ int new_file(char *arg, char *alpha) { } int is_alpha_file(char *alpha, int file_len) { - if (strcmp(".alpha", alpha + sizeof(char) * (file_len - ALPHA_OFFSET)) != 0) { - return -1; // not alpha file + if (strcmp(".alpha", + alpha + sizeof(char) * (file_len - ALPHA_OFFSET)) != 0) { + return -1; // not alpha file } - return 0; // is alpha file + return 0; // is alpha file } -void enter_scope(int line, int column) { - cur = CreateScope(cur, line, column); -} +void enter_scope(int line, int column) { cur = CreateScope(cur, line, column); } void exit_scope() { if (cur->Parent_Scope == NULL) { printf("Can't close top"); diff --git a/src/runner.h b/src/runner.h index 9f66407..d378be5 100644 --- a/src/runner.h +++ b/src/runner.h @@ -5,14 +5,18 @@ #define TOK_LEN 3 #define ST_LEN 2 #define HELP \ - "HELP:\nHow to run the alpha compiler:\n./alpha [options] program\nValid " \ - "options:\n-tok output the token number, token, line number, and column " \ - "number for each of the tokens to the .tok file\n-st output the symbol " \ - "table for the program to the .st file\n-help print this message and exit " \ - "the alpha compiler\n" + "HELP:\nHow to run the alpha compiler:\n./alpha [options] " \ + "program\nValid " \ + "options:\n-tok output the token number, token, line number, and " \ + "column " \ + "number for each of the tokens to the .tok file\n-st output the " \ + "symbol " \ + "table for the program to the .st file\n-help print this message " \ + "and exit " \ + "the alpha compiler\n" #define SET_FLAG 1 // Used to set flags for arg types -#define INVALID \ - "INVALID INPUT: Include a .alpha file or use -help for more inputs \n" +#define INVALID \ + "INVALID INPUT: Include a .alpha file or use -help for more inputs \n" #include #include @@ -22,7 +26,7 @@ #include "../tmp/flex.h" #include "symbol_table.h" -//#include "typedefs.h" +// #include "typedefs.h" #include "../tmp/grammar.tab.h" extern int line_number, column_number; diff --git a/src/symbol_table.c b/src/symbol_table.c index 83901df..1c08f27 100644 --- a/src/symbol_table.c +++ b/src/symbol_table.c @@ -6,42 +6,43 @@ #include #include #include -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 diff --git a/src/symbol_table.h b/src/symbol_table.h index 7763305..84b3e5a 100644 --- a/src/symbol_table.h +++ b/src/symbol_table.h @@ -5,9 +5,9 @@ struct TableNode; -typedef struct{ - int size; -}primitive_info; +typedef struct { + int size; +} primitive_info; /*This structure can be subsumed into the structure below (1-d array of chars) typedef struct{ @@ -17,86 +17,87 @@ typedef struct{ }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* arr; - //shouldn't need to store any values (like sizes of dimenions or the location - //int* sizesofdimensions; - //do have to store type of array - struct TableNode* typeofarray; -}array_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* + // arr; shouldn't need to store any values (like sizes of dimenions or + // the location int* sizesofdimensions; do have to store type of array + struct 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 > - int numofelements; - struct TableNode* listoftypes; -}record_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 > + int numofelements; + struct TableNode *listoftypes; +} record_info; -typedef struct{ - int startlinenumber; - bool regularoras; -}function_declaration_info; +typedef struct { + int startlinenumber; + bool regularoras; +} function_declaration_info; -typedef struct{ - struct TableNode* parameter; - struct TableNode* returntype; -}function_type_info; +typedef struct { + struct TableNode *parameter; + struct TableNode *returntype; +} function_type_info; typedef union { - primitive_info* PrimAdInfo; - array_info* ArrayAdInfo; - record_info* RecAdInfo; - //string_info* StringAdInfo; - function_declaration_info* FunDecAdInfo; - function_type_info* FunTypeAdInfo; - }AdInfo; + primitive_info *PrimAdInfo; + array_info *ArrayAdInfo; + record_info *RecAdInfo; + // string_info* StringAdInfo; + function_declaration_info *FunDecAdInfo; + function_type_info *FunTypeAdInfo; +} AdInfo; typedef struct ListOfTable { - struct SymbolTable* table; + struct SymbolTable *table; // struct ListOfTable* prev; - struct ListOfTable* next; + struct ListOfTable *next; } ListOfTable; typedef struct TableNode { - //reference to the type entry that this is - struct TableNode* theType; - char* theName; - AdInfo* additionalinfo; - struct TableNode* next; -}TableNode; + // reference to the type entry that this is + struct TableNode *theType; + char *theName; + AdInfo *additionalinfo; + struct TableNode *next; +} TableNode; typedef struct SymbolTable { - TableNode* entries; - struct SymbolTable* Parent_Scope; - struct ListOfTable* Children_Scope; + TableNode *entries; + struct SymbolTable *Parent_Scope; + struct ListOfTable *Children_Scope; int Line_Number; int Column_Number; } SymbolTable; -SymbolTable* CreateScope(SymbolTable* ParentScope, int Line, int Column); -TableNode* table_lookup(SymbolTable* table, char* x); -TableNode* look_up(SymbolTable* table, char* x); -void print_symbol_table(SymbolTable* table, FILE* file_ptr); +SymbolTable *CreateScope(SymbolTable *ParentScope, int Line, int Column); +TableNode *table_lookup(SymbolTable *table, char *x); +TableNode *look_up(SymbolTable *table, char *x); +void print_symbol_table(SymbolTable *table, FILE *file_ptr); -SymbolTable* getAncestor(SymbolTable* table); -SymbolTable* getParent(SymbolTable* st); -ListOfTable* getChildren(SymbolTable* st); -SymbolTable* getFirstChild(ListOfTable* lt); -ListOfTable* getRestOfChildren(ListOfTable* lt); -TableNode* getFirstEntry(SymbolTable* st); -TableNode* getNextEntry(TableNode* tn); -SymbolTable* init(SymbolTable* scope); -int getPrimSize(TableNode* definition); -int getNumArrDim(TableNode* definition); -TableNode* getArrType(TableNode* definition); -int getRecLength(TableNode* definition); -TableNode* getRecList(TableNode* definition); -int getStartLine(TableNode* definition); -bool getAsKeyword(TableNode* definition); -TableNode* getParameter(TableNode* definition); -TableNode* getReturn(TableNode* definition); +SymbolTable *getAncestor(SymbolTable *table); +SymbolTable *getParent(SymbolTable *st); +ListOfTable *getChildren(SymbolTable *st); +SymbolTable *getFirstChild(ListOfTable *lt); +ListOfTable *getRestOfChildren(ListOfTable *lt); +TableNode *getFirstEntry(SymbolTable *st); +TableNode *getNextEntry(TableNode *tn); +SymbolTable *init(SymbolTable *scope); +int getPrimSize(TableNode *definition); +int getNumArrDim(TableNode *definition); +TableNode *getArrType(TableNode *definition); +int getRecLength(TableNode *definition); +TableNode *getRecList(TableNode *definition); +int getStartLine(TableNode *definition); +bool getAsKeyword(TableNode *definition); +TableNode *getParameter(TableNode *definition); +TableNode *getReturn(TableNode *definition); -char* getType(TableNode* tn); -char* getName(TableNode* tn); -int getLine(SymbolTable* st); -int getColumn(SymbolTable* st); +char *getType(TableNode *tn); +char *getName(TableNode *tn); +int getLine(SymbolTable *st); +int getColumn(SymbolTable *st);