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; | |
} | |
$ |