sym_tab.c

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

# include "ansi_parse.h"
# include "lif.h"
# include <malloc.h>
# include <string.h>
	static  char    sccsid[] = "@(#)sym_tab.c	1.4  4/26/95";
static int scope_level = 1;
static symbol_table_entries	symbol_table[MAX_NEST];
static	max_local_id = 1;
static	max_global_id = 1;
static	in_typedef = 0;
# define MAX_ST 10000
static symbol_table_entries	closed_symbol_tables[MAX_ST];
static int	n_st = 0;

declared(var)
	char	*var;
{
	if (scope_level > 1) return;
	if(var)fprintf(h_file,"\t%s\n",var);
}

int	is_var_ptr_mod(t)
	token_ptr	t;
{
	type_ptr	mod;

	if (!t) return False;
	mod = t->desc.type_desc;
	while (mod){
		if (mod -> is == IS_PTR_TO) return True;
		mod = mod -> next;
	}
	return False;
}

int	is_type_ptr (t)
	type_ste_ptr	t;
{
	if (!t) return False;
	if (is_var_ptr_mod (t->token)) return True;
	if (t->detail  != STE_TYPEDEF) return False;

	if ( is_type_ptr (t -> type_entry)) return True;
	return False;
}

int	is_var_ptr(var)
	var_ste_ptr	var;
{
	/* is var declared pointer					*/
	if (is_var_ptr_mod(var->token)) return True;
	if (var->detail != STE_TYPEDEF) return False;
	/* var is a user defined type (might be pointer type) */

	if ( is_type_ptr (var -> type_entry)) return True;
	return False;
}

var_ste_ptr	get_var_members (var)
	var_ste_ptr	var;
{
	type_ste_ptr	t;

	if (!var) return NULL;
	if (var->detail == STE_ANON_STRUCT) return var->anon_entry;
	if (var->detail == STE_TAGGED_STRUCT)
		return var->tag_entry->vars;
	if (var->detail != STE_TYPEDEF) return NULL;
	t = var->type_entry;
	while (t){
		if (t->detail == STE_ANON_STRUCT) return t->anon_entry;
		if (t->detail == STE_TAGGED_STRUCT)
			return t->tag_entry->vars;
		if (t->detail != STE_TYPEDEF) return NULL;
		t = t->type_entry;
	}
	return NULL;

}


/*
struct hh {			 STE for variable 
	token_ptr	 token;
	token_ptr	 type_decl;
	int			 detail;
	type_ste_ptr type_entry;
	tag_ste_ptr	 tag_entry;
	var_ste_ptr	 anon_entry;
	int			 id;
	var_ste_ptr	 next;
};
*/

is_decl_array_or_pointer(t,is_array,is_pointer)
	type_ste_ptr	t;
	int			*is_array,*is_pointer;
{
	type_ptr    details;

	if (!t) return;
	details = t->token->desc.type_desc;
	while (details) {
		if (details->is == IS_ARRAY_OF) *is_array = 1;
		if (details->is == IS_PTR_TO) *is_pointer = 1;
		details = details -> next;
	}
	if ((!(*is_pointer && *is_array)) &&
		(t->type_decl->desc.decl->decl_flags & FLAG_TYPE_USER_NAME)){
		/* look at user defined type unless both array and pointer on */
		if (t->detail == STE_TYPEDEF)
			is_decl_array_or_pointer (t->type_entry,is_array,is_pointer);
		}
}

int is_var_array(v)
	var_ste_ptr  v;
{
	int		is_array,is_pointer;
	type_ptr	details;

	if(!v) return 0;
	details = v->token->desc.type_desc;
	while (details) {
		if (details->is == IS_ARRAY_OF) return 1;
		details = details -> next;
	}
	is_pointer = 0;
	is_array = 0;
	is_decl_array_or_pointer (v->type_entry,&is_array,&is_pointer);
	return is_array;

}

