www.pudn.com > bison.zip > bison.hairy

 
extern int timeclock; 
 
 
int yyerror;		/*  Yyerror and yycost are set by guards.	*/ 
int yycost;		/*  If yyerror is set to a nonzero value by a	*/ 
			/*  guard, the reduction with which the guard	*/ 
			/*  is associated is not performed, and the	*/ 
			/*  error recovery mechanism is invoked.	*/ 
			/*  Yycost indicates the cost of performing	*/ 
			/*  the reduction given the attributes of the	*/ 
			/*  symbols.					*/ 
 
 
/*  YYMAXDEPTH indicates the size of the parser's state and value	*/ 
/*  stacks.								*/ 
 
#ifndef	YYMAXDEPTH 
#define	YYMAXDEPTH	500 
#endif 
 
/*  YYMAXRULES must be at least as large as the number of rules that	*/ 
/*  could be placed in the rule queue.  That number could be determined	*/ 
/*  from the grammar and the size of the stack, but, as yet, it is not.	*/ 
 
#ifndef	YYMAXRULES 
#define	YYMAXRULES	100 
#endif 
 
#ifndef	YYMAXBACKUP 
#define YYMAXBACKUP	100 
#endif 
 
 
short	yyss[YYMAXDEPTH];	/*  the state stack			*/ 
YYSTYPE	yyvs[YYMAXDEPTH];	/*  the semantic value stack		*/ 
YYLTYPE yyls[YYMAXDEPTH];	/*  the location stack			*/ 
short	yyrq[YYMAXRULES];	/*  the rule queue			*/ 
int	yychar;			/*  the lookahead symbol		*/ 
 
YYSTYPE	yylval;			/*  the semantic value of the		*/ 
				/*  lookahead symbol			*/ 
 
YYSTYPE yytval;			/*  the semantic value for the state	*/ 
				/*  at the top of the state stack.	*/ 
 
YYSTYPE yyval;			/*  the variable used to return		*/ 
				/*  semantic values from the action	*/ 
				/*  routines				*/ 
 
YYLTYPE yylloc;		/*  location data for the lookahead	*/ 
				/*  symbol				*/ 
 
YYLTYPE yytloc;		/*  location data for the state at the	*/ 
				/*  top of the state stack		*/ 
 
 
int	yynunlexed; 
short	yyunchar[YYMAXBACKUP]; 
YYSTYPE	yyunval[YYMAXBACKUP]; 
YYLTYPE yyunloc[YYMAXBACKUP]; 
 
short *yygssp;			/*  a pointer to the top of the state	*/ 
				/*  stack; only set during error	*/ 
				/*  recovery.				*/ 
 
YYSTYPE *yygvsp;		/*  a pointer to the top of the value	*/ 
				/*  stack; only set during error	*/ 
				/*  recovery.				*/ 
 
YYLTYPE *yyglsp;		/*  a pointer to the top of the		*/ 
				/*  location stack; only set during	*/ 
				/*  error recovery.			*/ 
 
 
/*  Yyget is an interface between the parser and the lexical analyzer.	*/ 
/*  It is costly to provide such an interface, but it avoids requiring	*/ 
/*  the lexical analyzer to be able to back up the scan.		*/ 
 
yyget() 
{ 
  if (yynunlexed > 0) 
    { 
      yynunlexed--; 
      yychar = yyunchar[yynunlexed]; 
      yylval = yyunval[yynunlexed]; 
      yylloc = yyunloc[yynunlexed]; 
    } 
  else if (yychar <= 0) 
    yychar = 0; 
  else 
    { 
      yychar = yylex(); 
      if (yychar < 0) 
	yychar = 0; 
      else yychar = YYTRANSLATE(yychar); 
    } 
} 
 
 
 
yyunlex(chr, val, loc) 
int chr; 
YYSTYPE val; 
YYLTYPE loc; 
{ 
  yyunchar[yynunlexed] = chr; 
  yyunval[yynunlexed] = val; 
  yyunloc[yynunlexed] = loc; 
  yynunlexed++; 
} 
 
 
 
yyrestore(first, last) 
register short *first; 
register short *last; 
{ 
  register short *ssp; 
  register short *rp; 
  register int symbol; 
  register int state; 
  register int tvalsaved; 
 
  ssp = yygssp; 
  yyunlex(yychar, yylval, yylloc); 
 
  tvalsaved = 0; 
  while (first != last) 
    { 
      symbol = yystos[*ssp]; 
      if (symbol < YYNTBASE) 
	{ 
	  yyunlex(symbol, yytval, yytloc); 
	  tvalsaved = 1; 
	  ssp--; 
	} 
 
      ssp--; 
 
      if (first == yyrq) 
	first = yyrq + YYMAXRULES; 
 
      first--; 
 
      for (rp = yyrhs + yyprhs[*first]; symbol = *rp; rp++) 
	{ 
	  if (symbol < YYNTBASE) 
	    state = yytable[yypact[*ssp] + symbol]; 
	  else 
	    { 
	      state = yypgoto[symbol - YYNTBASE] + *ssp; 
 
	      if (state >= 0 && state <= YYLAST && yycheck[state] == *ssp) 
		state = yytable[state]; 
	      else 
		state = yydefgoto[symbol - YYNTBASE]; 
	    } 
 
	  *++ssp = state; 
	} 
    } 
 
  if ( ! tvalsaved && ssp > yyss) 
    { 
      yyunlex(yystos[*ssp], yytval, yytloc); 
      ssp--; 
    } 
 
  yygssp = ssp; 
} 
 
 
 
