slice-load.c

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

			files[cur_file].stmts[stmt].calls = call;
			break;
		case LIF_ACTUAL_SEP:
			sep_stack[top_call]++;
			actual = (actual_ptr) call_malloc (
					sizeof(actual_rec),"actual");
			actual->next = call->actuals;
			call->actuals = actual;
			actual->actuals = NULL;
			actual->actual_number = sep_stack[top_call];
			break;
		case LIF_CALL_END:
			top_call--;
			call = call_stack[top_call];
			break;
		case LIF_RETURN:
			sscanf (buff,"%*d(%d,%d",&stmt,&id);
			files[cur_file].stmts[stmt].is_return = 1;
			procs[cur_proc].returns_xpr |= id;
			new_return = new_set;
			new_return -> id = stmt;
			new_return -> next = procs[cur_proc].return_stmts;
			procs[cur_proc].return_stmts = new_return;
			break;
		case LIF_GOTO:
			break;
		}
	}

	fclose(l_file);

	/*
	generate_call_contexts();
	pr_structs();
	*/
	set_called_by();
	scan_structs();
	count_vars();
	flow();
	close_gdefs();

	return 0;
}

print_var_set(p,s)
	proc_ptr	p;
	var_ptr		s;
{
	field_ptr	at_field;
	int			i;

	while(s){
		/*
		printf ("  [code %d] ",s->code);
		*/
		switch (s->code){
		case LIF_REF:
		case LIF_DEF:
			for (i = 0 ; i < s->level; i++) printf ("*");
			printf ("%s ",p->locals[s->id].name);
			break;
		case LIF_GREF:
		case LIF_GDEF:
			for (i = 0 ; i < s->level; i++) printf ("*");
			printf ("%s ",globals[s->id].name);
			break;
		case LIF_AREF:
			printf ("&%s ",addrs[s->id].pid?
				p->locals[addrs[s->id].id].name:
				globals[addrs[s->id].id].name);
			break;
		case LIF_CREF:
		case LIF_CDEF:
			if (chains[s->id].pid &&
				(&procs[chains[s->id].pid] != p)){
			  fprintf(stderr,"local chain %d on %s of %s used in %s\n",
					s->id,var_name (chains[s->id].pid,chains[s->id].id),
					procs[chains[s->id].pid].proc_name,
					p->proc_name);
			}
			printf ("(%d)%s",s->id,chains[s->id].pid?
				procs[chains[s->id].pid].locals[chains[s->id].id].name:
				/*
				p->locals[chains[s->id].id].name:
				*/
				globals[chains[s->id].id].name);
			at_field = chains[s->id].fields;
			while (at_field){
				printf ("->%s",at_field->name);
				at_field = at_field -> next;
			}
			printf (" ");
			break;
		default:
			printf ("%d(%d) ",s->id,s->code);
		}
		s = s -> next;
	}
}

print_set (s)
	set_ptr	s;
{
	while (s){
		printf ("%d ",s->id);
		s = s -> next;
	}
}

print_proc_defs (nc,proc)
	int nc,proc;
{
	int			i = proc,j,fid,c;
	int			at;
	id_set_ptr	others;

		if (procs[i].global_defs){
			at = -1;
			while ((at = get_next_member(procs[i].global_defs,at)) >=
				0){
				if (nc == 0) printf ("\t\t");
				nc += printf ("%s ",globals[at].name);
				if (nc > 60){
					nc = 0;
					printf ("\n");
				}
			}
		}
		if (procs[i].other_defs){
			printf (" others ");
			others = procs[i].other_defs;
			while (others){
				if (nc == 0) printf ("\t\t");
				nc += printf ("%s ",
					procs[others->pid].locals[others->id].name);
				if (nc > 60){
					nc = 0;
					printf ("\n");
				}
				others = others -> next;
			}
		}
		if (procs[i].global_idefs){
			at = -1;
			while ((at = get_next_member(procs[i].global_idefs,at)) >=
				0){
				if (nc == 0) printf ("\t\t");
				nc += printf ("*%s ",globals[at].name);
				if (nc > 60){
					nc = 0;
					printf ("\n");
				}
			}
		}
		if (procs[i].local_idefs){
			at = -1;
			while ((at = get_next_member(procs[i].local_idefs,at)) >=
				0){
				if (nc == 0) printf ("\t\t");
				nc += printf ("*%s ",procs[i].locals[at].name);
				if (nc > 60){
					nc = 0;
					printf ("\n");
				}
			}
		}
}

