sym_tab.c

一个很不错的程序切片工具,希望大家来讨论以下,对测试人员很有帮助

			else {
			new_var = alloc_var_ste();
			new_var -> next = symbol_table[scope_level].var;
			new_var -> detail = 0;
			if (type_entry) new_var -> detail = STE_TYPEDEF;
			new_var -> type_entry = type_entry;
			if (tag_entry){
				new_var -> tag_entry = tag_entry;
				new_var -> detail = STE_TAGGED_STRUCT;
			}
			else new_var -> tag_entry = NULL;
			if (no_tag){
				new_var->anon_entry = type_desc->desc.decl->member_ste;
				new_var -> detail = STE_ANON_STRUCT;
			}
			else new_var -> anon_entry = NULL;
			new_var -> token = var;
			new_var -> type_decl = type_desc;
			new_var -> id = alloc_id();
			new_var -> addr = 0;
			symbol_table[scope_level].var = new_var;
			declared(var->text);
			/*
			printf ("Is %s ",var->text);
			if ( get_var_members (new_var)) printf ("struct ");
			if ( is_var_ptr(new_var)){
				printf (" yes*\n");
			}
			else {printf ("not a pointer\n"); }
			*/
			if (!is_var_ptr(new_var)){
				insert_members (var->text,
					get_var_members (new_var));
				if ((current_id() - new_var->id) > 0){
					if (scope_level > 1) pid = current_proc->proc_id;
					else pid = 0;
					/*
					if (scope_level > 1) printf (
						"cur proc is %d %s ",current_proc->proc_id,
						current_proc->proc->text);
					else printf ("global");
					printf (" struct %s\n",var->text);
					*/
					fprintf (outfile,"%d(%d,%d,%d)",LIF_STRUCT,pid,
						new_var->id,current_id() - new_var->id);
					if(z_opt) fprintf (outfile,
						"     %s is structure with %d members",
						var->text,current_id() - new_var->id);
					fprintf (outfile,"\n");
				}
			}
			}
			var = var -> next;
		}
	}
	}
}

/*
*********************************************************************
*                                                                   *
* called by scanner to look for possible TYPENAME tokens            *
*                                                                   *
*********************************************************************
*/
int is_type_name (t,local_flag)
	char	*t;
	int		*local_flag;
{
	int				level;
	type_ste_ptr	types;
	var_ste_ptr		vars;

	level = scope_level;

	*local_flag = True;
	while (level >= 0){
		types = symbol_table[level].type;
		while (types){
			if (strcmp(types->token->text,t) == 0) return True;
			types = types -> next;
		}
		vars = symbol_table[level].var;
		while (vars){
			if (strcmp(vars->token->text,t) == 0) return False;
			vars = vars -> next;
		}
		*local_flag = False;
		level--;
	}
	return False;

}

/*
*********************************************************************
*                                                                   *
*  find the STE entry for an identifier                             *
*  tabel is NULL for searching the full symbol table (normal case)  *
*                                                                   *
*  A table is passed when looking for structure members. Where the  *
*  table is a symbol table for the structure.                       *
*                                                                   *
*********************************************************************
*/
var_ste_ptr look_up_id (table,name,scope)
	char	*name;
	int		*scope;
	var_ste_ptr	table;
{
	int				level;
	var_ste_ptr		vars;

	level = scope_level;

	if (table){
			*scope = 0;
			vars = table;
			while (vars){
				if (strcmp(vars->token->text,name) == 0) return vars;
				vars = vars -> next;
			}
	}
	else {
		while (level >= 0){
			*scope = level;
			vars = symbol_table[level].var;
			while (vars){
				if (strcmp(vars->token->text,name) == 0) return vars;
				vars = vars -> next;
			}
			level--;
		}
	}
	return NULL;
}

/*
*********************************************************************
*                                                                   *
*  scanner/parser communication about typedef statements            *
*                                                                   *
*********************************************************************
*/
start_typedef()
{
	in_typedef = True;
}

end_typedef()
{
	in_typedef = False;
}

int top_scope() { return scope_level == 1;}

