Updated structure

2025-03-03 14:48:19 -05:00
parent 44ddfa41f8 d34a4d3a55
commit b22f0149c7
15 changed files with 595 additions and 231 deletions
--- a/src/grammar.y
+++ b/src/grammar.y
@@ -0,0 +1,279 @@
+/*           Syntax Analyzer with Bison (3.8.1)			  */
+/*  (referenced Bison manual for file boilerplate [3.1])  */
+
+// Prologue
+%{
+  #include <stdio.h>
+  #include "symbol_table.c"
+  extern int yylex(void);
+  void yyerror(const char *err);
+  extern char* yytext;
+  extern int yychar;
+  SymbolTable * st;
+  //char* cur_value;
+  //char* cur_type;
+  int token_tracker;
+  extern int line_number;
+  extern int column_number;
+%}
+
+%union {
+	int integ;
+	char * words;
+}
+//precedence order
+%precedence RESERVE
+%precedence RELEASE
+%precedence DOT
+%precedence SUB_OR_NEG
+%precedence NOT
+%left MUL
+%left DIV
+%left REM
+%left ADD
+//need subtraction only here
+%left LESS_THAN
+%left EQUAL_TO
+%left AND
+%left OR
+%left ASSIGN
+
+%token <words> ID 101
+%token T_INTEGER 201
+%token T_ADDRESS 202
+%token T_BOOLEAN 203
+%token T_CHARACTER 204
+%token T_STRING 205
+%token C_INTEGER 301
+%token C_NULL 302
+%token C_CHARACTER 303
+%token C_STRING 304
+%token C_TRUE 305
+%token C_FALSE 306
+%token WHILE 401
+%token IF 402
+%token THEN 403
+%token ELSE 404
+%token TYPE 405
+%token FUNCTION 406
+%token RETURN 407
+%token EXTERNAL 408
+%token AS 409
+%token L_PAREN 501
+%token R_PAREN 502
+%token L_BRACKET 503
+%token R_BRACKET 504
+%token L_BRACE 505
+%token R_BRACE 506
+%token SEMI_COLON 507
+%token COLON 508
+%token COMMA 509
+%token ARROW 510
+/* %token ADD 601
+%token SUB_OR_NEG 602
+%token MUL 603
+%token DIV 604
+%token REM 605
+%token LESS_THAN 606
+%token EQUAL_TO 607
+%token ASSIGN 608
+%token NOT 609
+%token AND 610
+%token OR 611
+%token DOT 612
+%token RESERVE 613
+%token RELEASE 614 */
+%token COMMENT 700
+
+
+%%
+
+program: 
+	prototype_or_definition_list;
+
+prototype_or_definition_list:
+	prototype prototype_or_definition_list
+	| definition prototype_or_definition_list
+	| prototype
+	| definition
+	;
+prototype:
+	L_PAREN EXTERNAL R_PAREN FUNCTION ID COLON ID;
+
+definition:
+	TYPE ID COLON dblock
+	| TYPE ID COLON constant ARROW ID
+	| TYPE ID COLON types ARROW ID
+	| FUNCTION ID COLON ID
+	| TYPE ID COLON ID ARROW ID
+	| ID parameter ASSIGN sblock
+	;
+
+parameter:
+	L_PAREN ID R_PAREN
+	| AS L_PAREN idlist R_PAREN
+	;
+
+idlist:
+	ID COMMA idlist
+	|ID
+	;
+
+sblock:
+	L_BRACE {st = CreateScope(st,2,2);} statement_list {st = getParent(st);} R_BRACE
+	| L_BRACE {st = CreateScope(st,2,2);} dblock statement_list {st = getParent(st);} R_BRACE
+	;
+
+dblock:
+	L_BRACKET declaration_list R_BRACKET;
+
+declaration_list:
+	declaration 
+	{printf(
+		"declaration list a rule encountered");
+		//CreateEntry(st,cur_type,cur_value);
+		} 
+		SEMI_COLON declaration_list
+	| declaration 
+	  {printf(
+		"declaration rule b encountered");
+		//CreateEntry(st,cur_type,cur_value);
+		}
+	;
+
+declaration:
+	ID COLON ID {
+	    
+	    CreateEntry(st,strdup($1),strdup($3));
+//	    printf("declaration rule encountered");
+//	    if(cur_value != NULL){
+//	    char* delete1 = cur_value;
+//	    printf("delete1 var assigned to cur_value");
+//	    free(delete1);
+//	    printf("delete1 var freed"); 
+//	}
+//	    if(cur_type != NULL){
+//            char* delete2 = cur_type;
+//	    free(delete2);}
+//            int len = strlen($1);
+//	    printf("length determined");
+//            cur_value = malloc(len + 1);
+//	    printf("space allocated");
+//            strcpy(cur_value, $1);
+//	    printf("string copied over");
+            
+//            len = strlen($3);
+//            cur_type = malloc(len + 1);
+//            strcpy(cur_type, $3);
+//            printf("value var is %s type var is %s\n",cur_value,cur_type);
+	}
+	| types COLON ID
+	;
+
+statement_list:
+	compound_statement statement_list
+	| compound_statement
+	| simple_statement SEMI_COLON statement_list
+	| simple_statement SEMI_COLON
+	;
+
+compound_statement:
+	WHILE L_PAREN expression R_PAREN sblock
+	| IF L_PAREN expression R_PAREN THEN sblock ELSE sblock
+	| sblock
+	;
+
+simple_statement:
+	assignable ASSIGN expression
+	| RETURN expression
+	;
+
+assignable:
+	ID
+	| assignable ablock
+	| assignable DOT ID
+	;
+
+expression:
+	constant
+	| UnaryOperator expression
+	| assignable
+	| constant binaryOperator expression
+	| L_PAREN expression R_PAREN
+	| memOp assignable
+	;
+
+ablock:
+	L_PAREN argument_list R_PAREN;
+
+argument_list:
+	expression COMMA argument_list
+	| expression
+	;
+
+UnaryOperator:
+	SUB_OR_NEG
+	| NOT
+	;
+
+memOp:
+	RESERVE
+	| RELEASE
+	;
+
+binaryOperator:
+	ADD
+	| SUB_OR_NEG
+	| MUL
+	| DIV
+	| REM
+	| AND
+	| OR
+	| LESS_THAN
+	| EQUAL_TO
+	;
+
+constant:
+	C_STRING
+	| C_INTEGER
+	| C_NULL
+	| C_CHARACTER
+	| C_TRUE
+	| C_FALSE
+	;
+
+types:
+	T_STRING
+	| T_INTEGER
+	| T_ADDRESS
+	| T_CHARACTER
+	| T_BOOLEAN
+	;
+//
+%%
+
+void yyerror(const char *err) {
+   // fprintf(stderr, "ERROR: %s at token %s at line number %d,column number %d\n", err,yytext,line_number,column_number);
+}
+
+int main() {
+	//char *str = strdup("taco");
+	//cur_value = NULL;
+	//cur_type = NULL;
+
+	token_tracker = 1;
+	st=CreateScope(NULL,1,1);
+	//int a;
+	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(st),f);
+			fclose(f);
+		//	break;
+		//}
+	//}
+	return 0;
+}
--- a/src/lexicalStructure.lex
+++ b/src/lexicalStructure.lex
@@ -0,0 +1,91 @@
+/* Lexical Analysis with Flex (1.6.0) We used some of the code from this manual */
+/*                                    so we placed the citation here. */
+/* definitions */
+
+%option noyywrap
+%option header-file="flex.h"
+%{
+	#include <stdbool.h>
+	//#include "typedefs.h"
+	#include "grammar.tab.h"
+	int line_number = 1, column_number = 1;
+	#ifndef DEBUG
+		#define DEBUG 0
+	#endif
+	  
+	
+%}
+
+STARCOM [^\*]|\*+[^\)\*]+
+PARENCOM [^\)]|[^\*\)]+\)+
+ID [A-Za-z_][0-9A-Za-z_]*
+DIGIT [0-9]
+CHAR \\n|\\t|\\'|[^'\n\t\\]|\\\\
+	/* char can be a newline, tab, an escaped quote, or anything but a single quote, an actual line break, an actual tab, or a backslash by itself (to prevent confusion from escaped quote */
+SCHAR \\n|\\t|\\\"|[^\"\n\\]
+	/* similar to above, a string Char (SCHAR) is the same as a CHAR except we cannot have double quotes instead of single quotes. Double quotes need to be escaped in Flex unlike single quotes based on documentation */
+
+%%
+
+"integer"		{if(DEBUG) {printf( "T_INTEGER:		%s	(%d)\n", yytext, T_INTEGER);} 		else {return T_INTEGER;}}
+"address"		{if(DEBUG) {printf( "T_ADDRESS:		%s	(%d)\n", yytext, T_ADDRESS);} 		else {return T_ADDRESS;}}
+"Boolean"		{if(DEBUG) {printf( "T_BOOLEAN:		%s	(%d)\n", yytext, T_BOOLEAN);} 		else {return T_BOOLEAN;}}
+"character"		{if(DEBUG) {printf( "T_CHARACTER:	%s	(%d)\n", yytext, T_CHARACTER);} 	else {return T_CHARACTER;}}
+
+"while"			{if(DEBUG) {printf( "WHILE:			%s	(%d)\n", yytext, WHILE);} 			else {return WHILE;}}
+"if"			{if(DEBUG) {printf( "IF:			%s	(%d)\n", yytext, IF);} 				else {return IF;}}
+"then"			{if(DEBUG) {printf( "THEN:			%s	(%d)\n", yytext, THEN);} 			else {return THEN;}}
+"else"			{if(DEBUG) {printf( "ELSE:			%s	(%d)\n", yytext, ELSE);} 			else {return ELSE;}}
+"type"			{if(DEBUG) {printf( "TYPE:			%s	(%d)\n", yytext, TYPE);} 			else {return TYPE;}}
+"function"		{if(DEBUG) {printf( "FUNCTION:		%s	(%d)\n", yytext, FUNCTION);} 		else {return FUNCTION;}}
+"return"		{if(DEBUG) {printf( "RETURN:		%s	(%d)\n", yytext, RETURN);} 			else {return RETURN;}}
+"external"		{if(DEBUG) {printf( "EXTERNAL:		%s	(%d)\n", yytext, EXTERNAL);} 		else {return EXTERNAL;}}
+"as"			{if(DEBUG) {printf( "AS:			%s	(%d)\n", yytext, AS);} 				else {return AS;}}
+
+"release"		{if(DEBUG) {printf( "RELEASE:		%s	(%d)\n", yytext, RELEASE);} 		else {return RELEASE;}}
+"reserve"		{if(DEBUG) {printf( "RESERVE:		%s	(%d)\n", yytext, RESERVE);} 		else {return RESERVE;}}
+
+"+"				{if(DEBUG) {printf( "ADD:			%s	(%d)\n", yytext, ADD);} 			else {return ADD;}}
+"-"				{if(DEBUG) {printf( "SUB_OR_NEG:	%s	(%d)\n", yytext, SUB_OR_NEG);}		else {return SUB_OR_NEG;}}
+"*"				{if(DEBUG) {printf( "MUL:			%s	(%d)\n", yytext, MUL);} 			else {return  MUL;}}
+"/"				{if(DEBUG) {printf( "DIV:			%s	(%d)\n", yytext, DIV);} 			else {return DIV;}}
+"%"				{if(DEBUG) {printf( "REM:			%s	(%d)\n", yytext, REM);} 			else {return REM;}}
+"<"				{if(DEBUG) {printf( "LESS_THAN:		%s	(%d)\n", yytext, LESS_THAN);} 		else {return LESS_THAN;}}
+"="				{if(DEBUG) {printf( "EQUAL_TO:		%s	(%d)\n", yytext, EQUAL_TO);} 		else {return EQUAL_TO;}}
+":="			{if(DEBUG) {printf( "ASSIGN:		%s	(%d)\n", yytext, ASSIGN);} 			else {return ASSIGN;}}
+"!"				{if(DEBUG) {printf( "NOT:			%s	(%d)\n", yytext, NOT);} 			else {return NOT;}}
+"&"				{if(DEBUG) {printf( "AND:			%s	(%d)\n", yytext, AND);} 			else {return AND;}}
+"|"				{if(DEBUG) {printf( "OR:			%s	(%d)\n", yytext, OR);} 				else {return OR;}}
+"."				{if(DEBUG) {printf( "DOT:			%s	(%d)\n", yytext, DOT);} 			else {return DOT;}}
+
+";"				{if(DEBUG) {printf( "SEMI_COLON:	%s	(%d)\n", yytext, SEMI_COLON);} 		else {return SEMI_COLON;}}
+":"				{if(DEBUG) {printf( "COLON:			%s	(%d)\n", yytext, COLON);} 			else {return COLON;}}
+","				{if(DEBUG) {printf( "COMMA:			%s	(%d)\n", yytext, COMMA);} 			else {return COMMA;}}
+"->"			{if(DEBUG) {printf( "ARROW:			%s	(%d)\n", yytext, ARROW);} 			else {return ARROW;}}
+
+{DIGIT}+		{if(DEBUG) {printf( "C_INTEGER:		%s	(%d)\n", yytext, C_INTEGER);} 		else {return C_INTEGER;}}
+'{CHAR}'		{if(DEBUG) {printf( "C_CHARACTER:	%s	(%d)\n", yytext, C_CHARACTER);} 	else {return C_CHARACTER;}}
+\"{SCHAR}*\"	{if(DEBUG) {printf( "C_STRING:		%s	(%d)\n", yytext, C_STRING);} 		else {return C_STRING;}}
+\(\*{STARCOM}*\*\)|\(\*{PARENCOM}*\*\)	{if(DEBUG) {printf( "COMMENT:		%s	(%d)\n", yytext, COMMENT);} 		else {return COMMENT;}}
+
+"("				{if(DEBUG) {printf( "L_PAREN:	%s	(%d)\n", yytext, L_PAREN);}		else {return L_PAREN;}}
+")"				{if(DEBUG) {printf( "R_PAREN:	%s	(%d)\n", yytext, R_PAREN);}		else {return R_PAREN;}}
+
+"["				{if(DEBUG) {printf( "L_BRACKET:	%s	(%d)\n", yytext, L_BRACKET);}		else {return L_BRACKET;}}
+"]"				{if(DEBUG) {printf( "R_BRACKET:	%s	(%d)\n", yytext, R_BRACKET);}		else {return R_BRACKET;}}
+
+"{"				{if(DEBUG) {printf( "L_BRACE:	%s	(%d)\n", yytext, L_BRACE);}		else {return L_BRACE;}}
+"}"				{if(DEBUG) {printf( "R_BRACE:	%s	(%d)\n", yytext, R_BRACE);}		else {return R_BRACE;}}
+
+"true"			{if(DEBUG) {printf( "C_TRUE:		%s	(%d)\n", yytext, C_TRUE);} 			else {return C_TRUE;}}
+"false"			{if(DEBUG) {printf( "C_FALSE:		%s	(%d)\n", yytext, C_FALSE);} 		else {return C_FALSE;}}
+"null"			{if(DEBUG) {printf( "C_NULL:		%s	(%d)\n", yytext, C_NULL);} 			else {return C_NULL;}}
+
+{ID}			{if(DEBUG) {printf( "ID:			%s	(%d)\n", yytext, ID);} 				else {yylval.words = strdup(yytext); return ID;}}
+
+\n				{line_number++; column_number = 1;}
+\t				{column_number++;}
+" "				{column_number++;}
+.				{column_number++; return 1999;}
+
+%%
--- a/src/runner.c
+++ b/src/runner.c
@@ -0,0 +1,177 @@
+//#include "symbol_table.h"
+#include "runner.h"
+
+int main(int argc, char *argv[]) {
+    if (argc == 1) {
+        fprintf(stderr, "INVALID INPUT: Include a .alpha file or use -help for more inputs \n");
+        return -1;
+    } else if (argc == 2) {
+        //can be either -help or .alpha file
+        if (is_help(argv[1])) {
+            return 0;
+        } else if (is_alpha_file(argv[1], strlen(argv[1])) == 0) {
+            //run flex for now
+            no_flag = SET_FLAG;   //no argument but valid input
+            alpha_file = fopen(argv[1], "r");
+
+        } else {
+            fprintf(stderr, "INVALID INPUT: Include a .alpha file or use -help for more inputs\n");
+            return -1;
+        }
+    } else {
+        //last input must be .alpha
+        if (is_alpha_file(argv[argc - 1], strlen(argv[argc - 1])) != 0) {
+            fprintf(stderr, "INVALID INPUT: Include a .alpha file at end of input or use -help for more inputs \n");
+            return -1;
+        } else {
+            //now check that other args are valid (flags will not be null if flag is present)
+            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");
+                    return -1;
+                }
+            }
+            alpha_file = fopen(argv[argc - 1], "r");
+        }
+    }
+    return run(alpha_file);
+}
+
+int check_flag(char *arg, char* alpha) {
+    if (strcmp("-tok", arg) == 0) {
+        if (tok_flag == NULL) {
+            return new_file(arg, alpha);
+        }
+        fprintf(stderr, "FLAGS REPEAT\n");
+        return -1;
+    } else if (strcmp("-st", arg) == 0) {
+        if (st_flag == NULL) {
+            return new_file(arg, alpha);
+        }
+        fprintf(stderr, "FLAGS REPEAT\n");
+        return -1;
+    } else {
+        fprintf(stderr, "INVALID FLAG: Use -help for valid inputs\n");
+        return -1;
+    }
+}
+
+
+int run(FILE *alpha) {
+    int token;
+    //check that file exists
+    if (alpha == NULL) {
+        fprintf(stderr, "INPUT FILE NOT FOUND\n");
+        return -1;
+    }
+    yyin = alpha;
+    while (0 != (token = yylex())) {
+        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'){
+                    line_number++;
+                    column_number = 0;
+                }
+                column_number++;
+            }
+            continue;
+	}
+   	if(token == 1999){
+                printf("On line number %d and column number %d we have an invalid character:%s\n",line_number,column_number,yytext);
+                //return -1;
+}
+	column_number += yyleng;
+    }
+
+    if (st_flag != NULL) {
+        //output symbol table, file pointer is
+        //print_symbol_table(top,st_flag);
+    }
+
+    if (yyin != NULL) {
+        fclose(yyin);
+    }
+
+    if (tok_flag != NULL) {
+        fclose(tok_flag);
+    }
+
+    return 0;
+}
+
+
+
+bool is_help(char * input) {
+    if (strcmp(input, "-help") == 0) {
+        printf("%s", HELP);
+        return true;
+    }
+    return false;
+}
+
+int new_file(char *arg, char *alpha) {
+    int type_len;
+    const char *basename = alpha;
+    const char *slash = strchr(alpha, '/');
+
+    while (slash != NULL) {
+        basename = slash + 1;
+        slash = strchr(basename, '/');
+    }
+	
+	mkdir("./out", 0777);
+
+	char *new_basename = calloc(strlen(basename) + 5, sizeof(char));
+	strcpy(new_basename, "./out/");
+	strcat(new_basename, basename);
+	basename = new_basename;
+
+    if (strcmp(arg, "-tok") == 0) {
+        type_len = TOK_LEN;
+    } else if (strcmp(arg, "-st") == 0) {
+        type_len = ST_LEN;
+    } else {
+        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));
+
+    //coy filename and add extension
+    strncpy(file_name, basename, basename_len - ALPHA_OFFSET);
+    strcat(file_name, ".");
+    strcat(file_name, arg + 1);
+
+
+    if (strcmp(arg, "-tok") == 0) {
+        tok_flag = fopen(file_name, "w");
+    } else if (strcmp(arg, "-st") == 0) {
+        st_flag = fopen(file_name, "w");
+    }
+    return 0;
+}
+
+
+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
+    }
+    return 0; //is alpha file
+}
+
+void enter_scope(int line, int column){
+        curr = CreateScope(curr, line, column);
+}
+void exit_scope() {
+        if(curr->Parent_Scope == NULL){
+                printf("Can't close top");
+                return;
+        }
+        curr = curr->Parent_Scope;
+}
--- a/src/runner.h
+++ b/src/runner.h
@@ -0,0 +1,41 @@
+#define ALPHA_OFFSET 6
+#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"
+//use to set flags for arg types
+#define SET_FLAG 1
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "../tmp/flex.h"
+#include "typedefs.h"
+#include <stdbool.h>
+#include "symbol_table.h"
+#include <sys/stat.h>
+
+extern int line_number, column_number;
+extern char *yytext;
+extern FILE *yyin;
+int arg;
+
+SymbolTable * top;
+SymbolTable * curr;
+
+// int main(int argc, char* argv[]);
+char *is_tok(int argc, char* argv[]);
+// int is_alpha_file(char *file, int file_len);
+void enter_scope(int, int);
+void exit_scope(void);
+
+FILE *alpha_file;
+FILE *tok_flag = NULL;
+FILE *st_flag = NULL;
+int no_flag = 0;
+
+int main(int argc, char* argv[]);
+int new_file(char *arg, char *alpha);
+int is_alpha_file(char *alpha, int file_len);
+bool is_help(char * input);
+int run(FILE*alpha);
+int check_flag(char * arg, char* alpha);
--- a/src/symbol_table.c
+++ b/src/symbol_table.c
@@ -0,0 +1,145 @@
+#include "symbol_table.h"
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+SymbolTable* CreateScope(SymbolTable* ParentScope, int Line, int Column) {
+  SymbolTable* table = (SymbolTable*)malloc(sizeof(SymbolTable));
+  table->Line_Number = Line;
+  table->Column_Number = Column;
+  table->Parent_Scope = ParentScope;
+  table->Children_Scope = NULL;
+  table->entries = NULL;
+  if (ParentScope != NULL) {
+    if (ParentScope->Children_Scope == NULL) {
+      ListOfTable* newEntry = (ListOfTable*)malloc(sizeof(ListOfTable));
+      newEntry->next = NULL;
+      // newEntry->prev = NULL;
+      newEntry->table = table;
+      ParentScope->Children_Scope = newEntry;
+    } else {
+      ListOfTable* newEntry = (ListOfTable*)malloc(sizeof(ListOfTable));
+      // newEntry->prev = NULL;
+      newEntry->table = table;
+      ListOfTable* oldEntry = ParentScope->Children_Scope;
+      ParentScope->Children_Scope = newEntry;
+      newEntry->next = oldEntry;
+    }
+  }
+  return table;
+}
+
+TableNode* CreateEntry(SymbolTable* table, char* typeOf, char* id) {
+  TableNode* newEntry = (TableNode*)malloc(sizeof(TableNode));
+  newEntry->theType = typeOf;
+  newEntry->theName = id;
+  if (table->entries == NULL) {
+    table->entries = newEntry;
+    return newEntry;
+  } else {
+    TableNode* oldEntry = table->entries;
+    table->entries = newEntry;
+    newEntry->next = oldEntry;
+    return newEntry;
+  }
+}
+TableNode* table_lookup(SymbolTable* table, char* x) {
+  TableNode* entrie = table->entries;
+  for (; entrie != NULL; entrie = entrie->next) {
+    if (!strcmp(entrie->theName, x)) {
+      return entrie;
+    }
+  }
+  return NULL;
+}
+TableNode* look_up(SymbolTable* table, char* x) {
+  if (table == NULL) {
+    return NULL;
+  }
+  TableNode* ret = table_lookup(table, x);
+  if (ret != NULL) {
+    return ret;
+  }
+  return look_up(table->Parent_Scope, x);
+}
+
+void print_symbol_table(SymbolTable* table, FILE* file_ptr) {
+  if (table->Parent_Scope == NULL) {
+    fprintf(file_ptr, "%-17s: %-6s : %-6s : %-21s: %-28s\n", "NAME", "SCOPE",
+            "PARENT", "TYPE", "Extra annotation");
+  }
+  TableNode* entrie = table->entries;
+  fprintf(file_ptr,
+          "-----------------:--------:--------:----------------------:---------"
+          "--------------------\n");
+  int parant_scope = 0;
+  int current_scope = 0;
+  if (table->Parent_Scope != NULL) {
+    parant_scope = table->Parent_Scope->Line_Number * 1000 +
+                   table->Parent_Scope->Column_Number;
+    current_scope = table->Line_Number * 1000 + table->Column_Number;
+  } else {
+    current_scope = 1001;
+  }
+
+  for (; entrie != NULL; entrie = entrie->next) {
+    if (parant_scope == 0) {
+      fprintf(file_ptr, "%-17s: %06d :        : %-21s: %-28s\n",
+              entrie->theName, current_scope, entrie->theType,
+              "Extra annotation");
+    } else {
+      fprintf(file_ptr, "%-17s: %06d : %06d : %-21s: %-28s\n", entrie->theName,
+              current_scope, parant_scope, entrie->theType, "Extra annotation");
+    }
+  }
+  if (table->Children_Scope != NULL) {
+    ListOfTable* node = table->Children_Scope;
+    for (; node != NULL; node = node->next) {
+      print_symbol_table(node->table, file_ptr);
+    }
+  }
+  if (table->Parent_Scope == NULL) {
+    fprintf(file_ptr,
+            "-----------------:--------:--------:----------------------:-------"
+            "----------------------\n");
+  }
+}
+
+SymbolTable* getAncestor(SymbolTable* table) {
+  if (table->Parent_Scope == NULL) {
+    // if table has no parent, return itself
+    return table;
+  } else {
+    // call function recursively to grab ancestor
+    return getAncestor(table->Parent_Scope);
+  }
+}
+
+SymbolTable* 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; }
+char* getType(TableNode* tn) { return tn->theType; }
+char* getName(TableNode* tn) { return tn->theName; }
+int getLine(SymbolTable* st) { return st->Line_Number; }
+int getColumn(SymbolTable* st) { return st->Column_Number; }
+// uncomment the below main function along with the headers above for a simple
+// standalone test of table and entry creation
+
+/*
+int main(){
+        char* String = "STRING";
+        char* X = "X";
+        SymbolTable* Second = CreateScope(NULL, 2,2);
+        printf("Line number is %d, Column number of scope is
+%d\n",Second->Line_Number,Second->Column_Number); TableNode* First_Entry =
+CreateEntry(Second,String,X);
+
+        printf("The type of the first entry is %s\n",First_Entry->theType);
+        return 0;
+    }
+    */
--- a/src/symbol_table.h
+++ b/src/symbol_table.h
@@ -0,0 +1,43 @@
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct ListOfTable {
+  struct SymbolTable* table;
+  // struct ListOfTable* prev;
+  struct ListOfTable* next;
+
+} ListOfTable;
+
+typedef struct TableNode {
+  char* theType;
+  char* theName;
+  struct TableNode* next;
+} TableNode;
+
+typedef struct SymbolTable {
+  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* CreateEntry(SymbolTable* table, char* typeOf, char* id);
+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);
+char* getType(TableNode* tn);
+char* getName(TableNode* tn);
+int getLine(SymbolTable* st);
+int getColumn(SymbolTable* st);
--- a/src/typedefs.h
+++ b/src/typedefs.h
@@ -0,0 +1,54 @@
+// identifier
+#define ID 101
+// type names
+#define T_INTEGER 201
+#define T_ADDRESS 202
+#define T_BOOLEAN 203
+#define T_CHARACTER 204
+#define T_STRING 205
+// constants (literals)
+#define C_INTEGER 301
+#define C_NULL 302
+#define C_CHARACTER 303
+#define C_STRING 304
+#define C_TRUE 305
+#define C_FALSE 306
+// other keywords
+#define WHILE 401
+#define IF 402
+#define THEN 403
+#define ELSE 404
+#define TYPE 405
+#define FUNCTION 406
+#define RETURN 407
+#define EXTERNAL 408
+#define AS 409
+// punctuation - grouping
+#define L_PAREN 501
+#define R_PAREN 502
+#define L_BRACKET 503
+#define R_BRACKET 504
+#define L_BRACE 505
+#define R_BRACE 506
+// punctuation - other
+#define SEMI_COLON 507
+#define COLON 508
+#define COMMA 509
+#define ARROW 510
+// operators
+#define ADD 601
+#define SUB_OR_NEG 602
+#define MUL 603
+#define DIV 604
+#define REM 605
+#define LESS_THAN 606
+#define EQUAL_TO 607
+#define ASSIGN 608
+#define NOT 609
+#define AND 610
+#define OR 611
+#define DOT 612
+#define RESERVE 613
+#define RELEASE 614
+// comments
+#define COMMENT 700