kgram.y

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

%{
# include <stdio.h>
# include "ansi_parse.h"
# include "lif.h"
	static	set_typedef = 0;
	static  char    sccsid[] = "@(#)kgram.y	1.7  10/26/94";
	static	char	*parse_h_sccs_id = PARSE_H_SCCS_ID;
	static	char	*lif_h_sccs_id = LIF_H_SCCS_ID;
%}

%token <token> IDENTIFIER CONSTANT STRING_LITERAL SIZEOF
%token <token> PTR_OP INC_OP DEC_OP LEFT_OP RIGHT_OP LE_OP GE_OP
%token <token> EQ_OP NE_OP
%token <token> AND_OP OR_OP MUL_ASSIGN DIV_ASSIGN MOD_ASSIGN ADD_ASSIGN
%token <token> SUB_ASSIGN LEFT_ASSIGN RIGHT_ASSIGN AND_ASSIGN
%token <token> XOR_ASSIGN OR_ASSIGN TYPE_NAME

%token <token> TYPEDEF EXTERN STATIC AUTO REGISTER
%token <token> CHAR SHORT INT LONG SIGNED UNSIGNED
%token <token> FLOAT DOUBLE CONST VOLATILE VOID
%token <token> STRUCT UNION ENUM ELIPSIS RANGE

%token <token> CASE DEFAULT IF ELSE SWITCH
%token <token> WHILE DO FOR GOTO CONTINUE BREAK RETURN
%type <tree> primary_expr
%type <tree> postfix_expr
%type <tree> argument_expr_list
%type <tree> unary_expr
%type <tree> unary_operator
%type <tree> cast_expr
%type <tree> multiplicative_expr
%type <tree> additive_expr
%type <tree> shift_expr
%type <tree> relational_expr
%type <tree> equality_expr
%type <tree> and_expr
%type <tree> exclusive_or_expr
%type <tree> inclusive_or_expr
%type <tree> logical_and_expr
%type <tree> logical_or_expr
%type <tree> conditional_expr
%type <tree> assignment_expr
%type <op> assignment_operator
%type <tree> oexpr expr
%type <tree> exprXX
%type <tree> constant_expr
%type <token> declaration declaration_specifiers init_declarator_list
%type <token> init_declarator storage_class_specifier type_specifier
%type <token> struct_or_union_specifier
%type <token> struct_or_union struct_declaration_list
%type <token> struct_declaration
%type <token> struct_declarator_list struct_declarator
%type <token> enum_specifier enumerator_list enumerator
%type <token> declarator declarator2 pointer
%type <token> parameter_identifier_list
%type <token> identifier_list parameter_type_list parameter_list
%type <token> parameter_declaration
%type <token> type_name abstract_declarator abstract_declarator2
%type <token> initializer initializer_list
%type <stmt> statement labeled_statement
%type <token> decl_end decl_start
%type <stmt> compound_statement
%type <token> declaration_list
%type <stmt> statement_list expression_statement selection_statement
%type <stmt> iteration_statement jump_statement function_body
%type <token> program file external_definition
%type <token> function_definition
%type <stmt> function_start
%type <token> identifier
%token <token> ';' '(' ')' '{' '}' ':'
%token <token> '&' '*' '~' '+' '-' '!'
%type <token> string_literal_list
%type <token> specifier_qual_list type_qualifier type_qualifier_list

%start program
%%

primary_expr
	: identifier
		{$$ = make_leaf(ID_OP,$1);}
	| CONSTANT
		{$$ = make_leaf(CON_OP,$1);}
	| string_literal_list
		{$$ = make_leaf(CON_OP,$1);}
	| '(' exprXX ')'
		{
			tree_ptr	t;
			t = make_tree (LEFTP_OP,$2,(token_ptr)NULL);
			$$ = make_tree (RIGHTP_OP,t,(token_ptr)NULL);
			t->token = $1;
			$$->token = $3;}
	;
string_literal_list
	: STRING_LITERAL
	| string_literal_list STRING_LITERAL
	;

postfix_expr
	: primary_expr
	| postfix_expr '[' exprXX ']'
		{$$ = make_tree (ARRAY_OP,$1,$3);}
	| postfix_expr '(' ')'
		{$$ = make_tree (CALL_OP,$1,(token_ptr)NULL);}
	| postfix_expr '(' argument_expr_list ')'
		{$$ = make_tree (CALL_OP,$1,$3);}
	| postfix_expr '.' identifier
		{$$ = make_tree (DOT_OP,$1,
			make_leaf(ID_OP,$3));}
	| postfix_expr PTR_OP identifier
		{$$ = make_tree (POINTER_OP,$1,
			make_leaf(ID_OP,$3));}
	| postfix_expr INC_OP
		{$$ = make_tree (POST_OP,$1,(token_ptr)NULL); $$->token = $2;}
	| postfix_expr DEC_OP
		{$$ = make_tree (POST_OP,$1,(token_ptr)NULL); $$->token = $2;}
	;

