Subversion Repositories planix.SVN

Rev

Rev 2 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 - 1 
#define YYFLAG 		-1000
2 
#define	yyclearin	yychar = -1
3 
#define	yyerrok		yyerrflag = 0
4 
 
5 
#ifdef	yydebug
6 
#include	"y.debug"
7 
#else
8 
#define	yydebug		0
9 
char*	yytoknames[1];		/* for debugging */
10 
char*	yystates[1];		/* for debugging */
11 
#endif
12 
 
13 
/*	parser for yacc output	*/
14 
 
15 
int	yynerrs = 0;		/* number of errors */
16 
int	yyerrflag = 0;		/* error recovery flag */
17 
 
18 
extern	int	fprint(int, char*, ...);
19 
extern	int	sprint(char*, char*, ...);
20 
 
21 
char*
22 
yytokname(int yyc)
23 
{
24 
	static char x[16];
25 
 
26 
	if(yyc > 0 && yyc <= sizeof(yytoknames)/sizeof(yytoknames[0]))
27 
	if(yytoknames[yyc-1])
28 
		return yytoknames[yyc-1];
29 
	sprint(x, "<%d>", yyc);
30 
	return x;
31 
}
32 
 
33 
char*
34 
yystatname(int yys)
35 
{
36 
	static char x[16];
37 
 
38 
	if(yys >= 0 && yys < sizeof(yystates)/sizeof(yystates[0]))
39 
	if(yystates[yys])
40 
		return yystates[yys];
41 
	sprint(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 
		fprint(2, "lex %.4lux %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 
	long yychar;
96 
	YYSTYPE save1, save2;
97 
	int save3, save4;
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 
		fprint(2, "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 
			yynerrs++;
184 
			if(yydebug >= 1) {
185 
				fprint(2, "%s", yystatname(yystate));
186 
				fprint(2, "saw %s\n", yytokname(yychar));
187 
			}
188 
 
189 
		case 1:
190 
		case 2: /* incompletely recovered error ... try again */
191 
			yyerrflag = 3;
192 
 
193 
			/* find a state where "error" is a legal shift action */
194 
			while(yyp >= yys) {
195 
				yyn = yypact[yyp->yys] + YYERRCODE;
196 
				if(yyn >= 0 && yyn < YYLAST) {
197 
					yystate = yyact[yyn];  /* simulate a shift of "error" */
198 
					if(yychk[yystate] == YYERRCODE)
199 
						goto yystack;
200 
				}
201 
 
202 
				/* the current yyp has no shift onn "error", pop stack */
203 
				if(yydebug >= 2)
204 
					fprint(2, "error recovery pops state %d, uncovers %d\n",
205 
						yyp->yys, (yyp-1)->yys );
206 
				yyp--;
207 
			}
208 
			/* there is no state on the stack with an error shift ... abort */
209 
			goto ret1;
210 
 
211 
		case 3:  /* no shift yet; clobber input char */
212 
			if(yydebug >= 2)
213 
				fprint(2, "error recovery discards %s\n", yytokname(yychar));
214 
			if(yychar == YYEOFCODE)
215 
				goto ret1;
216 
			yychar = -1;
217 
			goto yynewstate;   /* try again in the same state */
218 
		}
219 
	}
220 
 
221 
	/* reduction by production yyn */
222 
	if(yydebug >= 2)
223 
		fprint(2, "reduce %d in:\n\t%s", yyn, yystatname(yystate));
224 
 
225 
	yypt = yyp;
226 
	yyp -= yyr2[yyn];
227 
	yyval = (yyp+1)->yyv;
228 
	yym = yyn;
229 
 
230 
	/* consult goto table to find next state */
231 
	yyn = yyr1[yyn];
232 
	yyg = yypgo[yyn];
233 
	yyj = yyg + yyp->yys + 1;
234 
 
235 
	if(yyj >= YYLAST || yychk[yystate=yyact[yyj]] != -yyn)
236 
		yystate = yyact[yyg];
237 
	switch(yym) {
238 
		$A
239 
	}
240 
	goto yystack;  /* stack new state and value */
241 
}