/*
*********************************************************************
*                                                                   *
* Print the members of a structure                                  *
*                                                                   *
*********************************************************************
*/
static print_memb(prefix,v)
	var_ste_ptr		v;
	char			*prefix;
{
	var_ste_ptr		vars = v;
	char			buff[2000];
	static int		n;
	static var_ste_ptr	history[1000];
	int				i;

	for (i = 0; i < n; i++){
		if (history[i] == v){
			printf ("recursive\n");
			return;
		}
	}
	history[n++] = v;
	if (!vars) printf ("no members\n");
	while (vars){
		printf ("%s.%s " ,prefix,vars->token->text);
		vars = vars->next;
	}
	vars = v;
	while (vars){
		if (vars->detail == STE_ANON_STRUCT) {
			sprintf (buff ,"%s.%s",prefix,vars->token->text);
			printf ("\n\t\tanon members: ");
			print_memb(buff,vars->anon_entry);
		}
		else if (vars->detail == STE_TAGGED_STRUCT) {
			sprintf (buff ,"%s.%s",prefix,vars->token->text);
			printf ("\n\t\ttagged members: ");
			print_memb(buff,vars->tag_entry->vars);
		}
		vars = vars->next;
	}
	n--;
}

/*
*********************************************************************
*                                                                   *
*   See if variable is really a struct and see to printing members  *
*                                                                   *
*********************************************************************
*/
static print_types (t)
	type_ste_ptr	t;
{
	if (t->detail == STE_TYPEDEF){
		printf ("%s ",t->type_entry->token->text);
		if (t->type_entry->detail) print_types (t->type_entry);
	}
	else if (t->detail == STE_TAGGED_STRUCT){
		print_memb(t->token->text,t->tag_entry->vars);
	}
	else if (t->detail == STE_ANON_STRUCT){
		print_memb(t->token->text,t->anon_entry);
	}
}

/*
*********************************************************************
*                                                                   *
*  Print the symbol tables (even closed) (-s option)                *
*                                                                   *
*********************************************************************
*/
print_st()
{
	type_ste_ptr	types;
	var_ste_ptr		vars;
	tag_ste_ptr		tags;
	token_ptr		token,t;
	type_ptr		details;
	int		i;
	static	char	*ty[] = {"scalar","fun ret","array of","ptr to"};

	list_procs();
	printf ("\n%10sS Y M B O L    T A B L E\n\n","");
	for (i = 0; i < n_st; i++){
		vars = closed_symbol_tables[i].var;
		types = closed_symbol_tables[i].type;
		tags = closed_symbol_tables[i].tag;
		if(vars||tags||types)printf ("\n\tSymbol table %d\n",i);
		if (vars)printf ("Declared variables:\n");
		while (vars){
			printf ("\t%-15s (%03d.%02d..%02d)  ",vars->token->text,
				vars->token->at.line_start,
				vars->token->at.col_start,
				vars->token->at.col_end);
			printf ("%03d ",vars->id);
			printf ("F(%07o) <%d>  ",
				vars->type_decl->desc.decl->decl_flags,
				vars->detail);
			/*
			if (vars->type_decl->desc.decl->decl_flags &
				FLAG_TYPE_USER_NAME){
				printf ("Defined type ");
			} else if (vars->type_decl->desc.decl->decl_flags &
				FLAG_TYPE_US){
				printf ("struct/union ");
			}
			*/
			details = vars->token->desc.type_desc;
			while (details){
				printf ("%s ",ty[details->is]);
				details = details->next;
			}
			print_flags (vars->type_decl->desc.decl->decl_flags);
			if (vars->tag_entry) printf ("{%s} ",
				vars->tag_entry->tag->desc.decl->tag->text);
			if (vars->type_entry) printf ("[%s] ",
				vars->type_entry->token->text);
			printf ("\n");
			if (vars->detail == STE_ANON_STRUCT){
				printf ("%20s","members: ");
				print_memb(vars->token->text,vars->anon_entry);
				printf ("\n");
			}
			else if (vars->detail == STE_TAGGED_STRUCT){
				printf ("%20s","members: ");
				print_memb(vars->token->text,vars->tag_entry->vars);
				printf ("\n");
			}
			vars = vars -> next;
		}
		if(types)printf ("Declared types:\n");
		while (types){
			printf ("\t%-15s (%d.%d..%d) <%d>  ",types->token->text,
				types->token->at.line_start,
				types->token->at.col_start,
				types->token->at.col_end,
				types->detail);
			details = types->token->desc.type_desc;
			while (details){
				printf ("%s ",ty[details->is]);
				details = details->next;
			}
			if (types->detail) print_types (types);
			printf ("\n");
			types = types -> next;
		}
		if(tags)printf ("Declared tags:\n");
		while (tags){
			token = tags->tag->desc.decl->tag;
			printf ("\t%-15s (%d.%d..%d)",token->text,
				token->at.line_start,
				token->at.col_start,
				token->at.col_end);
			/*
			if (tags->tag->desc.decl->members){
				printf (" with members");
				t = tags->tag->desc.decl->members;
				while (t){
					if (t->desc.decl) print_decl (t,
						t->desc.decl->vars);
					t = t -> next;
				}
			}
			*/
			printf ("%20s","members: ");
			print_memb("",tags->vars);
			printf ("\n");
			tags = tags -> next;
		}
	}
	printf ("\n");
}

