compiler-the-translators/symbol_table.c

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

#include "symbol_table.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 * getParent(SymbolTable* st){
	return st->ParentScope;
	}

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;
	}
int getColumn(SymbolTable *st){
	return st->column;
	}
//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;
    }
    */