gram_old.y

C程序漏洞检查

	{
		$$ = (treenode *) $1;
		if (ParseStack->contxt)
		{	symentry_t *nmtbl = mk_enum_const($1->data.sval, $$);

			add_constant(nmtbl->nme->str);  /* gjh */

			if (!symtab_insert(ParseStack->contxt->syms, nmtbl))
				yyerr("Duplicate enumeration constant.");
		}
	}

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

struct_type_define: STRUCT opt_tag LBRACE
	{
            enter_scope(ParseStack->contxt);
	}
		field_list RBRACE
	{
		$1->hdr.type = TN_OBJ_DEF;
		$1->lnode = $2;
		$1->rnode = $5;
		free_tree($3);
		free_tree($6);
		if (ParseStack->contxt && $2)
		{	leafnode *leaf = (leafnode *) $2;
			symentry_t *nmtbl;

			nmtbl = mk_tag(leaf->data.sval, $$);
			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;
		}
    
		find_components($5,$1,$1,insert_component);
		name_scope(ParseStack->contxt,
			$2?((leafnode *) $2)->data.sval->str:"-UnNamed-", TN_OBJ_DEF);
		exit_scope(ParseStack->contxt);
	}

struct_type_ref:  STRUCT tag
	{
            $1->hdr.type = TN_OBJ_REF;
            $1->lnode = $2;
	}

union_type_define: UNION opt_tag LBRACE
	{
            enter_scope(ParseStack->contxt);
	}
		field_list RBRACE
	{
            $1->hdr.type = TN_OBJ_DEF;
            $1->lnode = $2;
            $1->rnode = $5;
            free_tree($3);
            free_tree($6);
            if (ParseStack->contxt && $2)
            {	leafnode *leaf = (leafnode *) $2;
		symentry_t *nmtbl;

		nmtbl = mk_tag(leaf->data.sval, $$);
		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;
            }

            find_components($5,$1,$1,insert_component);
		if ($2)
		{
		name_scope(ParseStack->contxt,
			((leafnode *) $2)->data.sval->str,
			TN_OBJ_DEF);
		}
            exit_scope(ParseStack->contxt);
	}

union_type_ref:  UNION tag
	{
            $1->hdr.type = TN_OBJ_REF;
            $1->lnode = $2;
	}

field_list:  comp_decl
	|  field_list comp_decl
	{
           treenode *tmpnode = make_node(TN_FIELD_LIST);
           tmpnode->lnode = $1;
           tmpnode->rnode = $2;
           $$ = tmpnode;
	}

comp_decl:  comp_decl_specs comp_decl_list SEMICOLON
	{
          $3->hdr.type = TN_COMP_DECL;
          $3->lnode = $1;
          $3->rnode = $2;
          $$ = $3;
	}

comp_decl_list:  comp_declarator
	|  comp_decl_list COMMA comp_declarator     %prec COMMA_OP
	{
            $2->hdr.type = TN_DECLS;
            $2->lnode = $1;
            $2->rnode = $3;
            $$ = $2;
	}
	| SEMICOLON	/* gjh - condone unnamed sub-structs */
	{	extern FILE *yyin;
		ungetc(';', yyin);
		$$ = (treenode *) 0;
	}

comp_declarator:  simple_comp
	|  bit_field
        ;


simple_comp:  declarator
        ;

bit_field:  opt_declarator COLON width
	{
            $2->hdr.type = TN_BIT_FIELD;
            $2->lnode = $1;
            $2->rnode = $3;
            $$ = $2;
	}
        ;

width:  assign_expr
        ;

type_qual: CONST
	| VOLATILE
        ;

type_name:  decl_specs
	{
            treenode *tmpnode = make_node(TN_TYPE_NME);
            tmpnode->lnode = $1;
            $$ = tmpnode;
	}
	| decl_specs abs_decl
	{
            treenode *tmpnode = make_node(TN_TYPE_NME);
            tmpnode->lnode = $1;
            tmpnode->rnode = $2;
            $$ = tmpnode;
	}

opt_declarator:  /* Nothing */
	{
           $$ = (treenode *) NULL;
	}
	|  declarator
        ;