argument_expr_list
	: assignment_expr
	| argument_expr_list comma_comming ',' assignment_expr
		{$$ = make_tree (ARG_OP,$1,$4);}
	;
comma_comming : /* empty */
			{if(!in_init)type_seen = 0;}
	;

unary_expr
	: postfix_expr
	| INC_OP unary_expr
		{$$ = make_tree (PRE_OP,$2,(token_ptr)NULL);$$->token = $1;}
	| DEC_OP unary_expr
		{$$ = make_tree (PRE_OP,$2,(token_ptr)NULL);$$->token = $1;}
	| unary_operator cast_expr
		{$$ = make_tree ($1->op_code,$2,(token_ptr)NULL);
		if ($1->op_code == DEREF_OP)
			$$->token = $1->token;}
	| SIZEOF unary_expr
		{$$ = make_tree (UN_OP,$2,(token_ptr)NULL);}
	| SIZEOF '(' type_name ')'
		{$$ = make_leaf(CON_OP,$1);}
	;

unary_operator
	: '&'
		{$$ = make_leaf(ADDR_OP,$1);}
	| '*'
		{$$ = make_leaf(DEREF_OP,$1);}
	| '+'
		{$$ = make_leaf(UN_OP,$1);}
	| '-'
		{$$ = make_leaf(UN_OP,$1);}
	| '~'
		{$$ = make_leaf(UN_OP,$1);}
	| '!'
		{$$ = make_leaf(UN_OP,$1);}
	;

cast_expr
	: unary_expr
	| '(' type_name ')' cast_expr
		{
			/*
			if ($2){if($2->desc.decl->decl_flags & FLAG_TYPE_USER_NAME)
					$$ = make_tree (CAST_OP,
						make_leaf(ID_OP,$2),$4);
				else 
					$$ = make_tree (CAST_OP,(token_ptr)NULL,$4);
			}
			else 
				$$ = make_tree (CAST_OP,(token_ptr)NULL,$4);
			*/
			$$ = make_tree (CAST_OP,
						make_leaf(TYPENAME_OP,$2),$4);
		}
	;

multiplicative_expr
	: cast_expr
	| multiplicative_expr '*' cast_expr
		{$$ = make_tree (BIN_OP,$1,$3);}
	| multiplicative_expr '/' cast_expr
		{$$ = make_tree (BIN_OP,$1,$3);}
	| multiplicative_expr '%' cast_expr
		{$$ = make_tree (BIN_OP,$1,$3);}
	;

additive_expr
	: multiplicative_expr
	| additive_expr '+' multiplicative_expr
		{$$ = make_tree (BIN_OP,$1,$3);}
	| additive_expr '-' multiplicative_expr
		{$$ = make_tree (BIN_OP,$1,$3);}
	;

shift_expr
	: additive_expr
	| shift_expr LEFT_OP additive_expr
		{$$ = make_tree (BIN_OP,$1,$3);}
	| shift_expr RIGHT_OP additive_expr
		{$$ = make_tree (BIN_OP,$1,$3);}
	;

relational_expr
	: shift_expr
	| relational_expr '<' shift_expr
		{$$ = make_tree (BIN_OP,$1,$3);}
	| relational_expr '>' shift_expr
		{$$ = make_tree (BIN_OP,$1,$3);}
	| relational_expr LE_OP shift_expr
		{$$ = make_tree (BIN_OP,$1,$3);}
	| relational_expr GE_OP shift_expr
		{$$ = make_tree (BIN_OP,$1,$3);}
	;

equality_expr
	: relational_expr
	| equality_expr EQ_OP relational_expr
		{$$ = make_tree (BIN_OP,$1,$3);}
	| equality_expr NE_OP relational_expr
		{$$ = make_tree (BIN_OP,$1,$3);}
	;

and_expr
	: equality_expr
	| and_expr '&' equality_expr
		{$$ = make_tree (BIN_OP,$1,$3);}
	;

exclusive_or_expr
	: and_expr
	| exclusive_or_expr '^' and_expr
		{$$ = make_tree (BIN_OP,$1,$3);}
	;

inclusive_or_expr
	: exclusive_or_expr
	| inclusive_or_expr '|' exclusive_or_expr
		{$$ = make_tree (BIN_OP,$1,$3);}
	;

logical_and_expr
	: inclusive_or_expr
	| logical_and_expr AND_OP inclusive_or_expr
		{$$ = make_tree (BIN_OP,$1,$3);}
	;

