tyaccpars - plan9port - [fork] Plan 9 from user space
(HTM) git clone git://src.adamsgaard.dk/plan9port
(DIR) Log
(DIR) Files
(DIR) Refs
(DIR) README
(DIR) LICENSE
---
tyaccpars (5149B)
---
1 #define YYFLAG -1000
2 #define YYERROR goto yyerrlab
3 #define YYACCEPT return(0)
4 #define YYABORT return(1)
5 #define yyclearin yychar = -1
6 #define yyerrok yyerrflag = 0
7
8 #ifdef yydebug
9 #include "y.debug"
10 #else
11 #define yydebug 0
12 static const char* yytoknames[1]; /* for debugging */
13 static const char* yystates[1]; /* for debugging */
14 #endif
15
16 /* parser for yacc output */
17 #ifdef YYARG
18 #define yynerrs yyarg->yynerrs
19 #define yyerrflag yyarg->yyerrflag
20 #define yyval yyarg->yyval
21 #define yylval yyarg->yylval
22 #else
23 int yynerrs = 0; /* number of errors */
24 int yyerrflag = 0; /* error recovery flag */
25 #endif
26
27 static const char*
28 yytokname(int yyc)
29 {
30 static char x[10];
31
32 if(yyc > 0 && yyc <= sizeof(yytoknames)/sizeof(yytoknames[0]))
33 if(yytoknames[yyc-1])
34 return yytoknames[yyc-1];
35 sprintf(x, "<%d>", yyc);
36 return x;
37 }
38
39 static const char*
40 yystatname(int yys)
41 {
42 static char x[10];
43
44 if(yys >= 0 && yys < sizeof(yystates)/sizeof(yystates[0]))
45 if(yystates[yys])
46 return yystates[yys];
47 sprintf(x, "<%d>\n", yys);
48 return x;
49 }
50
51 static long
52 #ifdef YYARG
53 yylex1(struct Yyarg *yyarg)
54 #else
55 yylex1(void)
56 #endif
57 {
58 long yychar;
59 const long *t3p;
60 int c;
61
62 #ifdef YYARG
63 yychar = yylex(yyarg);
64 #else
65 yychar = yylex();
66 #endif
67 if(yychar <= 0) {
68 c = yytok1[0];
69 goto out;
70 }
71 if(yychar < sizeof(yytok1)/sizeof(yytok1[0])) {
72 c = yytok1[yychar];
73 goto out;
74 }
75 if(yychar >= YYPRIVATE)
76 if(yychar < YYPRIVATE+sizeof(yytok2)/sizeof(yytok2[0])) {
77 c = yytok2[yychar-YYPRIVATE];
78 goto out;
79 }
80 for(t3p=yytok3;; t3p+=2) {
81 c = t3p[0];
82 if(c == yychar) {
83 c = t3p[1];
84 goto out;
85 }
86 if(c == 0)
87 break;
88 }
89 c = 0;
90
91 out:
92 if(c == 0)
93 c = yytok2[1]; /* unknown char */
94 if(yydebug >= 3)
95 printf("lex %.4lX %s\n", yychar, yytokname(c));
96 return c;
97 }
98
99 int
100 #ifdef YYARG
101 yyparse(struct Yyarg *yyarg)
102 #else
103 yyparse(void)
104 #endif
105 {
106 struct
107 {
108 YYSTYPE yyv;
109 int yys;
110 } yys[YYMAXDEPTH], *yyp, *yypt;
111 const short *yyxi;
112 int yyj, yym, yystate, yyn, yyg;
113 long yychar;
114 #ifndef YYARG
115 YYSTYPE save1, save2;
116 int save3, save4;
117
118 save1 = yylval;
119 save2 = yyval;
120 save3 = yynerrs;
121 save4 = yyerrflag;
122 #endif
123
124 yystate = 0;
125 yychar = -1;
126 yynerrs = 0;
127 yyerrflag = 0;
128 yyp = &yys[0];
129 yyp--;
130 goto yystack;
131
132 ret0:
133 yyn = 0;
134 goto ret;
135
136 ret1:
137 yyn = 1;
138 goto ret;
139
140 ret:
141 #ifndef YYARG
142 yylval = save1;
143 yyval = save2;
144 yynerrs = save3;
145 yyerrflag = save4;
146 #endif
147 return yyn;
148
149 yystack:
150 /* put a state and value onto the stack */
151 if(yydebug >= 4)
152 printf("char %s in %s", yytokname(yychar), yystatname(yystate));
153
154 yyp++;
155 if(yyp >= &yys[YYMAXDEPTH]) {
156 yyerror("yacc stack overflow");
157 goto ret1;
158 }
159 yyp->yys = yystate;
160 yyp->yyv = yyval;
161
162 yynewstate:
163 yyn = yypact[yystate];
164 if(yyn <= YYFLAG)
165 goto yydefault; /* simple state */
166 if(yychar < 0)
167 #ifdef YYARG
168 yychar = yylex1(yyarg);
169 #else
170 yychar = yylex1();
171 #endif
172 yyn += yychar;
173 if(yyn < 0 || yyn >= YYLAST)
174 goto yydefault;
175 yyn = yyact[yyn];
176 if(yychk[yyn] == yychar) { /* valid shift */
177 yychar = -1;
178 yyval = yylval;
179 yystate = yyn;
180 if(yyerrflag > 0)
181 yyerrflag--;
182 goto yystack;
183 }
184
185 yydefault:
186 /* default state action */
187 yyn = yydef[yystate];
188 if(yyn == -2) {
189 if(yychar < 0)
190 #ifdef YYARG
191 yychar = yylex1(yyarg);
192 #else
193 yychar = yylex1();
194 #endif
195
196 /* look through exception table */
197 for(yyxi=yyexca;; yyxi+=2)
198 if(yyxi[0] == -1 && yyxi[1] == yystate)
199 break;
200 for(yyxi += 2;; yyxi += 2) {
201 yyn = yyxi[0];
202 if(yyn < 0 || yyn == yychar)
203 break;
204 }
205 yyn = yyxi[1];
206 if(yyn < 0)
207 goto ret0;
208 }
209 if(yyn == 0) {
210 /* error ... attempt to resume parsing */
211 switch(yyerrflag) {
212 case 0: /* brand new error */
213 yyerror("syntax error");
214 if(yydebug >= 1) {
215 printf("%s", yystatname(yystate));
216 printf("saw %s\n", yytokname(yychar));
217 }
218 goto yyerrlab;
219 yyerrlab:
220 yynerrs++;
221
222 case 1:
223 case 2: /* incompletely recovered error ... try again */
224 yyerrflag = 3;
225
226 /* find a state where "error" is a legal shift action */
227 while(yyp >= yys) {
228 yyn = yypact[yyp->yys] + YYERRCODE;
229 if(yyn >= 0 && yyn < YYLAST) {
230 yystate = yyact[yyn]; /* simulate a shift of "error" */
231 if(yychk[yystate] == YYERRCODE)
232 goto yystack;
233 }
234
235 /* the current yyp has no shift onn "error", pop stack */
236 if(yydebug >= 2)
237 printf("error recovery pops state %d, uncovers %d\n",
238 yyp->yys, (yyp-1)->yys );
239 yyp--;
240 }
241 /* there is no state on the stack with an error shift ... abort */
242 goto ret1;
243
244 case 3: /* no shift yet; clobber input char */
245 if(yydebug >= YYEOFCODE)
246 printf("error recovery discards %s\n", yytokname(yychar));
247 if(yychar == YYEOFCODE)
248 goto ret1;
249 yychar = -1;
250 goto yynewstate; /* try again in the same state */
251 }
252 }
253
254 /* reduction by production yyn */
255 if(yydebug >= 2)
256 printf("reduce %d in:\n\t%s", yyn, yystatname(yystate));
257
258 yypt = yyp;
259 yyp -= yyr2[yyn];
260 yyval = (yyp+1)->yyv;
261 yym = yyn;
262
263 /* consult goto table to find next state */
264 yyn = yyr1[yyn];
265 yyg = yypgo[yyn];
266 yyj = yyg + yyp->yys + 1;
267
268 if(yyj >= YYLAST || yychk[yystate=yyact[yyj]] != -yyn)
269 yystate = yyact[yyg];
270 switch(yym) {
271 $A
272 }
273 goto yystack; /* stack new state and value */
274 }