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 }