path: root/contrib/bison/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;
}

$