* src/output.c (output_rule_data): Don't output NULL, it might

[bison.git] / data / bison.hairy

%%{section} %%{output-prefix} %%{output-infix} %%".c"
							  /* -*- C -*- */

/* YYERROR and YYCOST are set by guards. 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.  */
static int yyerror;
static int yycost;

/* 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


/* The state stack. */
static short yyss[YYMAXDEPTH];
/* The semantic value stack.  */
static YYSTYPE yyvs[YYMAXDEPTH];
/* The location stack.  */
static YYLTYPE yyls[YYMAXDEPTH];
/* The rule queue. */
static short yyrq[YYMAXRULES];
/* The lookahead symbol. */
static int yychar;

/* the semantic value of the lookahead symbol.  */
static YYSTYPE yylval;

/* the semantic value for the state at the top of the state stack.  */
static YYSTYPE yytval;

/* the variable used to return semantic values from the action
   routines.  */
static YYSTYPE yyval;

/* location data for the lookahead symbol.  */
static YYLTYPE yylloc;

/* location data for the state at the top of the state stack.  */
static YYLTYPE yytloc;


static int yynunlexed;
static short yyunchar[YYMAXBACKUP];
static YYSTYPE yyunval[YYMAXBACKUP];
static YYLTYPE yyunloc[YYMAXBACKUP];

/* a pointer to the top of the state stack; only set during error
   recovery.  */
static short *yygssp;

/* a pointer to the top of the value stack; only set during error
   recovery.  */
static YYSTYPE *yygvsp;

/* a pointer to the top of the location stack; only set during error
   recovery.  */
static YYLTYPE *yyglsp;


/*--------------------------------------------------------------------.
| 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.                |
`--------------------------------------------------------------------*/

static inline void
yyget (void)
{
  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);
    }
}


static inline void
yyunlex (int chr, YYSTYPE val, YYLTYPE loc)
{
  yyunchar[yynunlexed] = chr;
  yyunval[yynunlexed] = val;
  yyunloc[yynunlexed] = loc;
  yynunlexed++;
}


static inline void
yyrestore (short *first, short *last)
{
  short *ssp;
  short *rp;
  int symbol;
  int state;
  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 (void)
{
  int yystate;
  int yyn;
  short *yyssp;
  short *yyrq0;
  short *yyptr;
  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->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;
}

%%{actions}