int 
yyparse() 
{ 
  register int yystate; 
  register int yyn; 
  register short *yyssp; 
  register short *yyrq0; 
  register short *yyptr; 
  register YYSTYPE *yyvsp; 
 
  int yylen; 
  YYLTYPE *yylsp; 
  short *yyrq1; 
  short *yyrq2; 
 
  yystate = 0; 
  yyssp = yyss - 1; 
  yyvsp = yyvs - 1; 
  yylsp = yyls - 1; 
  yyrq0 = yyrq; 
  yyrq1 = yyrq0; 
  yyrq2 = yyrq0; 
 
  yychar = yylex(); 
  if (yychar < 0) 
    yychar = 0; 
  else yychar = YYTRANSLATE(yychar); 
 
yynewstate: 
 
  if (yyssp >= yyss + YYMAXDEPTH - 1) 
    { 
      yyabort("Parser Stack Overflow"); 
      YYABORT; 
    } 
 
  *++yyssp = yystate; 
 
yyresume: 
 
  yyn = yypact[yystate]; 
  if (yyn == YYFLAG) 
    goto yydefault; 
 
  yyn += yychar; 
  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar) 
    goto yydefault; 
 
  yyn = yytable[yyn]; 
  if (yyn < 0) 
    { 
      yyn = -yyn; 
      goto yyreduce; 
    } 
  else if (yyn == 0) 
    goto yyerrlab; 
 
  yystate = yyn; 
 
  yyptr = yyrq2; 
  while (yyptr != yyrq1) 
    { 
      yyn = *yyptr++; 
      yylen = yyr2[yyn]; 
      yyvsp -= yylen; 
      yylsp -= yylen; 
 
      yyguard(yyn, yyvsp, yylsp); 
      if (yyerror) 
	goto yysemerr; 
 
      yyaction(yyn, yyvsp, yylsp); 
      *++yyvsp = yyval; 
 
      yylsp++; 
      if (yylen == 0) 
	{ 
	  yylsp->timestamp = timeclock; 
	  yylsp->first_line = yytloc.first_line; 
	  yylsp->first_column = yytloc.first_column; 
	  yylsp->last_line = (yylsp-1)->last_line; 
	  yylsp->last_column = (yylsp-1)->last_column; 
	  yylsp->text = 0; 
	} 
      else 
	{ 
	  yylsp->last_line = (yylsp+yylen-1)->last_line; 
	  yylsp->last_column = (yylsp+yylen-1)->last_column; 
	} 
	   
      if (yyptr == yyrq + YYMAXRULES) 
        yyptr = yyrq; 
    } 
 
  if (yystate == YYFINAL) 
    YYACCEPT; 
 
  yyrq2 = yyptr; 
  yyrq1 = yyrq0; 
 
  *++yyvsp = yytval; 
  *++yylsp = yytloc; 
  yytval = yylval; 
  yytloc = yylloc; 
  yyget(); 
 
  goto yynewstate; 
 
yydefault: 
 
  yyn = yydefact[yystate]; 
  if (yyn == 0) 
    goto yyerrlab; 
 
yyreduce: 
 
  *yyrq0++ = yyn; 
 
  if (yyrq0 == yyrq + YYMAXRULES) 
    yyrq0 = yyrq; 
 
  if (yyrq0 == yyrq2) 
    { 
      yyabort("Parser Rule Queue Overflow"); 
      YYABORT; 
    } 
 
  yyssp -= yyr2[yyn]; 
  yyn = yyr1[yyn]; 
 
  yystate = yypgoto[yyn - YYNTBASE] + *yyssp; 
  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) 
    yystate = yytable[yystate]; 
  else 
    yystate = yydefgoto[yyn - YYNTBASE]; 
 
  goto yynewstate; 
 
yysemerr: 
  *--yyptr = yyn; 
  yyrq2 = yyptr; 
  yyvsp += yyr2[yyn]; 
 
yyerrlab: 
 
  yygssp = yyssp; 
  yygvsp = yyvsp; 
  yyglsp = yylsp; 
  yyrestore(yyrq0, yyrq2); 
  yyrecover(); 
  yystate = *yygssp; 
  yyssp = yygssp; 
  yyvsp = yygvsp; 
  yyrq0 = yyrq; 
  yyrq1 = yyrq0; 
  yyrq2 = yyrq0; 
  goto yyresume; 
} 
 
$