stmt.c

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

}

break_continue (stmt,break_node,continue_node)
	stmt_ptr	stmt;
	int			break_node,continue_node;
{
	list_ptr	nodes;

	if (stmt){
		nodes = stmt -> breaks;
		while (nodes && break_node) {
			connect_nodes (nodes->node,break_node);
			nodes = nodes -> next;
		}
		nodes = stmt -> continues;
		while (nodes && continue_node) {
			connect_nodes (nodes->node,continue_node);
			nodes = nodes -> next;
		}
	}
}

break_cases (stmt,xpr_to_case,break_to_end)
	stmt_ptr	stmt;
	int			xpr_to_case,break_to_end;
{
	list_ptr	nodes;

	if (stmt){
		nodes = stmt -> breaks;
		while (nodes && break_to_end) {
			connect_nodes (nodes->node,break_to_end);
			nodes = nodes -> next;
		}
		nodes = stmt -> cases;
		while (nodes && xpr_to_case) {
			connect_nodes (xpr_to_case,nodes->node);
			nodes = nodes -> next;
		}
	}
}

/* $$ = if_stmt ($1,$3,$4,$5,$6,$7) */
stmt_ptr if_stmt (if_token,xpr_tree,rp_token,then_stmt,
					else_token,else_stmt)
		token_ptr	if_token,rp_token,else_token;
		tree_ptr	xpr_tree;
		stmt_ptr	then_stmt,else_stmt;
{
	stmt_ptr	new;
	int			if_part,else_part,join_part;
	int			xfrom,xto;
/*
*****************************************************************
*                                                               *
*   IF ( XPR ) then_stmt join_part                              *
*            |   ^     |  ^                                     *
*            +---+     +--+                                     *
*            |            |                                     *
*            +------------+                                     *
*                                                               *
*****************************************************************
*/

	if_part = xpr_gen (xpr_tree,&xfrom,&xto);
	if(else_token)else_part = get_stmt_no();
	join_part = get_stmt_no();
	gen_require (if_part,join_part,join_part);
	require_stmt (join_part,then_stmt);

	if (!then_stmt->is_jump)connect_nodes (then_stmt->exit,join_part);
	connect_nodes (xto,then_stmt->entry);
	if (else_token){
		connect_nodes (else_part,else_stmt->entry);
		if (!else_stmt->is_jump)
			connect_nodes (else_stmt->exit,join_part);
		connect_nodes (xto,else_part);
		source_map (else_part,else_token,else_token);
		gen_require (join_part,else_part,else_part);
		require_stmt (join_part,else_stmt);
		require_stmt (else_part,else_stmt);
	}
	else connect_nodes (xto,join_part);

	source_map (if_part,if_token,rp_token);
	source_map (join_part,rp_token,rp_token);
	new = alloc_stmt();
	/* new -> from = then_stmt->from; */
	new -> from = if_part;
	new -> to = join_part;
	new -> entry = xfrom;
	new -> exit = join_part;
	new -> breaks = then_stmt -> breaks;
	new -> cases = then_stmt -> cases;
	new -> continues = then_stmt -> continues;
	new -> is_jump = 0;
	new -> next = NULL;
	new -> last = new;;
	if (else_stmt) merge_bc (new,else_stmt);
	/*
	printf ("IF %d-%d joins at %d  then [%d-%d]\n",
		xfrom,xto,join_part,then_stmt->entry,then_stmt->exit);
	*/
	return new;
}

/*
*****************************************************************
*                                                               *
*                                                               *
*   WHILE ( XPR ) STMT                                          *
*             | ^   ^                                           *
*             +-+   |                                           *
*             |     |                                           *
*             +-----+                                           *
*                                                               *
*****************************************************************
*/
stmt_ptr while_stmt (while_token,xpr_tree,rp_token,stmt)
	token_ptr	while_token,rp_token;
	tree_ptr	xpr_tree;
	stmt_ptr	stmt;
{
	int		while_node,rp_node;
	int		xfrom,xto;
	stmt_ptr	new;

	while_node = xpr_gen (xpr_tree,&xfrom,&xto);
	rp_node = get_stmt_no();
	source_map (while_node,while_token,rp_token);
	source_map (rp_node,rp_token,rp_token);
	connect_nodes (xto,stmt->entry);
	connect_nodes (xto,rp_node);
	connect_nodes (stmt->exit,xfrom);
	break_continue (stmt,rp_node,xfrom);

	gen_require (while_node,rp_node,rp_node);
	require_stmt (rp_node,stmt);

	/*
	printf ("WHILE [%d-%d] join %d  [%d-%d]\n",xfrom,xto,rp_node,
		stmt->entry,stmt->exit);
		*/
	control (WHILE_CTRL,xfrom,rp_node,stmt->entry,stmt->exit,NULL,
		NULL);

	new = alloc_stmt();
	new -> from = while_node;
	new -> to = rp_node;;
	new -> entry = xfrom;
	new -> exit = rp_node;;
	new -> breaks = NULL;
	new -> cases = NULL;
	new -> continues = NULL;
	new -> is_jump = 0;
	new -> next = NULL;
	new -> last = new;;
	return new;
}

