sym_tab.c

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

/*
*********************************************************************
*                                                                   *
* search symbol table for a type name                               *
*                                                                   *
*********************************************************************
*/
type_ste_ptr find_type (type_name)
	char	*type_name;
{
	int				level;
	type_ste_ptr	t;

	if (!type_name) return NULL;
	level = scope_level;

	/*
	printf ("look for type_name %s\n",type_name);
	*/
	while (level >= 0){
	/*	printf ("searching level %d\n",level); */
		t = symbol_table[level].type;
		while (t){
			if (strcmp(t->token->text,type_name) == 0)
				return t;
			t = t -> next;
		}
		level--;
	}
	return NULL;

}

/*
*********************************************************************
*                                                                   *
*                                                                   *
*                                                                   *
*********************************************************************
*/
static tag_decl (type_desc,var_list,tag_entry_ptr,
					detail_ptr,with_members)
	token_ptr		type_desc,var_list;
	tag_ste_ptr		*tag_entry_ptr;
	int				*detail_ptr,with_members;
{
	tag_ste_ptr		new_tag,tag_entry = NULL;
	int				no_tag = 0;
	int				is_local_tag;

	if (type_desc->desc.decl->decl_flags & FLAG_TYPE_US){
		/*printf ("Do struct/union\n");*/
		/* if this decl has a tag, see if it exists already */
		if (type_desc->desc.decl->tag) tag_entry = find_tag(
			type_desc->desc.decl->tag->text,&is_local_tag);
		else /* this structure has no tag => anon struct */
			{tag_entry = NULL; no_tag = 1;}
		if(c_opt)printf ("entry %d  no_tag (%d): ",tag_entry,no_tag);
		if (!tag_entry && !no_tag){ /* tag not found anywhere */
			tag_entry = new_tag = alloc_tag_ste();
			new_tag -> next = symbol_table[scope_level].tag;
			new_tag ->tag = type_desc;
			new_tag ->vars= type_desc->desc.decl->member_ste;
			symbol_table[scope_level].tag = new_tag;
			if(c_opt)
				printf ("declare new %s tag (%d) at scope level %d ",
					is_local_tag?"local":"non-local",tag_entry,
					scope_level);
		}
		else if (is_local_tag){ /* tag exists locally */
		/* if the new decl has members and the existing
			decl does not, then move the member list from
			the new decl to the tagged_ste */
			if (tag_entry){
				if (!tag_entry->vars) tag_entry->vars =
					type_desc->desc.decl->member_ste;
			}
		}
		else if (no_tag){ /* anon struct */
		}
		else { /* tag found non-local */
			/* declare tag as local if either:
				(1) tag has members or
				(2) tag does not have variables
			*/
			if ((type_desc->desc.decl->members) ||
					!var_list || with_members){
				tag_entry = new_tag = alloc_tag_ste();
				new_tag -> next = symbol_table[scope_level].tag;
				new_tag ->tag = type_desc;
				new_tag ->vars= type_desc->desc.decl->member_ste;
				symbol_table[scope_level].tag = new_tag;
				if(c_opt)printf (
					"declare new masking tag (%d) at scope level %d ",
					tag_entry,scope_level);
			}
		}
		if(c_opt)if (type_desc->desc.decl->tag)
			printf ("tag %s ",type_desc->desc.decl->tag->text);
		if(c_opt)if (type_desc->desc.decl->decl_flags & FLAG_TYPE_UNION)
			printf ("union ");
			else printf ("struct ");
		if(c_opt)printf ("declared %s members ",
		type_desc->desc.decl->members ?"with":"without");
		if(c_opt)printf ("and %s variables\n",
			var_list?"with":"without");
	}
	*tag_entry_ptr = tag_entry;
	*detail_ptr = no_tag;
	if(c_opt)printf ("tag decl returns tag_entry %d and no tag %d\n",
		tag_entry,no_tag);
}


