gram_old.y

C程序漏洞检查

	{
            $2->hdr.type = TN_EXPR;
            $2->lnode = $1;
            $2->rnode = $3;
            $$ = $2;
	}

bitwise_xor_expr:  bitwise_and_expr
	|  bitwise_xor_expr B_XOR bitwise_and_expr
	{
            $2->hdr.type = TN_EXPR;
            $2->lnode = $1;
            $2->rnode = $3;
            $$ = $2;
	}

bitwise_and_expr:  equality_expr
	|  bitwise_and_expr B_AND equality_expr
	{
            $2->hdr.type = TN_EXPR;
            $2->lnode = $1;
            $2->rnode = $3;
            $$ = $2;
	}

bitwise_neg_expr:  B_NOT cast_expr
	{
            $1->hdr.type = TN_EXPR;
            $1->rnode = $2;
	}

cast_expr:  unary_expr
	|  LPAREN type_name RPAREN cast_expr     %prec CAST
	{
            $1->hdr.type = TN_CAST;
            $1->lnode = $2;
            $1->rnode = $4;
            free_tree($3);
	}

equality_expr:  relational_expr
	|  equality_expr equality_op relational_expr
	{
            $2->hdr.type = TN_EXPR;
            $2->lnode = $1;
            $2->rnode = $3;
            $$ = $2;
	}

relational_expr:  shift_expr
	|  relational_expr relation_op shift_expr 
	{
            $2->hdr.type = TN_EXPR;
            $2->lnode = $1;
            $2->rnode = $3;
            $$ = $2;
	}

shift_expr:  additive_expr
	|  shift_expr shift_op additive_expr
	{
            $2->hdr.type = TN_EXPR;
            $2->lnode = $1;
            $2->rnode = $3;
            $$ = $2;
	}

additive_expr:  mult_expr
	|  additive_expr add_op mult_expr
	{
            $2->hdr.type = TN_EXPR;
            $2->lnode = $1;
            $2->rnode = $3;
            $$ = $2;
	}

mult_expr:  cast_expr
	|  mult_expr mult_op cast_expr
	{
            $2->hdr.type = TN_EXPR;
            $2->lnode = $1;
            $2->rnode = $3;
            $$ = $2;
	}

unary_expr:  postfix_expr
	|  sizeof_expr
	|  alignof_expr
	|  unary_minus_expr
	|  unary_plus_expr
	|  log_neg_expr
	|  bitwise_neg_expr
	|  addr_expr
	|  indirection_expr
	|  preinc_expr
	|  predec_expr
        ;

sizeof_expr:  SIZEOF LPAREN type_name RPAREN   %prec HYPERUNARY
	{
            $1->hdr.type = TN_EXPR;
            $1->rnode = $3;
            free_tree($2);
            free_tree($4);
	}
	|  SIZEOF unary_expr 
	{
            $1->hdr.type = TN_EXPR;
            $1->rnode = $2;
	}

alignof_expr:  ALIGNOF LPAREN type_name RPAREN   %prec HYPERUNARY
	{
            $1->hdr.type = TN_EXPR;
            $1->rnode = $3;
            free_tree($2);
            free_tree($4);
	}
	|  ALIGNOF unary_expr 
	{
            $1->hdr.type = TN_EXPR;
            $1->rnode = $2;
	}

unary_minus_expr:  MINUS cast_expr    %prec UNARY
	{
            $1->hdr.type = TN_EXPR;
            $1->rnode = $2;
	}

unary_plus_expr:  PLUS cast_expr      %prec UNARY
	{
            /* Unary plus is an ISO addition (for symmetry) - ignore it */
            $$ = $2;
            free_tree($1);
	}

addr_expr:  B_AND cast_expr           %prec UNARY
	{
            $1->hdr.type = TN_EXPR;
            $1->rnode = $2;
	}

indirection_expr:  STAR cast_expr     %prec UNARY
	{
            $1->hdr.type = TN_DEREF;
            $1->rnode = $2;
	}

preinc_expr:  INCR unary_expr
	{
            $1->hdr.type = TN_EXPR;
            $1->rnode = $2;
	}

predec_expr:  DECR unary_expr
	{
            $1->hdr.type = TN_EXPR;
            $1->rnode = $2;
	}

assign_expr:  cond_expr
	|  unary_expr assign_op assign_expr
	{
            $2->hdr.type = TN_ASSIGN;
            $2->lnode = $1;
            $2->rnode = $3;
            $$ = $2;
	}

opt_const_expr:    /* Nothing */
	{
            $$ = (treenode *) NULL;
	}
	| const_expr
        ;

const_expr: expr
        ;

opt_expr:  /* Nothing */
	{
           $$ = (treenode *) NULL;
	}
	|  expr
        ;

expr:    comma_expr
        ;

comma_expr:  assign_expr
	|  comma_expr COMMA assign_expr    %prec COMMA_OP
	{
           $2->hdr.type = TN_EXPR;
           $2->lnode = $1;
           $2->rnode = $3;
           $$ = $2;
	}

