compiler-the-translators/symbol_table.c

#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;
    }
    */