verify_input(l_opt)
	int	l_opt;
{
	int			nc,i,j,fid,c;
	int			at;
	char		*line;
	call_ptr	call,cp;
	actual_ptr	actual;
	field_ptr	f;
	id_set_ptr	others;

	printf ("Files\n");
	for (i = 0; i < n_files; i++){
		printf ("\t%-15s %3d %3d %5d %7d\n",
		files[i].name,files[i].n_procs,files[i].n_stmts,
		files[i].n_lines,files[i].n_chars);
	}
	printf ("Procs\n");
	for (i = 1; i <= n_procs; i++)if (procs[i].entry != -1){
		printf ("\t%-20s %3d  %3d %c [%d..%d] (%s)\n",
			procs[i].proc_name,i,procs[i].n_locals,
			procs[i].s_or_x,procs[i].entry,procs[i].exit,
			files[procs[i].file_id].name);
	}
	printf ("Procs global/non-local defs\n");
	for (i = 1; i <= n_procs; i++)if (procs[i].entry != -1){
		nc = printf ("\t%-20s ", procs[i].proc_name);
		print_proc_defs (nc,i);
		if (!procs[i].global_defs &&
			!procs[i].other_defs &&
			!procs[i].global_idefs &&
			!procs[i].local_idefs )printf ("none");
		if (nc) printf ("\n");
	}
	printf ("Calls\n");
	for (i = 1; i <= n_procs; i++)
		if ((procs[i].entry != -1) && procs[i].calls){
		printf ("\t%-20s %3d  %3d %c [%d..%d] (%s)\n",
			procs[i].proc_name,i,procs[i].n_locals,
			procs[i].s_or_x,procs[i].entry,procs[i].exit,
			files[procs[i].file_id].name);
		call = procs[i].calls;
		while (call){
			printf ("\t%4d %s: (",
				call->stmt,procs[call->pid].proc_name);
			actual = call->actuals;
			while (actual){
				print_var_set (&procs[i],actual->actuals);
				actual = actual->next;
				if (actual) printf (", ");
			}
			printf (")\n");
			call = call -> next;
		}
	}
	printf ("Library Functions\n");
	for (i = 1; i <= n_procs; i++)if (procs[i].entry == -1){
		printf ("\t%-20s %3d\n", procs[i].proc_name,i);
	}
	printf ("Globals\n");
	for (i = 1; i <= n_globals; i++){
		printf ("\t%3d %c %c %c %s",
			i,
			globals[i].is_formal?'F':' ',
			globals[i].is_pointer?'P':' ',
			globals[i].is_array?'A':' ',
			globals[i].name);
		if (globals[i].offset) printf (" struct with %d members\n",
			globals[i].offset);
		else printf ("\n");
	}
	printf ("Locals\n");
	for (i = 1; i <= n_procs; i++)if (procs[i].entry != -1){
		printf ("\t%-20s \n", procs[i].proc_name);
		for (j = 1; j <= procs[i].n_locals; j++){
			printf ("\t\t%3d %c %c %c %s",
				j,
				procs[i].locals[j].is_formal?'F':' ',
				procs[i].locals[j].is_pointer?'P':' ',
				procs[i].locals[j].is_array?'A':' ',
				procs[i].locals[j].name);
		if (procs[i].locals[j].offset)
			printf (" struct with %d members\n",
				procs[i].locals[j].offset);
		else printf ("\n");
		}
	}
	printf ("Addrs\n");
	for (i = 1; i <= n_addrs; i++){
		printf ("%4d ==> %s.%s (%d,%d)\n",i,
		addrs[i].pid?procs[addrs[i].pid].proc_name:"global",
		addrs[i].pid?procs[addrs[i].pid].locals[addrs[i].id].name:
		globals[addrs[i].id].name,addrs[i].pid,addrs[i].id);
	}
	printf ("Chains\n");
	for (i = 1; i <= n_chains; i++){
		printf ("%4d ==> (%d,%d) (%s) %s",i,
			chains[i].pid,chains[i].id,
			chains[i].pid?
				procs[chains[i].pid].proc_name:
				"global",
			chains[i].pid?
				procs[chains[i].pid].locals[chains[i].id].name:
				globals[chains[i].id].name);
		f = chains[i].fields;
		while (f){
			printf ("->%s",f->name);
			f = f -> next;
		}
		printf ("\n");
	}
	if (!l_opt) return;
	printf ("Statements\n");
	for (i = 1; i <= n_procs; i++)if (procs[i].entry != -1){
		printf ("\t%-20s %3d  %3d %c [%d..%d] (%s)\n",
			procs[i].proc_name,i,procs[i].n_locals,
			procs[i].s_or_x,procs[i].entry,procs[i].exit,
			files[procs[i].file_id].name);
		fid = procs[i].file_id;
		for (j = procs[i].entry; j <= procs[i].exit; j++){
			nc = printf ("\t%4d @ %d  ",j,files[fid].stmts[j].froml);
			for (;nc < 12; nc++) printf (" ");
			line = files[procs[i].file_id].src_index[
				files[fid].stmts[j].froml];
			while (*line != '\n') printf ("%c",*line++);
			if (files[fid].stmts[j].joins != 1)
				printf ("\n\t     %d pred",files[fid].stmts[j].joins);
			if (files[fid].stmts[j].calls) printf ("\n\t     Calls:");
			cp = files[fid].stmts[j].calls;
			while (cp){
				printf (" %s",procs[cp->pid].proc_name);
				cp = cp -> next_this_stmt;
			}
			printf ("\n\t     Defs: ");
			print_var_set(&procs[i],files[fid].stmts[j].defs);
			printf ("\n\t     Refs: ");
			if (files[fid].stmts[j].is_return) printf ("returns ");
			if (procs[i].returns_xpr) printf ("expression ");
			print_var_set(&procs[i],files[fid].stmts[j].refs);
			printf ("\n\t     Succ: ");
			print_set(files[fid].stmts[j].succ);
			printf ("  Requires: ");
			print_set(files[fid].stmts[j].requires);
			printf ("  Visits next: %d",files[fid].stmts[j].visit_next);
			printf("\n");
		}
	}
}