prim_expr:  ident
	{
           $$ = (treenode *) $1;
	}
	|  paren_expr
	|  constant
	{
           $$ = (treenode *) $1;
	}

paren_expr: LPAREN expr RPAREN
	{
           $$ = $2;
           free_tree($1);
           free_tree($3);
	}
	| LPAREN error RPAREN
	{
           $$ = (treenode *) NULL;
           free_tree($1);
           free_tree($3);
	}

postfix_expr: prim_expr
	| subscript_expr
	| comp_select_expr
	| func_call
	| postinc_expr
	| postdec_expr
        ;

subscript_expr: postfix_expr LBRCKT expr RBRCKT
	{
            $2->hdr.type = TN_INDEX;
            $2->lnode = $1;
            $2->rnode = $3;
            $$ = $2;
            free_tree($4);
	}

comp_select_expr: direct_comp_select
	| indirect_comp_select
        ;

postinc_expr: postfix_expr INCR
	{
            $2->hdr.type = TN_EXPR;
            $2->lnode = $1;
            $$ = $2;
	}

postdec_expr: postfix_expr DECR
	{
            $2->hdr.type = TN_EXPR;
            $2->lnode = $1;
            $$ = $2;
	}

opt_expr_list:  /* Nothing */
	{
            $$ = (treenode *) NULL;
	}
	| expr_list
        ;

expr_list:  assign_expr
	|  expr_list COMMA assign_expr    %prec COMMA_SEP
	{
            $2->hdr.type = TN_EXPR_LIST;
            $2->lnode = $1;
            $2->rnode = $3;
            $$ = $2;
	}
	|  LPAREN type_name RPAREN LBRACE initializer_list RBRACE
	{	$$ = (treenode *) 0; }	/* gjh don't choke on structs as parameters */
	|  expr_list COMMA LPAREN type_name RPAREN LBRACE initializer_list RBRACE
	{	$$ = $1; }		/* gjh */


named_label:  IDENT
	{
		$$ = (treenode *) $1;
		if (ParseStack->contxt)
		{	symentry_t *nmtbl, *y;
			nmtbl = mk_label($1->data.sval, $$);

			if (0) printf("named label %s %u\n", $1->data.sval->str, nmtbl);

			y = symtab_insert_at(ParseStack->contxt->labels,
					nmtbl, FUNCTION_SCOPE);
			if (!y)
				yyerr("Duplicate label.");

	/*		$$->syment = y;	*/
		}
	}

case_label:  CASE const_expr
	{
            $1->hdr.type = TN_EXPR;
            $1->rnode = $2;
            $$ = (treenode *) $1;
	}

deflt_label:  DEFLT
        ;

add_op:  PLUS
	|  MINUS
        ;

mult_op:  STAR
	|  DIV
	|  MOD
        ;

equality_op:  COMP_EQ
        ;

relation_op:  COMP_ARITH
        ;

shift_op:  L_SHIFT
	|  R_SHIFT
        ;

declaration: decl_specs opt_init_decl_list SEMICOLON
	{
            leafnode *lm;
            $3->hdr.type = TN_DECL;
            $3->lnode = $1;
            $3->rnode = $2;
            $$ = $3;

            lm = leftmost($$);
            if (lm)
            {
              if (lm->hdr.tok == TYPEDEF)
              {
                /* Decl is a typedef. Scan the subtree for the
                   ident naming the new type.  Don't use rightmost()
                   since it doesn't give the ident for complex
                   types (like arrays). */
                find_typedef_name($$,$$,insert_typedef);
              } else {
                /* Find the identifier for a normal declaration. */
                find_ident_name($$,$$,NULL,insert_decl);
              }
            }
	}
	|  COMMENT
	{
           $$ = (treenode *) $1;
	}

opt_comment:  /* Nothing */
	{
           $$ = (treenode *) NULL;
	}
	|     COMMENT 
	{
           $$ = (treenode *) $1;
	}

opt_decl_specs:   /* Nothing */
	{
           $$ = (treenode *) NULL;
	}
	| decl_specs
        ;

decl_specs:  storage_class opt_decl_specs
	{
            treenode *tmpnode = make_node(TN_TYPE_LIST);
            tmpnode->lnode = $1;
            tmpnode->rnode = $2;
            $$ = tmpnode;
	}
	|  type_spec opt_decl_specs
	{
            treenode *tmpnode = make_node(TN_TYPE_LIST);
            tmpnode->lnode = $1;
            tmpnode->rnode = $2;
            $$ = tmpnode;
	}
	|  type_qual opt_decl_specs
	{
            treenode *tmpnode = make_node(TN_TYPE_LIST);
            tmpnode->lnode = $1;
            tmpnode->rnode = $2;
            $$ = tmpnode;
	}
        ;