/*
*********************************************************************
*                                                                   *
* do_ids is called when a scope level is closed to output a list    *
* of all identifiers in LIF format                                  *
*                                                                   *
*********************************************************************
*/
do_ids()
{
	var_ste_ptr	v;
	int		class;
	int		is_array,is_pointer;
	type_ptr	details;

	class = scope_level == 1 ? LIF_GLOBAL_ID : LIF_LOCAL_ID;
	v = symbol_table[scope_level].var;
	while (v){
		is_array = 0;
		is_pointer = 0;
		details = v->token->desc.type_desc;
		while (details) {
			if (details->is == IS_ARRAY_OF) is_array = 1;
			if (details->is == IS_PTR_TO) is_pointer = 1;
			details = details -> next;
		}
		if ((!(is_pointer && is_array)) &&
			(v->type_decl->desc.decl->decl_flags &
				FLAG_TYPE_USER_NAME)){
	/* look at user defined type unless both array and pointer on */
			if (v->detail == STE_TYPEDEF)
				is_decl_array_or_pointer
					(v->type_entry,&is_array,&is_pointer);
		}
		fprintf(outfile,"%d(%d,%s",
			class,v->id,v->token->text);
		if (FLAG_SC_STATIC & v->type_decl->desc.decl->decl_flags)
			fprintf(outfile,",S");
		if (is_pointer) fprintf(outfile,",P");
		if (FLAG_SC_EXTERN & v->type_decl->desc.decl->decl_flags)
			fprintf(outfile,",X");
		if (is_array) fprintf(outfile,",A");
		fprintf(outfile,")");
		if (z_opt){
			fprintf (outfile,"    %s id",
				class == LIF_GLOBAL_ID ? "Global":"local");
			if (is_pointer) fprintf(outfile," pointer");
			if (is_array) fprintf(outfile," array");
		}
		fprintf(outfile,"\n");
		v = v -> next;
	}
}

/*
*********************************************************************
*                                                                   *
* do_formals is called when a fun decl is done to output a list     *
* of all formal parms in LIF format                                 *
*                                                                   *
*********************************************************************
*/
do_formals()
{
	var_ste_ptr	v;
	type_ptr	details;
	int			is_array = 0, is_pointer = 0;

	v = symbol_table[scope_level].var;
	while (v){
		is_array = 0;
		is_pointer = 0;
		details = v->token->desc.type_desc;
		while (details) {
			if (details->is == IS_ARRAY_OF) is_array = 1;
			if (details->is == IS_PTR_TO) is_pointer = 1;
			details = details -> next;
		}
		if ((!(is_pointer && is_array)) &&
			(v->type_decl->desc.decl->decl_flags &
				FLAG_TYPE_USER_NAME)){
	/* look at user defined type unless both array and pointer on */
			if (v->detail == STE_TYPEDEF)
				is_decl_array_or_pointer
					(v->type_entry,&is_array,&is_pointer);
		}
		fprintf(outfile,"%d(%d,%s",
			LIF_FORMAL_ID,v->id,v->token->text);
		if (is_pointer) fprintf(outfile,",P");
		if (is_array) fprintf(outfile,",A");
		fprintf(outfile,")");
		if (z_opt){
			fprintf (outfile,"    Formal parm");
			if (is_pointer) fprintf(outfile," pointer");
			if (is_array) fprintf(outfile," array");
		}
		fprintf(outfile,"\n");
		v = v -> next;
	}
}

/*
*********************************************************************
*                                                                   *
* reset id counter for a new procedure                              *
*                                                                   *
*********************************************************************
*/
start_local_decls()
{
	max_local_id = 1;
}

/*
*********************************************************************
*                                                                   *
* allocate an id from locals or globals                             *
*                                                                   *
*********************************************************************
*/
int current_global()
{
	return max_global_id - 1;
}
int current_local()
{
	return max_local_id - 1;
}
int alloc_local()
{
	return max_local_id++;
}
int alloc_global()
{
	return max_global_id++;
}
int current_id()
{
	if (scope_level == 1) return max_global_id - 1;
	return max_local_id - 1;
}

int	alloc_id()
{
	int		id;

	if (scope_level == 1) id = max_global_id++;
	else id = max_local_id++;

	return id;
}