logical_or_expr
	: logical_and_expr
	| logical_or_expr OR_OP logical_and_expr
		{$$ = make_tree (BIN_OP,$1,$3);}
	;

conditional_expr
	: logical_or_expr
	| logical_or_expr '?' expr ':' conditional_expr
		{$$ = make_tree (BIN_OP,$1,
			make_tree (BIN_OP,$3,$5));
		}
	;

assignment_expr
	: conditional_expr
	| unary_expr assignment_operator assignment_expr
		{$$ = make_tree (($2 == 0)?RELASGN_OP:ASGN_OP,$1,$3);}
	;

assignment_operator
	: '='
		{ $$ = 1;}
	| MUL_ASSIGN
		{ $$ = NULL;}
	| DIV_ASSIGN
		{ $$ = NULL;}
	| MOD_ASSIGN
		{ $$ = NULL;}
	| ADD_ASSIGN
		{ $$ = NULL;}
	| SUB_ASSIGN
		{ $$ = NULL;}
	| LEFT_ASSIGN
		{ $$ = NULL;}
	| RIGHT_ASSIGN
		{ $$ = NULL;}
	| AND_ASSIGN
		{ $$ = NULL;}
	| XOR_ASSIGN
		{ $$ = NULL;}
	| OR_ASSIGN
		{ $$ = NULL;}
	;

expr
	: exprXX
	;
exprXX
	: assignment_expr
	| expr ',' assignment_expr
		{$$ = make_tree (COMMA_OP,$1,$3);}
	;

constant_expr
	: conditional_expr
	;

declaration
	: declaration_specifiers ';'
		{
			decl ($1,(token_ptr)NULL,False);
			end_typedef();
		}
	| declaration_specifiers init_declarator_list ';'
		{
			decl ($1,$2,False);
			if(c_opt)print_decl ($1,$2);
			$1->desc.decl->vars = $2;
			end_typedef();
		}
	;

declaration_specifiers
	: storage_class_specifier
	| storage_class_specifier declaration_specifiers
		{$1->desc.decl->decl_flags |=
			$2->desc.decl->decl_flags ;
		$1->desc.decl->tag = $2->desc.decl->tag;
		$1->desc.decl->vars = $2->desc.decl->vars;
		$1->desc.decl->members = $2->desc.decl->members;
		$1->desc.decl->member_ste = $2->desc.decl->member_ste;
		if (!$1->text) $1->text = $2->text;
		}
	| type_qualifier
	| type_qualifier declaration_specifiers
		{if ($1 && $2)$2->desc.decl->decl_flags |=
				$1->desc.decl->decl_flags ;
			$$ = $2;
		}
	| type_specifier 
	| type_specifier declaration_specifiers 
		{$1->desc.decl->decl_flags |=
			$2->desc.decl->decl_flags ;
		if (!$1->text) $1->text = $2->text;
		}
	;

init_declarator_list
	: init_declarator
	| init_declarator_list ',' init_declarator
		{
			token_ptr	t;
/*
**********************************************************
*                                                        *
*  Collect list of declarators                           *
*                                                        *
**********************************************************
*/

			if ($1){
				t = $1;
				while (t->next) t = t->next;
				t->next = $3;
			}
			else $$ = $3;
		}
	;

init_declarator
	: declarator
	| declarator '=' initializer
		{ end_init();}
	;

storage_class_specifier
	: TYPEDEF
		{make_decl ($1, FLAG_SC_TYPEDEF);
			start_typedef();
			set_typedef = True;}
	| EXTERN
		{make_decl ($1, FLAG_SC_EXTERN);}
	| STATIC
		{make_decl ($1, FLAG_SC_STATIC);}
	| AUTO
		{make_decl ($1, FLAG_SC_AUTO);}
	| REGISTER
		{make_decl ($1, FLAG_SC_REGISTER);}
	;

type_specifier
	: CHAR {make_decl ($1, FLAG_TYPE_CHAR);}
	| SHORT {make_decl ($1, FLAG_TYPE_SHORT);}
	| INT {make_decl ($1, FLAG_TYPE_INT);}
	| LONG {make_decl ($1, FLAG_TYPE_LONG);}
	| SIGNED {make_decl ($1, FLAG_TYPE_SIGNED);}
	| UNSIGNED {make_decl ($1, FLAG_TYPE_UNSIGNED);}
	| FLOAT {make_decl ($1, FLAG_TYPE_FLOAT);}
	| DOUBLE {make_decl ($1, FLAG_TYPE_DOUBLE);}
	| VOID {make_decl ($1, FLAG_TYPE_VOID);}
	| struct_or_union_specifier
	| enum_specifier
	| TYPE_NAME {make_decl ($1, FLAG_TYPE_USER_NAME);}
	;

