1 /* $Id: mkpar.c,v 1.15 2016/06/07 00:22:12 tom Exp $ */ 2 3 #include "defs.h" 4 5 #define NotSuppressed(p) ((p)->suppressed == 0) 6 7 #if defined(YYBTYACC) 8 #define MaySuppress(p) ((backtrack ? ((p)->suppressed <= 1) : (p)->suppressed == 0)) 9 /* suppress the preferred action => enable backtracking */ 10 #define StartBacktrack(p) if (backtrack && (p) != NULL && NotSuppressed(p)) (p)->suppressed = 1 11 #else 12 #define MaySuppress(p) ((p)->suppressed == 0) 13 #define StartBacktrack(p) /*nothing */ 14 #endif 15 16 static action *add_reduce(action *actions, int ruleno, int symbol); 17 static action *add_reductions(int stateno, action *actions); 18 static action *get_shifts(int stateno); 19 static action *parse_actions(int stateno); 20 static int sole_reduction(int stateno); 21 static void defreds(void); 22 static void find_final_state(void); 23 static void free_action_row(action *p); 24 static void remove_conflicts(void); 25 static void total_conflicts(void); 26 static void unused_rules(void); 27 28 action **parser; 29 30 int SRexpect; 31 int RRexpect; 32 33 int SRtotal; 34 int RRtotal; 35 36 Value_t *SRconflicts; 37 Value_t *RRconflicts; 38 Value_t *defred; 39 Value_t *rules_used; 40 Value_t nunused; 41 Value_t final_state; 42 43 static Value_t SRcount; 44 static Value_t RRcount; 45 46 void 47 make_parser(void) 48 { 49 int i; 50 51 parser = NEW2(nstates, action *); 52 for (i = 0; i < nstates; i++) 53 parser[i] = parse_actions(i); 54 55 find_final_state(); 56 remove_conflicts(); 57 unused_rules(); 58 if (SRtotal + RRtotal > 0) 59 total_conflicts(); 60 defreds(); 61 } 62 63 static action * 64 parse_actions(int stateno) 65 { 66 action *actions; 67 68 actions = get_shifts(stateno); 69 actions = add_reductions(stateno, actions); 70 return (actions); 71 } 72 73 static action * 74 get_shifts(int stateno) 75 { 76 action *actions, *temp; 77 shifts *sp; 78 Value_t *to_state2; 79 Value_t i, k; 80 Value_t symbol; 81 82 actions = 0; 83 sp = shift_table[stateno]; 84 if (sp) 85 { 86 to_state2 = sp->shift; 87 for (i = (Value_t)(sp->nshifts - 1); i >= 0; i--) 88 { 89 k = to_state2[i]; 90 symbol = accessing_symbol[k]; 91 if (ISTOKEN(symbol)) 92 { 93 temp = NEW(action); 94 temp->next = actions; 95 temp->symbol = symbol; 96 temp->number = k; 97 temp->prec = symbol_prec[symbol]; 98 temp->action_code = SHIFT; 99 temp->assoc = symbol_assoc[symbol]; 100 actions = temp; 101 } 102 } 103 } 104 return (actions); 105 } 106 107 static action * 108 add_reductions(int stateno, action *actions) 109 { 110 int i, j, m, n; 111 int ruleno, tokensetsize; 112 unsigned *rowp; 113 114 tokensetsize = WORDSIZE(ntokens); 115 m = lookaheads[stateno]; 116 n = lookaheads[stateno + 1]; 117 for (i = m; i < n; i++) 118 { 119 ruleno = LAruleno[i]; 120 rowp = LA + i * tokensetsize; 121 for (j = ntokens - 1; j >= 0; j--) 122 { 123 if (BIT(rowp, j)) 124 actions = add_reduce(actions, ruleno, j); 125 } 126 } 127 return (actions); 128 } 129 130 static action * 131 add_reduce(action *actions, 132 int ruleno, 133 int symbol) 134 { 135 action *temp, *prev, *next; 136 137 prev = 0; 138 for (next = actions; next && next->symbol < symbol; next = next->next) 139 prev = next; 140 141 while (next && next->symbol == symbol && next->action_code == SHIFT) 142 { 143 prev = next; 144 next = next->next; 145 } 146 147 while (next && next->symbol == symbol && 148 next->action_code == REDUCE && next->number < ruleno) 149 { 150 prev = next; 151 next = next->next; 152 } 153 154 temp = NEW(action); 155 temp->next = next; 156 temp->symbol = (Value_t)symbol; 157 temp->number = (Value_t)ruleno; 158 temp->prec = rprec[ruleno]; 159 temp->action_code = REDUCE; 160 temp->assoc = rassoc[ruleno]; 161 162 if (prev) 163 prev->next = temp; 164 else 165 actions = temp; 166 167 return (actions); 168 } 169 170 static void 171 find_final_state(void) 172 { 173 int goal, i; 174 Value_t *to_state2; 175 shifts *p; 176 177 p = shift_table[0]; 178 to_state2 = p->shift; 179 goal = ritem[1]; 180 for (i = p->nshifts - 1; i >= 0; --i) 181 { 182 final_state = to_state2[i]; 183 if (accessing_symbol[final_state] == goal) 184 break; 185 } 186 } 187 188 static void 189 unused_rules(void) 190 { 191 int i; 192 action *p; 193 194 rules_used = TMALLOC(Value_t, nrules); 195 NO_SPACE(rules_used); 196 197 for (i = 0; i < nrules; ++i) 198 rules_used[i] = 0; 199 200 for (i = 0; i < nstates; ++i) 201 { 202 for (p = parser[i]; p; p = p->next) 203 { 204 if ((p->action_code == REDUCE) && MaySuppress(p)) 205 rules_used[p->number] = 1; 206 } 207 } 208 209 nunused = 0; 210 for (i = 3; i < nrules; ++i) 211 if (!rules_used[i]) 212 ++nunused; 213 214 if (nunused) 215 { 216 if (nunused == 1) 217 fprintf(stderr, "%s: 1 rule never reduced\n", myname); 218 else 219 fprintf(stderr, "%s: %d rules never reduced\n", myname, nunused); 220 } 221 } 222 223 static void 224 remove_conflicts(void) 225 { 226 int i; 227 int symbol; 228 action *p, *pref = 0; 229 230 SRtotal = 0; 231 RRtotal = 0; 232 SRconflicts = NEW2(nstates, Value_t); 233 RRconflicts = NEW2(nstates, Value_t); 234 for (i = 0; i < nstates; i++) 235 { 236 SRcount = 0; 237 RRcount = 0; 238 symbol = -1; 239 #if defined(YYBTYACC) 240 pref = NULL; 241 #endif 242 for (p = parser[i]; p; p = p->next) 243 { 244 if (p->symbol != symbol) 245 { 246 /* the first parse action for each symbol is the preferred action */ 247 pref = p; 248 symbol = p->symbol; 249 } 250 /* following conditions handle multiple, i.e., conflicting, parse actions */ 251 else if (i == final_state && symbol == 0) 252 { 253 SRcount++; 254 p->suppressed = 1; 255 StartBacktrack(pref); 256 } 257 else if (pref != 0 && pref->action_code == SHIFT) 258 { 259 if (pref->prec > 0 && p->prec > 0) 260 { 261 if (pref->prec < p->prec) 262 { 263 pref->suppressed = 2; 264 pref = p; 265 } 266 else if (pref->prec > p->prec) 267 { 268 p->suppressed = 2; 269 } 270 else if (pref->assoc == LEFT) 271 { 272 pref->suppressed = 2; 273 pref = p; 274 } 275 else if (pref->assoc == RIGHT) 276 { 277 p->suppressed = 2; 278 } 279 else 280 { 281 pref->suppressed = 2; 282 p->suppressed = 2; 283 } 284 } 285 else 286 { 287 SRcount++; 288 p->suppressed = 1; 289 StartBacktrack(pref); 290 } 291 } 292 else 293 { 294 RRcount++; 295 p->suppressed = 1; 296 StartBacktrack(pref); 297 } 298 } 299 SRtotal += SRcount; 300 RRtotal += RRcount; 301 SRconflicts[i] = SRcount; 302 RRconflicts[i] = RRcount; 303 } 304 } 305 306 static void 307 total_conflicts(void) 308 { 309 fprintf(stderr, "%s: ", myname); 310 if (SRtotal == 1) 311 fprintf(stderr, "1 shift/reduce conflict"); 312 else if (SRtotal > 1) 313 fprintf(stderr, "%d shift/reduce conflicts", SRtotal); 314 315 if (SRtotal && RRtotal) 316 fprintf(stderr, ", "); 317 318 if (RRtotal == 1) 319 fprintf(stderr, "1 reduce/reduce conflict"); 320 else if (RRtotal > 1) 321 fprintf(stderr, "%d reduce/reduce conflicts", RRtotal); 322 323 fprintf(stderr, ".\n"); 324 325 if (SRexpect >= 0 && SRtotal != SRexpect) 326 { 327 fprintf(stderr, "%s: ", myname); 328 fprintf(stderr, "expected %d shift/reduce conflict%s.\n", 329 SRexpect, PLURAL(SRexpect)); 330 exit_code = EXIT_FAILURE; 331 } 332 if (RRexpect >= 0 && RRtotal != RRexpect) 333 { 334 fprintf(stderr, "%s: ", myname); 335 fprintf(stderr, "expected %d reduce/reduce conflict%s.\n", 336 RRexpect, PLURAL(RRexpect)); 337 exit_code = EXIT_FAILURE; 338 } 339 } 340 341 static int 342 sole_reduction(int stateno) 343 { 344 int count, ruleno; 345 action *p; 346 347 count = 0; 348 ruleno = 0; 349 for (p = parser[stateno]; p; p = p->next) 350 { 351 if (p->action_code == SHIFT && MaySuppress(p)) 352 return (0); 353 else if ((p->action_code == REDUCE) && MaySuppress(p)) 354 { 355 if (ruleno > 0 && p->number != ruleno) 356 return (0); 357 if (p->symbol != 1) 358 ++count; 359 ruleno = p->number; 360 } 361 } 362 363 if (count == 0) 364 return (0); 365 return (ruleno); 366 } 367 368 static void 369 defreds(void) 370 { 371 int i; 372 373 defred = NEW2(nstates, Value_t); 374 for (i = 0; i < nstates; i++) 375 defred[i] = (Value_t)sole_reduction(i); 376 } 377 378 static void 379 free_action_row(action *p) 380 { 381 action *q; 382 383 while (p) 384 { 385 q = p->next; 386 FREE(p); 387 p = q; 388 } 389 } 390 391 void 392 free_parser(void) 393 { 394 int i; 395 396 for (i = 0; i < nstates; i++) 397 free_action_row(parser[i]); 398 399 FREE(parser); 400 } 401 402 #ifdef NO_LEAKS 403 void 404 mkpar_leaks(void) 405 { 406 DO_FREE(defred); 407 DO_FREE(rules_used); 408 DO_FREE(SRconflicts); 409 DO_FREE(RRconflicts); 410 } 411 #endif 412