yaccpars (5149B)
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 }