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

adding function to get adinfo type

Browse Source
This commit is contained in:
Partho Bhattacharya
2025-03-26 11:17:45 -04:00
parent d1f7041c31 94b80b024d
commit 0c8c3e30f3
5 changed files with 537 additions and 508 deletions
Download Patch File Download Diff File Expand all files Collapse all files

106
src/grammar.y
View File

@ -2,30 +2,30 @@
/* The Translators - Spring 2025 */ /* The Translators - Spring 2025 */
%{ %{
#include <stdio.h> #include <stdio.h>
#include "../src/symbol_table.c" #include "../src/symbol_table.c"
#include <math.h> #include <math.h>
extern int yylex(void); extern int yylex(void);
void yyerror(const char *err); void yyerror(const char *err);
extern char* yytext; extern char* yytext;
extern int yyleng; extern int yyleng;
extern int yychar; extern int yychar;
extern SymbolTable * cur; extern SymbolTable * cur;
//char* cur_value; //char* cur_value;
//char* cur_type; //char* cur_type;
int token_tracker; int token_tracker;
extern int line_number; extern int line_number;
extern int column_number; extern int column_number;
extern FILE * yyin; extern FILE * yyin;
extern TableNode* funprime; extern TableNode* funprime;
extern TableNode* arrayprim; extern TableNode* arrayprim;
extern TableNode* recprime; extern TableNode* recprime;
extern TableNode* funtypeprime; extern TableNode* funtypeprime;
extern TableNode* integ; extern TableNode* integ;
extern TableNode* addr; extern TableNode* addr;
extern TableNode* chara; extern TableNode* chara;
extern TableNode* stri; extern TableNode* stri;
extern TableNode* boo; extern TableNode* boo;
%} %}
//%define api.location.type {location_t} //%define api.location.type {location_t}
%locations %locations
@ -123,7 +123,8 @@ definition:
| TYPE ID COLON constant ARROW ID | TYPE ID COLON constant ARROW ID
| function_declaration | function_declaration
| TYPE ID COLON id_or_types ARROW id_or_types { | 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 | ID parameter ASSIGN sblock
; ;
@ -192,15 +193,12 @@ rec_op :
DOT DOT
expression: expression:
constant {printf("constant expression\n");} {$$ = $<words>1;} constant {printf("constant expression\n");} {$$ = $<words>1;}
| SUB_OR_NEG expression %prec UMINUS {printf("negative expression\n");if(strcmp($2,"integer") != 0) | 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); {printf("cant negate something not an integer at line %d and column %d\n",@2.first_line,@2.first_column);
$$=strdup("undefined");}else{$$=$2;}} $$=strdup("undefined");}else{$$=$2;}}
| NOT expression {printf("not expression\n"); if(strcmp($2,"Boolean")==0){$$=$2;}else{$$=strdup("undefined"); | 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 ADD expression {printf("add expression\n");}
| expression SUB_OR_NEG expression {printf("subtract expression\n");} | expression SUB_OR_NEG expression {printf("subtract expression\n");}
| expression MUL expression {printf("multiply expression\n");} | expression MUL expression {printf("multiply expression\n");}
@ -212,16 +210,16 @@ expression:
| expression OR expression {printf("or expression\n");} | expression OR expression {printf("or expression\n");}
| expression LESS_THAN expression {printf("less than expression\n");if(strcmp($1,$3)==0 && | 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); 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");}} $$=strdup("Boolean");$$=strdup("undefined");}}
| expression EQUAL_TO expression {printf("equals check expression\n"); | 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|| 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");} 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");}} else{printf("mismatch at line %d and column %d\n",@2.first_line,@2.first_column);$$=strdup("undefined");}}
| assignable {printf("assignable expression\n");$$=$1;} | assignable {printf("assignable expression\n");$$=$1;}
| L_PAREN expression R_PAREN {printf("paren expression\n");$$=$2;} | L_PAREN expression R_PAREN {printf("paren expression\n");$$=$2;}
| memOp assignable {$$ = strdup("address");} | memOp assignable {$$ = strdup("address");}
; ;
ablock: ablock:
@ -250,9 +248,9 @@ constant:
; ;
types: types:
// Commented out T_String below // Commented out T_String below
// T_STRING {printf("string of T_STRING in types is %s\n",$<words>1);} {$$ = $<words>1;} // T_STRING {printf("string of T_STRING in types is %s\n",$<words>1);} {$$ = $<words>1;}
T_INTEGER {printf("string of T_INTEGER in types is %s\n",$<words>1);} {$$ = $<words>1;} T_INTEGER {printf("string of T_INTEGER in types is %s\n",$<words>1);} {$$ = $<words>1;}
| T_ADDRESS {printf("string of T_ADDRESS in types is %s\n",$<words>1);} {$$ = $<words>1;} | T_ADDRESS {printf("string of T_ADDRESS in types is %s\n",$<words>1);} {$$ = $<words>1;}
| T_CHARACTER {printf("string of T_CHARACTER in types is %s\n",$<words>1);} {$$ = $<words>1;} | T_CHARACTER {printf("string of T_CHARACTER in types is %s\n",$<words>1);} {$$ = $<words>1;}
| T_BOOLEAN {printf("string of T_BOOLEAN in types is %s\n",$<words>1);} {$$ = $<words>1;} | T_BOOLEAN {printf("string of T_BOOLEAN in types is %s\n",$<words>1);} {$$ = $<words>1;}
@ -261,31 +259,5 @@ types:
%% %%
void yyerror(const char *err) { 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;
} */