declarator: pointer direct_declarator
	{
            treenode *tmpnode = make_node(TN_DECL);
            tmpnode->lnode = $1;
            tmpnode->rnode = $2;
            $$ = tmpnode;
	}
	| direct_declarator
        ;

direct_declarator:  field_ident
	{	/* gjh: was simple_decl - should be field_ident
		 * to allow typedef'ed names as identifiers
		 * but this introduces 5 shift reduce and 23 reduce/reduce conflicts
		 */
		$$ = $1;
	}
	|  LPAREN declarator RPAREN
	{
            $$ = $2;
            free_tree($1);
            free_tree($3);
	}
	|  array_decl
	|  direct_declarator LPAREN param_type_list RPAREN
	{
            $2->hdr.type = TN_FUNC_DECL;
            $2->lnode = $1;
            $2->rnode = $3;
            $$ = $2;
            free_tree($4);
	}
	|  direct_declarator LPAREN ident_list RPAREN
	{
            $2->hdr.type = TN_FUNC_DECL;
            $2->lnode = $1;
            $2->rnode = $3;
            $$ = $2;
            free_tree($4);
	}
	|  direct_declarator LPAREN RPAREN
	{
            $2->hdr.type = TN_FUNC_DECL;
            $2->lnode = $1;
            $$ = $2;
            free_tree($3);
	}
        ;

simple_decl:  IDENT 
	{
	/* NYI - Need error check code here
           leafnode *ln = $1;
           fprintf(stdout,"Value: %s\n", nmestr(ln->data.sval));
	*/
	}

pointer_start:  STAR opt_type_qual_list
	{
            $1->hdr.type = TN_PNTR;
            $1->lnode = $2;
            $1->rnode = NULL;
	}

pointer:  pointer_start
	|  pointer_start pointer
	{
            $1->hdr.type = TN_PNTR;
            $1->rnode = $2;
	}

opt_param_type_list:  /* Nothing */
	{
           $$ = (treenode *) NULL;
	}
	|  param_type_list
        ;

param_type_list: param_list
	| param_list COMMA ELLIPSIS        %prec COMMA_OP
	{
            $2->hdr.type = TN_PARAM_LIST;
            $2->lnode = $1;
            $2->rnode = $3;
            $$ = $2;
	}

param_list: param_decl
	| param_list COMMA param_decl        %prec COMMA_OP
	{
            $2->hdr.type = TN_PARAM_LIST;
            $2->lnode = $1;
            $2->rnode = $3;
            $$ = $2;
	}

param_decl: decl_specs declarator
	{
            treenode *tmpnode = make_node(TN_DECL);
            tmpnode->lnode = $1;
            tmpnode->rnode = $2;
            $$ = tmpnode;
	}
	| decl_specs abs_decl
	{
            treenode *tmpnode = make_node(TN_DECL);
            tmpnode->lnode = $1;
            tmpnode->rnode = $2;
            $$ = tmpnode;
	}
	| decl_specs
	{
            treenode *tmpnode = make_node(TN_DECL);
            tmpnode->lnode = $1;
            $$ = tmpnode;
	}

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

ident: IDENT
        ;

field_ident: simple_decl
	| typename_as_ident
        ;

typename_as_ident: typedef_name
	{
            /* Convert a TYPEDEF_NAME back into a normal IDENT */
            $1->hdr.type = TN_IDENT;
            $1->hdr.tok  = IDENT;
            $$ = (treenode *) $1;
	}
        ;

abs_decl:  pointer
	|  direct_abs_decl
	{
            treenode *tmpnode = make_node(TN_DECL);
            tmpnode->rnode = $1;
            $$ = tmpnode;
	}
	|  pointer direct_abs_decl
	{
            treenode *tmpnode = make_node(TN_DECL);
            tmpnode->lnode = $1;
            tmpnode->rnode = $2;
            $$ = tmpnode;
	}

