/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ | |
/* Skeleton output parser for bison, | |
Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. | |
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. */ | |
#ifdef __GNUC__ | |
#define alloca __builtin_alloca | |
#else /* not __GNUC__ */ | |
#if HAVE_ALLOCA_H | |
#include <alloca.h> | |
#else /* not HAVE_ALLOCA_H */ | |
#ifdef _AIX | |
#pragma alloca | |
#else /* not _AIX */ | |
char *alloca (); | |
#endif /* not _AIX */ | |
#endif /* not HAVE_ALLOCA_H */ | |
#endif /* not __GNUC__ */ | |
extern void yyerror(char* s); | |
#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__)) || defined (WIN32) | |
#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; | |
size_t count; | |
{ | |
register char *f = from; | |
register char *t = to; | |
register size_t i = 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, size_t count) | |
{ | |
register char *f = from; | |
register char *t = to; | |
register size_t i = count; | |
while (i-- > 0) | |
*t++ = *f++; | |
} | |
#endif | |
#endif | |
/* 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 | |
#ifndef YYPARSE_PARAM_DECL | |
#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; | |
#endif | |
#else | |
#define YYPARSE_PARAM | |
#define YYPARSE_PARAM_DECL | |
#endif | |
extern YY_DECL; | |
int | |
yyparse(YYPARSE_PARAM_DECL YYPARSE_PARAM) { | |
register int yystate; | |
register int yyn; | |
register short *yyssp; | |
register YYSTYPE *yyvsp; | |
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 | |
size_t yystacksize = YYINITDEPTH; | |
#ifdef YYPURE | |
int yychar; | |
YYSTYPE yylval; | |
int yynerrs; | |
#ifdef YYLSP_NEEDED | |
YYLTYPE yylloc; | |
#endif | |
#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 | |
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. */ | |
size_t 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 */ | |
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; | |
} |