/*
*********************************************************************
*                                                                   *
*  struct_decl is called to reduce the member list of a struct/union*
*                                                                   *
*  type_desc is a list of declarations (type tokens)                *
*  each declaration has a type and a list of variables              *
*                                                                   *
*  struct_decl returns a symbol table for the members of the struct *
*                                                                   *
*********************************************************************
struct_or_union_specifier
	: struct_or_union identifier
		{
			$1->desc.decl->tag = $2;
			decl ($1,NULL,True);
		}
		'{' struct_declaration_list '}'
		{
			$1->desc.decl->member_ste = struct_decl($5);
			$1->desc.decl->members = $5;
		}
	| struct_or_union '{' struct_declaration_list '}'
		{
			$1->desc.decl->members = $3;
			$1->desc.decl->member_ste = struct_decl($3);
		}
*/
var_ste_ptr	struct_decl (type_desc,off)
	token_ptr	type_desc;
	int			*off;
{
	token_ptr	d,vars;
	var_ste_ptr	st = NULL,new_var;
	int			detail,no_tag;
	int			off_set = 0;
	var_ste_ptr	anon,last;
	tag_ste_ptr tag_entry;
	type_ste_ptr type_entry = NULL;

	if(c_opt)printf ("struct decl: ");
	d = type_desc;
	while (d){
		vars = d->desc.decl->vars;
		if(c_opt)printf ("(%08o) ",d->desc.decl->decl_flags);
		detail = STE_NONE;
		anon = NULL;
		tag_entry = NULL;
		if (d->desc.decl->decl_flags & FLAG_TYPE_US){
		/*
			if (d->desc.decl->tag){
				tag_entry = find_tag(d->desc.decl->tag->text,
					&is_local_tag);
				if (tag_entry) detail = STE_TAGGED_STRUCT;
				else detail = STE_NONE;
			}
			else {
				detail = STE_ANON_STRUCT;
				anon = d->desc.decl->member_ste;
			}
		*/
			tag_decl (d,vars,&tag_entry,&no_tag,
					d->desc.decl->members!=NULL);
			if (no_tag){
				detail = STE_ANON_STRUCT;
				anon = d->desc.decl->member_ste;
			}
			else {
				if (tag_entry) detail = STE_TAGGED_STRUCT;
				else detail = STE_NONE;
			}
		}
		else if (d->desc.decl->decl_flags & FLAG_TYPE_USER_NAME){
			type_entry = find_type (d->text);
			if (type_entry) detail = STE_TYPEDEF;
		}
		else {
			detail = STE_NONE;
			anon = NULL;
		}
		last = st;
		if(last) while (last->next) last = last -> next;
		while(vars){
			if(c_opt)printf (" %s <detail %d> ",vars->text,detail);
			new_var = alloc_var_ste();
			new_var -> detail = detail;
			new_var -> next = NULL;
			new_var -> type_entry = type_entry;
			new_var -> tag_entry = tag_entry;
			new_var -> anon_entry = anon;
			new_var -> token = vars;
			new_var -> type_decl = d;
			new_var -> id = ++off_set;
			new_var -> addr = 0;
			if (last) last-> next = new_var;
			else st = new_var;
			last = new_var;
			if (!is_var_ptr(new_var)){
				if(c_opt)
					printf ("call insert from struct_decl add(%s)\n",
					vars->text);
				insert_struct_members (vars->text,
					get_var_members (new_var),&st,&off_set);
				if(last) while (last->next) last = last -> next;
			}
			vars = vars->next;
		}

		d = d -> next;
	}
	if(c_opt)printf ("\n");
	if(c_opt){ var_ste_ptr	s;
		printf ("Declare a struct: (members)\n");
		s = st;
		while (s){
			printf ("\t%s \n",s->token->text); fflush(stdout);
			s = s -> next;
		}
	}
	*off = off_set;
	return st;
}

insert_ptr_var(scope,var)
	int	scope;
	var_ste_ptr	var;
{
	var -> next = symbol_table[scope].var;
	symbol_table[scope].var = var;
	declared(var->token->text);
}

/*
*********************************************************************
*                                                                   *
*  used to declare an undeclared old style parm (declared as int)   *
*                                                                   *
*********************************************************************
*/

insert_var_decl (var)
	token_ptr	var;
{
	var_ste_ptr		new_var;

	new_var = alloc_var_ste();
	new_var -> token = var;
	new_var -> type_decl = create_token((char *)NULL);
	new_var -> next = symbol_table[scope_level].var;
	new_var -> detail = 0;
	new_var -> type_entry = NULL;
	new_var -> tag_entry = NULL;
	new_var -> anon_entry = NULL;
	new_var -> id = alloc_id();
	new_var -> addr = 0;
	symbol_table[scope_level].var = new_var;
	make_decl(new_var->type_decl,FLAG_TYPE_INT);
	/* used to declare an undeclared old style parm
		(declared as int)							*/
}

insert_struct_members (base,members,st,off_set)
	char	*base;
	var_ste_ptr	members,*st;
	int		*off_set;

{
	char		name[3000];
	var_ste_ptr	new_var,last;
	
	last = *st;
	if (last){
		while (last->next) last = last-> next;
	}
	while (members){
		sprintf (name,"%s.%s",base,members->token->text);
		if(c_opt)printf ("INS struct mem new: %s\n",name);
		new_var = alloc_var_ste();
		new_var -> token = create_token(name);
		new_var -> token -> desc = members -> token -> desc;
		new_var -> type_decl = members -> type_decl;
		new_var -> next = NULL;
		new_var -> detail = members -> detail;
		new_var -> type_entry = members -> type_entry;
		new_var -> tag_entry = members -> tag_entry;
		new_var -> anon_entry = members -> anon_entry;
		new_var -> id = ++(*off_set);
		new_var -> addr = 0;
		if (last){
			last->next = new_var;
		}
		else {
			*st = new_var;
		}
		last = new_var;
		members = members->next;
	}
}

