1 /* IELR's inadequacy annotation list. 2 3 Copyright (C) 2009-2012 Free Software Foundation, Inc. 4 5 This file is part of Bison, the GNU Compiler Compiler. 6 7 This program is free software: you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation, either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include <config.h> 21 #include "system.h" 22 23 #include "AnnotationList.h" 24 #include "lalr.h" 25 #include "ielr.h" 26 27 /** 28 * \pre 29 * - <tt>annotations_obstackp != NULL</tt>. 30 * \post 31 * - \c result is a new \c AnnotationList with one node whose: 32 * - \c inadequacyNode member is \c NULL. 33 * - \c contributions member is allocated with \c contribution_count 34 * uninitialized elements. 35 * - All memory was allocated on \c annotations_obstackp. 36 */ 37 static AnnotationList* 38 AnnotationList__alloc_on_obstack (ContributionIndex contribution_count, 39 struct obstack *annotations_obstackp) 40 { 41 AnnotationList *result; 42 size_t contributions_size = 43 contribution_count * sizeof result->contributions[0]; 44 result = obstack_alloc (annotations_obstackp, 45 offsetof (AnnotationList, contributions) 46 + contributions_size); 47 result->next = NULL; 48 result->inadequacyNode = NULL; 49 return result; 50 } 51 52 /** 53 * \pre 54 * - <tt>self != NULL</tt>. 55 * - <tt>0 <= ci < self->inadequacyNode->contributionCount</tt>. 56 * \post 57 * - \c result = true iff contribution \c ci in \c self represents an 58 * "always" contribution. 59 */ 60 static bool 61 AnnotationList__isContributionAlways (AnnotationList const *self, 62 ContributionIndex ci) 63 { 64 aver (0 <= ci && ci < self->inadequacyNode->contributionCount); 65 return self->contributions[ci] == NULL; 66 } 67 68 /** 69 * \pre 70 * - \c self is a single node. 71 * - \c self annotates the same state as every other node in \c list, and 72 * that state has \c nitems kernel items. 73 * \post 74 * - If the list \c list already contains an identical annotation to \c self, 75 * \c self was discarded, \c result is false, and the caller is responsible 76 * for the memory of \c self. 77 * - Otherwise, \c list now contains the node \c self, \c result is true, and 78 * \c list assumes responsibility for the memory of \c self. 79 * - The sort in \c list is: 80 * - Sort in reverse order on the unique ID of the associated 81 * inadequacy node. Because these IDs are assigned in ascending 82 * order, this should mean that the insertion position within an 83 * annotation list is usually near the beginning with other 84 * annotations associated with the same inadequacy. 85 * - Next, sort on the first contribution that is different as follows: 86 * - Sort an always-contribution before a never-contribution before a 87 * potential-contribution. 88 * - Two always-contributions are identical. 89 * - Two never-contributions are identical. 90 * - For two potential-contributions, sort on the contributions' kernel 91 * item bitsets interpreted as binary numbers. 92 * - The sorting has a few effects: 93 * - It accelerates elimination of identical annotations during insertion. 94 * - It determines how the output of \c AnnotationList__debug is sorted. 95 * - Other than that, it's probably not important. 96 */ 97 static bool 98 AnnotationList__insertInto (AnnotationList *self, AnnotationList **list, 99 size_t nitems) 100 { 101 AnnotationList **node; 102 for (node = list; *node; node = &(*node)->next) 103 { 104 int cmp = 0; 105 ContributionIndex ci; 106 if (self->inadequacyNode->id < (*node)->inadequacyNode->id) 107 cmp = 1; 108 else if ((*node)->inadequacyNode->id < self->inadequacyNode->id) 109 cmp = -1; 110 else 111 for (ci = 0; 112 cmp == 0 && ci < self->inadequacyNode->contributionCount; 113 ++ci) 114 { 115 if (AnnotationList__isContributionAlways (self, ci)) 116 { 117 if (!AnnotationList__isContributionAlways (*node, ci)) 118 cmp = -1; 119 } 120 else if (AnnotationList__isContributionAlways (*node, ci)) 121 cmp = 1; 122 else 123 { 124 size_t item; 125 for (item = 0; cmp == 0 && item < nitems; ++item) 126 { 127 if (!Sbitset__test (self->contributions[ci], item)) 128 { 129 if (Sbitset__test ((*node)->contributions[ci], item)) 130 cmp = -1; 131 } 132 else if (!Sbitset__test ((*node)->contributions[ci], item)) 133 cmp = 1; 134 } 135 } 136 } 137 if (cmp < 0) 138 { 139 self->next = *node; 140 *node = self; 141 break; 142 } 143 else if (cmp == 0) 144 { 145 self = NULL; 146 break; 147 } 148 } 149 if (!*node) 150 *node = self; 151 return self != NULL; 152 } 153 154 static bitset 155 AnnotationList__compute_shift_tokens (transitions *trans) 156 { 157 bitset shift_tokens = bitset_create (ntokens, BITSET_FIXED); 158 int i; 159 FOR_EACH_SHIFT (trans, i) 160 bitset_set (shift_tokens, TRANSITION_SYMBOL (trans, i)); 161 return shift_tokens; 162 } 163 164 static bitset 165 AnnotationList__compute_conflicted_tokens (bitset shift_tokens, 166 reductions *reds) 167 { 168 bitset conflicted_tokens = bitset_create (ntokens, BITSET_FIXED); 169 bitset conflicted_tokens_rule = bitset_create (ntokens, BITSET_FIXED); 170 bitset tokens = bitset_create (ntokens, BITSET_FIXED); 171 int i; 172 173 bitset_copy (tokens, shift_tokens); 174 for (i = 0; i < reds->num; ++i) 175 { 176 bitset_and (conflicted_tokens_rule, tokens, reds->lookahead_tokens[i]); 177 bitset_or (conflicted_tokens, 178 conflicted_tokens, conflicted_tokens_rule); 179 bitset_or (tokens, tokens, reds->lookahead_tokens[i]); 180 /* Check that rules are sorted on rule number or the next step in 181 AnnotationList__compute_from_inadequacies will misbehave. */ 182 aver (i == 0 || reds->rules[i-1] < reds->rules[i]); 183 } 184 185 bitset_free (tokens); 186 bitset_free (conflicted_tokens_rule); 187 188 return conflicted_tokens; 189 } 190 191 static bool 192 AnnotationList__compute_lhs_contributions (state *s, rule *the_rule, 193 symbol_number conflicted_token, 194 bitsetv follow_kernel_items, 195 bitsetv always_follows, 196 state ***predecessors, 197 bitset **item_lookahead_sets, 198 Sbitset *items, 199 struct obstack 200 *annotations_obstackp) 201 { 202 goto_number lhs_goto = map_goto (s->number, the_rule->lhs->number); 203 if (bitset_test (always_follows[lhs_goto], conflicted_token)) 204 return true; 205 *items = Sbitset__new_on_obstack (s->nitems, annotations_obstackp); 206 { 207 bitset_iterator biter_item; 208 bitset_bindex item; 209 BITSET_FOR_EACH (biter_item, follow_kernel_items[lhs_goto], item, 0) 210 if (ielr_item_has_lookahead (s, 0, item, conflicted_token, 211 predecessors, item_lookahead_sets)) 212 Sbitset__set (*items, item); 213 } 214 return false; 215 } 216 217 static void 218 AnnotationList__computePredecessorAnnotations (AnnotationList *self, state *s, 219 bitsetv follow_kernel_items, 220 bitsetv always_follows, 221 state ***predecessors, 222 bitset **item_lookahead_sets, 223 AnnotationList 224 **annotation_lists, 225 AnnotationIndex 226 *annotation_counts, 227 struct obstack 228 *annotations_obstackp) 229 { 230 state **predecessor; 231 for (predecessor = predecessors[s->number]; *predecessor; ++predecessor) 232 { 233 AnnotationList *annotation_node = 234 AnnotationList__alloc_on_obstack ( 235 self->inadequacyNode->contributionCount, annotations_obstackp); 236 annotation_node->inadequacyNode = self->inadequacyNode; 237 bool potential_contribution = false; 238 bitset *lookaheads = NULL; 239 { 240 ContributionIndex ci; 241 for (ci = 0; ci < self->inadequacyNode->contributionCount; ++ci) 242 { 243 symbol_number contribution_token = 244 InadequacyList__getContributionToken (self->inadequacyNode, ci) 245 ->number; 246 if (AnnotationList__isContributionAlways (self, ci)) 247 { 248 annotation_node->contributions[ci] = NULL; 249 continue; 250 } 251 annotation_node->contributions[ci] = 252 Sbitset__new_on_obstack ((*predecessor)->nitems, 253 annotations_obstackp); 254 { 255 size_t predecessor_item = 0; 256 Sbitset sbiter_item; 257 Sbitset__Index self_item; 258 SBITSET__FOR_EACH (self->contributions[ci], s->nitems, 259 sbiter_item, self_item) 260 { 261 /* If this kernel item is the beginning of a RHS, it must be 262 the kernel item in the start state, and so it has an empty 263 lookahead set. Thus, it can't contribute to inadequacies, 264 and so it should never have been identified as a 265 contribution. If, instead, this kernel item is the 266 successor of the start state's kernel item, the lookahead 267 set is still empty, and so it also should never have been 268 identified as a contribution. This situation is fortunate 269 because we want to avoid the - 2 below in both cases. */ 270 aver (s->items[self_item] > 1); 271 /* If this kernel item is next to the beginning of the RHS, 272 then check all of the predecessor's goto follows for the 273 LHS. */ 274 if (item_number_is_rule_number (ritem[s->items[self_item] 275 - 2])) 276 { 277 Sbitset items; 278 unsigned int rulei; 279 for (rulei = s->items[self_item]; 280 !item_number_is_rule_number (ritem[rulei]); 281 ++rulei) 282 ; 283 if (AnnotationList__compute_lhs_contributions ( 284 *predecessor, 285 &rules[item_number_as_rule_number (ritem[rulei])], 286 contribution_token, 287 follow_kernel_items, always_follows, predecessors, 288 item_lookahead_sets, &items, annotations_obstackp)) 289 { 290 obstack_free (annotations_obstackp, 291 annotation_node->contributions[ci]); 292 annotation_node->contributions[ci] = NULL; 293 break; 294 } 295 else 296 { 297 Sbitset__or (annotation_node->contributions[ci], 298 annotation_node->contributions[ci], 299 items, (*predecessor)->nitems); 300 obstack_free (annotations_obstackp, items); 301 } 302 } 303 /* If this kernel item is later in the RHS, then check the 304 predecessor item's lookahead set. */ 305 else 306 { 307 /* We don't have to start the predecessor item search at 308 the beginning every time because items from both 309 states are sorted by their indices in ritem. */ 310 for (; 311 predecessor_item < (*predecessor)->nitems; 312 ++predecessor_item) 313 if ((*predecessor)->items[predecessor_item] 314 == s->items[self_item] - 1) 315 break; 316 aver (predecessor_item != (*predecessor)->nitems); 317 if (ielr_item_has_lookahead (*predecessor, 0, 318 predecessor_item, 319 contribution_token, 320 predecessors, 321 item_lookahead_sets)) 322 Sbitset__set (annotation_node->contributions[ci], 323 predecessor_item); 324 } 325 } 326 } 327 if (annotation_node->contributions[ci]) 328 { 329 Sbitset biter; 330 Sbitset__Index i; 331 SBITSET__FOR_EACH (annotation_node->contributions[ci], 332 (*predecessor)->nitems, biter, i) 333 { 334 potential_contribution = true; 335 if (!lookaheads) 336 { 337 size_t j; 338 lookaheads = xnmalloc ((*predecessor)->nitems, 339 sizeof *lookaheads); 340 for (j = 0; j < (*predecessor)->nitems; ++j) 341 lookaheads[j] = NULL; 342 } 343 if (!lookaheads[i]) 344 lookaheads[i] = bitset_create (ntokens, BITSET_FIXED); 345 bitset_set (lookaheads[i], contribution_token); 346 } 347 } 348 } 349 } 350 351 /* If the predecessor has any contributions besides just "always" and 352 "never" contributions: 353 - If the dominant contribution is split-stable, the annotation could 354 not affect merging on this predecessor state or its eventual 355 predecessor states. Moreover, all contributions that affect 356 whether the dominant contribution remains dominant must be "always" 357 or "never" contributions in order for the dominant contribution to 358 be split-stable. Thus, the dominant contribution computation result 359 in eventual successor states will not be affected by lookaheads 360 tracked for this predecessor state. (Also, as in the isocore 361 compatibility test, we depend on the fact that isocores with equal 362 dominant contributions will have the same dominant contribution when 363 merged. Otherwise, we might have to worry that the presence of a 364 potential contribution might somehow be the culprit of that behavior 365 and thus need to be tracked regardless of the split stability of the 366 dominant contribution.) Thus, go ahead and discard the annotation 367 to save space now plus time during state splitting. 368 - Otherwise, record the annotation, and compute any resulting 369 annotations needed on predecessor states. */ 370 if (potential_contribution) 371 { 372 if (ContributionIndex__none 373 != AnnotationList__computeDominantContribution ( 374 annotation_node, (*predecessor)->nitems, lookaheads, true)) 375 { 376 obstack_free (annotations_obstackp, annotation_node); 377 annotation_node = NULL; 378 } 379 { 380 size_t i; 381 for (i = 0; i < (*predecessor)->nitems; ++i) 382 if (lookaheads[i]) 383 bitset_free (lookaheads[i]); 384 free (lookaheads); 385 } 386 if (annotation_node) 387 { 388 if (AnnotationList__insertInto (annotation_node, 389 &annotation_lists[(*predecessor) 390 ->number], 391 (*predecessor)->nitems)) 392 { 393 ++annotation_counts[(*predecessor)->number]; 394 AnnotationList__computePredecessorAnnotations ( 395 annotation_node, *predecessor, 396 follow_kernel_items, always_follows, predecessors, 397 item_lookahead_sets, annotation_lists, annotation_counts, 398 annotations_obstackp); 399 } 400 else 401 obstack_free (annotations_obstackp, annotation_node); 402 } 403 } 404 else 405 obstack_free (annotations_obstackp, annotation_node); 406 } 407 } 408 409 void 410 AnnotationList__compute_from_inadequacies ( 411 state *s, bitsetv follow_kernel_items, bitsetv always_follows, 412 state ***predecessors, bitset **item_lookahead_sets, 413 InadequacyList **inadequacy_lists, AnnotationList **annotation_lists, 414 AnnotationIndex *annotation_counts, 415 ContributionIndex *max_contributionsp, 416 struct obstack *annotations_obstackp, 417 InadequacyListNodeCount *inadequacy_list_node_count) 418 { 419 bitsetv all_lookaheads; 420 bitset shift_tokens; 421 bitset conflicted_tokens; 422 bitset_iterator biter_conflict; 423 bitset_bindex conflicted_token; 424 425 /* Return an empty list if s->lookahead_tokens = NULL. */ 426 if (s->consistent) 427 return; 428 429 all_lookaheads = bitsetv_create (s->nitems, ntokens, BITSET_FIXED); 430 bitsetv_ones (all_lookaheads); 431 shift_tokens = AnnotationList__compute_shift_tokens (s->transitions); 432 conflicted_tokens = 433 AnnotationList__compute_conflicted_tokens (shift_tokens, s->reductions); 434 435 /* Add an inadequacy annotation for each conflicted_token. */ 436 BITSET_FOR_EACH (biter_conflict, conflicted_tokens, conflicted_token, 0) 437 { 438 AnnotationList *annotation_node; 439 /* FIXME: Would a BITSET_FRUGAL or BITEST_SPARSE be more efficient? Now 440 or convert it inside InadequacyList__new_conflict? */ 441 bitset actions = bitset_create (s->reductions->num + 1, BITSET_FIXED); 442 ContributionIndex contribution_count = 0; 443 bool potential_contribution = false; 444 445 /* Allocate the annotation node. */ 446 { 447 int rule_i; 448 for (rule_i = 0; rule_i < s->reductions->num; ++rule_i) 449 if (bitset_test (s->reductions->lookahead_tokens[rule_i], 450 conflicted_token)) 451 ++contribution_count; 452 if (bitset_test (shift_tokens, conflicted_token)) 453 ++contribution_count; 454 annotation_node = 455 AnnotationList__alloc_on_obstack (contribution_count, 456 annotations_obstackp); 457 } 458 459 /* Add a contribution for each reduction that has conflicted_token as a 460 lookahead. */ 461 { 462 ContributionIndex ci = 0; 463 int item_i = 0; 464 int rule_i; 465 for (rule_i = 0; rule_i < s->reductions->num; ++rule_i) 466 { 467 rule *the_rule = s->reductions->rules[rule_i]; 468 if (bitset_test (s->reductions->lookahead_tokens[rule_i], 469 conflicted_token)) 470 { 471 bitset_set (actions, rule_i); 472 /* If this reduction is on a kernel item, just add it. */ 473 if (!item_number_is_rule_number (the_rule->rhs[0])) 474 { 475 annotation_node->contributions[ci] = 476 Sbitset__new_on_obstack (s->nitems, 477 annotations_obstackp); 478 /* Catch item_i up to rule_i. This works because both are 479 sorted on rule number. */ 480 while (!item_number_is_rule_number ( 481 ritem[s->items[item_i]]) 482 || item_number_as_rule_number ( 483 ritem[s->items[item_i]]) 484 != the_rule->number) 485 { 486 ++item_i; 487 aver (item_i < s->nitems); 488 } 489 Sbitset__set (annotation_node->contributions[ci], item_i); 490 } 491 /* Otherwise, add the kernel items whose lookahead sets 492 contribute the conflicted token to this reduction's 493 lookahead set. */ 494 else if (AnnotationList__compute_lhs_contributions ( 495 s, the_rule, conflicted_token, follow_kernel_items, 496 always_follows, predecessors, item_lookahead_sets, 497 &annotation_node->contributions[ci], 498 annotations_obstackp)) 499 { 500 annotation_node->contributions[ci++] = NULL; 501 continue; 502 } 503 /* The lookahead token has to come from somewhere. */ 504 aver (!Sbitset__isEmpty (annotation_node->contributions[ci], 505 s->nitems)); 506 ++ci; 507 potential_contribution = true; 508 } 509 } 510 } 511 512 /* If there are any contributions besides just "always" contributions: 513 - If there's also a shift contribution, record it. 514 - If the dominant contribution is split-stable, then the annotation 515 could not affect merging, so go ahead and discard the annotation and 516 the inadequacy to save space now plus time during state splitting. 517 - Otherwise, record the annotation and the inadequacy, and compute any 518 resulting annotations needed on predecessor states. */ 519 if (potential_contribution) 520 { 521 if (bitset_test (shift_tokens, conflicted_token)) 522 { 523 bitset_set (actions, s->reductions->num); 524 annotation_node->contributions[contribution_count - 1] = NULL; 525 } 526 { 527 InadequacyList *conflict_node = 528 InadequacyList__new_conflict ( 529 s, symbols[conflicted_token], actions, 530 inadequacy_list_node_count); 531 actions = NULL; 532 annotation_node->inadequacyNode = conflict_node; 533 if (ContributionIndex__none 534 != AnnotationList__computeDominantContribution ( 535 annotation_node, s->nitems, all_lookaheads, true)) 536 { 537 obstack_free (annotations_obstackp, annotation_node); 538 InadequacyList__delete (conflict_node); 539 } 540 else 541 { 542 InadequacyList__prependTo (conflict_node, 543 &inadequacy_lists[s->number]); 544 aver (AnnotationList__insertInto ( 545 annotation_node, &annotation_lists[s->number], 546 s->nitems)); 547 /* This aver makes sure the 548 AnnotationList__computeDominantContribution check above 549 does discard annotations in the simplest case of a S/R 550 conflict with no token precedence. */ 551 aver (!bitset_test (shift_tokens, conflicted_token) 552 || symbols[conflicted_token]->prec); 553 ++annotation_counts[s->number]; 554 if (contribution_count > *max_contributionsp) 555 *max_contributionsp = contribution_count; 556 AnnotationList__computePredecessorAnnotations ( 557 annotation_node, s, 558 follow_kernel_items, always_follows, predecessors, 559 item_lookahead_sets, annotation_lists, annotation_counts, 560 annotations_obstackp); 561 } 562 } 563 } 564 else 565 { 566 bitset_free (actions); 567 obstack_free (annotations_obstackp, annotation_node); 568 } 569 } 570 571 bitsetv_free (all_lookaheads); 572 bitset_free (shift_tokens); 573 bitset_free (conflicted_tokens); 574 } 575 576 void 577 AnnotationList__debug (AnnotationList const *self, size_t nitems, int spaces) 578 { 579 AnnotationList const *a; 580 AnnotationIndex ai; 581 for (a = self, ai = 0; a; a = a->next, ++ai) 582 { 583 { 584 int j; 585 for (j = 0; j < spaces; ++j) 586 putc (' ', stderr); 587 } 588 fprintf (stderr, "Annotation %d (manifesting state %d):\n", 589 ai, a->inadequacyNode->manifestingState->number); 590 { 591 ContributionIndex ci; 592 bitset_bindex rulei = 0; /* init suppresses compiler warning */ 593 rulei = bitset_first (a->inadequacyNode->inadequacy.conflict.actions); 594 for (ci = 0; ci < a->inadequacyNode->contributionCount; ++ci) 595 { 596 symbol_number token = 597 InadequacyList__getContributionToken (a->inadequacyNode, ci) 598 ->number; 599 { 600 int j; 601 for (j = 0; j < spaces+2; ++j) 602 putc (' ', stderr); 603 } 604 if (ci == InadequacyList__getShiftContributionIndex ( 605 a->inadequacyNode)) 606 fprintf (stderr, "Contributes shift of token %d.\n", token); 607 else 608 { 609 fprintf (stderr, "Contributes token %d", token); 610 aver (rulei != BITSET_BINDEX_MAX); 611 fprintf (stderr, " as lookahead, rule number %d", 612 a->inadequacyNode->manifestingState 613 ->reductions->rules[rulei]->number); 614 rulei = 615 bitset_next (a->inadequacyNode->inadequacy.conflict.actions, 616 rulei+1); 617 if (AnnotationList__isContributionAlways (a, ci)) 618 fprintf (stderr, " always."); 619 else 620 { 621 fprintf (stderr, ", items: "); 622 Sbitset__fprint (a->contributions[ci], nitems, stderr); 623 } 624 fprintf (stderr, "\n"); 625 } 626 } 627 } 628 } 629 } 630 631 void 632 AnnotationList__computeLookaheadFilter (AnnotationList const *self, 633 size_t nitems, 634 bitsetv lookahead_filter) 635 { 636 bitsetv_zero (lookahead_filter); 637 for (; self; self = self->next) 638 { 639 ContributionIndex ci; 640 for (ci = 0; ci < self->inadequacyNode->contributionCount; ++ci) 641 if (!AnnotationList__isContributionAlways (self, ci)) 642 { 643 Sbitset__Index item; 644 Sbitset biter; 645 symbol_number token = 646 InadequacyList__getContributionToken (self->inadequacyNode, ci) 647 ->number; 648 SBITSET__FOR_EACH (self->contributions[ci], nitems, biter, item) 649 bitset_set (lookahead_filter[item], token); 650 } 651 } 652 } 653 654 /** 655 * \pre 656 * - <tt>self != NULL</tt>. 657 * - \c nitems is the number of kernel items in the LR(0) state that \c self 658 * annotates. 659 * - \c lookaheads describes the lookahead sets on the kernel items of some 660 * isocore of the LR(0) state that \c self annotates. Either: 661 * - <tt>lookaheads = NULL</tt> only if the lookahead set on every kernel 662 * item is empty. 663 * - For any <tt>0 <= i < nitems</tt>, <tt>lookaheads[i]</tt> is either: 664 * - \c NULL only if the lookahead set on kernel item \c i is empty. 665 * - The (possibly empty) lookahead set on kernel item \c i. 666 * - <tt>0 <= ci < self->inadequacyNode->contributionCount</tt>. 667 * \post 668 * - \c result = true iff contribution \c ci in \c self is made by the state 669 * described by \c lookaheads. 670 */ 671 static bool 672 AnnotationList__stateMakesContribution (AnnotationList const *self, 673 size_t nitems, ContributionIndex ci, 674 bitset *lookaheads) 675 { 676 if (AnnotationList__isContributionAlways (self, ci)) 677 return true; 678 if (!lookaheads) 679 return false; 680 { 681 symbol_number token = 682 InadequacyList__getContributionToken (self->inadequacyNode, ci)->number; 683 Sbitset__Index item; 684 Sbitset biter; 685 SBITSET__FOR_EACH (self->contributions[ci], nitems, biter, item) 686 if (lookaheads[item] && bitset_test (lookaheads[item], token)) 687 return true; 688 } 689 return false; 690 } 691 692 ContributionIndex 693 AnnotationList__computeDominantContribution (AnnotationList const *self, 694 size_t nitems, bitset *lookaheads, 695 bool require_split_stable) 696 { 697 symbol *token; 698 ContributionIndex const ci_shift = 699 InadequacyList__getShiftContributionIndex (self->inadequacyNode); 700 701 token = self->inadequacyNode->inadequacy.conflict.token; 702 703 /* S/R conflict. */ 704 if (ci_shift != ContributionIndex__none) 705 { 706 bool find_stable_domination_over_shift = false; 707 bool find_stable_error_action_domination = false; 708 { 709 ContributionIndex ci; 710 int actioni; 711 ContributionIndex ci_rr_dominator = ContributionIndex__none; 712 int shift_precedence = token->prec; 713 714 /* If the token has no precedence set, shift is always chosen. */ 715 if (!shift_precedence) 716 return ci_shift; 717 718 /* Figure out which reductions contribute, which of those would 719 dominate in a R/R comparison, and whether any reduction dominates 720 the shift so that the R/R comparison is actually needed. */ 721 for (ci = 0, actioni = bitset_first (self->inadequacyNode->inadequacy 722 .conflict.actions); 723 ci < self->inadequacyNode->contributionCount; 724 ++ci, actioni = bitset_next (self->inadequacyNode->inadequacy 725 .conflict.actions, actioni+1)) 726 { 727 int reduce_precedence = 0; 728 if (ci == ci_shift) 729 continue; 730 { 731 rule *r = self->inadequacyNode->manifestingState 732 ->reductions->rules[actioni]; 733 if (r->prec) 734 reduce_precedence = r->prec->prec; 735 } 736 /* If there's no need to check whether this reduction actually 737 contributes because the shift eliminates it from the R/R 738 comparison anyway, continue to the next reduction. */ 739 if (reduce_precedence 740 && (reduce_precedence < shift_precedence 741 || (reduce_precedence == shift_precedence 742 && token->assoc == right_assoc))) 743 continue; 744 if (!AnnotationList__stateMakesContribution (self, nitems, ci, 745 lookaheads)) 746 continue; 747 /* This uneliminated reduction contributes, so see if it can cause 748 an error action. */ 749 if (reduce_precedence == shift_precedence 750 && token->assoc == non_assoc) 751 { 752 /* It's not possible to find split-stable domination over 753 shift after a potential %nonassoc. */ 754 if (find_stable_domination_over_shift) 755 return ContributionIndex__none; 756 if (!require_split_stable 757 || AnnotationList__isContributionAlways (self, ci)) 758 return ContributionIndex__error_action; 759 find_stable_error_action_domination = true; 760 } 761 /* Consider this uneliminated contributing reduction in the R/R 762 comparison. */ 763 if (ci_rr_dominator == ContributionIndex__none) 764 ci_rr_dominator = ci; 765 /* If precedence is set for this uneliminated contributing 766 reduction, it dominates the shift, so try to figure out which 767 reduction dominates the R/R comparison. */ 768 if (reduce_precedence) 769 { 770 /* It's not possible to find split-stable error action 771 domination after a potential reduction. */ 772 if (find_stable_error_action_domination) 773 return ContributionIndex__none; 774 if (!require_split_stable) 775 return ci_rr_dominator; 776 if (!AnnotationList__isContributionAlways (self, 777 ci_rr_dominator)) 778 return ContributionIndex__none; 779 if (AnnotationList__isContributionAlways (self, ci)) 780 return ci_rr_dominator; 781 find_stable_domination_over_shift = true; 782 } 783 } 784 } 785 if (find_stable_domination_over_shift 786 || find_stable_error_action_domination) 787 return ContributionIndex__none; 788 /* No reduce or error action domination found, so shift dominates. */ 789 return ci_shift; 790 } 791 792 /* R/R conflict, so the reduction with the lowest rule number dominates. 793 Fortunately, contributions are sorted by rule number. */ 794 { 795 ContributionIndex ci; 796 for (ci = 0; ci < self->inadequacyNode->contributionCount; ++ci) 797 if (AnnotationList__stateMakesContribution (self, nitems, ci, 798 lookaheads)) 799 { 800 if (require_split_stable 801 && !AnnotationList__isContributionAlways (self, ci)) 802 return ContributionIndex__none; 803 return ci; 804 } 805 } 806 return ContributionIndex__none; 807 } 808