/*
*********************************************************************
*                                                                   *
* modify the token (some typename e.g. int) with a flag to          *
* indicate the type being used                                      *
*                                                                   *
*********************************************************************
*/
make_decl (token,flag)
	token_ptr	token;
	unsigned int flag;
{
	token->desc.decl = alloc_decl();
	token->desc.decl->decl_flags = flag;
	token->desc.decl->vars = NULL;
	token->desc.decl->tag = NULL;
	token->desc.decl->members = NULL;
	token->desc.decl->member_ste = NULL;
	token->desc.decl->offset = 0;
}

/*
*********************************************************************
*                                                                   *
* modify an identifier (token) to indicate pointers, arrays,        *
* or style of function declaration                                  *
*                                                                   *
*********************************************************************
*/
modify_type (token,flag,style,formals)
	token_ptr	token,formals;
	unsigned int flag;
	int			style;
{
	type_ptr	new,old;

	new = alloc_type();
	new -> is = flag;
	new -> next = NULL;
	new -> style = style;
	new -> formals = formals;
	if (old = token->desc.type_desc){
		while (old->next) old = old->next;
		old->next = new;
	}
	else token->desc.type_desc = new;
}

type_ptr make_abstract_type (flag,style,formals)
	token_ptr	formals;
	unsigned int flag;
	int			style;
{
	type_ptr	new,old;

	new = alloc_type();
	new -> is = flag;
	new -> next = NULL;
	new -> style = style;
	new -> formals = formals;
	return new;
}

merge_abstract_type (old,new)
	type_ptr    new,old;
{
	if (old){
		while (old->next) old = old->next;
		old->next = new;
	}
}

/*
*********************************************************************
*                                                                   *
* stack a new scope level for the symbol table                      *
*                                                                   *
*********************************************************************
*/
open_scope()
{
	scope_level++;
	if (c_opt) printf ("Open scope level %d\n",scope_level);
	symbol_table[scope_level].var = NULL;
	symbol_table[scope_level].type = NULL;
	symbol_table[scope_level].tag = NULL;
}

/*
*********************************************************************
*                                                                   *
*  close a scope level and if c_opt print the variables, tags and   *
*  types.                                                           *
*                                                                   *
*********************************************************************
*/
close_scope()
{
	type_ste_ptr	types;
	var_ste_ptr		vars;
	tag_ste_ptr		tags;

	if (c_opt) printf ("Close scope level %d ==> st[%d]\n",
		scope_level,n_st);
	if (scope_level == 2) do_formals ();
	else do_ids();
	closed_symbol_tables[n_st].var = symbol_table[scope_level].var;
	closed_symbol_tables[n_st].type = symbol_table[scope_level].type;
	closed_symbol_tables[n_st++].tag = symbol_table[scope_level].tag;
	if (c_opt){
		vars = symbol_table[scope_level].var;
		printf ("\nS C O P E    L E V E L    %d    => st[%d]\n",
			scope_level,n_st-1);
		printf ("Declared variables:\n");
		while (vars){
			printf ("%s\n",vars->token->text);
			vars = vars -> next;
		}
		types = symbol_table[scope_level].type;
		printf ("Declared types:\n");
		while (types){
			printf ("%s\n",types->token->text);
			types = types -> next;
		}
		tags = symbol_table[scope_level].tag;
		printf ("Declared tags:\n");
		while (tags){
			printf ("%s\n",tags->tag->desc.decl->tag->text);
			tags = tags -> next;
		}
	}
	scope_level--;
}

/*
*********************************************************************
*                                                                   *
* look for a tag,  return the ste and if tag is found in            *
* the local scope, set local_flag to true.                          *
*                                                                   *
*********************************************************************
*/
tag_ste_ptr find_tag (tag,local_flag)
	char	*tag;
	int		*local_flag;
{
	int				level;
	tag_ste_ptr		vars;

	level = scope_level;

	/*printf ("look for tag %s\n",tag);*/
	*local_flag = True;
	while (level >= 0){
	/*	printf ("searching level %d\n",level); */
		vars = symbol_table[level].tag;
		while (vars){
			if (strcmp(vars->tag->desc.decl->tag->text,tag) == 0)
				return vars;
			vars = vars -> next;
		}
		*local_flag = False;
		level--;
	}
	/*printf ("tag %s not found\n",tag);*/
	return NULL;

}