struct_or_union_specifier
	: struct_or_union identifier
		{
			$1->desc.decl->tag = $2;
			decl ($1,(token_ptr)NULL,True);
		}
		'{' struct_declaration_list '}'
		{
			int		offset;

			$1->desc.decl->member_ste = struct_decl($5,&offset);
			$1->desc.decl->members = $5;
			$1->desc.decl->offset = offset;
		}
	| struct_or_union '{' struct_declaration_list '}'
		{
			int		offset;

			$1->desc.decl->members = $3;
			$1->desc.decl->member_ste = struct_decl($3,&offset);
			$1->desc.decl->offset = offset;
		}
	| struct_or_union identifier 
		{
			$1->desc.decl->tag = $2;
		}
	;

struct_or_union
	: STRUCT
		{make_decl ($1, FLAG_TYPE_US | FLAG_TYPE_STRUCT); }
	| UNION
		{make_decl ($1, FLAG_TYPE_US | FLAG_TYPE_UNION); }
	;
	

struct_declaration_list
	: struct_declaration
	| struct_declaration_list struct_declaration
		{
			token_ptr	t;

			t = $1;
			if (t){
				while (t->next) t = t->next;
				t->next = $2;
			}
			else $$ = $2;
		}
	;

specifier_qual_list
	: type_specifier
	| type_qualifier
	| specifier_qual_list type_qualifier
		{
			$1->desc.decl->decl_flags |= $2->desc.decl->decl_flags;
			if ($1->desc.decl->tag == NULL)
				$1->desc.decl->tag = $2->desc.decl->tag;
			if ($1->desc.decl->vars == NULL)
				$1->desc.decl->vars = $2->desc.decl->vars;
			if ($1->desc.decl->members == NULL)
				$1->desc.decl->members = $2->desc.decl->members;
			if ($1->desc.decl->member_ste == NULL)
				$1->desc.decl->member_ste = $2->desc.decl->member_ste;
		}
	| specifier_qual_list type_specifier
		{
			$1->desc.decl->decl_flags |= $2->desc.decl->decl_flags;
			if ($1->desc.decl->tag == NULL)
				$1->desc.decl->tag = $2->desc.decl->tag;
			if ($1->desc.decl->vars == NULL)
				$1->desc.decl->vars = $2->desc.decl->vars;
			if ($1->desc.decl->members == NULL)
				$1->desc.decl->members = $2->desc.decl->members;
			if ($1->desc.decl->member_ste == NULL)
				$1->desc.decl->member_ste = $2->desc.decl->member_ste;
		}
	;

struct_declaration
	/* : type_specifier_list struct_declarator_list ';'
	| type_specifier_list ';' */
	: specifier_qual_list struct_declarator_list ';'
		{
			$1->desc.decl->vars = $2;
		}
	| specifier_qual_list ';'
		{
			$1->desc.decl->vars = NULL;
		}
	;

struct_declarator_list
	: struct_declarator
	| struct_declarator_list ',' struct_declarator
		{
			token_ptr	t;
/*
**********************************************************
*                                                        *
*  Collect list of declarators                           *
*                                                        *
**********************************************************
*/

			if ($1){
				t = $1;
				while (t->next) t = t->next;
				t->next = $3;
			}
			else $$ = $3;
		}
	;

struct_declarator
	: declarator
	| ':' constant_expr
		{$$ = NULL;}
	| declarator ':' constant_expr
	;

enum_specifier
	: ENUM '{' enumerator_list '}'
		{ make_decl ($1, FLAG_TYPE_ENUM);$1->desc.decl->members = $3;}
	| ENUM identifier '{' enumerator_list '}'
		{ make_decl ($1,FLAG_TYPE_ENUM);$1->desc.decl->members = $4;}
	| ENUM identifier
		{ make_decl ($1,FLAG_TYPE_ENUM); $1->desc.decl->members = NULL;}
	;

enumerator_list
	: enumerator
	| enumerator_list ',' enumerator
		{
			token_ptr	t;
/*
**********************************************************
*                                                        *
*  Collect list of enumerators                           *
*                                                        *
**********************************************************
*/

			if ($1){
				t = $1;
				while (t->next) t = t->next;
				t->next = $3;
			}
			else $$ = $3;
		}
	| enumerator_list ','
	;

enumerator
	: identifier
	| identifier '=' constant_expr
	;

declarator
	: declarator2
	| pointer declarator2
		{	int i;
			for (i = 0; i < (int)$1; i++)
				modify_type ($2,IS_PTR_TO,NO_STYLE,(token_ptr)NULL);
			$$ = $2;
		}
	;

parms_next : /* empty */
		{ /*printf ("PARM(%d)\n",lineno);*/in_parms = 1;}
	;
declarator2
	: identifier