82
src/runner.c
View File

@ -2,13 +2,13 @@
/* The Translators - Spring 2025 */ /* The Translators - Spring 2025 */
#include "runner.h" #include "runner.h"
extern TableNode* funprime; extern TableNode *funprime;
extern TableNode* arrayprim; extern TableNode *arrayprim;
extern TableNode* integ; extern TableNode *integ;
extern TableNode* addr; extern TableNode *addr;
extern TableNode* chara; extern TableNode *chara;
extern TableNode* stri; extern TableNode *stri;
extern TableNode* boo; extern TableNode *boo;
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
if (argc == 1) { if (argc == 1) {
@ -29,13 +29,16 @@ int main(int argc, char *argv[]) {
} }
else { 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); fprintf(stderr, INVALID);
return -1; return -1;
} else { } else {
for (int i = 1; i < argc - 1; i++) { for (int i = 1; i < argc - 1; i++) {
if (check_flag(argv[i], argv[argc - 1]) != 0) { 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; return -1;
} }
} }
@ -64,21 +67,22 @@ int check_flag(char *arg, char *alpha) {
} }
} }
void incr(int lnum,int cnum, int tok){ void incr(int lnum, int cnum, int tok) {
//if (tok == COMMENT) { // if (tok == COMMENT) {
for (int i = 0; i < yyleng; i++) { for (int i = 0; i < yyleng; i++) {
if (yytext[i] == '\n') { if (yytext[i] == '\n') {
line_number++; line_number++;
column_number = 0; column_number = 0;
} }
column_number++; column_number++;
} }
// }else{ // }else{
// column_number += yyleng; // column_number += yyleng;
// } // }
} }
void print_tok(int tok){ void print_tok(int tok) {
fprintf(tok_flag, "%d %d %3d \"%s\"\n", line_number, column_number,tok, yytext); fprintf(tok_flag, "%d %d %3d \"%s\"\n", line_number, column_number, tok,
yytext);
} }
int run(FILE *alpha) { int run(FILE *alpha) {
int token; int token;
@ -94,10 +98,11 @@ int run(FILE *alpha) {
// TOK FLAG // TOK FLAG
if (tok_flag != NULL) { if (tok_flag != NULL) {
while (0 != (token = yylex())) { while (0 != (token = yylex())) {
//if (tok_flag != NULL) { // if (tok_flag != NULL) {
// fprintf(tok_flag, "%d %d %3d \"%s\"\n", line_number, column_number, // fprintf(tok_flag, "%d %d %3d \"%s\"\n",
// token, yytext); // line_number, column_number,
//} // token, yytext);
// }
/*if (token == COMMENT) { /*if (token == COMMENT) {
for (int i = 0; i < yyleng; i++) { for (int i = 0; i < yyleng; i++) {
if (yytext[i] == '\n') { if (yytext[i] == '\n') {
@ -110,9 +115,10 @@ int run(FILE *alpha) {
} }
if (token == 1999) { if (token == 1999) {
printf( printf(
"On line number %d and column number %d we have an invalid " "On line number %d and column
"character:%s\n", number %d we have an invalid " "character:%s\n",
line_number, column_number, yytext); line_number, column_number,
yytext);
} }
column_number += yyleng; */ column_number += yyleng; */
} }
@ -172,14 +178,15 @@ int new_file(char *arg, char *alpha) {
} else if (strcmp(arg, "-st") == 0) { } else if (strcmp(arg, "-st") == 0) {
type_len = ST_LEN; type_len = ST_LEN;
} else { } 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; return -1;
} }
// calculate lengths // calculate lengths
int basename_len = strlen(basename); int basename_len = strlen(basename);
char *file_name = 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 // coy filename and add extension
strncpy(file_name, basename, basename_len - ALPHA_OFFSET); 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) { int is_alpha_file(char *alpha, int file_len) {
if (strcmp(".alpha", alpha + sizeof(char) * (file_len - ALPHA_OFFSET)) != 0) { if (strcmp(".alpha",
return -1; // not alpha file 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) { void enter_scope(int line, int column) { cur = CreateScope(cur, line, column); }
cur = CreateScope(cur, line, column);
}
void exit_scope() { void exit_scope() {
if (cur->Parent_Scope == NULL) { if (cur->Parent_Scope == NULL) {
printf("Can't close top"); printf("Can't close top");

20
src/runner.h
View File

@ -5,14 +5,18 @@
#define TOK_LEN 3 #define TOK_LEN 3
#define ST_LEN 2 #define ST_LEN 2
#define HELP \ #define HELP \
"HELP:\nHow to run the alpha compiler:\n./alpha [options] program\nValid " \ "HELP:\nHow to run the alpha compiler:\n./alpha [options] " \
"options:\n-tok output the token number, token, line number, and column " \ "program\nValid " \
"number for each of the tokens to the .tok file\n-st output the symbol " \ "options:\n-tok output the token number, token, line number, and " \
"table for the program to the .st file\n-help print this message and exit " \ "column " \
"the alpha compiler\n" "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 SET_FLAG 1 // Used to set flags for arg types
#define INVALID \ #define INVALID \
"INVALID INPUT: Include a .alpha file or use -help for more inputs \n" "INVALID INPUT: Include a .alpha file or use -help for more inputs \n"
#include <stdbool.h> #include <stdbool.h>
#include <stdio.h> #include <stdio.h>
@ -22,7 +26,7 @@
#include "../tmp/flex.h" #include "../tmp/flex.h"
#include "symbol_table.h" #include "symbol_table.h"
//#include "typedefs.h" // #include "typedefs.h"
#include "../tmp/grammar.tab.h" #include "../tmp/grammar.tab.h"
extern int line_number, column_number; extern int line_number, column_number;

686
src/symbol_table.c
View File

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

135
src/symbol_table.h
View File

@ -5,9 +5,9 @@
struct TableNode; struct TableNode;
typedef struct{ typedef struct {
int size; int size;
}primitive_info; } primitive_info;
/*This structure can be subsumed into the structure below (1-d array of chars) /*This structure can be subsumed into the structure below (1-d array of chars)
typedef struct{ typedef struct{
@ -17,86 +17,87 @@ typedef struct{
}string_info; }string_info;
*/ */
typedef struct{ typedef struct {
int numofdimensions; 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; // the above value tells you how long the below array is. For example if
//shouldn't need to store any values (like sizes of dimenions or the location // num of dimensions is 5, I can store 1,3,2,5,9 to define > int*
//int* sizesofdimensions; // arr; shouldn't need to store any values (like sizes of dimenions or
//do have to store type of array // the location int* sizesofdimensions; do have to store type of array
struct TableNode* typeofarray; struct TableNode *typeofarray;
}array_info; } array_info;
typedef struct{ 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 > // similar to above we define a record to hold the number of elements
int numofelements; // and an array of tablenodes (types) that it contains in the >
struct TableNode* listoftypes; int numofelements;
}record_info; struct TableNode *listoftypes;
} record_info;
typedef struct{ typedef struct {
int startlinenumber; int startlinenumber;
bool regularoras; bool regularoras;
}function_declaration_info; } function_declaration_info;
typedef struct{ typedef struct {
struct TableNode* parameter; struct TableNode *parameter;
struct TableNode* returntype; struct TableNode *returntype;
}function_type_info; } function_type_info;
typedef union { typedef union {
primitive_info* PrimAdInfo; primitive_info *PrimAdInfo;
array_info* ArrayAdInfo; array_info *ArrayAdInfo;
record_info* RecAdInfo; record_info *RecAdInfo;
//string_info* StringAdInfo; // string_info* StringAdInfo;
function_declaration_info* FunDecAdInfo; function_declaration_info *FunDecAdInfo;
function_type_info* FunTypeAdInfo; function_type_info *FunTypeAdInfo;
}AdInfo; } AdInfo;
typedef struct ListOfTable { typedef struct ListOfTable {
struct SymbolTable* table; struct SymbolTable *table;
// struct ListOfTable* prev; // struct ListOfTable* prev;
struct ListOfTable* next; struct ListOfTable *next;
} ListOfTable; } ListOfTable;
typedef struct TableNode { typedef struct TableNode {
//reference to the type entry that this is // reference to the type entry that this is
struct TableNode* theType; struct TableNode *theType;
char* theName; char *theName;
AdInfo* additionalinfo; AdInfo *additionalinfo;
struct TableNode* next; struct TableNode *next;
}TableNode; } TableNode;
typedef struct SymbolTable { typedef struct SymbolTable {
TableNode* entries; TableNode *entries;
struct SymbolTable* Parent_Scope; struct SymbolTable *Parent_Scope;
struct ListOfTable* Children_Scope; struct ListOfTable *Children_Scope;
int Line_Number; int Line_Number;
int Column_Number; int Column_Number;
} SymbolTable; } SymbolTable;
SymbolTable* CreateScope(SymbolTable* ParentScope, int Line, int Column); SymbolTable *CreateScope(SymbolTable *ParentScope, int Line, int Column);
TableNode* table_lookup(SymbolTable* table, char* x); TableNode *table_lookup(SymbolTable *table, char *x);
TableNode* look_up(SymbolTable* table, char* x); TableNode *look_up(SymbolTable *table, char *x);
void print_symbol_table(SymbolTable* table, FILE* file_ptr); void print_symbol_table(SymbolTable *table, FILE *file_ptr);
SymbolTable* getAncestor(SymbolTable* table); SymbolTable *getAncestor(SymbolTable *table);
SymbolTable* getParent(SymbolTable* st); SymbolTable *getParent(SymbolTable *st);
ListOfTable* getChildren(SymbolTable* st); ListOfTable *getChildren(SymbolTable *st);
SymbolTable* getFirstChild(ListOfTable* lt); SymbolTable *getFirstChild(ListOfTable *lt);
ListOfTable* getRestOfChildren(ListOfTable* lt); ListOfTable *getRestOfChildren(ListOfTable *lt);
TableNode* getFirstEntry(SymbolTable* st); TableNode *getFirstEntry(SymbolTable *st);
TableNode* getNextEntry(TableNode* tn); TableNode *getNextEntry(TableNode *tn);
SymbolTable* init(SymbolTable* scope); SymbolTable *init(SymbolTable *scope);
int getPrimSize(TableNode* definition); int getPrimSize(TableNode *definition);
int getNumArrDim(TableNode* definition); int getNumArrDim(TableNode *definition);
TableNode* getArrType(TableNode* definition); TableNode *getArrType(TableNode *definition);
int getRecLength(TableNode* definition); int getRecLength(TableNode *definition);
TableNode* getRecList(TableNode* definition); TableNode *getRecList(TableNode *definition);
int getStartLine(TableNode* definition); int getStartLine(TableNode *definition);
bool getAsKeyword(TableNode* definition); bool getAsKeyword(TableNode *definition);
TableNode* getParameter(TableNode* definition); TableNode *getParameter(TableNode *definition);
TableNode* getReturn(TableNode* definition); TableNode *getReturn(TableNode *definition);
char* getType(TableNode* tn); char *getType(TableNode *tn);
char* getName(TableNode* tn); char *getName(TableNode *tn);
int getLine(SymbolTable* st); int getLine(SymbolTable *st);
int getColumn(SymbolTable* st); int getColumn(SymbolTable *st);