yaccpar (5236B)
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 }