191 lines
5.9 KiB
C
191 lines
5.9 KiB
C
#include <vslc.h>
|
|
|
|
|
|
|
|
|
|
// 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 );
|
|
|
|
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;
|
|
|
|
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);
|
|
*/
|
|
}
|
|
|
|
|
|
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[no_globals];
|
|
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 );
|
|
|
|
}
|
|
}
|
|
|
|
void
|
|
destroy_symbol_table ( void )
|
|
{
|
|
/* TODO: release memory allocated to the symbol table */
|
|
}
|
|
|
|
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
|
|
bind_names ( symbol_t *function, node_t *root )
|
|
{
|
|
/* TODO: Bind names and string literals in local symbol table */
|
|
}
|