1 /* Output the generated parsing program for Bison. 2 3 Copyright (C) 1984, 1986, 1989, 1992, 2000-2006, 2009-2012 Free 4 Software Foundation, Inc. 5 6 This file is part of Bison, the GNU Compiler Compiler. 7 8 This program is free software: you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation, either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21 #include <config.h> 22 #include "system.h" 23 24 #include <bitsetv.h> 25 26 #include "complain.h" 27 #include "conflicts.h" 28 #include "files.h" 29 #include "getargs.h" 30 #include "gram.h" 31 #include "lalr.h" 32 #include "muscle-tab.h" 33 #include "reader.h" 34 #include "symtab.h" 35 #include "tables.h" 36 37 /* Several tables are indexed both by state and nonterminal numbers. 38 We call such an index a `vector'; i.e., a vector is either a state 39 or a nonterminal number. 40 41 Of course vector_number_t ought to be wide enough to contain 42 state_number and symbol_number. */ 43 typedef int vector_number; 44 45 #if 0 /* Not currently used. */ 46 static inline vector_number 47 state_number_to_vector_number (state_number s) 48 { 49 return s; 50 } 51 #endif 52 53 static inline vector_number 54 symbol_number_to_vector_number (symbol_number sym) 55 { 56 return state_number_as_int (nstates) + sym - ntokens; 57 } 58 59 int nvectors; 60 61 62 /* FROMS and TOS are indexed by vector_number. 63 64 If VECTOR is a nonterminal, (FROMS[VECTOR], TOS[VECTOR]) form an 65 array of state numbers of the non defaulted GOTO on VECTOR. 66 67 If VECTOR is a state, TOS[VECTOR] is the array of actions to do on 68 the (array of) symbols FROMS[VECTOR]. 69 70 In both cases, TALLY[VECTOR] is the size of the arrays 71 FROMS[VECTOR], TOS[VECTOR]; and WIDTH[VECTOR] = 72 (FROMS[VECTOR][SIZE] - FROMS[VECTOR][0] + 1) where SIZE = 73 TALLY[VECTOR]. 74 75 FROMS therefore contains symbol_number and action_number, 76 TOS state_number and action_number, 77 TALLY sizes, 78 WIDTH differences of FROMS. 79 80 Let base_number be the type of FROMS, TOS, and WIDTH. */ 81 #define BASE_MAXIMUM INT_MAX 82 #define BASE_MINIMUM INT_MIN 83 84 static base_number **froms; 85 static base_number **tos; 86 static unsigned int **conflict_tos; 87 static int *tally; 88 static base_number *width; 89 90 91 /* For a given state, N = ACTROW[SYMBOL]: 92 93 If N = 0, stands for `run the default action'. 94 If N = MIN, stands for `raise a syntax error'. 95 If N > 0, stands for `shift SYMBOL and go to n'. 96 If N < 0, stands for `reduce -N'. */ 97 typedef int action_number; 98 #define ACTION_NUMBER_MINIMUM INT_MIN 99 100 static action_number *actrow; 101 102 /* FROMS and TOS are reordered to be compressed. ORDER[VECTOR] is the 103 new vector number of VECTOR. We skip `empty' vectors (i.e., 104 TALLY[VECTOR] = 0), and call these `entries'. */ 105 static vector_number *order; 106 static int nentries; 107 108 base_number *base = NULL; 109 /* A distinguished value of BASE, negative infinite. During the 110 computation equals to BASE_MINIMUM, later mapped to BASE_NINF to 111 keep parser tables small. */ 112 base_number base_ninf = 0; 113 static base_number *pos = NULL; 114 115 static unsigned int *conflrow; 116 unsigned int *conflict_table; 117 unsigned int *conflict_list; 118 int conflict_list_cnt; 119 static int conflict_list_free; 120 121 /* TABLE_SIZE is the allocated size of both TABLE and CHECK. We start 122 with more or less the original hard-coded value (which was 123 SHRT_MAX). */ 124 static int table_size = 32768; 125 base_number *table; 126 base_number *check; 127 /* The value used in TABLE to denote explicit syntax errors 128 (%nonassoc), a negative infinite. First defaults to ACTION_NUMBER_MINIMUM, 129 but in order to keep small tables, renumbered as TABLE_ERROR, which 130 is the smallest (non error) value minus 1. */ 131 base_number table_ninf = 0; 132 static int lowzero; 133 int high; 134 135 state_number *yydefgoto; 136 rule_number *yydefact; 137 138 /*----------------------------------------------------------------. 139 | If TABLE (and CHECK) appear to be small to be addressed at | 140 | DESIRED, grow them. Note that TABLE[DESIRED] is to be used, so | 141 | the desired size is at least DESIRED + 1. | 142 `----------------------------------------------------------------*/ 143 144 static void 145 table_grow (int desired) 146 { 147 int old_size = table_size; 148 149 while (table_size <= desired) 150 table_size *= 2; 151 152 if (trace_flag & trace_resource) 153 fprintf (stderr, "growing table and check from: %d to %d\n", 154 old_size, table_size); 155 156 table = xnrealloc (table, table_size, sizeof *table); 157 conflict_table = xnrealloc (conflict_table, table_size, 158 sizeof *conflict_table); 159 check = xnrealloc (check, table_size, sizeof *check); 160 161 for (/* Nothing. */; old_size < table_size; ++old_size) 162 { 163 table[old_size] = 0; 164 conflict_table[old_size] = 0; 165 check[old_size] = -1; 166 } 167 } 168 169 170 171 172 /*-------------------------------------------------------------------. 173 | For GLR parsers, for each conflicted token in S, as indicated | 174 | by non-zero entries in CONFLROW, create a list of possible | 175 | reductions that are alternatives to the shift or reduction | 176 | currently recorded for that token in S. Store the alternative | 177 | reductions followed by a 0 in CONFLICT_LIST, updating | 178 | CONFLICT_LIST_CNT, and storing an index to the start of the list | 179 | back into CONFLROW. | 180 `-------------------------------------------------------------------*/ 181 182 static void 183 conflict_row (state *s) 184 { 185 int i, j; 186 reductions *reds = s->reductions; 187 188 if (!nondeterministic_parser) 189 return; 190 191 for (j = 0; j < ntokens; j += 1) 192 if (conflrow[j]) 193 { 194 conflrow[j] = conflict_list_cnt; 195 196 /* Find all reductions for token J, and record all that do not 197 match ACTROW[J]. */ 198 for (i = 0; i < reds->num; i += 1) 199 if (bitset_test (reds->lookahead_tokens[i], j) 200 && (actrow[j] 201 != rule_number_as_item_number (reds->rules[i]->number))) 202 { 203 aver (0 < conflict_list_free); 204 conflict_list[conflict_list_cnt] = reds->rules[i]->number + 1; 205 conflict_list_cnt += 1; 206 conflict_list_free -= 1; 207 } 208 209 /* Leave a 0 at the end. */ 210 aver (0 < conflict_list_free); 211 conflict_list[conflict_list_cnt] = 0; 212 conflict_list_cnt += 1; 213 conflict_list_free -= 1; 214 } 215 } 216 217 218 /*------------------------------------------------------------------. 219 | Decide what to do for each type of token if seen as the | 220 | lookahead in specified state. The value returned is used as the | 221 | default action (yydefact) for the state. In addition, ACTROW is | 222 | filled with what to do for each kind of token, index by symbol | 223 | number, with zero meaning do the default action. The value | 224 | ACTION_NUMBER_MINIMUM, a very negative number, means this | 225 | situation is an error. The parser recognizes this value | 226 | specially. | 227 | | 228 | This is where conflicts are resolved. The loop over lookahead | 229 | rules considered lower-numbered rules last, and the last rule | 230 | considered that likes a token gets to handle it. | 231 | | 232 | For GLR parsers, also sets CONFLROW[SYM] to an index into | 233 | CONFLICT_LIST iff there is an unresolved conflict (s/r or r/r) | 234 | with symbol SYM. The default reduction is not used for a symbol | 235 | that has any such conflicts. | 236 `------------------------------------------------------------------*/ 237 238 static rule * 239 action_row (state *s) 240 { 241 int i; 242 rule *default_reduction = NULL; 243 reductions *reds = s->reductions; 244 transitions *trans = s->transitions; 245 errs *errp = s->errs; 246 /* Set to nonzero to inhibit having any default reduction. */ 247 bool nodefault = false; 248 bool conflicted = false; 249 250 for (i = 0; i < ntokens; i++) 251 actrow[i] = conflrow[i] = 0; 252 253 if (reds->lookahead_tokens) 254 { 255 int j; 256 bitset_iterator biter; 257 /* loop over all the rules available here which require 258 lookahead (in reverse order to give precedence to the first 259 rule) */ 260 for (i = reds->num - 1; i >= 0; --i) 261 /* and find each token which the rule finds acceptable 262 to come next */ 263 BITSET_FOR_EACH (biter, reds->lookahead_tokens[i], j, 0) 264 { 265 /* and record this rule as the rule to use if that 266 token follows. */ 267 if (actrow[j] != 0) 268 { 269 conflicted = true; 270 conflrow[j] = 1; 271 } 272 actrow[j] = rule_number_as_item_number (reds->rules[i]->number); 273 } 274 } 275 276 /* Now see which tokens are allowed for shifts in this state. For 277 them, record the shift as the thing to do. So shift is preferred 278 to reduce. */ 279 FOR_EACH_SHIFT (trans, i) 280 { 281 symbol_number sym = TRANSITION_SYMBOL (trans, i); 282 state *shift_state = trans->states[i]; 283 284 if (actrow[sym] != 0) 285 { 286 conflicted = true; 287 conflrow[sym] = 1; 288 } 289 actrow[sym] = state_number_as_int (shift_state->number); 290 291 /* Do not use any default reduction if there is a shift for 292 error */ 293 if (sym == errtoken->number) 294 nodefault = true; 295 } 296 297 /* See which tokens are an explicit error in this state (due to 298 %nonassoc). For them, record ACTION_NUMBER_MINIMUM as the 299 action. */ 300 for (i = 0; i < errp->num; i++) 301 { 302 symbol *sym = errp->symbols[i]; 303 actrow[sym->number] = ACTION_NUMBER_MINIMUM; 304 } 305 306 /* Turn off default reductions where requested by the user. See 307 state_lookahead_tokens_count in lalr.c to understand when states are 308 labeled as consistent. */ 309 { 310 char *default_reductions = 311 muscle_percent_define_get ("lr.default-reductions"); 312 if (0 != strcmp (default_reductions, "most") && !s->consistent) 313 nodefault = true; 314 free (default_reductions); 315 } 316 317 /* Now find the most common reduction and make it the default action 318 for this state. */ 319 320 if (reds->num >= 1 && !nodefault) 321 { 322 if (s->consistent) 323 default_reduction = reds->rules[0]; 324 else 325 { 326 int max = 0; 327 for (i = 0; i < reds->num; i++) 328 { 329 int count = 0; 330 rule *r = reds->rules[i]; 331 symbol_number j; 332 333 for (j = 0; j < ntokens; j++) 334 if (actrow[j] == rule_number_as_item_number (r->number)) 335 count++; 336 337 if (count > max) 338 { 339 max = count; 340 default_reduction = r; 341 } 342 } 343 344 /* GLR parsers need space for conflict lists, so we can't 345 default conflicted entries. For non-conflicted entries 346 or as long as we are not building a GLR parser, 347 actions that match the default are replaced with zero, 348 which means "use the default". */ 349 350 if (max > 0) 351 { 352 int j; 353 for (j = 0; j < ntokens; j++) 354 if (actrow[j] 355 == rule_number_as_item_number (default_reduction->number) 356 && ! (nondeterministic_parser && conflrow[j])) 357 actrow[j] = 0; 358 } 359 } 360 } 361 362 /* If have no default reduction, the default is an error. 363 So replace any action which says "error" with "use default". */ 364 365 if (!default_reduction) 366 for (i = 0; i < ntokens; i++) 367 if (actrow[i] == ACTION_NUMBER_MINIMUM) 368 actrow[i] = 0; 369 370 if (conflicted) 371 conflict_row (s); 372 373 return default_reduction; 374 } 375 376 377 /*----------------------------------------. 378 | Set FROMS, TOS, TALLY and WIDTH for S. | 379 `----------------------------------------*/ 380 381 static void 382 save_row (state_number s) 383 { 384 symbol_number i; 385 int count; 386 base_number *sp; 387 base_number *sp1; 388 base_number *sp2; 389 unsigned int *sp3; 390 391 /* Number of non default actions in S. */ 392 count = 0; 393 for (i = 0; i < ntokens; i++) 394 if (actrow[i] != 0) 395 count++; 396 397 if (count == 0) 398 return; 399 400 /* Allocate non defaulted actions. */ 401 froms[s] = sp = sp1 = xnmalloc (count, sizeof *sp1); 402 tos[s] = sp2 = xnmalloc (count, sizeof *sp2); 403 conflict_tos[s] = sp3 = 404 nondeterministic_parser ? xnmalloc (count, sizeof *sp3) : NULL; 405 406 /* Store non defaulted actions. */ 407 for (i = 0; i < ntokens; i++) 408 if (actrow[i] != 0) 409 { 410 *sp1++ = i; 411 *sp2++ = actrow[i]; 412 if (nondeterministic_parser) 413 *sp3++ = conflrow[i]; 414 } 415 416 tally[s] = count; 417 width[s] = sp1[-1] - sp[0] + 1; 418 } 419 420 421 /*------------------------------------------------------------------. 422 | Figure out the actions for the specified state, indexed by | 423 | lookahead token type. | 424 | | 425 | The YYDEFACT table is output now. The detailed info is saved for | 426 | putting into YYTABLE later. | 427 `------------------------------------------------------------------*/ 428 429 static void 430 token_actions (void) 431 { 432 state_number i; 433 symbol_number j; 434 rule_number r; 435 436 int nconflict = nondeterministic_parser ? conflicts_total_count () : 0; 437 438 yydefact = xnmalloc (nstates, sizeof *yydefact); 439 440 actrow = xnmalloc (ntokens, sizeof *actrow); 441 conflrow = xnmalloc (ntokens, sizeof *conflrow); 442 443 conflict_list = xnmalloc (1 + 2 * nconflict, sizeof *conflict_list); 444 conflict_list_free = 2 * nconflict; 445 conflict_list_cnt = 1; 446 447 /* Find the rules which are reduced. */ 448 if (!nondeterministic_parser) 449 for (r = 0; r < nrules; ++r) 450 rules[r].useful = false; 451 452 for (i = 0; i < nstates; ++i) 453 { 454 rule *default_reduction = action_row (states[i]); 455 yydefact[i] = default_reduction ? default_reduction->number + 1 : 0; 456 save_row (i); 457 458 /* Now that the parser was computed, we can find which rules are 459 really reduced, and which are not because of SR or RR 460 conflicts. */ 461 if (!nondeterministic_parser) 462 { 463 for (j = 0; j < ntokens; ++j) 464 if (actrow[j] < 0 && actrow[j] != ACTION_NUMBER_MINIMUM) 465 rules[item_number_as_rule_number (actrow[j])].useful = true; 466 if (yydefact[i]) 467 rules[yydefact[i] - 1].useful = true; 468 } 469 } 470 471 free (actrow); 472 free (conflrow); 473 } 474 475 476 /*------------------------------------------------------------------. 477 | Compute FROMS[VECTOR], TOS[VECTOR], TALLY[VECTOR], WIDTH[VECTOR], | 478 | i.e., the information related to non defaulted GOTO on the nterm | 479 | SYM. | 480 | | 481 | DEFAULT_STATE is the principal destination on SYM, i.e., the | 482 | default GOTO destination on SYM. | 483 `------------------------------------------------------------------*/ 484 485 static void 486 save_column (symbol_number sym, state_number default_state) 487 { 488 goto_number i; 489 base_number *sp; 490 base_number *sp1; 491 base_number *sp2; 492 int count; 493 vector_number symno = symbol_number_to_vector_number (sym); 494 495 goto_number begin = goto_map[sym - ntokens]; 496 goto_number end = goto_map[sym - ntokens + 1]; 497 498 /* Number of non default GOTO. */ 499 count = 0; 500 for (i = begin; i < end; i++) 501 if (to_state[i] != default_state) 502 count++; 503 504 if (count == 0) 505 return; 506 507 /* Allocate room for non defaulted gotos. */ 508 froms[symno] = sp = sp1 = xnmalloc (count, sizeof *sp1); 509 tos[symno] = sp2 = xnmalloc (count, sizeof *sp2); 510 511 /* Store the state numbers of the non defaulted gotos. */ 512 for (i = begin; i < end; i++) 513 if (to_state[i] != default_state) 514 { 515 *sp1++ = from_state[i]; 516 *sp2++ = to_state[i]; 517 } 518 519 tally[symno] = count; 520 width[symno] = sp1[-1] - sp[0] + 1; 521 } 522 523 524 /*-------------------------------------------------------------. 525 | Return `the' most common destination GOTO on SYM (a nterm). | 526 `-------------------------------------------------------------*/ 527 528 static state_number 529 default_goto (symbol_number sym, size_t state_count[]) 530 { 531 state_number s; 532 goto_number i; 533 goto_number m = goto_map[sym - ntokens]; 534 goto_number n = goto_map[sym - ntokens + 1]; 535 state_number default_state = -1; 536 size_t max = 0; 537 538 if (m == n) 539 return -1; 540 541 for (s = 0; s < nstates; s++) 542 state_count[s] = 0; 543 544 for (i = m; i < n; i++) 545 state_count[to_state[i]]++; 546 547 for (s = 0; s < nstates; s++) 548 if (state_count[s] > max) 549 { 550 max = state_count[s]; 551 default_state = s; 552 } 553 554 return default_state; 555 } 556 557 558 /*-------------------------------------------------------------------. 559 | Figure out what to do after reducing with each rule, depending on | 560 | the saved state from before the beginning of parsing the data that | 561 | matched this rule. | 562 | | 563 | The YYDEFGOTO table is output now. The detailed info is saved for | 564 | putting into YYTABLE later. | 565 `-------------------------------------------------------------------*/ 566 567 static void 568 goto_actions (void) 569 { 570 symbol_number i; 571 size_t *state_count = xnmalloc (nstates, sizeof *state_count); 572 yydefgoto = xnmalloc (nvars, sizeof *yydefgoto); 573 574 /* For a given nterm I, STATE_COUNT[S] is the number of times there 575 is a GOTO to S on I. */ 576 for (i = ntokens; i < nsyms; ++i) 577 { 578 state_number default_state = default_goto (i, state_count); 579 save_column (i, default_state); 580 yydefgoto[i - ntokens] = default_state; 581 } 582 free (state_count); 583 } 584 585 586 /*------------------------------------------------------------------. 587 | Compute ORDER, a reordering of vectors, in order to decide how to | 588 | pack the actions and gotos information into yytable. | 589 `------------------------------------------------------------------*/ 590 591 static void 592 sort_actions (void) 593 { 594 int i; 595 596 nentries = 0; 597 598 for (i = 0; i < nvectors; i++) 599 if (tally[i] > 0) 600 { 601 int k; 602 int t = tally[i]; 603 int w = width[i]; 604 int j = nentries - 1; 605 606 while (j >= 0 && (width[order[j]] < w)) 607 j--; 608 609 while (j >= 0 && (width[order[j]] == w) && (tally[order[j]] < t)) 610 j--; 611 612 for (k = nentries - 1; k > j; k--) 613 order[k + 1] = order[k]; 614 615 order[j + 1] = i; 616 nentries++; 617 } 618 } 619 620 621 /* If VECTOR is a state which actions (reflected by FROMS, TOS, TALLY 622 and WIDTH of VECTOR) are common to a previous state, return this 623 state number. 624 625 In any other case, return -1. */ 626 627 static state_number 628 matching_state (vector_number vector) 629 { 630 vector_number i = order[vector]; 631 int t; 632 int w; 633 int prev; 634 635 /* If VECTOR is a nterm, return -1. */ 636 if (nstates <= i) 637 return -1; 638 639 t = tally[i]; 640 w = width[i]; 641 642 /* If VECTOR has GLR conflicts, return -1 */ 643 if (conflict_tos[i] != NULL) 644 { 645 int j; 646 for (j = 0; j < t; j += 1) 647 if (conflict_tos[i][j] != 0) 648 return -1; 649 } 650 651 for (prev = vector - 1; prev >= 0; prev--) 652 { 653 vector_number j = order[prev]; 654 int k; 655 int match = 1; 656 657 /* Given how ORDER was computed, if the WIDTH or TALLY is 658 different, there cannot be a matching state. */ 659 if (width[j] != w || tally[j] != t) 660 return -1; 661 662 for (k = 0; match && k < t; k++) 663 if (tos[j][k] != tos[i][k] || froms[j][k] != froms[i][k] 664 || (conflict_tos[j] != NULL && conflict_tos[j][k] != 0)) 665 match = 0; 666 667 if (match) 668 return j; 669 } 670 671 return -1; 672 } 673 674 675 static base_number 676 pack_vector (vector_number vector) 677 { 678 vector_number i = order[vector]; 679 int j; 680 int t = tally[i]; 681 int loc = 0; 682 base_number *from = froms[i]; 683 base_number *to = tos[i]; 684 unsigned int *conflict_to = conflict_tos[i]; 685 686 aver (t != 0); 687 688 for (j = lowzero - from[0]; ; j++) 689 { 690 int k; 691 bool ok = true; 692 693 aver (j < table_size); 694 695 for (k = 0; ok && k < t; k++) 696 { 697 loc = j + state_number_as_int (from[k]); 698 if (table_size <= loc) 699 table_grow (loc); 700 701 if (table[loc] != 0) 702 ok = false; 703 } 704 705 for (k = 0; ok && k < vector; k++) 706 if (pos[k] == j) 707 ok = false; 708 709 if (ok) 710 { 711 for (k = 0; k < t; k++) 712 { 713 loc = j + from[k]; 714 table[loc] = to[k]; 715 if (nondeterministic_parser && conflict_to != NULL) 716 conflict_table[loc] = conflict_to[k]; 717 check[loc] = from[k]; 718 } 719 720 while (table[lowzero] != 0) 721 lowzero++; 722 723 if (loc > high) 724 high = loc; 725 726 aver (BASE_MINIMUM <= j && j <= BASE_MAXIMUM); 727 return j; 728 } 729 } 730 } 731 732 733 /*-------------------------------------------------------------. 734 | Remap the negative infinite in TAB from NINF to the greatest | 735 | possible smallest value. Return it. | 736 | | 737 | In most case this allows us to use shorts instead of ints in | 738 | parsers. | 739 `-------------------------------------------------------------*/ 740 741 static base_number 742 table_ninf_remap (base_number tab[], int size, base_number ninf) 743 { 744 base_number res = 0; 745 int i; 746 747 for (i = 0; i < size; i++) 748 if (tab[i] < res && tab[i] != ninf) 749 res = tab[i]; 750 751 --res; 752 753 for (i = 0; i < size; i++) 754 if (tab[i] == ninf) 755 tab[i] = res; 756 757 return res; 758 } 759 760 static void 761 pack_table (void) 762 { 763 int i; 764 765 base = xnmalloc (nvectors, sizeof *base); 766 pos = xnmalloc (nentries, sizeof *pos); 767 table = xcalloc (table_size, sizeof *table); 768 conflict_table = xcalloc (table_size, sizeof *conflict_table); 769 check = xnmalloc (table_size, sizeof *check); 770 771 lowzero = 0; 772 high = 0; 773 774 for (i = 0; i < nvectors; i++) 775 base[i] = BASE_MINIMUM; 776 777 for (i = 0; i < table_size; i++) 778 check[i] = -1; 779 780 for (i = 0; i < nentries; i++) 781 { 782 state_number s = matching_state (i); 783 base_number place; 784 785 if (s < 0) 786 /* A new set of state actions, or a nonterminal. */ 787 place = pack_vector (i); 788 else 789 /* Action of I were already coded for S. */ 790 place = base[s]; 791 792 pos[i] = place; 793 base[order[i]] = place; 794 } 795 796 /* Use the greatest possible negative infinites. */ 797 base_ninf = table_ninf_remap (base, nvectors, BASE_MINIMUM); 798 table_ninf = table_ninf_remap (table, high + 1, ACTION_NUMBER_MINIMUM); 799 800 free (pos); 801 } 802 803 804 806 /*-----------------------------------------------------------------. 807 | Compute and output yydefact, yydefgoto, yypact, yypgoto, yytable | 808 | and yycheck. | 809 `-----------------------------------------------------------------*/ 810 811 void 812 tables_generate (void) 813 { 814 int i; 815 816 /* This is a poor way to make sure the sizes are properly 817 correlated. In particular the signedness is not taken into 818 account. But it's not useless. */ 819 verify (sizeof nstates <= sizeof nvectors 820 && sizeof nvars <= sizeof nvectors); 821 822 nvectors = state_number_as_int (nstates) + nvars; 823 824 froms = xcalloc (nvectors, sizeof *froms); 825 tos = xcalloc (nvectors, sizeof *tos); 826 conflict_tos = xcalloc (nvectors, sizeof *conflict_tos); 827 tally = xcalloc (nvectors, sizeof *tally); 828 width = xnmalloc (nvectors, sizeof *width); 829 830 token_actions (); 831 832 goto_actions (); 833 free (goto_map); 834 free (from_state); 835 free (to_state); 836 837 order = xcalloc (nvectors, sizeof *order); 838 sort_actions (); 839 pack_table (); 840 free (order); 841 842 free (tally); 843 free (width); 844 845 for (i = 0; i < nvectors; i++) 846 { 847 free (froms[i]); 848 free (tos[i]); 849 free (conflict_tos[i]); 850 } 851 852 free (froms); 853 free (tos); 854 free (conflict_tos); 855 } 856 857 858 /*-------------------------. 859 | Free the parser tables. | 860 `-------------------------*/ 861 862 void 863 tables_free (void) 864 { 865 free (base); 866 free (conflict_table); 867 free (conflict_list); 868 free (table); 869 free (check); 870 free (yydefgoto); 871 free (yydefact); 872 } 873
