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