insert_members (base,members)
	char	*base;
	var_ste_ptr	members;
{
	char		name[3000];
	var_ste_ptr	new_var,last;
	
	last = symbol_table[scope_level].var;
	if (last){
		while (last->next) last = last-> next;
	}
	while (members){
		sprintf (name,"%s.%s",base,members->token->text);
		/* printf ("new: %s\n",name); */
		new_var = alloc_var_ste();
		new_var -> token = create_token(name);
		new_var -> token -> desc = members -> token -> desc;
		new_var -> type_decl = members -> type_decl;
		new_var -> next = NULL;
		new_var -> detail = members -> detail;
		new_var -> type_entry = members -> type_entry;
		new_var -> tag_entry = members -> tag_entry;
		new_var -> anon_entry = members -> anon_entry;
		new_var -> id = alloc_id();
		new_var -> addr = 0;
		/*
		symbol_table[scope_level].var = new_var;
		*/
		declared(name);
		if (last){
			last->next = new_var;
		}
		else {
			symbol_table[scope_level].var = new_var;
		}
		last = new_var;
		/*
		if (!is_var_ptr(new_var)){
			insert_members (name,
				get_var_members (new_var));
		}
		*/
		members = members->next;
	}
}

/*
*********************************************************************
*                                                                   *
*   Declare the variables on var_list as type type_desc in the      *
*   current symbol table level.                                     *
*                                                                   *
*   with_members is used to declare a structure tag with members    *
*   from inside a structure (i.e. nested structures)                *
*                                                                   *
*********************************************************************
*/
decl (type_desc,var_list,with_members)
	token_ptr	type_desc,var_list;
	int			with_members;
{
	token_ptr		var,enum_const;
	type_ste_ptr	new_type,type_entry;
	var_ste_ptr		new_var;
	tag_ste_ptr		tag_entry = NULL;
	int				no_tag = 0,pid;
	type_ptr		type_mod;

	if(c_opt)printf ("Do Decl at line %d\n",type_desc?type_desc->
		at.line_start:lineno);
	var = var_list;
	if (type_desc){
		if (type_desc->desc.decl->decl_flags & FLAG_TYPE_USER_NAME){
			type_entry = find_type (type_desc->text);
			if(c_opt)printf ("at line %d using user defined type: ",
				lineno);
			if(c_opt)printf ("%s",type_desc->text);
			if(c_opt)if (type_entry)printf (
					" %s\n",type_entry->token->text);
				else printf (" not found\n");
		}
		else type_entry = NULL;
		if (type_desc->desc.decl->decl_flags & FLAG_TYPE_US){
			tag_decl (type_desc,var_list,&tag_entry,&no_tag,
				with_members);
		}
		if (type_desc->desc.decl->decl_flags & FLAG_TYPE_ENUM){
			enum_const = type_desc->desc.decl->members;
			while (enum_const){
				if(c_opt)printf ("enum %s\n",enum_const->text);

				new_var = alloc_var_ste();
				new_var -> token = enum_const;
				new_var -> type_decl = type_desc;
				new_var -> next = symbol_table[scope_level].var;
				new_var -> detail = 0;
				new_var -> type_entry = NULL;
				new_var -> tag_entry = NULL;
				new_var -> anon_entry = NULL;
				new_var -> id = alloc_id();
				new_var -> addr = 0;
				symbol_table[scope_level].var = new_var;
				enum_const = enum_const->next;
			}
		}
		if (type_desc->desc.decl->decl_flags & FLAG_SC_TYPEDEF){
			/* var_list is list of type names */
			while(var){
				if(c_opt)printf ("User defined type: %s  at level %d\n",
					var->text,scope_level);
				new_type = alloc_type_ste();
				new_type -> next = symbol_table[scope_level].type;
				new_type -> token = var;
				new_type -> type_decl = type_desc;
				new_type -> anon_entry = NULL;
				if (type_entry) new_type -> detail = STE_TYPEDEF;
				else if (tag_entry)new_type->detail = STE_TAGGED_STRUCT;
				else if (no_tag) {
					new_type -> detail = STE_ANON_STRUCT;
					new_type -> anon_entry =
						type_desc->desc.decl->member_ste;
				}
				else new_type->detail = STE_NONE;
				new_type -> tag_entry = tag_entry;
				new_type -> type_entry = type_entry;
				symbol_table[scope_level].type = new_type;
				var = var -> next;
			}
		}
	else {
		 /* variable declaration */
		 if(c_opt)printf ("Do vars %s (%d)\n",
			tag_entry?"tag found":"tag not found", no_tag);
		while(var){
			if(c_opt)printf ("variable declared: %s  at level %d\n",
				var->text,scope_level);
			type_mod = var->desc.type_desc;
			if (type_mod && (type_mod->is == IS_FUNC_RET)){
				if(c_opt)printf ("%s Is a function\n",var->text);
			}