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