comp_decl_specs:  type_spec opt_comp_decl_specs
	{
            treenode *tmpnode = make_node(TN_TYPE_LIST);
            tmpnode->lnode = $1;
            tmpnode->rnode = $2;
            $$ = tmpnode;
	}
	|  type_qual opt_comp_decl_specs
	{
            treenode *tmpnode = make_node(TN_TYPE_LIST);
            tmpnode->lnode = $1;
            tmpnode->rnode = $2;
            $$ = tmpnode;
	}
        ;

opt_comp_decl_specs:   /* Nothing */
	{
           $$ = (treenode *) NULL;
	}
	| comp_decl_specs
        ;

init_decl: declarator
	| declarator EQ initializer
	{
           $2->hdr.type = TN_ASSIGN;
           $2->lnode = $1;
           $2->rnode = $3;
           $$ = $2;
	}

opt_init_decl_list:  /* Nothing */
	{
          $$ = (treenode *) NULL;
	}
	|  init_decl_list
        ;

init_decl_list: init_decl
	| init_decl_list COMMA init_decl        %prec COMMA_OP
	{
            $2->hdr.type = TN_DECLS;
            $2->lnode = $1;
            $2->rnode = $3;
            $$ = $2;
	}

initializer_list:  initializer
	|  initializer_list COMMA initializer    %prec COMMA_OP
	{
            $2->hdr.type = TN_INIT_LIST;
            $2->lnode = $1;
            $2->rnode = $3;
            $$ = $2;
	}

initializer:  assign_expr
	|  LBRACE initializer_list opt_comma RBRACE
	{
            $2->hdr.type = TN_INIT_BLK;
            $$ = $2;
            free_tree($1);
            free_tree($3);
            free_tree($4);
	}
	| LBRCKT assign_expr RBRCKT initializer		/* gjh allow [] field initializers */
	{	$$ = $4;
	}
	| DOT field_ident EQ initializer			/* gjh allow .n field initializers */
	{	$$ = $3
	}

opt_comma:    /* Nothing */
	{
           $$ = (treenode *) NULL;
	}
	|  COMMA    %prec COMMA_SEP
        ;

type_qual_list: type_qual
	| type_qual_list type_qual
	{
            treenode *tmpnode = make_node(TN_TYPE_LIST);
            tmpnode->lnode = $1;
            tmpnode->rnode = $2;
            $$ = tmpnode;
	}
        ;

opt_type_qual_list:    /* Nothing */
	{
            $$ = (treenode *) NULL;
	}
	|   type_qual_list
        ;
        
storage_class: AUTO
	| EXTRN
	| REGISTR
	| STATIC
	| TYPEDEF
        ;

type_spec:  enum_type_spec
	|  struct_type_spec
	|  typedef_name
	|  union_type_spec
	|  VOID
	|  CHAR
	|  SHORT
	|  INT
	|  LONG
	|  FLOAT
	|  DOUBLE
	|  SGNED
	|  UNSGNED
        ;

enum_type_spec:  enum_type_define
	|  enum_type_ref
        ;

struct_type_spec:  struct_type_define
	|  struct_type_ref
        ;

typedef_name:  TYPEDEF_NAME
	{
           $$ = (treenode *) $1;
	}

union_type_spec:  union_type_define
	|  union_type_ref
        ;

opt_tag:  /* Nothing */
	{
           $$ = (treenode *) NULL;
	}
	|  tag
        ;

tag:    IDENT
	{
          $$ = (treenode *) $1;
	}
	| typename_as_ident
        ;

enum_type_define:  ENUM opt_tag LBRACE enum_def_list opt_trailing_comma RBRACE
	{
		$1->hdr.type = TN_OBJ_DEF;
		$1->lnode = $2;
		$1->rnode = $4;
		free_tree($3);
		free_tree($5);
		free_tree($6);

		if (ParseStack->contxt && $2)
		{	leafnode *leaf = (leafnode *) $2;
			symentry_t *nmtbl;

			nmtbl = mk_tag(leaf->data.sval, $$);	/* enum name */

			if (leaf->syment) printf("typename redefined: %s\n", leaf->syment->nme->str);

			leaf->syment = nmtbl;
			if (!symtab_insert(ParseStack->contxt->tags, nmtbl))
				yyerr("Duplicate tag.");
			leaf->syment->nes = ParseStack->contxt->syms->current;
			leaf->syment->decl_level = ParseStack->contxt->syms->clevel;
		}
	}
 
enum_type_ref:  ENUM tag
	{
            $1->hdr.type = TN_OBJ_REF;
            $1->lnode = $2;
	}

enum_def_list:  enum_const_def
	|  enum_def_list COMMA enum_const_def        %prec COMMA_OP
	{
           $2->hdr.type = TN_ENUM_LIST;
           $2->lnode = (treenode *) $1;
           $2->rnode = $3;
           $$ = $2;
	}

enum_const_def:  enum_constant
	|  enum_constant EQ assign_expr 
	{
            $2->hdr.type = TN_ASSIGN;
            $2->lnode = $1;
            $2->rnode = $3;
            $$ = $2;
	}

enum_constant:  IDENT