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[-1];
132 	goto yystack;
133 
134 ret0:
135 	yyn = 0;
136 	goto ret;
137 
138 ret1:
139 	yyn = 1;
140 	goto ret;
141 
142 ret:
143 #ifndef YYARG
144 	yylval = save1;
145 	yyval = save2;
146 	yynerrs = save3;
147 	yyerrflag = save4;
148 #endif
149 	return yyn;
150 
151 yystack:
152 	/* put a state and value onto the stack */
153 	if(yydebug >= 4)
154 		fprint(2, "char %s in %s", yytokname(yychar), yystatname(yystate));
155 
156 	yyp++;
157 	if(yyp >= &yys[YYMAXDEPTH]) {
158 		yyerror("yacc stack overflow");
159 		goto ret1;
160 	}
161 	yyp->yys = yystate;
162 	yyp->yyv = yyval;
163 
164 yynewstate:
165 	yyn = yypact[yystate];
166 	if(yyn <= YYFLAG)
167 		goto yydefault; /* simple state */
168 	if(yychar < 0)
169 #ifdef YYARG
170 		yychar = yylex1(yyarg);
171 #else
172 		yychar = yylex1();
173 #endif
174 	yyn += yychar;
175 	if(yyn < 0 || yyn >= YYLAST)
176 		goto yydefault;
177 	yyn = yyact[yyn];
178 	if(yychk[yyn] == yychar) { /* valid shift */
179 		yychar = -1;
180 		yyval = yylval;
181 		yystate = yyn;
182 		if(yyerrflag > 0)
183 			yyerrflag--;
184 		goto yystack;
185 	}
186 
187 yydefault:
188 	/* default state action */
189 	yyn = yydef[yystate];
190 	if(yyn == -2) {
191 		if(yychar < 0)
192 #ifdef YYARG
193 		yychar = yylex1(yyarg);
194 #else
195 		yychar = yylex1();
196 #endif
197 
198 		/* look through exception table */
199 		for(yyxi=yyexca;; yyxi+=2)
200 			if(yyxi[0] == -1 && yyxi[1] == yystate)
201 				break;
202 		for(yyxi += 2;; yyxi += 2) {
203 			yyn = yyxi[0];
204 			if(yyn < 0 || yyn == yychar)
205 				break;
206 		}
207 		yyn = yyxi[1];
208 		if(yyn < 0)
209 			goto ret0;
210 	}
211 	if(yyn == 0) {
212 		/* error ... attempt to resume parsing */
213 		switch(yyerrflag) {
214 		case 0:   /* brand new error */
215 			yyerror("syntax error");
216 			if(yydebug >= 1) {
217 				fprint(2, "%s", yystatname(yystate));
218 				fprint(2, "saw %s\n", yytokname(yychar));
219 			}
220 			goto yyerrlab;
221 		yyerrlab:
222 			yynerrs++;
223 
224 		case 1:
225 		case 2: /* incompletely recovered error ... try again */
226 			yyerrflag = 3;
227 
228 			/* find a state where "error" is a legal shift action */
229 			while(yyp >= yys) {
230 				yyn = yypact[yyp->yys] + YYERRCODE;
231 				if(yyn >= 0 && yyn < YYLAST) {
232 					yystate = yyact[yyn];  /* simulate a shift of "error" */
233 					if(yychk[yystate] == YYERRCODE)
234 						goto yystack;
235 				}
236 
237 				/* the current yyp has no shift onn "error", pop stack */
238 				if(yydebug >= 2)
239 					fprint(2, "error recovery pops state %d, uncovers %d\n",
240 						yyp->yys, (yyp-1)->yys );
241 				yyp--;
242 			}
243 			/* there is no state on the stack with an error shift ... abort */
244 			goto ret1;
245 
246 		case 3:  /* no shift yet; clobber input char */
247 			if(yydebug >= 2)
248 				fprint(2, "error recovery discards %s\n", yytokname(yychar));
249 			if(yychar == YYEOFCODE)
250 				goto ret1;
251 			yychar = -1;
252 			goto yynewstate;   /* try again in the same state */
253 		}
254 	}
255 
256 	/* reduction by production yyn */
257 	if(yydebug >= 2)
258 		fprint(2, "reduce %d in:\n\t%s", yyn, yystatname(yystate));
259 
260 	yypt = yyp;
261 	yyp -= yyr2[yyn];
262 	yyval = (yyp+1)->yyv;
263 	yym = yyn;
264 
265 	/* consult goto table to find next state */
266 	yyn = yyr1[yyn];
267 	yyg = yypgo[yyn];
268 	yyj = yyg + yyp->yys + 1;
269 
270 	if(yyj >= YYLAST || yychk[yystate=yyact[yyj]] != -yyn)
271 		yystate = yyact[yyg];
272 	switch(yym) {
273 		$A
274 	}
275 	goto yystack;  /* stack new state and value */
276 }