一个加法编译器(bison.simple)

/* -*-C-*- Note some compilers choke on comments on `#line' lines. */

#line 3 "bison.simple"

/* Skeleton output parser for bison,

This program is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 2, or (at your option)

any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software

Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */

/* As a special exception, when this file is copied by Bison into a

Bison output file, you may use that output file without restriction.

This special exception was added by the Free Software Foundation

in version 1.24 of Bison. */

#ifndef alloca

#ifdef __GNUC__

#define alloca __builtin_alloca

#else /* not GNU C. */

#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)

#include <alloca.h>

#else /* not sparc */

#if defined (MSDOS) && !defined (__TURBOC__)

#include <malloc.h>

#else /* not MSDOS, or __TURBOC__ */

#if defined(_AIX)

#include <malloc.h>

#pragma alloca

#else /* not MSDOS, __TURBOC__, or _AIX */

#ifdef __hpux

#ifdef __cplusplus

extern "C" {

void *alloca (unsigned int);

};

#else /* not __cplusplus */

void *alloca ();

#endif /* not __cplusplus */

#endif /* __hpux */

#endif /* not _AIX */

#endif /* not MSDOS, or __TURBOC__ */

#endif /* not sparc. */

#endif /* not GNU C. */

#endif /* alloca not defined. */

/* This is the parser code that is written into each bison parser

when the %semantic_parser declaration is not specified in the grammar.

It was written by Richard Stallman by simplifying the hairy parser

used when %semantic_parser is specified. */

/* Note: there must be only one dollar sign in this file.

It is replaced by the list of actions, each action

as one case of the switch. */

#define yyerrok (yyerrstatus = 0)

#define yyclearin (yychar = YYEMPTY)

#define YYEMPTY -2

#define YYEOF 0

#define YYACCEPT return(0)

#define YYABORT return(1)

#define YYERROR goto yyerrlab1

/* Like YYERROR except do call yyerror.

This remains here temporarily to ease the

transition to the new meaning of YYERROR, for GCC.

Once GCC version 2 has supplanted version 1, this can go. */

#define YYFAIL goto yyerrlab

#define YYRECOVERING() (!!yyerrstatus)

#define YYBACKUP(token, value) do if (yychar == YYEMPTY && yylen == 1) { yychar = (token), yylval = (value); yychar1 = YYTRANSLATE (yychar); YYPOPSTACK; goto yybackup; } else { yyerror ("syntax error: cannot back up"); YYERROR; } while (0)

#define YYTERROR 1

#define YYERRCODE 256

#ifndef YYPURE

#define YYLEX yylex()

#endif

#ifdef YYPURE

#ifdef YYLSP_NEEDED

#ifdef YYLEX_PARAM

#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)

#else

#define YYLEX yylex(&yylval, &yylloc)

#endif

#else /* not YYLSP_NEEDED */

#ifdef YYLEX_PARAM

#define YYLEX yylex(&yylval, YYLEX_PARAM)

#else

#define YYLEX yylex(&yylval)

#endif

#endif /* not YYLSP_NEEDED */

#endif

/* If nonreentrant, generate the variables here */

#ifndef YYPURE

int yychar; /* the lookahead symbol */

YYSTYPE yylval; /* the semantic value of the */

/* lookahead symbol */

#ifdef YYLSP_NEEDED

YYLTYPE yylloc; /* location data for the lookahead */

/* symbol */

#endif

int yynerrs; /* number of parse errors so far */

#endif /* not YYPURE */

#if YYDEBUG != 0

int yydebug; /* nonzero means print parse trace */

/* Since this is uninitialized, it does not stop multiple parsers

from coexisting. */

#endif

/* YYINITDEPTH indicates the initial size of the parser's stacks */

#ifndef YYINITDEPTH

#define YYINITDEPTH 200

#endif

/* YYMAXDEPTH is the maximum size the stacks can grow to

(effective only if the built-in stack extension method is used). */

#if YYMAXDEPTH == 0

#undef YYMAXDEPTH

#endif

#ifndef YYMAXDEPTH

#define YYMAXDEPTH 10000

#endif

/* Prevent warning if -Wstrict-prototypes. */

