ytab.c

这是一个C程序分析工具

				printf(gettext("read %s (%d)\n"), 	\
				yyptok(yychar),				\
				yychar);				\
		} else
#else
# define YYREAD	if (yychar < 0) {					\
			if ((yychar = yylex()) < 0)			\
				yychar = 0;				\
		} else
#endif
#define YYERRCODE	256		/* value of `error' */
#if 0 && defined(__TURBOC__) && __SMALL__
	/* THIS ONLY WORKS ON TURBO C 1.5 !!! */
#define	YYQYYP	*(int *)((int)yyq + ((int)yyq-(int)yyp))
#else
#define	YYQYYP	yyq[yyq-yyp]
#endif

YYSTYPE	yyval;				/* $$ */
YYSTYPE	*yypvt;				/* $n */
YYSTYPE	yylval;				/* yylex() sets this */

int	yychar,				/* current token */
	yyerrflag,			/* error flag */
	yynerrs;			/* error count */

#ifdef YYDEBUG
int yydebug = 0;		/* debug flag & tables */
extern char	*yysvar[], *yystoken[], *yyptok();
extern short	yyrmap[], yysmap[];
extern int	yynstate, yynvar, yyntoken, yynrule;
# define yyassert(condition, msg, arg) \
	if (!(condition)) { printf(gettext("\nyacc bug: ")); printf(msg, arg); YYABORT; }
#else /* !YYDEBUG */
# define yyassert(condition, msg, arg)
#endif

