src/print.c

   1 /* Print information on generated parser, for bison,
   2    Copyright 1984, 1986, 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 #include "system.h"
  23 #include "files.h"
  24 #include "gram.h"
  25 #include "LR0.h"
  26 #include "lalr.h"
  27 #include "conflicts.h"
  28 #include "getargs.h"
  29 #include "state.h"
  30 #include "reader.h"
  31 #include "print.h"
  32 #include "reduce.h"
  33 #include "closure.h"
  34
  35 static unsigned *shiftset = NULL;
  36 static unsigned *lookaheadset = NULL;
  37
  38 #if 0
  39 static void
  40 print_token (int extnum, int token)
  41 {
  42   fprintf (out, _(" type %d is %s\n"), extnum, tags[token]);
  43 }
  44 #endif
  45
  46 \f
  47 /*--------------------------------.
  48 | Report information on a state.  |
  49 `--------------------------------*/
  50
  51 static void
  52 print_core (FILE *out, state_t *state)
  53 {
  54   int i;
  55   short *sitems = state->items;
  56   int snitems   = state->nitems;
  57
  58   /* New experimental feature: if TRACE_FLAGS output all the items of
  59      a state, not only its kernel.  */
  60   if (trace_flag)
  61     {
  62       closure (sitems, snitems);
  63       sitems = itemset;
  64       snitems = nitemset;
  65     }
  66
  67   if (snitems)
  68     {
  69       for (i = 0; i < snitems; i++)
  70         {
  71           short *sp;
  72           short *sp1;
  73           int rule;
  74
  75           sp1 = sp = ritem + sitems[i];
  76
  77           while (*sp > 0)
  78             sp++;
  79
  80           rule = -(*sp);
  81           fprintf (out, "    %s  ->  ", tags[rule_table[rule].lhs]);
  82
  83           for (sp = ritem + rule_table[rule].rhs; sp < sp1; sp++)
  84             fprintf (out, "%s ", tags[*sp]);
  85
  86           fputc ('.', out);
  87
  88           for (/* Nothing */; *sp > 0; ++sp)
  89             fprintf (out, " %s", tags[*sp]);
  90
  91           fprintf (out, _("   (rule %d)"), rule);
  92           fputc ('\n', out);
  93         }
  94
  95       fputc ('\n', out);
  96     }
  97 }
  98
  99
 100 static void
 101 print_shifts (FILE *out, state_t *state)
 102 {
 103   int i;
 104   shifts *shiftp = state->shifts;
 105
 106   for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
 107     if (!SHIFT_IS_DISABLED (shiftp, i))
 108       {
 109         int state1 = shiftp->shifts[i];
 110         int symbol = state_table[state1]->accessing_symbol;
 111         fprintf (out,
 112                  _("    %-4s\tshift, and go to state %d\n"),
 113                  tags[symbol], state1);
 114       }
 115
 116   if (i > 0)
 117     fputc ('\n', out);
 118 }
 119
 120
 121 static void
 122 print_errs (FILE *out, state_t *state)
 123 {
 124   errs *errp = state->errs;
 125   int i;
 126
 127   for (i = 0; i < errp->nerrs; ++i)
 128     if (errp->errs[i])
 129       fprintf (out, _("    %-4s\terror (nonassociative)\n"),
 130                tags[errp->errs[i]]);
 131
 132   if (i > 0)
 133     fputc ('\n', out);
 134 }
 135
 136
 137 static void
 138 print_gotos (FILE *out, state_t *state)
 139 {
 140   int i;
 141   shifts *shiftp = state->shifts;
 142
 143   for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
 144     /* Skip token shifts.  */;
 145
 146   if (i < shiftp->nshifts)
 147     {
 148       for (; i < shiftp->nshifts; i++)
 149         if (!SHIFT_IS_DISABLED (shiftp, i))
 150           {
 151             int state1 = shiftp->shifts[i];
 152             int symbol = state_table[state1]->accessing_symbol;
 153             fprintf (out, _("    %-4s\tgo to state %d\n"),
 154                      tags[symbol], state1);
 155           }
 156
 157       fputc ('\n', out);
 158     }
 159 }
 160
 161 static void
 162 print_reductions (FILE *out, state_t *state)
 163 {
 164   int i;
 165   shifts *shiftp = state->shifts;
 166   reductions *redp = state->reductions;
 167   errs *errp = state->errs;
 168   int nodefault = 0;
 169
 170   if (redp->nreds == 0)
 171     return;
 172
 173   if (state->consistent)
 174     {
 175       int rule = redp->rules[0];
 176       int symbol = rule_table[rule].lhs;
 177       fprintf (out, _("    $default\treduce using rule %d (%s)\n\n"),
 178                rule, tags[symbol]);
 179       return;
 180     }
 181
 182   for (i = 0; i < tokensetsize; i++)
 183     shiftset[i] = 0;
 184
 185   for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
 186     if (!SHIFT_IS_DISABLED (shiftp, i))
 187       {
 188         /* if this state has a shift for the error token, don't use a
 189            default rule.  */
 190         if (SHIFT_IS_ERROR (shiftp, i))
 191           nodefault = 1;
 192         SETBIT (shiftset, SHIFT_SYMBOL (shiftp, i));
 193       }
 194
 195   for (i = 0; i < errp->nerrs; i++)
 196     if (errp->errs[i])
 197       SETBIT (shiftset, errp->errs[i]);
 198
 199   if (state->nlookaheads == 1 && !nodefault)
 200     {
 201       int k;
 202       int default_rule = LAruleno[state->lookaheadsp];
 203
 204       for (k = 0; k < tokensetsize; ++k)
 205         lookaheadset[k] = LA (state->lookaheadsp)[k] & shiftset[k];
 206
 207       for (i = 0; i < ntokens; i++)
 208         if (BITISSET (lookaheadset, i))
 209           fprintf (out, _("    %-4s\t[reduce using rule %d (%s)]\n"),
 210                    tags[i], default_rule,
 211                    tags[rule_table[default_rule].lhs]);
 212
 213       fprintf (out, _("    $default\treduce using rule %d (%s)\n\n"),
 214                default_rule, tags[rule_table[default_rule].lhs]);
 215     }
 216   else if (state->nlookaheads >= 1)
 217     {
 218       int cmax = 0;
 219       int default_LA = -1;
 220       int default_rule = 0;
 221
 222       if (!nodefault)
 223         for (i = 0; i < state->nlookaheads; ++i)
 224           {
 225             int count = 0;
 226             int j, k;
 227
 228             for (k = 0; k < tokensetsize; ++k)
 229               lookaheadset[k] = LA (state->lookaheadsp + i)[k] & ~shiftset[k];
 230
 231             for (j = 0; j < ntokens; j++)
 232               if (BITISSET (lookaheadset, j))
 233                 count++;
 234
 235             if (count > cmax)
 236               {
 237                 cmax = count;
 238                 default_LA = state->lookaheadsp + i;
 239                 default_rule = LAruleno[state->lookaheadsp + i];
 240               }
 241
 242             for (k = 0; k < tokensetsize; ++k)
 243               shiftset[k] |= lookaheadset[k];
 244           }
 245
 246       for (i = 0; i < tokensetsize; i++)
 247         shiftset[i] = 0;
 248
 249       for (i = 0; i < shiftp->nshifts && SHIFT_IS_SHIFT (shiftp, i); i++)
 250         if (!SHIFT_IS_DISABLED (shiftp, i))
 251           SETBIT (shiftset, SHIFT_SYMBOL (shiftp, i));
 252
 253       for (i = 0; i < ntokens; i++)
 254         {
 255           int j;
 256           int defaulted = 0;
 257           int count = BITISSET (shiftset, i);
 258
 259           for (j = 0; j < state->nlookaheads; ++j)
 260             {
 261               if (BITISSET (LA (state->lookaheadsp + j), i))
 262                 {
 263                   if (count == 0)
 264                     {
 265                       if (state->lookaheadsp + j != default_LA)
 266                         fprintf (out,
 267                                  _("    %-4s\treduce using rule %d (%s)\n"),
 268                                  tags[i],
 269                                  LAruleno[state->lookaheadsp + j],
 270                                  tags[rule_table[LAruleno[state->lookaheadsp + j]].lhs]);
 271                       else
 272                         defaulted = 1;
 273
 274                       count++;
 275                     }
 276                   else
 277                     {
 278                       if (defaulted)
 279                         fprintf (out,
 280                                  _("    %-4s\treduce using rule %d (%s)\n"),
 281                                  tags[i],
 282                                  LAruleno[default_LA],
 283                                  tags[rule_table[LAruleno[default_LA]].lhs]);
 284                       defaulted = 0;
 285                       fprintf (out,
 286                                _("    %-4s\t[reduce using rule %d (%s)]\n"),
 287                                tags[i],
 288                                LAruleno[state->lookaheadsp + j],
 289                                tags[rule_table[LAruleno[state->lookaheadsp + j]].lhs]);
 290                     }
 291                 }
 292             }
 293         }
 294
 295       if (default_LA >= 0)
 296         fprintf (out, _("    $default\treduce using rule %d (%s)\n"),
 297                  default_rule, tags[rule_table[default_rule].lhs]);
 298     }
 299 }
 300
 301
 302 static void
 303 print_actions (FILE *out, state_t *state)
 304 {
 305   reductions *redp = state->reductions;
 306   shifts *shiftp = state->shifts;
 307
 308   if (shiftp->nshifts == 0 && redp->nreds == 0)
 309     {
 310       if (final_state == state->number)
 311         fprintf (out, _("    $default\taccept\n"));
 312       else
 313         fprintf (out, _("    NO ACTIONS\n"));
 314       return;
 315     }
 316
 317   print_shifts (out, state);
 318   print_errs (out, state);
 319   print_reductions (out, state);
 320   print_gotos (out, state);
 321 }
 322
 323 static void
 324 print_state (FILE *out, state_t *state)
 325 {
 326   fprintf (out, _("state %d"), state->number);
 327   fputs ("\n\n", out);
 328   print_core (out, state);
 329   print_actions (out, state);
 330   fputs ("\n\n", out);
 331 }
 332 \f
 333 /*-----------------------------------------.
 334 | Print information on the whole grammar.  |
 335 `-----------------------------------------*/
 336
 337 #define END_TEST(End)                           \
 338 do {                                            \
 339   if (column + strlen(buffer) > (End))          \
 340     {                                           \
 341       fprintf (out, "%s\n   ", buffer);         \
 342       column = 3;                               \
 343       buffer[0] = 0;                            \
 344     }                                           \
 345 } while (0)
 346
 347
 348 static void
 349 print_grammar (FILE *out)
 350 {
 351   int i, j;
 352   short *rule;
 353   char buffer[90];
 354   int column = 0;
 355
 356   /* rule # : LHS -> RHS */
 357   fprintf (out, "%s\n\n", _("Grammar"));
 358   fprintf (out, "  %s\n", _("Number, Line, Rule"));
 359   for (i = 1; i <= nrules; i++)
 360     /* Don't print rules disabled in reduce_grammar_tables.  */
 361     if (rule_table[i].useful)
 362       {
 363         fprintf (out, _("  %3d %3d %s ->"),
 364                  i, rule_table[i].line, tags[rule_table[i].lhs]);
 365         rule = &ritem[rule_table[i].rhs];
 366         if (*rule > 0)
 367           while (*rule > 0)
 368             fprintf (out, " %s", tags[*rule++]);
 369         else
 370           fprintf (out, " /* %s */", _("empty"));
 371         fputc ('\n', out);
 372       }
 373   fputs ("\n\n", out);
 374
 375
 376   /* TERMINAL (type #) : rule #s terminal is on RHS */
 377   fprintf (out, "%s\n\n", _("Terminals, with rules where they appear"));
 378   fprintf (out, "%s (-1)\n", tags[0]);
 379
 380   for (i = 0; i <= max_user_token_number; i++)
 381     if (token_translations[i] != 2)
 382       {
 383         buffer[0] = 0;
 384         column = strlen (tags[token_translations[i]]);
 385         fputs (tags[token_translations[i]], out);
 386         END_TEST (50);
 387         sprintf (buffer, " (%d)", i);
 388
 389         for (j = 1; j <= nrules; j++)
 390           for (rule = &ritem[rule_table[j].rhs]; *rule > 0; rule++)
 391             if (*rule == token_translations[i])
 392               {
 393                 END_TEST (65);
 394                 sprintf (buffer + strlen (buffer), " %d", j);
 395                 break;
 396               }
 397         fprintf (out, "%s\n", buffer);
 398       }
 399   fputs ("\n\n", out);
 400
 401
 402   fprintf (out, "%s\n\n", _("Nonterminals, with rules where they appear"));
 403   for (i = ntokens; i <= nsyms - 1; i++)
 404     {
 405       int left_count = 0, right_count = 0;
 406
 407       for (j = 1; j <= nrules; j++)
 408         {
 409           if (rule_table[j].lhs == i)
 410             left_count++;
 411           for (rule = &ritem[rule_table[j].rhs]; *rule > 0; rule++)
 412             if (*rule == i)
 413               {
 414                 right_count++;
 415                 break;
 416               }
 417         }
 418
 419       buffer[0] = 0;
 420       fputs (tags[i], out);
 421       column = strlen (tags[i]);
 422       sprintf (buffer, " (%d)", i);
 423       END_TEST (0);
 424
 425       if (left_count > 0)
 426         {
 427           END_TEST (50);
 428           sprintf (buffer + strlen (buffer), _(" on left:"));
 429
 430           for (j = 1; j <= nrules; j++)
 431             {
 432               END_TEST (65);
 433               if (rule_table[j].lhs == i)
 434                 sprintf (buffer + strlen (buffer), " %d", j);
 435             }
 436         }
 437
 438       if (right_count > 0)
 439         {
 440           if (left_count > 0)
 441             sprintf (buffer + strlen (buffer), ",");
 442           END_TEST (50);
 443           sprintf (buffer + strlen (buffer), _(" on right:"));
 444           for (j = 1; j <= nrules; j++)
 445             {
 446               for (rule = &ritem[rule_table[j].rhs]; *rule > 0; rule++)
 447                 if (*rule == i)
 448                   {
 449                     END_TEST (65);
 450                     sprintf (buffer + strlen (buffer), " %d", j);
 451                     break;
 452                   }
 453             }
 454         }
 455       fprintf (out, "%s\n", buffer);
 456     }
 457   fputs ("\n\n", out);
 458 }
 459 \f
 460 void
 461 print_results (void)
 462 {
 463   int i;
 464
 465   /* We used to use just .out if SPEC_NAME_PREFIX (-p) was used, but
 466      that conflicts with Posix.  */
 467   FILE *out = xfopen (spec_verbose_file, "w");
 468
 469   size_t size = obstack_object_size (&output_obstack);
 470   fwrite (obstack_finish (&output_obstack), 1, size, out);
 471   obstack_free (&output_obstack, NULL);
 472
 473   if (size)
 474     fputs ("\n\n", out);
 475
 476   reduce_output (out);
 477   conflicts_output (out);
 478
 479   print_grammar (out);
 480
 481   /* New experimental feature: output all the items of a state, not
 482      only its kernel.  Requires to run closure, which need memory
 483      allocation/deallocation.  */
 484   if (trace_flag)
 485     new_closure (nitems);
 486   /* Storage for print_reductions.  */
 487   shiftset = XCALLOC (unsigned, tokensetsize);
 488   lookaheadset = XCALLOC (unsigned, tokensetsize);
 489   for (i = 0; i < nstates; i++)
 490     print_state (out, state_table[i]);
 491   free (shiftset);
 492   free (lookaheadset);
 493   if (trace_flag)
 494     free_closure ();
 495
 496   xfclose (out);
 497 }