/*
*********************************************************************
* find the proc_id for a given proc name                            *
* Note that the first name found is returned                        *
* procs declared static could be a problem?????                     *
*********************************************************************
*/
int find_proc(name)
	char	*name;
{
	int		ix;

	for (ix = 1; ix <= n_procs; ix++){
		if (0 == strcmp(procs[ix].proc_name,name)){
			return ix;
		}
	}
	return -1;
}

/*
*********************************************************************
* Translate a file name to a file_id                                *
*********************************************************************
*/
int find_file(name)
	char	*name;
{
	int		ix;

	for (ix = 0; ix < n_files; ix++){
		if (0 == strcmp(files[ix].name,name)){
			return ix;
		}
	}
	return -1;
}

/*
*********************************************************************
*                                                                   *
* Translate a variable name to a variable id                        *
* pid == 0 => global id                                             *
* pid > 0  => local id of procedure pid                             *
*                                                                   *
*********************************************************************
*/
int find_var(pid,name)
	int		pid;
	char	*name;
{
	int		n,ix;
	id_ptr	vars;

	if (pid) {
		vars = procs[pid].locals;
		n = procs[pid].n_locals;
	}
	else {
		vars = globals;
		n = n_globals;
	}
	for (ix = 1; ix <= n; ix++){
		if (0 == strcmp(vars[ix].name,name)){
			return ix;
		}
	}
	return -1;
}

int make_criterion (file_name,line_number,var_spec,
			file,stmt,proc,var)
	char *file_name,*var_spec;
	int		line_number,*file,*stmt,*proc,*var;
{
	int		len;
	char	proc_name[1000],var_name[1000];
	int		n;

	len = strlen(file_name);
	file_name[len-1] = '\0';
	*file = find_file(file_name);
	/*
	printf ("find file %s => %d\n",file_name,*file);
	*/
	if (*file == -1){
		fprintf (stderr,"file %sc not part of %sc system\n",
			file_name,files[0].name);
		return 1;
	}

	if (var_spec[0] == '\'') {
		*proc = 0;
		n = sscanf (var_spec,"'%s",var_name);
	}
	else {
		n = sscanf (var_spec,"%[^']'%s",proc_name,var_name);
		if (n == 1){
			*proc = 0;
			strcpy(var_name,proc_name);
		}
		else *proc = find_proc(proc_name);
	}
	/*
	printf ("find proc %s => %d\n",*proc?proc_name:"global",*proc);
	*/
	if (*proc == -1){
		fprintf (stderr,"proc %s not part of %sc system\n",
			proc_name,files[0].name);
		return 1;
	}
	*var = find_var (*proc,var_name);
	/*
	printf ("find var %s => %d\n",var_name,*var);
	*/
	*stmt = line_to_stmt(*file,line_number);

	return 0;

}

/*
*********************************************************************
*  Translate a line number within a file to a node (stmt) number    *
*  If the line has no stmt (e.g., is blank) find a close stmt.      *
*********************************************************************
*/
int line_to_stmt(file,line)
	int		file,line;
{
	int		i;
	int		best_stmt,best_line;

	for (i = 1; i <= files[file].n_stmts; i++){
		if (files[file].stmts[i].froml == line) return i;
	}
	best_line = -1;
	best_stmt = 1;
	for (i = 1; i <= files[file].n_stmts; i++){
		if (files[file].stmts[i].froml < line){
			if (files[file].stmts[i].froml > best_line){
				best_stmt = i;
				best_line = files[file].stmts[i].froml;
			}
		}
	}
	return best_stmt;
}