src/reduce.c

   1 /* Grammar reduction for Bison.
   2    Copyright 1988, 1989, 2000, 2001  Free Software Foundation, Inc.
   3
   4    This file is part of Bison, the GNU Compiler Compiler.
   5
   6    Bison is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    Bison is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with Bison; see the file COPYING.  If not, write to
  18    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.  */
  20
  21
  22 /* Reduce the grammar: Find and eliminate unreachable terminals,
  23    nonterminals, and productions.  David S. Bakin.  */
  24
  25 /* Don't eliminate unreachable terminals: They may be used by the
  26    user's parser.  */
  27
  28 #include "system.h"
  29 #include "getargs.h"
  30 #include "files.h"
  31 #include "gram.h"
  32 #include "complain.h"
  33 #include "reduce.h"
  34 #include "reader.h"
  35 #include "getargs.h"
  36
  37 typedef unsigned *BSet;
  38 typedef short *rule;
  39
  40
  41 /* Set of all nonterminals which are not useless.  */
  42 static BSet N;
  43
  44 /* Set of all rules which have no useless nonterminals in their RHS.  */
  45 static BSet P;
  46
  47 /* Set of all accessible symbols.  */
  48 static BSet V;
  49
  50 /* Set of symbols used to define rule precedence (so they are
  51    `useless', but no warning should be issued).  */
  52 static BSet V1;
  53
  54 static int nuseful_productions;
  55 static int nuseless_productions;
  56 static int nuseful_nonterminals;
  57 int nuseless_nonterminals;
  58 \f
  59 static bool
  60 bits_equal (BSet L, BSet R, int n)
  61 {
  62   int i;
  63
  64   for (i = n - 1; i >= 0; i--)
  65     if (L[i] != R[i])
  66       return FALSE;
  67   return TRUE;
  68 }
  69
  70
  71 static int
  72 nbits (unsigned i)
  73 {
  74   int count = 0;
  75
  76   while (i != 0)
  77     {
  78       i ^= (i & ((unsigned) (-(int) i)));
  79       ++count;
  80     }
  81   return count;
  82 }
  83
  84
  85 static int
  86 bits_size (BSet S, int n)
  87 {
  88   int i, count = 0;
  89
  90   for (i = n - 1; i >= 0; i--)
  91     count += nbits (S[i]);
  92   return count;
  93 }
  94 \f
  95 /*-------------------------------------------------------------------.
  96 | Another way to do this would be with a set for each production and |
  97 | then do subset tests against N0, but even for the C grammar the    |
  98 | whole reducing process takes only 2 seconds on my 8Mhz AT.         |
  99 `-------------------------------------------------------------------*/
 100
 101 static bool
 102 useful_production (int i, BSet N0)
 103 {
 104   rule r;
 105   short n;
 106
 107   /* A production is useful if all of the nonterminals in its appear
 108      in the set of useful nonterminals.  */
 109
 110   for (r = &ritem[rule_table[i].rhs]; *r >= 0; r++)
 111     if (ISVAR (n = *r))
 112       if (!BITISSET (N0, n - ntokens))
 113         return FALSE;
 114   return TRUE;
 115 }
 116
 117
 118 /*---------------------------------------------------------.
 119 | Remember that rules are 1-origin, symbols are 0-origin.  |
 120 `---------------------------------------------------------*/
 121
 122 static void
 123 useless_nonterminals (void)
 124 {
 125   BSet Np, Ns;
 126   int i;
 127
 128   /* N is set as built.  Np is set being built this iteration. P is
 129      set of all productions which have a RHS all in N.  */
 130
 131   Np = XCALLOC (unsigned, WORDSIZE (nvars));
 132
 133   /* The set being computed is a set of nonterminals which can derive
 134      the empty string or strings consisting of all terminals. At each
 135      iteration a nonterminal is added to the set if there is a
 136      production with that nonterminal as its LHS for which all the
 137      nonterminals in its RHS are already in the set.  Iterate until
 138      the set being computed remains unchanged.  Any nonterminals not
 139      in the set at that point are useless in that they will never be
 140      used in deriving a sentence of the language.
 141
 142      This iteration doesn't use any special traversal over the
 143      productions.  A set is kept of all productions for which all the
 144      nonterminals in the RHS are in useful.  Only productions not in
 145      this set are scanned on each iteration.  At the end, this set is
 146      saved to be used when finding useful productions: only
 147      productions in this set will appear in the final grammar.  */
 148
 149   while (1)
 150     {
 151       for (i = WORDSIZE (nvars) - 1; i >= 0; i--)
 152         Np[i] = N[i];
 153       for (i = 1; i <= nrules; i++)
 154         {
 155           if (!BITISSET (P, i))
 156             {
 157               if (useful_production (i, N))
 158                 {
 159                   SETBIT (Np, rule_table[i].lhs - ntokens);
 160                   SETBIT (P, i);
 161                 }
 162             }
 163         }
 164       if (bits_equal (N, Np, WORDSIZE (nvars)))
 165         break;
 166       Ns = Np;
 167       Np = N;
 168       N = Ns;
 169     }
 170   XFREE (N);
 171   N = Np;
 172 }
 173
 174
 175 static void
 176 inaccessable_symbols (void)
 177 {
 178   BSet Vp, Vs, Pp;
 179   int i;
 180   short t;
 181   rule r;
 182
 183   /* Find out which productions are reachable and which symbols are
 184      used.  Starting with an empty set of productions and a set of
 185      symbols which only has the start symbol in it, iterate over all
 186      productions until the set of productions remains unchanged for an
 187      iteration.  For each production which has a LHS in the set of
 188      reachable symbols, add the production to the set of reachable
 189      productions, and add all of the nonterminals in the RHS of the
 190      production to the set of reachable symbols.
 191
 192      Consider only the (partially) reduced grammar which has only
 193      nonterminals in N and productions in P.
 194
 195      The result is the set P of productions in the reduced grammar,
 196      and the set V of symbols in the reduced grammar.
 197
 198      Although this algorithm also computes the set of terminals which
 199      are reachable, no terminal will be deleted from the grammar. Some
 200      terminals might not be in the grammar but might be generated by
 201      semantic routines, and so the user might want them available with
 202      specified numbers.  (Is this true?)  However, the nonreachable
 203      terminals are printed (if running in verbose mode) so that the
 204      user can know.  */
 205
 206   Vp = XCALLOC (unsigned, WORDSIZE (nsyms));
 207   Pp = XCALLOC (unsigned, WORDSIZE (nrules + 1));
 208
 209   /* If the start symbol isn't useful, then nothing will be useful. */
 210   if (BITISSET (N, start_symbol - ntokens))
 211     {
 212       SETBIT (V, start_symbol);
 213
 214       while (1)
 215         {
 216           for (i = WORDSIZE (nsyms) - 1; i >= 0; i--)
 217             Vp[i] = V[i];
 218           for (i = 1; i <= nrules; i++)
 219             {
 220               if (!BITISSET (Pp, i)
 221                   && BITISSET (P, i)
 222                   && BITISSET (V, rule_table[i].lhs))
 223                 {
 224                   for (r = &ritem[rule_table[i].rhs]; *r >= 0; r++)
 225                     if (ISTOKEN (t = *r) || BITISSET (N, t - ntokens))
 226                       SETBIT (Vp, t);
 227                   SETBIT (Pp, i);
 228                 }
 229             }
 230           if (bits_equal (V, Vp, WORDSIZE (nsyms)))
 231             break;
 232           Vs = Vp;
 233           Vp = V;
 234           V = Vs;
 235         }
 236     }
 237
 238   XFREE (V);
 239   V = Vp;
 240
 241   /* Tokens 0, 1, and 2 are internal to Bison.  Consider them useful. */
 242   SETBIT (V, 0);                /* end-of-input token */
 243   SETBIT (V, 1);                /* error token */
 244   SETBIT (V, 2);                /* some undefined token */
 245
 246   XFREE (P);
 247   P = Pp;
 248
 249   nuseful_productions = bits_size (P, WORDSIZE (nrules + 1));
 250   nuseless_productions = nrules - nuseful_productions;
 251
 252   nuseful_nonterminals = 0;
 253   for (i = ntokens; i < nsyms; i++)
 254     if (BITISSET (V, i))
 255       nuseful_nonterminals++;
 256   nuseless_nonterminals = nvars - nuseful_nonterminals;
 257
 258   /* A token that was used in %prec should not be warned about.  */
 259   for (i = 1; i < nrules; i++)
 260     if (rule_table[i].precsym != 0)
 261       SETBIT (V1, rule_table[i].precsym);
 262 }
 263
 264 static void
 265 reduce_grammar_tables (void)
 266 {
 267   /* This is turned off because we would need to change the numbers in
 268      the case statements in the actions file.
 269
 270      We don't disable it via CPP so that it is still checked with the
 271      rest of the code, to avoid its becoming completely obsolete.
 272
 273      FIXME: I think the comment above demonstrates this code must be
 274      turned off for *semantic* parser, not in the general case.  Try
 275      to understand this better --akim.  */
 276
 277   if (0)
 278     /* remove useless productions */
 279     if (nuseless_productions > 0)
 280       {
 281         short np, pn, ni, pi;
 282
 283         np = 0;
 284         ni = 0;
 285         for (pn = 1; pn <= nrules; pn++)
 286           if (BITISSET (P, pn))
 287             {
 288               np++;
 289               if (pn != np)
 290                 {
 291                   rule_table[np].lhs   = rule_table[pn].lhs;
 292                   rule_table[np].line  = rule_table[pn].line;
 293                   rule_table[np].prec  = rule_table[pn].prec;
 294                   rule_table[np].assoc = rule_table[pn].assoc;
 295                   rule_table[np].rhs   = rule_table[pn].rhs;
 296                   if (rule_table[np].rhs != ni)
 297                     {
 298                       pi = rule_table[np].rhs;
 299                       rule_table[np].rhs = ni;
 300                       while (ritem[pi] >= 0)
 301                         ritem[ni++] = ritem[pi++];
 302                       ritem[ni++] = -np;
 303                     }
 304                 }
 305               else
 306                 {
 307                   while (ritem[ni++] >= 0)
 308                     /* Nothing. */;
 309                 }
 310             }
 311
 312         ritem[ni] = 0;
 313         nrules -= nuseless_productions;
 314         nitems = ni;
 315         nritems = ni;
 316
 317         /* Is it worth it to reduce the amount of memory for the
 318            grammar? Probably not.  */
 319       }
 320
 321   /* Disable useless productions. */
 322   if (nuseless_productions > 0)
 323     {
 324       int pn;
 325       for (pn = 1; pn <= nrules; pn++)
 326         rule_table[pn].useful = BITISSET (P, pn);
 327     }
 328 }
 329
 330
 331 /*------------------------------.
 332 | Remove useless nonterminals.  |
 333 `------------------------------*/
 334
 335 static void
 336 nonterminals_reduce (void)
 337 {
 338   int i, n;
 339   rule r;
 340
 341   /* Map the nonterminals to their new index: useful first, useless
 342      afterwards.  Kept for later report.  */
 343
 344   short *nontermmap = XCALLOC (short, nvars) - ntokens;
 345   n = ntokens;
 346   for (i = ntokens; i < nsyms; i++)
 347     if (BITISSET (V, i))
 348       nontermmap[i] = n++;
 349   for (i = ntokens; i < nsyms; i++)
 350     if (!BITISSET (V, i))
 351       nontermmap[i] = n++;
 352
 353
 354   /* Shuffle elements of tables indexed by symbol number.  */
 355   {
 356     short *sassoc_sorted = XMALLOC (short, nvars) - ntokens;
 357     short *sprec_sorted  = XMALLOC (short, nvars) - ntokens;
 358     char **tags_sorted   = XMALLOC (char *, nvars) - ntokens;
 359
 360     for (i = ntokens; i < nsyms; i++)
 361       {
 362         n = nontermmap[i];
 363         sassoc_sorted[n] = sassoc[i];
 364         sprec_sorted[n]  = sprec[i];
 365         tags_sorted[n]   = tags[i];
 366       }
 367     for (i = ntokens; i < nsyms; i++)
 368       {
 369         sassoc[i] = sassoc_sorted[i];
 370         sprec[i]  = sprec_sorted[i];
 371         tags[i]   = tags_sorted[i];
 372       }
 373     free (sassoc_sorted + ntokens);
 374     free (sprec_sorted + ntokens);
 375     free (tags_sorted + ntokens);
 376   }
 377
 378   /* Replace all symbol numbers in valid data structures.  */
 379
 380   for (i = 1; i <= nrules; i++)
 381     {
 382       rule_table[i].lhs = nontermmap[rule_table[i].lhs];
 383       if (ISVAR (rule_table[i].precsym))
 384         /* Can this happen?  */
 385         rule_table[i].precsym = nontermmap[rule_table[i].precsym];
 386     }
 387
 388   for (i = 0; i < nritems; ++i)
 389     if (ISVAR (ritem[i]))
 390       ritem[i] = nontermmap[ritem[i]];
 391
 392   start_symbol = nontermmap[start_symbol];
 393
 394   nsyms -= nuseless_nonterminals;
 395   nvars -= nuseless_nonterminals;
 396
 397   free (nontermmap + ntokens);
 398 }
 399
 400
 401 /*------------------------------------------------------------------.
 402 | Output the detailed results of the reductions.  For FILE.output.  |
 403 `------------------------------------------------------------------*/
 404
 405 void
 406 reduce_output (FILE *out)
 407 {
 408   if (nuseless_nonterminals > 0)
 409     {
 410       int i;
 411       fprintf (out, "%s\n\n", _("Useless nonterminals:"));
 412       for (i = 0; i < nuseless_nonterminals; ++i)
 413         fprintf (out, "   %s\n", tags[nsyms + i]);
 414       fputs ("\n\n", out);
 415     }
 416
 417   {
 418     bool b = FALSE;
 419     int i;
 420     for (i = 0; i < ntokens; i++)
 421       if (!BITISSET (V, i) && !BITISSET (V1, i))
 422         {
 423           if (!b)
 424             fprintf (out, "%s\n\n", _("Terminals which are not used:"));
 425           b = TRUE;
 426           fprintf (out, "   %s\n", tags[i]);
 427         }
 428     if (b)
 429       fputs ("\n\n", out);
 430   }
 431
 432   if (nuseless_productions > 0)
 433     {
 434       int i;
 435       fprintf (out, "%s\n\n", _("Useless rules:"));
 436       for (i = 1; i <= nrules; i++)
 437         if (!rule_table[i].useful)
 438           {
 439             rule r;
 440             fprintf (out, "#%-4d  ", i - 1);
 441             fprintf (out, "%s:", tags[rule_table[i].lhs]);
 442             for (r = &ritem[rule_table[i].rhs]; *r >= 0; r++)
 443               fprintf (out, " %s", tags[*r]);
 444             fputs (";\n", out);
 445           }
 446       fputs ("\n\n", out);
 447     }
 448 }
 449 \f
 450 static void
 451 dump_grammar (FILE *out)
 452 {
 453   int i;
 454   rule r;
 455
 456   fprintf (out, "REDUCED GRAMMAR\n\n");
 457   fprintf (out,
 458            "ntokens = %d, nvars = %d, nsyms = %d, nrules = %d, nitems = %d\n\n",
 459            ntokens, nvars, nsyms, nrules, nitems);
 460   fprintf (out, "Variables\n---------\n\n");
 461   fprintf (out, "Value  Sprec  Sassoc  Tag\n");
 462   for (i = ntokens; i < nsyms; i++)
 463     fprintf (out, "%5d  %5d   %5d  %s\n", i, sprec[i], sassoc[i], tags[i]);
 464   fprintf (out, "\n\n");
 465   fprintf (out, "Rules\n-----\n\n");
 466   fprintf (out, "Num (Prec, Assoc, Useful, Ritem Range) Lhs -> Rhs (Ritem range) [Num]\n");
 467   for (i = 1; i <= nrules; i++)
 468     {
 469       int rhs_count = 0;
 470       /* Find the last RHS index in ritems. */
 471       for (r = &ritem[rule_table[i].rhs]; *r >= 0; ++r)
 472         ++rhs_count;
 473       fprintf (out, "%3d (%2d, %2d, %2d, %2d-%2d)   %2d ->",
 474                i - 1,
 475                rule_table[i].prec, rule_table[i].assoc, rule_table[i].useful,
 476                rule_table[i].rhs, rule_table[i].rhs + rhs_count - 1,
 477                rule_table[i].lhs);
 478       /* Dumped the RHS. */
 479       for (r = &ritem[rule_table[i].rhs]; *r >= 0; r++)
 480         fprintf (out, "%3d", *r);
 481       fprintf (out, "  [%d]\n", -(*r) - 1);
 482     }
 483   fprintf (out, "\n\n");
 484   fprintf (out, "Rules interpreted\n-----------------\n\n");
 485   for (i = 1; i <= nrules; i++)
 486     {
 487       fprintf (out, "%-5d  %s :", i, tags[rule_table[i].lhs]);
 488       for (r = &ritem[rule_table[i].rhs]; *r >= 0; r++)
 489         fprintf (out, " %s", tags[*r]);
 490       fputc ('\n', out);
 491     }
 492   fprintf (out, "\n\n");
 493 }
 494
 495
 496
 497 /*-------------------------------.
 498 | Report the results to STDERR.  |
 499 `-------------------------------*/
 500
 501 static void
 502 reduce_print (void)
 503 {
 504   if (yacc_flag && nuseless_productions)
 505     fprintf (stderr, ngettext ("%d rule never reduced\n",
 506                                "%d rules never reduced\n",
 507                                nuseless_productions),
 508              nuseless_productions);
 509
 510   fprintf (stderr, _("%s contains "), infile);
 511
 512   if (nuseless_nonterminals > 0)
 513     fprintf (stderr, ngettext ("%d useless nonterminal",
 514                                "%d useless nonterminals",
 515                                nuseless_nonterminals),
 516              nuseless_nonterminals);
 517
 518   if (nuseless_nonterminals > 0 && nuseless_productions > 0)
 519     fprintf (stderr, _(" and "));
 520
 521   if (nuseless_productions > 0)
 522     fprintf (stderr, ngettext ("%d useless rule",
 523                                "%d useless rules",
 524                                nuseless_productions),
 525              nuseless_productions);
 526   fprintf (stderr, "\n");
 527   fflush (stderr);
 528 }
 529 \f
 530 void
 531 reduce_grammar (void)
 532 {
 533   bool reduced;
 534
 535   /* Allocate the global sets used to compute the reduced grammar */
 536
 537   N = XCALLOC (unsigned, WORDSIZE (nvars));
 538   P = XCALLOC (unsigned, WORDSIZE (nrules + 1));
 539   V = XCALLOC (unsigned, WORDSIZE (nsyms));
 540   V1 = XCALLOC (unsigned, WORDSIZE (nsyms));
 541
 542   useless_nonterminals ();
 543   inaccessable_symbols ();
 544
 545   reduced = (bool) (nuseless_nonterminals + nuseless_productions > 0);
 546
 547   if (!reduced)
 548     return;
 549
 550   reduce_print ();
 551
 552   if (!BITISSET (N, start_symbol - ntokens))
 553     fatal (_("Start symbol %s does not derive any sentence"),
 554            tags[start_symbol]);
 555
 556   reduce_grammar_tables ();
 557   if (nuseless_nonterminals > 0)
 558     nonterminals_reduce ();
 559
 560   if (trace_flag)
 561     {
 562       dump_grammar (stderr);
 563
 564       fprintf (stderr, "reduced %s defines %d terminals, %d nonterminals\
 565 , and %d productions.\n",
 566                infile, ntokens, nvars, nrules);
 567     }
 568 }
 569
 570
 571 /*-----------------------------------------------------------.
 572 | Free the global sets used to compute the reduced grammar.  |
 573 `-----------------------------------------------------------*/
 574
 575 void
 576 reduce_free (void)
 577 {
 578   XFREE (N);
 579   XFREE (V);
 580   XFREE (V1);
 581   XFREE (P);
 582 }