#ifdef __GNUC__

int yyparse (void);

#endif

#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */

#define __yy_memcpy(FROM,TO,COUNT) __builtin_memcpy(TO,FROM,COUNT)

#else /* not GNU C or C++ */

#ifndef __cplusplus

/* This is the most reliable way to avoid incompatibilities

in available built-in functions on various systems. */

static void

__yy_memcpy (from, to, count)

char *from;

char *to;

int count;

{

while (i-- > 0)

*t++ = *f++;

}

#else /* __cplusplus */

/* This is the most reliable way to avoid incompatibilities

in available built-in functions on various systems. */

static void

__yy_memcpy (char *from, char *to, int count)

{

while (i-- > 0)

*t++ = *f++;

}

#endif

#line 192 "bison.simple"

/* The user can define YYPARSE_PARAM as the name of an argument to be passed

into yyparse. The argument should have type void *.

It should actually point to an object.

Grammar actions can access the variable by casting it

to the proper pointer type. */

#ifdef YYPARSE_PARAM

#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;

#else

#define YYPARSE_PARAM

#define YYPARSE_PARAM_DECL

#endif

int

yyparse(YYPARSE_PARAM)

YYPARSE_PARAM_DECL

{

int yyerrstatus; /* number of tokens to shift before error messages enabled */

int yychar1 = 0; /* lookahead token as an internal (translated) token number */

short yyssa[YYINITDEPTH]; /* the state stack */

YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */

short *yyss = yyssa; /* refer to the stacks thru separate pointers */

YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */

#ifdef YYLSP_NEEDED

YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */

YYLTYPE *yyls = yylsa;

YYLTYPE *yylsp;

#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)

#else

#define YYPOPSTACK (yyvsp--, yyssp--)

#endif

int yystacksize = YYINITDEPTH;

#ifdef YYPURE

int yychar;

YYSTYPE yylval;

int yynerrs;

#ifdef YYLSP_NEEDED

YYLTYPE yylloc;

#endif

YYSTYPE yyval; /* the variable used to return */

/* semantic values from the action */

/* routines */

int yylen;

#if YYDEBUG != 0

if (yydebug)

fprintf(stderr, "Starting parse\n");

#endif

yyval = 0;

yystate = 0;

yyerrstatus = 0;

yynerrs = 0;

yychar = YYEMPTY; /* Cause a token to be read. */

/* Initialize stack pointers.

Waste one element of value and location stack

so that they stay on the same level as the state stack.

The wasted elements are never initialized. */

yyssp = yyss - 1;

yyvsp = yyvs;

#ifdef YYLSP_NEEDED

yylsp = yyls;

#endif

/* Push a new state, which is found in yystate . */

/* In all cases, when you get here, the value and location stacks

have just been pushed. so pushing a state here evens the stacks. */

yynewstate:

*++yyssp = yystate;

if (yyssp >= yyss + yystacksize - 1)

{

/* Give user a chance to reallocate the stack */

/* Use copies of these so that the &'s don't force the real ones into memory. */

YYSTYPE *yyvs1 = yyvs;

short *yyss1 = yyss;

#ifdef YYLSP_NEEDED

YYLTYPE *yyls1 = yyls;

#endif

/* Get the current used size of the three stacks, in elements. */

int size = yyssp - yyss + 1;

#ifdef yyoverflow

/* Each stack pointer address is followed by the size of

the data in use in that stack, in bytes. */

#ifdef YYLSP_NEEDED

/* This used to be a conditional around just the two extra args,

but that might be undefined if yyoverflow is a macro. */

yyoverflow("parser stack overflow",

&yyss1, size * sizeof (*yyssp),

&yyvs1, size * sizeof (*yyvsp),

&yyls1, size * sizeof (*yylsp),

&yystacksize);

#else

yyoverflow("parser stack overflow",

&yyss1, size * sizeof (*yyssp),

&yyvs1, size * sizeof (*yyvsp),

&yystacksize);

#endif

yyss = yyss1; yyvs = yyvs1;

#ifdef YYLSP_NEEDED

yyls = yyls1;

#endif

#else /* no yyoverflow */

/* Extend the stack our own way. */

if (yystacksize >= YYMAXDEPTH)

{

yyerror("parser stack overflow");

return 2;

}

yystacksize *= 2;

if (yystacksize > YYMAXDEPTH)

yystacksize = YYMAXDEPTH;

yyss = (short *) alloca (yystacksize * sizeof (*yyssp));

__yy_memcpy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));

yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));

__yy_memcpy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));

#ifdef YYLSP_NEEDED

yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));

__yy_memcpy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));

#endif

#endif /* no yyoverflow */

yyssp = yyss + size - 1;

yyvsp = yyvs + size - 1;

#ifdef YYLSP_NEEDED

yylsp = yyls + size - 1;

#endif

#if YYDEBUG != 0

if (yydebug)

fprintf(stderr, "Stack size increased to %d\n", yystacksize);

#endif

if (yyssp >= yyss + yystacksize - 1)

YYABORT;

}

#if YYDEBUG != 0

if (yydebug)

fprintf(stderr, "Entering state %d\n", yystate);

#endif

goto yybackup;

yybackup:

/* Do appropriate processing given the current state. */

/* Read a lookahead token if we need one and don't already have one. */

/* yyresume: */

/* First try to decide what to do without reference to lookahead token. */

yyn = yypact[yystate];

if (yyn == YYFLAG)

goto yydefault;

/* Not known => get a lookahead token if don't already have one. */

/* yychar is either YYEMPTY or YYEOF

or a valid token in external form. */

if (yychar == YYEMPTY)

{

#if YYDEBUG != 0

if (yydebug)

fprintf(stderr, "Reading a token: ");

#endif

yychar = YYLEX;

}

/* Convert token to internal form (in yychar1) for indexing tables with */

if (yychar <= 0) /* This means end of input. */

{

yychar1 = 0;

yychar = YYEOF; /* Don't call YYLEX any more */

#if YYDEBUG != 0

if (yydebug)

fprintf(stderr, "Now at end of input.\n");

#endif

}

else

{

yychar1 = YYTRANSLATE(yychar);

#if YYDEBUG != 0

if (yydebug)

{

fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);

/* Give the individual parser a way to print the precise meaning

of a token, for further debugging info. */

#ifdef YYPRINT

YYPRINT (stderr, yychar, yylval);

#endif

fprintf (stderr, ")\n");

}

#endif

}

yyn += yychar1;

if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)

goto yydefault;

yyn = yytable[yyn];

/* yyn is what to do for this token type in this state.

Negative => reduce, -yyn is rule number.

Positive => shift, yyn is new state.

New state is final state => don't bother to shift,

just return success.

0, or most negative number => error. */

if (yyn < 0)

{

if (yyn == YYFLAG)

goto yyerrlab;

yyn = -yyn;

goto yyreduce;

}

else if (yyn == 0)

goto yyerrlab;

if (yyn == YYFINAL)

YYACCEPT;

/* Shift the lookahead token. */

#if YYDEBUG != 0

if (yydebug)

fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);

#endif

/* Discard the token being shifted unless it is eof. */

if (yychar != YYEOF)

yychar = YYEMPTY;

*++yyvsp = yylval;

#ifdef YYLSP_NEEDED

*++yylsp = yylloc;

#endif

/* count tokens shifted since error; after three, turn off error status. */

if (yyerrstatus) yyerrstatus--;

yystate = yyn;

goto yynewstate;

/* Do the default action for the current state. */

yydefault:

yyn = yydefact[yystate];

if (yyn == 0)

goto yyerrlab;

/* Do a reduction. yyn is the number of a rule to reduce with. */

yyreduce:

yylen = yyr2[yyn];

if (yylen > 0)

yyval = yyvsp[1-yylen]; /* implement default value of the action */

#if YYDEBUG != 0

if (yydebug)

{

int i;

fprintf (stderr, "Reducing via rule %d (line %d), ",

yyn, yyrline[yyn]);

/* Print the symbols being reduced, and their result. */

for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)

fprintf (stderr, "%s ", yytname[yyrhs[i]]);

fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);

}

#endif

$ /* the action file gets copied in in place of this dollarsign */

