#include // Externally visible, for the generator extern tlhash_t *global_names; extern char **string_list; extern size_t n_string_list, stringc; // Implementation choices, only relevant internally static void find_globals ( void ); /** @param function Function's symbol table entry * @param root Function's root node */ static void bind_names ( symbol_t *function, node_t *root ); /* Helper functions */ void print_global_tree(symbol_t* global); void insert_symbol(tlhash_t *hash_table, symbol_t* symbol); void push_scope(void); void pop_scope(void); static uint64_t no_scopes, cur_scope_depth; static tlhash_t **scopes; void create_symbol_table ( void ) { // Initialize string array string_list = malloc(n_string_list * sizeof(char*)); n_string_list = DEFAULT_STRING_LIST_SIZE; stringc = 0; no_scopes = DEFAULT_NO_SCOPES; cur_scope_depth = 0; scopes = malloc(no_scopes * sizeof(tlhash_t)); find_globals(); /* TODO: traverse the syntax tree and create the symbol table */ /* // ! Example code solely to demonstrate usage of tlhash. Make sure to remove // ! or comment this out when implementing your solution. // Initialize table tlhash_t *my_table = (tlhash_t*)malloc(sizeof(tlhash_t)); tlhash_init(my_table, 64); char *my_key0 = "key"; // Keep in mind that these are stack allocated for simplicity, yours should not char *my_val0 = "valuable"; // Also, I'm using strings as values, you will be using symbol_t pointers char *my_key1 = "another_key"; char *my_val1 = "more valuable"; // Insert some values to the table. Remember that the length of a string // interpreted as an array is the string length plus one '\0' character tlhash_insert(my_table, my_key0, strlen(my_key0)+1, my_val0); tlhash_insert(my_table, my_key1, strlen(my_key1)+1, my_val1); // Iterate keys and lookup their values size_t size = tlhash_size(my_table); char **keys = (char **)malloc(size); tlhash_keys(my_table, keys); char *val; for (int i = 0; i < size; i++) { tlhash_lookup(my_table, keys[i], strlen(keys[i])+1, &val); printf("my_table[%s] = \"%s\"\n", keys[i], val); } // Free allocated memory when done with the symbol table tlhash_finalize(my_table); free(my_table); free(keys); */ } const char *symbol_names[4] = {"GLOBAL_VAR", "FUNCTION", "PARAMETER", "LOCAL_VAR"}; void print_global_tree(symbol_t* global) { if (!global) return; printf("─%s(%s, %ld)\n", symbol_names[global->type], global->name, global->seq); if (!global->nparms && !global->locals) return; uint64_t no_locals = tlhash_size(global->locals); symbol_t **locals_list = malloc(no_locals * sizeof(symbol_t)); tlhash_values(global->locals, (void **)locals_list ); for (int l = 0; l < no_locals; l++) { printf(" %s─%s(%s, %ld)\n", (l < (global->nparms - 1)) ? "ā”œ" : "ā””", symbol_names[locals_list[l]->type], locals_list[l]->name, locals_list[l]->seq ); } //putchar('\n'); free(locals_list); } void print_symbol_table ( void ) { /* TODO: output its contents */ /* Get the number of symbols, size up a temporary list and fill it */ uint64_t no_globals = tlhash_size(global_names); symbol_t **global_list = malloc(no_globals * sizeof(symbol_t)); tlhash_values(global_names, (void **)global_list ); /* Iterate over the temporary list, printing entries */ for (uint64_t g = 0; g < no_globals; g++ ) { //printf("global: %s\n", global_list[g]->name ); print_global_tree(global_list[g]); } free(global_list); } void destroy_global(symbol_t* global) { if (!global) return; if (!global->locals) { free(global); return; } uint64_t no_locals = tlhash_size(global->locals); symbol_t **locals_list = malloc(no_locals * sizeof(symbol_t)); tlhash_values(global->locals, (void **)locals_list ); for (int l = 0; l < no_locals; l++) free(locals_list[l]); tlhash_finalize(global->locals); free(global->locals); free(global); free(locals_list); } void destroy_symbol_table ( void ) { //return; /* TODO: release memory allocated to the symbol table */ for (uint64_t c = 0; c < stringc; c++) free(string_list[c]); free(string_list); if (!global_names) return; uint64_t no_globals = tlhash_size(global_names); symbol_t **global_list = malloc(no_globals * sizeof(symbol_t)); tlhash_values(global_names, (void **)global_list ); for (uint64_t g = 0; g < no_globals; g++) destroy_global(global_list[g]); tlhash_finalize(global_names); free(global_names); free(global_list); } void insert_symbol(tlhash_t *hash_table, symbol_t* symbol) { tlhash_insert(hash_table, symbol->name, strlen(symbol->name), symbol); } void find_globals ( void ) { tlhash_init(global_names = malloc(sizeof(tlhash_t)), GLOBAL_BUCKET_SIZE); /* TODO: Populate symbol table with global variables and functions */ uint64_t no_functions = 0; node_t *global_list = root; // Check if not nullptr if (!global_list) return; symbol_t* global_symbol; for (uint64_t global_i = 0; global_i < global_list->n_children; global_i++) { node_t *current_global = global_list->children[global_i]; switch (current_global->type) { case VARIABLE_LIST: // Go through the variable list and get all the global variables for (uint64_t var_i = 0; var_i < current_global->n_children; var_i++) { global_symbol = malloc(sizeof(symbol_t)); *global_symbol = (symbol_t){ .type = SYM_GLOBAL_VAR, .name = current_global->children[var_i]->data, .node = current_global->children[var_i], .seq = 0, .nparms = 0, .locals = NULL }; insert_symbol(global_names, global_symbol); } break; case FUNCTION: node_t *function = current_global; // Function node allways have the same structure, // [0] are the identifier // [1] are the variable list, within a paramerer_list if (!function->children[0]) break; // Create the function symbol global_symbol = malloc(sizeof(symbol_t)); *global_symbol = (symbol_t){ .type = SYM_FUNCTION, .name = current_global->children[0]->data, .node = current_global->children[0], .seq = no_functions++, .nparms = 0, .locals = malloc(sizeof(tlhash_t)) }; // Initialize the local variable table tlhash_init(global_symbol->locals, LOCAL_BUCKET_SIZE); // Insert the pointer to the newly created symbol insert_symbol(global_names, global_symbol); // If there are no parameters in function, break. if (!current_global->children[1]->n_children) break; // Find all params and insert into hash table in global_symbol symbol_t *param_sym; node_t *param_list = current_global->children[1]->children[0]; global_symbol->nparms = param_list->n_children; for (uint64_t param_i = 0; param_i < param_list->n_children; param_i++) { param_sym = malloc(sizeof(symbol_t)); *param_sym = (symbol_t){ .type = SYM_PARAMETER, .name = param_list->children[param_i]->data, .node = param_list->children[param_i], .seq = param_i, .nparms = 0, .locals = NULL }; insert_symbol(global_symbol->locals, param_sym); } break; } } } void push_scope(void) { scopes[cur_scope_depth] = malloc(sizeof(tlhash_t)); tlhash_init(scopes[cur_scope_depth++], LOCAL_BUCKET_SIZE); if (cur_scope_depth >= no_scopes) { no_scopes *= 2; tlhash_t **new_scopes = realloc(scopes, no_scopes * sizeof(tlhash_t)); if (!new_scopes) { fprintf(stderr, "[ERROR] Could not realloc scopes!\n"); exit(EXIT_FAILURE); } scopes = new_scopes; } } void pop_scope(void) { tlhash_finalize(scopes[--cur_scope_depth]); free(scopes[cur_scope_depth]); //scopes[cur_scope_depth] = NULL; } void bind_names ( symbol_t *function, node_t *root ) { /* TODO: Bind names and string literals in local symbol table */ if (!function) return; if (!root) return; // We want do top to bottom traverse, so do not // call recusivly unless we need to go deeper switch (root->type) { case BLOCK: push_scope(); for (uint64_t i = 0; i < root->n_children; i++) bind_names(function, root->children[i]); pop_scope(); case DECLARATION_LIST: /* code */ break; case IDENTIFIER_DATA: break; case STRING_DATA: break; default: for (uint64_t i = 0; i < root->n_children; i++) bind_names(function, root->children[i]); break; } }