/*
*****************************************************************
*                                                               *
*    +----------------+                                         *
*    v                |                                         *
*   DO stmt WHILE ( EXPR )                                      *
*    |  ^ |  ^        |  ^                                      *
*    +--+ +--+        +--+                                      *
*                                                               *
*****************************************************************
*/
stmt_ptr do_stmt(do_token,stmt,while_token,xpr_tree,rp_token)
	token_ptr	do_token,while_token,rp_token;
	tree_ptr	xpr_tree;
	stmt_ptr	stmt;
{
	int		do_node,while_node,rp_node;
	int		xfrom,xto;
	stmt_ptr	new;

	do_node = get_stmt_no();
	while_node = xpr_gen (xpr_tree,&xfrom,&xto);
	rp_node = get_stmt_no();
	break_continue (stmt,rp_node,xfrom);
	source_map (do_node,do_token,do_token);
	source_map (rp_node,rp_token,rp_token);
	source_map (while_node,while_token,rp_token);

	connect_nodes (do_node,stmt->entry);
	connect_nodes (stmt->exit,xfrom);
	connect_nodes (xto,do_node);
	connect_nodes (xto,rp_node);

	gen_require (while_node,do_node,do_node);
	gen_require (rp_node,while_node,while_node);
	require_stmt (do_node,stmt);
	new = alloc_stmt();
	new -> from = do_node;
	new -> to = rp_node;
	new -> entry = do_node;
	new -> exit = rp_node;;
	new -> breaks = NULL;
	new -> cases = NULL;
	new -> continues = NULL;
	new -> is_jump = 0;
	new -> next = NULL;
	new -> last = new;;
	return new;
}

/*
	| FOR '(' oexpr ';' oexpr ';' oexpr ')' statement
		{$$ = for_stmt ($1,$2,$3,$5,$7,$8,$9);}
*/

stmt_ptr for_stmt(for_token,lp_token,init_tree,semi1_token,cond_tree,
				semi2_token,delta_tree,rp_token,stmt)
	token_ptr	for_token,lp_token,rp_token,semi1_token,semi2_token;
	tree_ptr	init_tree,cond_tree,delta_tree;
	stmt_ptr	stmt;
{
	int			init_node,for_node,exit_node;
	int			init_from,init_to,
				delta_node,delta_from,delta_to,
				cond_node,cond_from,cond_to;
	stmt_ptr	new;

	for_node = get_stmt_no();
	source_map (for_node,for_token,lp_token);
	if (init_tree){
		init_node = xpr_gen (init_tree,&init_from,&init_to);
		source_map (init_node,lp_token,semi1_token);
		gen_require (for_node,init_from,init_to);
	}
	if (cond_tree){
		cond_node = xpr_gen (cond_tree,&cond_from,&cond_to);
		source_map (cond_node,semi1_token,semi2_token);
		gen_require (for_node,cond_from,cond_to);
	}
	if (delta_tree){
		delta_node = xpr_gen (delta_tree,&delta_from,&delta_to);
		source_map (delta_node,semi2_token,rp_token);
		gen_require (for_node,delta_from,delta_to);
	}

	exit_node = get_stmt_no();
	source_map (exit_node,rp_token,rp_token);
	gen_require (exit_node,for_node,for_node);

	break_continue (stmt,exit_node,delta_tree?delta_from:
		(cond_tree?cond_from:stmt->entry));

	require_stmt (for_node,stmt);
	if (cond_tree) {
		require_stmt (cond_node,stmt);
		if (delta_tree) gen_require (cond_node, delta_from,delta_to);
	}

	if (init_tree) {
		connect_nodes (for_node,init_from);
		if (cond_tree) connect_nodes (init_to,cond_from);
		else connect_nodes (init_to,stmt->entry);
	}
	else if (cond_tree) connect_nodes (for_node,cond_from);
	else connect_nodes (for_node,stmt->entry);

	if (cond_tree){
		connect_nodes (cond_to,stmt->entry);
		connect_nodes (cond_to,exit_node);
	}

	if (delta_tree){
		connect_nodes (stmt->exit,delta_from);
		if (cond_tree)
			connect_nodes (delta_to,cond_from);
		else
			connect_nodes (delta_to,stmt->entry);
	}
	else if (cond_tree)
		connect_nodes (stmt->exit,cond_from);
	else
		connect_nodes (stmt->exit,stmt->entry);

	new = alloc_stmt();
	new -> from = stmt->from;
	new -> to = exit_node;
	new -> entry = for_node;
	new -> exit = exit_node;;
	new -> breaks = NULL;
	new -> cases = NULL;
	new -> continues = NULL;
	new -> is_jump = 0;
	new -> next = NULL;
	new -> last = new;;
	return new;

}

