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