direct_abs_decl:  LPAREN abs_decl RPAREN
	{
            $$ = $2;
            free_tree($1);
            free_tree($3);
	}
	|  LBRCKT opt_const_expr RBRCKT
	{
            $1->hdr.type = TN_ARRAY_DECL;
            $1->rnode = $2;
            free_tree($3);
	}
	|  direct_abs_decl LBRCKT opt_const_expr RBRCKT
	{
            $2->hdr.type = TN_ARRAY_DECL;
            $2->lnode = $1;
            $2->rnode = $3;
            $$ = $2;
            free_tree($4);
	}
	|  LPAREN opt_param_type_list RPAREN
	{
            $1->hdr.type = TN_FUNC_DECL;
            $2->rnode = $2;
            free_tree($3);
	}
	|  direct_abs_decl LPAREN opt_param_type_list RPAREN
	{
            $2->hdr.type = TN_FUNC_DECL;
            $2->lnode = $1;
            $2->rnode = $3;
            $$ = $2;
            free_tree($4);
	}

array_decl: direct_declarator LBRCKT opt_const_expr RBRCKT
	{
            $2->hdr.type = TN_ARRAY_DECL;
            $2->lnode = $1;
            $2->rnode = $3;
            $$ = $2;
            free_tree($4);
	}

direct_comp_select: postfix_expr DOT
	{   /* gjh */ structfieldflag = 1;
	}
	field_ident
	{   /* gjh */ structfieldflag = 0;
	
            $2->hdr.type = TN_SELECT;
            $2->lnode = $1;
            $2->rnode = (treenode *) $4;
            $$ = $2;
	}

indirect_comp_select: postfix_expr ARROW
	{   /* gjh */ structfieldflag = 1;
	}
	field_ident
	{   /* gjh */ structfieldflag = 0;
	
            $2->hdr.type = TN_SELECT;
            $2->lnode = $1;
            $2->rnode = (treenode *) $4;
            $$ = $2;
	}

func_call: postfix_expr LPAREN opt_expr_list RPAREN
	{
            $2->hdr.type = TN_FUNC_CALL;
            $2->lnode = $1;
            $2->rnode = $3;
            $$ = $2;
            free_tree($4);
	}

assign_op:  EQ
	|  ASSIGN
        ;

strings:  STRING
	| strings STRING	/* should concatenate the strings */
	;

constant:   INUM
	| RNUM
	| CHAR_CONST
	| strings		/* was STRING, changed gjh 11/11/01 */
        ;

%%

static void
insert_decl(leafnode *leaf, treenode *def, treenode *container)
{
	if (leaf
	&& (leaf->hdr.tok == IDENT)
	&&  ParseStack->contxt)
	{	symentry_t *nmtbl = mk_vardecl(leaf->data.sval, def);
#define ILYA
#ifdef ILYA
		leafnode *lm = leftmost(def);
		if (lm
		&& (lm->hdr.tok != STATIC)
		&& ParseStack->contxt->syms->clevel == FILE_SCOPE)
		{	leaf->syment = symtab_insert_at(ParseStack->contxt->syms, nmtbl, EXTERN_SCOPE);
			if (Verbose&2)
			printf("%s: line %d lifting %s to extern scope\n",
				progname, leaf->hdr.line,
				nmestr(leaf->data.sval));
		} else
#endif	  
		leaf->syment = symtab_insert(ParseStack->contxt->syms, nmtbl);

		if (0) fprintf(stdout, "\tinsert_decl: %s -- %d -- line %d\n",
			nmestr(leaf->data.sval),
			ParseStack->contxt->syms->clevel,
			leaf->hdr.line);
		leaf->syment->nes = ParseStack->contxt->syms->current;
		leaf->syment->decl_level = ParseStack->contxt->syms->clevel;
		if (0)
		{	extern char *x_stmnt(treenode *);
			printf("insert decl for %s - nes=%u, owner=%s - <%s>\n",
			nmestr(leaf->data.sval),
			leaf->syment->nes,
			leaf->syment->nes && leaf->syment->nes->owner ? leaf->syment->nes->owner : "no owner",
			x_stmnt(leaf->syment->node));
	}	}
}

