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 }