int is_ptr_to_type_ptr (te)
	type_ste_ptr	te;
{
	int		n_ptr = 0;
	type_ptr    tp = NULL;

	if (!te) return 0;
	if (te->token){
		tp = te->token->desc.type_desc;
		while (tp){
			if (tp->is == IS_PTR_TO) n_ptr++;
			tp = tp->next;
		}
	}
	if (!te->type_decl) return n_ptr;
	if (te->detail == STE_TYPEDEF){
			n_ptr += is_ptr_to_type_ptr (te->type_entry);
	}
	return n_ptr;
}

int is_ptr_to_ptr(t,nx)
	token_ptr	t;
	int			*nx;
{
	int		n_ptr = 0;
	type_ptr	tp = NULL;
	type_ste_ptr type_entry;

	if (!t) return 0;
	tp = t ->desc.type_desc;
	while (tp){
		if (tp->is == IS_PTR_TO) n_ptr++;
		tp = tp -> next;
	}
	*nx = n_ptr;
/*	if (n_ptr > 1) return n_ptr; */
	if (t->desc.decl->decl_flags & FLAG_TYPE_USER_NAME){
		type_entry = find_type (t->text);
		if (type_entry){
			n_ptr += is_ptr_to_type_ptr (type_entry);
		}
	}
	return n_ptr;
}

static token_ptr get_base_type(t)
	token_ptr	t;
{
	type_ste_ptr type_entry;

	type_entry = find_type (t->text);
	if (type_entry){
		while (type_entry->detail == STE_TYPEDEF){
			type_entry = type_entry -> type_entry;
		}
		return type_entry->type_decl;
	}
	return NULL;
}

token_ptr fake_var_decl(t)
	token_ptr	t;
{
	decl_ptr	ty;
	token_ptr	var_token;
	token_ptr	new_token,type_token;
	char		buff[1000],name[1000],*at;
	static int	ix = 0;
	int			save_scope;
	int			nx,np;

	if(c_opt)printf ("make malloc at %d on line %d\n",stmtno,lineno);
	var_token = alloc_token();
	at = strrchr (the_current_file,'/');
	if (at) at++;
	else at = the_current_file;
	strcpy (name,at);
	at = strchr (name,'.');
	if (at) *at = '\0';
	sprintf (buff,"@%s#%d[%d]",name,lineno,ix++);
	var_token->text = malloc(strlen(buff) + 1);
	var_token->text = strcpy(var_token->text,buff);
	var_token->next = NULL;
	if ((!t) || ((np = is_ptr_to_ptr(t,&nx)) > 1)){
		type_token = alloc_token();
		make_decl(type_token,FLAG_SC_STATIC|FLAG_TYPE_CHAR);
		modify_type (var_token,IS_PTR_TO,NO_STYLE,NULL);
	}
	else {
		if(nx)type_token = t;
		else {
			type_token = get_base_type(t);
			if (!type_token) type_token = t;
			else {
				new_token = alloc_token();
				new_token -> text = type_token->text;
				new_token -> at = t -> at;
				new_token -> desc = type_token ->desc;
				ty = new_token -> desc.decl = alloc_decl();
				ty -> decl_flags = (type_token->desc.decl->decl_flags)
					& (~FLAG_SC_TYPEDEF);
				ty -> vars = type_token->desc.decl->vars;
				ty -> tag = type_token->desc.decl->tag;
				ty -> members = type_token->desc.decl->members;
				ty -> member_ste = type_token->desc.decl->member_ste;
				ty -> offset = type_token->desc.decl->offset;
				type_token = new_token;
			}
		}
	}
	var_token->desc.any = NULL;
	decl(type_token,var_token,0);
	save_scope = scope_level;
	scope_level = 1;
	scope_level = save_scope;
	return var_token;
}