#line 487 "bison.simple"

yyvsp -= yylen;

yyssp -= yylen;

#ifdef YYLSP_NEEDED

yylsp -= yylen;

#endif

#if YYDEBUG != 0

if (yydebug)

{

short *ssp1 = yyss - 1;

fprintf (stderr, "state stack now");

while (ssp1 != yyssp)

fprintf (stderr, " %d", *++ssp1);

fprintf (stderr, "\n");

}

#endif

*++yyvsp = yyval;

#ifdef YYLSP_NEEDED

yylsp++;

if (yylen == 0)

{

yylsp->first_line = yylloc.first_line;

yylsp->first_column = yylloc.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;

}

#endif

/* Now "shift" the result of the reduction.

Determine what state that goes to,

based on the state we popped back to

and the rule number reduced by. */

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;

yyerrlab: /* here on detecting error */

if (! yyerrstatus)

/* If not already recovering from an error, report this error. */

{

++yynerrs;

#ifdef YYERROR_VERBOSE

yyn = yypact[yystate];

if (yyn > YYFLAG && yyn < YYLAST)

{

int size = 0;

char *msg;

int x, count;

count = 0;

/* Start X at -yyn if nec to avoid negative indexes in yycheck. */

for (x = (yyn < 0 ? -yyn : 0);

x < (sizeof(yytname) / sizeof(char *)); x++)

if (yycheck[x + yyn] == x)

size += strlen(yytname[x]) + 15, count++;

msg = (char *) malloc(size + 15);

if (msg != 0)

{

strcpy(msg, "parse error");

if (count < 5)

{

count = 0;

for (x = (yyn < 0 ? -yyn : 0);

x < (sizeof(yytname) / sizeof(char *)); x++)

if (yycheck[x + yyn] == x)

{

strcat(msg, count == 0 ? ", expecting `" : " or `");

strcat(msg, yytname[x]);

strcat(msg, "'");

count++;

}

yyerror(msg);

free(msg);

}

else

yyerror ("parse error; also virtual memory exceeded");

}

else

#endif /* YYERROR_VERBOSE */

yyerror("parse error");

}

goto yyerrlab1;

yyerrlab1: /* here on error raised explicitly by an action */

if (yyerrstatus == 3)

{

/* if just tried and failed to reuse lookahead token after an error, discard it. */

/* return failure if at end of input */

if (yychar == YYEOF)

YYABORT;

#if YYDEBUG != 0

if (yydebug)

fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);

#endif

yychar = YYEMPTY;

}

/* Else will try to reuse lookahead token

after shifting the error token. */

yyerrstatus = 3; /* Each real token shifted decrements this */

goto yyerrhandle;

yyerrdefault: /* current state does not do anything special for the error token. */

#if 0

/* This is wrong; only states that explicitly want error tokens

should shift them. */

yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/

if (yyn) goto yydefault;

#endif

yyerrpop: /* pop the current state because it cannot handle the error token */

if (yyssp == yyss) YYABORT;

yyvsp--;

yystate = *--yyssp;

#ifdef YYLSP_NEEDED

yylsp--;

#endif

#if YYDEBUG != 0

if (yydebug)

{

short *ssp1 = yyss - 1;

fprintf (stderr, "Error: state stack now");

while (ssp1 != yyssp)

fprintf (stderr, " %d", *++ssp1);

fprintf (stderr, "\n");

}

#endif

yyerrhandle:

yyn = yypact[yystate];

if (yyn == YYFLAG)

goto yyerrdefault;

yyn += YYTERROR;

if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)

goto yyerrdefault;

yyn = yytable[yyn];

if (yyn < 0)

{

if (yyn == YYFLAG)

goto yyerrpop;

yyn = -yyn;

goto yyreduce;

}

else if (yyn == 0)

goto yyerrpop;

if (yyn == YYFINAL)

YYACCEPT;

#if YYDEBUG != 0

if (yydebug)

fprintf(stderr, "Shifting error token, ");

#endif

*++yyvsp = yylval;

#ifdef YYLSP_NEEDED

*++yylsp = yylloc;

#endif

yystate = yyn;

goto yynewstate;

}