![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bison.hairy CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / bison|
Return to bison.hairy CVS log | Up to [Apple XNU] / GNUtools / bison |
1.1 root 1:
2: extern int timeclock;
3:
4:
5: int yyerror; /* Yyerror and yycost are set by guards. */
6: int yycost; /* If yyerror is set to a nonzero value by a */
7: /* guard, the reduction with which the guard */
8: /* is associated is not performed, and the */
9: /* error recovery mechanism is invoked. */
10: /* Yycost indicates the cost of performing */
11: /* the reduction given the attributes of the */
12: /* symbols. */
13:
14:
15: /* YYMAXDEPTH indicates the size of the parser's state and value */
16: /* stacks. */
17:
18: #ifndef YYMAXDEPTH
19: #define YYMAXDEPTH 500
20: #endif
21:
22: /* YYMAXRULES must be at least as large as the number of rules that */
23: /* could be placed in the rule queue. That number could be determined */
24: /* from the grammar and the size of the stack, but, as yet, it is not. */
25:
26: #ifndef YYMAXRULES
27: #define YYMAXRULES 100
28: #endif
29:
30: #ifndef YYMAXBACKUP
31: #define YYMAXBACKUP 100
32: #endif
33:
34:
35: short yyss[YYMAXDEPTH]; /* the state stack */
36: YYSTYPE yyvs[YYMAXDEPTH]; /* the semantic value stack */
37: YYLTYPE yyls[YYMAXDEPTH]; /* the location stack */
38: short yyrq[YYMAXRULES]; /* the rule queue */
39: int yychar; /* the lookahead symbol */
40:
41: YYSTYPE yylval; /* the semantic value of the */
42: /* lookahead symbol */
43:
44: YYSTYPE yytval; /* the semantic value for the state */
45: /* at the top of the state stack. */
46:
47: YYSTYPE yyval; /* the variable used to return */
48: /* semantic values from the action */
49: /* routines */
50:
51: YYLTYPE yylloc; /* location data for the lookahead */
52: /* symbol */
53:
54: YYLTYPE yytloc; /* location data for the state at the */
55: /* top of the state stack */
56:
57:
58: int yynunlexed;
59: short yyunchar[YYMAXBACKUP];
60: YYSTYPE yyunval[YYMAXBACKUP];
61: YYLTYPE yyunloc[YYMAXBACKUP];
62:
63: short *yygssp; /* a pointer to the top of the state */
64: /* stack; only set during error */
65: /* recovery. */
66:
67: YYSTYPE *yygvsp; /* a pointer to the top of the value */
68: /* stack; only set during error */
69: /* recovery. */
70:
71: YYLTYPE *yyglsp; /* a pointer to the top of the */
72: /* location stack; only set during */
73: /* error recovery. */
74:
75:
76: /* Yyget is an interface between the parser and the lexical analyzer. */
77: /* It is costly to provide such an interface, but it avoids requiring */
78: /* the lexical analyzer to be able to back up the scan. */
79:
80: yyget()
81: {
82: if (yynunlexed > 0)
83: {
84: yynunlexed--;
85: yychar = yyunchar[yynunlexed];
86: yylval = yyunval[yynunlexed];
87: yylloc = yyunloc[yynunlexed];
88: }
89: else if (yychar <= 0)
90: yychar = 0;
91: else
92: {
93: yychar = yylex();
94: if (yychar < 0)
95: yychar = 0;
96: else yychar = YYTRANSLATE(yychar);
97: }
98: }
99:
100:
101:
102: yyunlex(chr, val, loc)
103: int chr;
104: YYSTYPE val;
105: YYLTYPE loc;
106: {
107: yyunchar[yynunlexed] = chr;
108: yyunval[yynunlexed] = val;
109: yyunloc[yynunlexed] = loc;
110: yynunlexed++;
111: }
112:
113:
114:
115: yyrestore(first, last)
116: register short *first;
117: register short *last;
118: {
119: register short *ssp;
120: register short *rp;
121: register int symbol;
122: register int state;
123: register int tvalsaved;
124:
125: ssp = yygssp;
126: yyunlex(yychar, yylval, yylloc);
127:
128: tvalsaved = 0;
129: while (first != last)
130: {
131: symbol = yystos[*ssp];
132: if (symbol < YYNTBASE)
133: {
134: yyunlex(symbol, yytval, yytloc);
135: tvalsaved = 1;
136: ssp--;
137: }
138:
139: ssp--;
140:
141: if (first == yyrq)
142: first = yyrq + YYMAXRULES;
143:
144: first--;
145:
146: for (rp = yyrhs + yyprhs[*first]; symbol = *rp; rp++)
147: {
148: if (symbol < YYNTBASE)
149: state = yytable[yypact[*ssp] + symbol];
150: else
151: {
152: state = yypgoto[symbol - YYNTBASE] + *ssp;
153:
154: if (state >= 0 && state <= YYLAST && yycheck[state] == *ssp)
155: state = yytable[state];
156: else
157: state = yydefgoto[symbol - YYNTBASE];
158: }
159:
160: *++ssp = state;
161: }
162: }
163:
164: if ( ! tvalsaved && ssp > yyss)
165: {
166: yyunlex(yystos[*ssp], yytval, yytloc);
167: ssp--;
168: }
169:
170: yygssp = ssp;
171: }
172:
173:
174:
175: int
176: yyparse()
177: {
178: register int yystate;
179: register int yyn;
180: register short *yyssp;
181: register short *yyrq0;
182: register short *yyptr;
183: register YYSTYPE *yyvsp;
184:
185: int yylen;
186: YYLTYPE *yylsp;
187: short *yyrq1;
188: short *yyrq2;
189:
190: yystate = 0;
191: yyssp = yyss - 1;
192: yyvsp = yyvs - 1;
193: yylsp = yyls - 1;
194: yyrq0 = yyrq;
195: yyrq1 = yyrq0;
196: yyrq2 = yyrq0;
197:
198: yychar = yylex();
199: if (yychar < 0)
200: yychar = 0;
201: else yychar = YYTRANSLATE(yychar);
202:
203: yynewstate:
204:
205: if (yyssp >= yyss + YYMAXDEPTH - 1)
206: {
207: yyabort("Parser Stack Overflow");
208: YYABORT;
209: }
210:
211: *++yyssp = yystate;
212:
213: yyresume:
214:
215: yyn = yypact[yystate];
216: if (yyn == YYFLAG)
217: goto yydefault;
218:
219: yyn += yychar;
220: if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar)
221: goto yydefault;
222:
223: yyn = yytable[yyn];
224: if (yyn < 0)
225: {
226: yyn = -yyn;
227: goto yyreduce;
228: }
229: else if (yyn == 0)
230: goto yyerrlab;
231:
232: yystate = yyn;
233:
234: yyptr = yyrq2;
235: while (yyptr != yyrq1)
236: {
237: yyn = *yyptr++;
238: yylen = yyr2[yyn];
239: yyvsp -= yylen;
240: yylsp -= yylen;
241:
242: yyguard(yyn, yyvsp, yylsp);
243: if (yyerror)
244: goto yysemerr;
245:
246: yyaction(yyn, yyvsp, yylsp);
247: *++yyvsp = yyval;
248:
249: yylsp++;
250: if (yylen == 0)
251: {
252: yylsp->timestamp = timeclock;
253: yylsp->first_line = yytloc.first_line;
254: yylsp->first_column = yytloc.first_column;
255: yylsp->last_line = (yylsp-1)->last_line;
256: yylsp->last_column = (yylsp-1)->last_column;
257: yylsp->text = 0;
258: }
259: else
260: {
261: yylsp->last_line = (yylsp+yylen-1)->last_line;
262: yylsp->last_column = (yylsp+yylen-1)->last_column;
263: }
264:
265: if (yyptr == yyrq + YYMAXRULES)
266: yyptr = yyrq;
267: }
268:
269: if (yystate == YYFINAL)
270: YYACCEPT;
271:
272: yyrq2 = yyptr;
273: yyrq1 = yyrq0;
274:
275: *++yyvsp = yytval;
276: *++yylsp = yytloc;
277: yytval = yylval;
278: yytloc = yylloc;
279: yyget();
280:
281: goto yynewstate;
282:
283: yydefault:
284:
285: yyn = yydefact[yystate];
286: if (yyn == 0)
287: goto yyerrlab;
288:
289: yyreduce:
290:
291: *yyrq0++ = yyn;
292:
293: if (yyrq0 == yyrq + YYMAXRULES)
294: yyrq0 = yyrq;
295:
296: if (yyrq0 == yyrq2)
297: {
298: yyabort("Parser Rule Queue Overflow");
299: YYABORT;
300: }
301:
302: yyssp -= yyr2[yyn];
303: yyn = yyr1[yyn];
304:
305: yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
306: if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
307: yystate = yytable[yystate];
308: else
309: yystate = yydefgoto[yyn - YYNTBASE];
310:
311: goto yynewstate;
312:
313: yysemerr:
314: *--yyptr = yyn;
315: yyrq2 = yyptr;
316: yyvsp += yyr2[yyn];
317:
318: yyerrlab:
319:
320: yygssp = yyssp;
321: yygvsp = yyvsp;
322: yyglsp = yylsp;
323: yyrestore(yyrq0, yyrq2);
324: yyrecover();
325: yystate = *yygssp;
326: yyssp = yygssp;
327: yyvsp = yygvsp;
328: yyrq0 = yyrq;
329: yyrq1 = yyrq0;
330: yyrq2 = yyrq0;
331: goto yyresume;
332: }
333:
334: $
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.