static void
insert_typedef(leafnode *leaf, treenode *def, treenode *container)
{
	if (leaf && (leaf->hdr.tok == IDENT))
	{	if (ParseStack->contxt)
		{	symentry_t *entry = mk_typedef(leaf->data.sval, def); 
			leaf->syment = symtab_insert(ParseStack->contxt->syms, entry);
			leaf->syment->nes = ParseStack->contxt->syms->current;
			leaf->syment->decl_level = ParseStack->contxt->syms->clevel;
		if (0)
			fprintf(stderr, "%s:%d, Insert Typedef: %s\n",
			leaf->hdr.fnm, leaf->hdr.line, entry->nme->str);
		}
	}
	else if (leaf) printf("uno: %s:%d: cannot happen, insert_typedef for %s - %s\n",	/* gjh */
	leaf->hdr.fnm, leaf->hdr.line, name_of_node(leaf->hdr.type), toksym(leaf->hdr.tok,1));
}

static void
insert_component(leafnode *leaf, treenode *def, treenode *container)
{
	if (leaf && (leaf->hdr.tok == IDENT))
	if (ParseStack->contxt)
	{	symentry_t *entry = mk_component(leaf->data.sval, def, container);
		leaf->syment = symtab_insert(ParseStack->contxt->syms, entry);
		leaf->syment->nes = ParseStack->contxt->syms->current;
		leaf->syment->decl_level = ParseStack->contxt->syms->clevel;
	}
}

static void
add_params_to_symtab(treenode *funcdecl)
{
	/* Parameters are defined at prototype/function scope */
	enter_scope(ParseStack->contxt);
#ifdef ILYA
	while (funcdecl->hdr.type == TN_DECL)
		funcdecl = funcdecl->rnode;	/* e.g., fct returns ptr */

	if (funcdecl->hdr.type != TN_FUNC_DECL)
	{	if (debug)
		printf("%s: line %d, unexpected, funcdecl = %s (%s)\n",
			progname, funcdecl->hdr.line,
			name_of_node(funcdecl->hdr.type),
			((leafnode *)funcdecl)->data.sval->str);
		return;
	}
#endif
	find_params(funcdecl, insert_decl);
}

int
current_linenumber(void)
{
	if (Parse_TOS)
		return Parse_TOS->yylineno;
	return 0;
}

char *
current_filename(void)
{	static char *CurFile = (char *) 0;

	if (Parse_TOS
	&& (!CurFile
	||  strcmp(CurFile, Parse_TOS->filename) != 0))
	{	CurFile = (char *) emalloc(strlen(Parse_TOS->filename)+1);
		strcpy(CurFile, Parse_TOS->filename);
	}
	return CurFile;
}

leafnode *
mk_ident(void)	/* lts.c */
{	static int Lnr = 1;
	char Lnm[16];
	leafnode *ln;

	sprintf(Lnm, "_L_%3d", Lnr++);
	ln = (leafnode *) emalloc(sizeof(leafnode));
	ln->hdr.which = LEAF_T;
	ln->hdr.type = TN_IDENT;
	ln->hdr.tok = IDENT;
	ln->data.sval = nmelook(Lnm,0);
	ln->syment = symtab_lookup(ParseStack->contxt->labels, ln->data.sval);

	return ln;
}

leafnode *
mk_bool(char *s)	/* "true" or "false" as identifiers - lts.c */
{	leafnode *ln;

	ln = (leafnode *) emalloc(sizeof(leafnode));
	ln->hdr.which = LEAF_T;
	ln->hdr.type = TN_IDENT;
	ln->hdr.tok = IDENT;
	ln->data.sval = nmelook(s,0);
	ln->syment = symtab_lookup(ParseStack->contxt->labels, ln->data.sval);

	return ln;
}

treenode *
mk_int(int d)	/* lts.c */
{	leafnode *ln;

	ln = (leafnode *) emalloc(sizeof(leafnode));
	ln->hdr.which = LEAF_T;
	ln->hdr.type = TN_INT;
	ln->hdr.tok = INUM;
	ln->data.ival = d;

	return (treenode *) ln;
}

treenode *
mk_deflt(void)
{	leafnode *ln;

	ln = (leafnode *) emalloc(sizeof(leafnode));
	ln->hdr.which = LEAF_T;
	ln->hdr.type = TN_LABEL;
	ln->hdr.tok = DEFLT;

	return (treenode *) ln;
}