/** @todo implement this function */
int symbol_add (sym_table_t* symTab, const char* name, int addr) {
int hash;
int index;
char* cpyName = (char *) name;
if(symbol_search(symTab, name, &hash, &index) == NULL) {
node_t *newNode = malloc(sizeof(struct node));
struct symbol *newSymbol = malloc(sizeof(struct symbol));
newSymbol->name = malloc(sizeof(char *));
strcpy(newSymbol->name, cpyName);
newSymbol->addr = addr;
newNode->symbol = *newSymbol;
newNode->hash = symbol_hash(cpyName);
int newIndex = symbol_hash(cpyName) % SYMBOL_SIZE;
newNode->next = symTab->hash_table[newIndex];
symTab->hash_table[newIndex] = newNode;
if(addr < SYMBOL_SIZE) {
strcpy(symTab->addr_table[addr], cpyName);
}
return 1;
} else {
return 0;
}
}
static void generate_entity_for_each(struct triargexpr_list * tmp_node)
{
struct triargexpr * expr = get_tae_entity(tmp_node, cur_func_index);
struct value_info * arg1_info;
struct entity_type entity;
switch(expr -> op)
{
case Subscript:
/*The arg1 must be id and is pointer or array*/
arg1_info = symbol_search(simb_table, cur_func_info -> func_symt, expr -> arg1.idname);
if(arg1_info -> type -> type == Pointer)
{
tmp_node -> pointer_entity = var_list_new();
tmp_node -> pointer_entity = var_list_copy(tmp_out[arg1_info -> no], tmp_node -> pointer_entity);
}
break;
case Arglist:
case Deref:
/*The arg1 can be any thing*/
if(expr -> arg1.type == IdArg)//must be a pointer or an array
{
arg1_info = symbol_search(simb_table, cur_func_info -> func_symt, expr -> arg1.idname);
if(arg1_info -> type -> type == Pointer)//if Array, need not to deal with it
{
tmp_node -> pointer_entity = var_list_new();
tmp_node -> pointer_entity = var_list_copy(tmp_out[arg1_info -> no], tmp_node -> pointer_entity);
}
else tmp_node -> pointer_entity = NULL;
}
else if(expr -> arg1.type == ExprArg)
{
entity = search_entity(expr -> arg1.expr, 0);
switch(entity.ispointer)
{
case -1:
tmp_node -> pointer_entity = NULL;//Empty
break;
case 0:
case 2:
tmp_node -> pointer_entity = var_list_new();
tmp_node -> pointer_entity = var_list_append(tmp_node -> pointer_entity, entity.index);
break;
case 1:
tmp_node -> pointer_entity = var_list_new();
tmp_node -> pointer_entity = var_list_copy(tmp_out[entity.index], tmp_node -> pointer_entity);
break;
case 3:
tmp_node -> pointer_entity = var_list_new();
tmp_node -> pointer_entity = var_list_copy_array(tmp_out[entity.index], tmp_node -> pointer_entity);
break;
default:
fprintf(stderr, "Error when generate_entity\n");
break;
}
}
else
tmp_node -> pointer_entity = NULL;/* for Arglist */
break;
default:
break;
}
}/*editing now*/
static struct entity_type search_entity(int exprnum, int ispointer)
{
struct triargexpr expr = cur_expr_table[exprnum];
struct value_info * temp_info;
struct entity_type entity;
/*#ifdef ENTITY_DEBUG
printf("Expr:%d\n", exprnum);
printf("Ispointer:%d\n", ispointer);
#endif */
switch(expr.op)
{
case Ref:
if(expr.arg1.type == IdArg)
{
temp_info = symbol_search(simb_table, cur_func_info -> func_symt, expr.arg1.idname);
entity.index = temp_info -> no;
switch(ispointer)
{
case -1://solved in type check
if(temp_info -> type -> type == Pointer)
entity.ispointer = 1;
else if(temp_info -> type -> type == Array)
entity.ispointer = 2;
else entity.ispointer = -1;
return entity;
case 0:
if(temp_info -> type -> type != Pointer && temp_info -> type -> type != Array)
entity.ispointer = 0;
else
entity.ispointer = -1;
return entity;
}
}
if(expr.arg1.type == ExprArg)//ispointer == 1 has been checked
return search_entity(expr.arg1.expr, ispointer + 1);
//there won't be more than one & * once a time
break;
case Deref:
if(expr.arg1.type == IdArg)
{
temp_info = symbol_search(simb_table, cur_func_info -> func_symt, expr.arg1.idname);
entity.index = temp_info -> no;
switch(ispointer)
{
case 0:
entity.ispointer = -1;
return entity;
case 1:
if(temp_info -> type -> type == Pointer)
entity.ispointer = 1;
else if(temp_info -> type -> type == Array)
entity.ispointer = 2;
else
entity.ispointer = -1;
return entity;
}
}
if(expr.arg1.type == ExprArg)
return search_entity(expr.arg1.expr, ispointer - 1);
break;
case Subscript://The arg of subscript can only be an ident
if(expr.arg1.type == IdArg)//just in case
{
temp_info = symbol_search(simb_table, cur_func_info -> func_symt, expr.arg1.idname);
entity.index = temp_info -> no;
switch(ispointer)//if the id is not suitable, the program has been wrong before
{
case 0:
entity.ispointer = -1;
return entity;
case 1:
if(temp_info -> type -> type == Pointer)
entity.ispointer = 3;//modified pointer
else entity.ispointer = 2;//is other type, then has been wrong
return entity;
}
// other wrong case has been checked before
}
break;
case Plusplus:
case Minusminus:
if(expr.arg1.type == IdArg)
{
temp_info = symbol_search(simb_table, cur_func_info -> func_symt, expr.arg1.idname);
entity.index = temp_info -> no;
switch(ispointer)
{
case -1://only pointer or array
entity.ispointer = -1;
return entity;
case 0://Pointer ++ also return -1
if(temp_info -> type -> type == Pointer)
entity.ispointer = 3;//modified pointer
else entity.ispointer = -1;
return entity;
}
}
if(expr.arg1.type == ExprArg)
{
entity = search_entity(expr.arg1.expr, ispointer);
if(entity.ispointer == 1)
{
entity.ispointer = 3;//modified pointer
return entity;
}
else if(entity.ispointer == 3)//if array => wrong
return entity;
}
break;
case Minus:
if(expr.arg1.type == IdArg)
{
temp_info = symbol_search(simb_table, cur_func_info -> func_symt, expr.arg1.idname);
entity.index = temp_info -> no;
switch(ispointer)
{
case -1:
entity.ispointer = -1;
return entity;
case 0://Pointer + or Pointer - also return -1
if( temp_info -> type -> type == Array)
entity.ispointer = 2;
else if(temp_info -> type -> type == Pointer)
entity.ispointer = 3;//modified pointer
else
entity.ispointer = -1;
return entity;
}
}
if(expr.arg1.type == ExprArg)
{
entity = search_entity(expr.arg1.expr, ispointer);
if(entity.ispointer == 1)
{
entity.ispointer = 3;
return entity;
}
else if(entity.ispointer >= 2)//modified pointer or array
return entity;
}
break;
case Plus://there should be only one entity
if(expr.arg1.type == IdArg)
{
temp_info = symbol_search(simb_table, cur_func_info -> func_symt, expr.arg1.idname);
entity.index = temp_info -> no;
switch(ispointer)
{
case -1:
if(temp_info -> type -> type == Pointer || temp_info -> type -> type == Array)
{
entity.ispointer = -1;
return entity;
}
break;
case 0:
if( temp_info -> type -> type == Array)
{
entity.ispointer = 2;
return entity;
}
else if(temp_info -> type -> type == Pointer)
{
entity.ispointer = 3;//modified pointer
return entity;
}
break;
}
}
if(expr.arg2.type == IdArg)//if arg1 and arg2 are all Id, will return -1 at the end
{
temp_info = symbol_search(simb_table, cur_func_info -> func_symt, expr.arg2.idname);
entity.index = temp_info -> no;
switch(ispointer)
{
case -1:
if(temp_info -> type -> type == Pointer || temp_info -> type -> type == Array)
{
entity.ispointer = -1;
return entity;
}
break;
case 0://Pointer + or - also return -1
if(temp_info -> type -> type == Array)
{
entity.ispointer = 2;
return entity;
}
else if(temp_info -> type -> type == Pointer)
{
entity.ispointer = 3;
return entity;
}
break;
}
}
if(expr.arg1.type == ExprArg)
{
entity = search_entity(expr.arg1.expr, ispointer);
if(entity.ispointer == 1)
{
entity.ispointer = 3;
return entity;
}
else if(entity.ispointer >= 2)//modified pointer or array
return entity;
}
if(expr.arg2.type == ExprArg)//number is better than -1
{
entity = search_entity(expr.arg2.expr, ispointer);
if(entity.ispointer == 1)
{
entity.ispointer = 3;
return entity;
}
else if(entity.ispointer >= 2)//modified pointer or array
return entity;
}
break;//don't care other case
default://if there are some other op, the arg can't be Pointer and there won't be & before the expr, just return -1
break;
}
/* if the program has already been wrong, anything returned is meaningless, so just return -1 */
entity.ispointer = -1;
return entity;
}
int main (int argc, char *argv[])
#endif
{
parsed_symbol symbol;
int count = 0;
globals.mode = NONE;
globals.forward_dll = NULL;
globals.input_name = NULL;
globals.dumpsect = NULL;
parse_options (argv);
memset (&symbol, 0, sizeof (parsed_symbol));
switch (globals.mode)
{
case DMGL:
VERBOSE = TRUE;
if (globals.input_name == NULL)
fatal("No symbol name has been given\n");
printf("%s\n", get_symbol_str(globals.input_name));
break;
case SPEC:
if (globals.input_name == NULL)
fatal("No file name has been given\n");
set_module_name(TRUE);
if (!dll_open (globals.input_name))
break;
output_spec_preamble ();
output_header_preamble ();
output_c_preamble ();
while (dll_next_symbol (&symbol))
{
count++;
if (NORMAL)
printf ("Export %3d - '%s' ...%c", count, symbol.symbol,
VERBOSE ? '\n' : ' ');
if (globals.do_code && symbol_searched(count, symbol.symbol))
{
/* Attempt to get information about the symbol */
BOOL result = symbol_demangle (&symbol) || symbol_search(&symbol);
if (result && symbol.function_name)
/* Clean up the prototype */
symbol_clean_string (symbol.function_name);
if (NORMAL)
puts (result ? "[OK]" : "[Not Found]");
}
else if (NORMAL)
puts ("[Ignoring]");
output_spec_symbol (&symbol);
output_header_symbol (&symbol);
output_c_symbol (&symbol);
symbol_clear (&symbol);
}
output_makefile ();
if (VERBOSE)
puts ("Finished, Cleaning up...");
if (symbol_finish())
return 1;
break;
case NONE:
do_usage(0);
break;
case DUMP:
if (globals.input_name == NULL)
fatal("No file name has been given\n");
set_module_name(FALSE);
dump_file(globals.input_name);
break;
}
return 0;
}
/** Entry point of the program
* @param argc count of arguments, will always be at least 1
* @param argv array of parameters to program argv[0] is the name of
* the program, so additional parameters will begin at index 1.
* @return 0 the Linux convention for success.
*/
int main (int argc, char* argv[]) {
char line[MAX_LINE_LENGTH];
int count, addr;
char *cmd, *name;
sym_table_t* symTab;
if (argc != 2)
usage();
symTab = symbol_init(atoi(argv[1]));
while (fgets(line, sizeof(line), stdin) != NULL) {
char *cr = strchr(line ,'\n'); /* get rid of trailing \n, if any */
if (cr)
*cr = '\0';
cmd = strtok(line, delim);
if (! cmd)
continue;
if (strcmp(cmd, "add") == 0) {
name = nextToken();
addr = nextInt();
printf("%s\n", (symbol_add(symTab, name, addr) ? "OK" : "Duplicate"));
}
else if (strcmp(cmd, "count") == 0) {
count = 0;
symbol_iterate(symTab, countSymbols, &count);
printf("symbol count: %d\n", count);
}
else if ((strcmp(cmd, "exit") == 0) || (strcmp(cmd, "quit") == 0)) {
break;
}
else if (strcmp(cmd, "get") == 0) {
name = nextToken();
printResult(symbol_find_by_name(symTab, name), stdout);
}
else if (strcmp(cmd, "help") == 0) {
help();
}
else if (strcmp(cmd, "label") == 0) {
addr = nextInt();
printf("label at addr %d '%s'\n", addr,
symbol_find_by_addr(symTab, addr));
}
else if (strcmp(cmd, "list") == 0) {
symbol_iterate(symTab, printResult, stdout);
}
else if (strcmp(cmd, "reset") == 0) {
symbol_reset(symTab);
}
else if (strcmp(cmd, "search") == 0) {
int hash, index;
name = nextToken();
struct node* node = symbol_search(symTab, name, &hash, &index);
printf("symbol '%s' hash: %d index: %d is %s in symbol table\n", name,
hash, index, (node ? "" : "NOT"));
}
else {
help();
}
}
symbol_term(symTab); /* can check for memory leaks now */
return 0;
}