yyparse()
{

	register short		yyi, *yyp;	/* for table lookup */
	register short		*yyps;		/* top of state stack */
	register short		yystate;	/* current state */
	register YYSTYPE	*yypv;		/* top of value stack */
	register short		*yyq;
	register int		yyj;

#ifdef YYSTATIC
	static short	yys[YYSSIZE + 1];
	static YYSTYPE	yyv[YYSSIZE + 1];
#else
#ifdef YYALLOC
	YYSTYPE *yyv;
	short	*yys;
	YYSTYPE save_yylval;
	YYSTYPE save_yyval;
	YYSTYPE *save_yypvt;
	int save_yychar, save_yyerrflag, save_yynerrs;
	int retval;
#if 0	/* defined in <stdlib.h>*/
	extern char	*malloc();
#endif
#else
	short		yys[YYSSIZE + 1];
	static YYSTYPE	yyv[YYSSIZE + 1];	/* historically static */
#endif
#endif

#ifdef YYALLOC
	yys = (short *) malloc((YYSSIZE + 1) * sizeof(short));
	yyv = (YYSTYPE *) malloc((YYSSIZE + 1) * sizeof(YYSTYPE));
	if (yys == (short *)0 || yyv == (YYSTYPE *)0) {
		yyerror("Not enough space for parser stacks");
		return 1;
	}
	save_yylval = yylval;
	save_yyval = yyval;
	save_yypvt = yypvt;
	save_yychar = yychar;
	save_yyerrflag = yyerrflag;
	save_yynerrs = yynerrs;
#endif

	yynerrs = 0;
	yyerrflag = 0;
	yychar = -1;
	yyps = yys;
	yypv = yyv;
	yystate = YYS0;		/* start state */

yyStack:
	yyassert((unsigned)yystate < yynstate, gettext("state %d\n"), yystate);
	if (++yyps > &yys[YYSSIZE]) {
		yyerror("Parser stack overflow");
		YYABORT;
	}
	*yyps = yystate;	/* stack current state */
	*++yypv = yyval;	/* ... and value */

#ifdef YYDEBUG
	if (yydebug)
		printf(gettext("state %d (%d), char %s (%d)\n"),yysmap[yystate],
			yystate, yyptok(yychar), yychar);
#endif

	/*
	 *	Look up next action in action table.
	 */
yyEncore:
#ifdef YYSYNC
	YYREAD;
#endif
	if (yystate >= sizeof yypact/sizeof yypact[0]) 	/* simple state */
		yyi = yystate - YYDELTA;	/* reduce in any case */
	else {
		if(*(yyp = &yyact[yypact[yystate]]) >= 0) {
			/* Look for a shift on yychar */
#ifndef YYSYNC
			YYREAD;
#endif
			yyq = yyp;
			yyi = yychar;
#if 0 && defined(__TURBOC__) && __SMALL__
	/* THIS ONLY WORKS ON TURBO C 1.5 !!! */
			/* yyi is in di, yyp is in si */
		L01:
			asm lodsw	/* ax = *yyp++; */
			asm cmp yyi, ax
			asm jl L01
#else
			while (yyi < *yyp++)
				;
#endif
			if (yyi == yyp[-1]) {
				yystate = ~YYQYYP;
#ifdef YYDEBUG
				if (yydebug)
					printf(gettext("shift %d (%d)\n"),
						yysmap[yystate], yystate);
#endif
				yyval = yylval;		/* stack what yylex() set */
				yychar = -1;		/* clear token */
				if (yyerrflag)
					yyerrflag--;	/* successful shift */
				goto yyStack;
			}
		}

		/*
	 	 *	Fell through - take default action
	 	 */

		if (yystate >= sizeof yydef /sizeof yydef[0])
			goto yyError;
		if ((yyi = yydef[yystate]) < 0)	 { /* default == reduce? */
											/* Search exception table */
			yyassert((unsigned)~yyi < sizeof yyex/sizeof yyex[0],
				gettext("exception %d\n"), yystate);
			yyp = &yyex[~yyi];
#ifndef YYSYNC
			YYREAD;
#endif
			while((yyi = *yyp) >= 0 && yyi != yychar)
				yyp += 2;
			yyi = yyp[1];
			yyassert(yyi >= 0,
				 gettext("Ex table not reduce %d\n"), yyi);
		}
	}

#ifdef YYLR2
yyReduce:	/* reduce yyi */
#endif
	yyassert((unsigned)yyi < yynrule, gettext("reduce %d\n"), yyi);
	yyj = yyrlen[yyi];
#ifdef YYDEBUG
	if (yydebug) printf(gettext("reduce %d (%d), pops %d (%d)\n"), 
		yyrmap[yyi], yyi, yysmap[yyps[-yyj]], yyps[-yyj]);
#endif
	yyps -= yyj;		/* pop stacks */
	yypvt = yypv;		/* save top */
	yypv -= yyj;
	yyval = yypv[1];	/* default action $$ = $1 */
	switch (yyi) {		/* perform semantic action */
		
case YYr1: {	/* tk_lparen :  '(' */
#line 282 "gram.y"
 fire_operator(); 
} break;

case YYr2: {	/* tk_rparen :  ')' */
#line 287 "gram.y"
 fire_operator(); 
} break;

case YYr3: {	/* tk_lsquare_brace :  '[' */
#line 292 "gram.y"
 fire_operator(); 
} break;

case YYr4: {	/* tk_rsquare_brace :  ']' */
#line 297 "gram.y"
 fire_operator(); 
} break;

case YYr5: {	/* tk_dot :  '.' */
#line 302 "gram.y"
 fire_operator(); 
} break;

case YYr6: {	/* tk_ptr_to :  TK_PTR_OP */
#line 307 "gram.y"
 fire_operator(); 
} break;

case YYr7: {	/* tk_inc :  TK_INC_OP */
#line 312 "gram.y"
 fire_operator(); 
} break;

case YYr8: {	/* tk_dec :  TK_DEC_OP */
#line 317 "gram.y"
 fire_operator(); 
} break;

case YYr9: {	/* tk_comma :  ',' */
#line 322 "gram.y"
 fire_operator(); 
} break;

case YYr10: {	/* tk_sizeof :  TK_SIZEOF */
#line 328 "gram.y"
 fire_keyword(); 
} break;

case YYr11: {	/* tk_ampersand :  '&' */
#line 333 "gram.y"
 fire_operator(); 
} break;

case YYr12: {	/* tk_asterisk :  '*' */
#line 338 "gram.y"
 fire_operator(); 
} break;

case YYr13: {	/* tk_plus :  '+' */
#line 343 "gram.y"
 fire_operator(); 
} break;

case YYr14: {	/* tk_minus :  '-' */
#line 348 "gram.y"
 fire_operator(); 
} break;

case YYr15: {	/* tk_tilde :  '~' */
#line 353 "gram.y"
 fire_operator(); 
} break;

case YYr16: {	/* tk_exclamation :  '!' */
#line 358 "gram.y"
 fire_operator(); 
} break;

case YYr17: {	/* tk_slash :  '/' */
#line 363 "gram.y"
 fire_operator(); 
} break;

case YYr18: {	/* tk_percent :  '%' */
#line 368 "gram.y"
 fire_operator(); 
} break;

case YYr19: {	/* tk_left :  TK_LEFT_OP */
#line 373 "gram.y"
 fire_operator(); 
} break;

case YYr20: {	/* tk_right :  TK_RIGHT_OP */
#line 378 "gram.y"
 fire_operator(); 
} break;

case YYr21: {	/* tk_lt :  '<' */
#line 383 "gram.y"
 fire_operator(); 
} break;

case YYr22: {	/* tk_gt :  '>' */
#line 388 "gram.y"
 fire_operator(); 
} break;

case YYr23: {	/* tk_le :  TK_LE_OP */
#line 393 "gram.y"
 fire_operator(); 
} break;

case YYr24: {	/* tk_ge :  TK_GE_OP */
#line 398 "gram.y"
 fire_operator(); 
} break;

case YYr25: {	/* tk_eq :  TK_EQ_OP */
#line 403 "gram.y"
 fire_operator(); 
} break;

case YYr26: {	/* tk_ne :  TK_NE_OP */
#line 408 "gram.y"
 fire_operator(); 
} break;

case YYr27: {	/* tk_circumflex :  '^' */
#line 413 "gram.y"
 fire_operator(); 
} break;

case YYr28: {	/* tk_bar :  '|' */
#line 418 "gram.y"
 fire_operator(); 
} break;

case YYr29: {	/* tk_land :  TK_AND_OP */
#line 423 "gram.y"
 fire_operator(); 
} break;

case YYr30: {	/* tk_lor :  TK_OR_OP */
#line 428 "gram.y"
 fire_operator(); 
} break;

case YYr31: {	/* tk_question :  '?' */
#line 433 "gram.y"
 fire_operator(); 
} break;

case YYr32: {	/* tk_colon :  ':' */
#line 438 "gram.y"
 fire_operator(); 
} break;

case YYr33: {	/* tk_assign :  '=' */
#line 443 "gram.y"
 fire_operator(); 
} break;

case YYr34: {	/* tk_mul_assign :  TK_MUL_ASSIGN */
#line 448 "gram.y"
 fire_operator(); 
} break;

case YYr35: {	/* tk_div_assign :  TK_DIV_ASSIGN */
#line 453 "gram.y"
 fire_operator(); 
} break;

case YYr36: {	/* tk_mod_assign :  TK_MOD_ASSIGN */
#line 458 "gram.y"
 fire_operator(); 
} break;

case YYr37: {	/* tk_add_assign :  TK_ADD_ASSIGN */
#line 463 "gram.y"
 fire_operator(); 
} break;

case YYr38: {	/* tk_sub_assign :  TK_SUB_ASSIGN */
#line 468 "gram.y"
 fire_operator(); 
} break;

case YYr39: {	/* tk_left_assign :  TK_LEFT_ASSIGN */
#line 473 "gram.y"
 fire_operator(); 
} break;

case YYr40: {	/* tk_right_assign :  TK_RIGHT_ASSIGN */
#line 478 "gram.y"
 fire_operator(); 
} break;

case YYr41: {	/* tk_and_assign :  TK_AND_ASSIGN */
#line 483 "gram.y"
 fire_operator(); 
} break;

case YYr42: {	/* tk_xor_assign :  TK_XOR_ASSIGN */
#line 488 "gram.y"
 fire_operator(); 
} break;

case YYr43: {	/* tk_or_assign :  TK_OR_ASSIGN */
#line 493 "gram.y"
 fire_operator(); 
} break;

case YYr44: {	/* tk_semicolon :  ';' */
#line 498 "gram.y"
 fire_operator(); 
} break;

case YYr45: {	/* tk_typedef :  TK_TYPEDEF */
#line 503 "gram.y"
 fire_keyword(); 
} break;

case YYr46: {	/* tk_extern :  TK_EXTERN */
#line 508 "gram.y"
 fire_keyword(); 
} break;

case YYr47: {	/* tk_static :  TK_STATIC */
#line 513 "gram.y"
 fire_keyword(); 
} break;

case YYr48: {	/* tk_auto :  TK_AUTO */
#line 518 "gram.y"
 fire_keyword(); 
} break;

case YYr49: {	/* tk_register :  TK_REGISTER */
#line 523 "gram.y"
 fire_keyword(); 
} break;

case YYr50: {	/* tk_char :  TK_CHAR */
#line 528 "gram.y"
 fire_keyword(); 
} break;

case YYr51: {	/* tk_short :  TK_SHORT */
#line 533 "gram.y"
 fire_keyword(); 
} break;

case YYr52: {	/* tk_int :  TK_INT */
#line 538 "gram.y"
 fire_