/*
	| SWITCH '(' expr ')' statement
		{$$ = switch_stmt ($1,$3,$4,$5);}
*/
stmt_ptr switch_stmt(switch_token,xpr_tree,rp_token,stmt)
	token_ptr	switch_token,rp_token;
	stmt_ptr	stmt;
	tree_ptr	xpr_tree;
{
	int			switch_node,sfrom,sto,rp_node;
	int			has_default;
	stmt_ptr	new;
	list_ptr	c;

	switch_node = xpr_gen (xpr_tree,&sfrom,&sto);
	rp_node = get_stmt_no();
	source_map (switch_node,switch_token,rp_token);
	source_map (rp_node,rp_token,rp_token);
	break_cases (stmt,sto,rp_node);
	connect_nodes (stmt->exit,rp_node);
	gen_require (switch_node,rp_node,rp_node);
	gen_require (rp_node,stmt->to,stmt->to);
	c = stmt->cases;
	has_default = 0;
	while (c){
		if (c->is_default_case){
			has_default = 1;
			break;
		}
		c = c -> next;
	}
	if (!has_default){
		connect_nodes (sto,rp_node);
	}
	new = alloc_stmt();
	new -> from = switch_node;
	new -> to = rp_node;
	new -> entry = sfrom;
	new -> exit = rp_node;
	new -> breaks = NULL;
	new -> cases = NULL;
	new -> continues = stmt->continues;
	new -> is_jump = 0;
	new -> next = NULL;
	new -> last = new;;
	return new;
}

/*
	| CASE constant_expr ':' statement
		{$$ = case_stmt ($1,$3,$4,False);}
	| DEFAULT ':' statement
		{$$ = case_stmt ($1,$2,$3,True);}
*/
stmt_ptr case_stmt(case_token,colon_token,stmt,is_default_case)
	token_ptr	case_token,colon_token;
	int			is_default_case;
	stmt_ptr	stmt;
{
	int			node;
	list_ptr	list;

	node = get_stmt_no();
	source_map (node,case_token,colon_token);
	connect_nodes (node,stmt->entry);
	gen_require (node,stmt->from,stmt->to);
	stmt->entry = node;
	stmt->to = node;
	list = alloc_list();
	list -> node = node;
	list -> next = stmt->cases;
	list -> is_marked = False;
	list -> is_default_case = is_default_case;
	stmt -> cases  = list;

	return stmt;
}

stmt_ptr return_stmt (return_token,xpr_tree,semi_token)
	token_ptr	return_token,semi_token;
	tree_ptr	xpr_tree;
{
	int			return_node,rfrom,rto;
	stmt_ptr	new;
	list_ptr	list;

	if (xpr_tree){
		return_node = xpr_gen (xpr_tree,&rfrom,&rto);
		current_proc -> has_return_xpr = 1;
	}
	else {
		return_node = rfrom = rto = get_stmt_no();
	}
	source_map(return_node,return_token,semi_token);
	new = make_stmt (rfrom,rto,rfrom,rto);
	new -> is_jump = 1;

	list = alloc_list();
	list -> next = returns;
	list -> node = rto;
	returns = list;
	fprintf (outfile,"%d(%d,%d)",LIF_RETURN,rto,xpr_tree?1:0);
	if (z_opt)fprintf (outfile,"    return at %d %s",rto,
			xpr_tree?"with vaules":"with no values");
	fprintf (outfile,"\n");

	return new;
}

do_returns (end_stmt)
	int		end_stmt;
{
	while (returns){
		connect_nodes (returns->node,end_stmt);
		returns = returns -> next;
	}
}

stmt_ptr	fun_stmt(t)
	token_ptr	t;
{
	int			node;
	stmt_ptr	new;
	proc_ptr	p;

	node = get_stmt_no();
	p = find_proc(t);
	if (p) {
		p->entry_node = node;
		pid = p->proc_id;
		current_proc = p;
	}
	else {
		max_proc++;
		add_proc(t,node,max_proc);
		pid = max_proc;
	}
	if(t)source_map (node,t,t);
	new = make_stmt (node,node,node,node);
	fprintf (outfile,"%d(%d,%d,%s)",LIF_PROC_START,
		node,pid,t?t->text:"NO PROC NAME");
	if (z_opt){
		fprintf (outfile,"   Function %s %d entry at %d",
			t?t->text:"LOST NAME",pid,node);
	}
	fprintf (outfile,"\n");
	labels = NULL;
	return new;
}