src/print.c

   1 /* Print information on generated parser, for bison,
   2    Copyright (C) 1984, 1986, 1989, 2000 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 "xalloc.h"
  24 #include "files.h"
  25 #include "gram.h"
  26 #include "LR0.h"
  27 #include "lalr.h"
  28 #include "conflicts.h"
  29 #include "getargs.h"
  30 #include "state.h"
  31 #include "reader.h"
  32 #include "print.h"
  33
  34 #if 0
  35 static void
  36 print_token (int extnum, int token)
  37 {
  38   fprintf (foutput, _(" type %d is %s\n"), extnum, tags[token]);
  39 }
  40 #endif
  41
  42 \f
  43 /*================================\
  44 | Report information on a state.  |
  45 \================================*/
  46
  47 static void
  48 print_core (int state)
  49 {
  50   int i;
  51   int k;
  52   int rule;
  53   core *statep;
  54   short *sp;
  55   short *sp1;
  56
  57   statep = state_table[state];
  58   k = statep->nitems;
  59
  60   if (k == 0)
  61     return;
  62
  63   for (i = 0; i < k; i++)
  64     {
  65       sp1 = sp = ritem + statep->items[i];
  66
  67       while (*sp > 0)
  68         sp++;
  69
  70       rule = -(*sp);
  71       fprintf (foutput, "    %s  ->  ", tags[rlhs[rule]]);
  72
  73       for (sp = ritem + rrhs[rule]; sp < sp1; sp++)
  74         {
  75           fprintf (foutput, "%s ", tags[*sp]);
  76         }
  77
  78       putc ('.', foutput);
  79
  80       while (*sp > 0)
  81         {
  82           fprintf (foutput, " %s", tags[*sp]);
  83           sp++;
  84         }
  85
  86       fprintf (foutput, _("   (rule %d)"), rule);
  87       putc ('\n', foutput);
  88     }
  89
  90   putc ('\n', foutput);
  91 }
  92
  93 static void
  94 print_actions (int state)
  95 {
  96   int i;
  97   int k;
  98   int state1;
  99   int symbol;
 100   shifts *shiftp;
 101   errs *errp;
 102   reductions *redp;
 103   int rule;
 104
 105   shiftp = shift_table[state];
 106   redp = reduction_table[state];
 107   errp = err_table[state];
 108
 109   if (!shiftp && !redp)
 110     {
 111       if (final_state == state)
 112         fprintf (foutput, _("    $default\taccept\n"));
 113       else
 114         fprintf (foutput, _("    NO ACTIONS\n"));
 115       return;
 116     }
 117
 118   if (shiftp)
 119     {
 120       k = shiftp->nshifts;
 121
 122       for (i = 0; i < k; i++)
 123         {
 124           if (!shiftp->shifts[i])
 125             continue;
 126           state1 = shiftp->shifts[i];
 127           symbol = accessing_symbol[state1];
 128           /* The following line used to be turned off.  */
 129           if (ISVAR (symbol))
 130             break;
 131           if (symbol == 0)      /* I.e. strcmp(tags[symbol],"$")==0 */
 132             fprintf (foutput, _("    $   \tgo to state %d\n"), state1);
 133           else
 134             fprintf (foutput, _("    %-4s\tshift, and go to state %d\n"),
 135                      tags[symbol], state1);
 136         }
 137
 138       if (i > 0)
 139         putc ('\n', foutput);
 140     }
 141   else
 142     {
 143       i = 0;
 144       k = 0;
 145     }
 146
 147   if (errp)
 148     {
 149       int j, nerrs;
 150
 151       nerrs = errp->nerrs;
 152
 153       for (j = 0; j < nerrs; j++)
 154         {
 155           if (!errp->errs[j])
 156             continue;
 157           symbol = errp->errs[j];
 158           fprintf (foutput, _("    %-4s\terror (nonassociative)\n"),
 159                    tags[symbol]);
 160         }
 161
 162       if (j > 0)
 163         putc ('\n', foutput);
 164     }
 165
 166   if (consistent[state] && redp)
 167     {
 168       rule = redp->rules[0];
 169       symbol = rlhs[rule];
 170       fprintf (foutput, _("    $default\treduce using rule %d (%s)\n\n"),
 171                rule, tags[symbol]);
 172     }
 173   else if (redp)
 174     {
 175       print_reductions (state);
 176     }
 177
 178   if (i < k)
 179     {
 180       for (; i < k; i++)
 181         {
 182           if (!shiftp->shifts[i])
 183             continue;
 184           state1 = shiftp->shifts[i];
 185           symbol = accessing_symbol[state1];
 186           fprintf (foutput, _("    %-4s\tgo to state %d\n"), tags[symbol],
 187                    state1);
 188         }
 189
 190       putc ('\n', foutput);
 191     }
 192 }
 193
 194 static void
 195 print_state (int state)
 196 {
 197   fputs ("\n\n", foutput);
 198   fprintf (foutput, _("state %d"), state);
 199   fputs ("\n\n", foutput);
 200   print_core (state);
 201   print_actions (state);
 202 }
 203 \f
 204 /*-----------------------------------------.
 205 | Print information on the whole grammar.  |
 206 `-----------------------------------------*/
 207
 208 #define END_TEST(end)                           \
 209   do {                                          \
 210     if (column + strlen(buffer) > (end)) {      \
 211       fprintf (foutput, "%s\n   ", buffer);     \
 212       column = 3;                               \
 213       buffer[0] = 0;                            \
 214     }                                           \
 215   } while (0)
 216
 217
 218 static void
 219 print_grammar (void)
 220 {
 221   int i, j;
 222   short *rule;
 223   char buffer[90];
 224   int column = 0;
 225
 226   /* rule # : LHS -> RHS */
 227   putc ('\n', foutput);
 228   fputs (_("Grammar"), foutput);
 229   putc ('\n', foutput);
 230   for (i = 1; i <= nrules; i++)
 231     /* Don't print rules disabled in reduce_grammar_tables.  */
 232     if (rlhs[i] >= 0)
 233       {
 234         fprintf (foutput, _("rule %-4d %s ->"), i, tags[rlhs[i]]);
 235         rule = &ritem[rrhs[i]];
 236         if (*rule > 0)
 237           while (*rule > 0)
 238             fprintf (foutput, " %s", tags[*rule++]);
 239         else
 240           fputs (_("            /* empty */"), foutput);
 241         putc ('\n', foutput);
 242       }
 243
 244   /* TERMINAL (type #) : rule #s terminal is on RHS */
 245   fputs ("\n", foutput);
 246   fputs (_("Terminals, with rules where they appear"), foutput);
 247   fputs ("\n\n", foutput);
 248   fprintf (foutput, "%s (-1)\n", tags[0]);
 249   if (translations)
 250     {
 251       for (i = 0; i <= max_user_token_number; i++)
 252         if (token_translations[i] != 2)
 253           {
 254             buffer[0] = 0;
 255             column = strlen (tags[token_translations[i]]);
 256             fprintf (foutput, "%s", tags[token_translations[i]]);
 257             END_TEST (50);
 258             sprintf (buffer, " (%d)", i);
 259
 260             for (j = 1; j <= nrules; j++)
 261               {
 262                 for (rule = &ritem[rrhs[j]]; *rule > 0; rule++)
 263                   if (*rule == token_translations[i])
 264                     {
 265                       END_TEST (65);
 266                       sprintf (buffer + strlen (buffer), " %d", j);
 267                       break;
 268                     }
 269               }
 270             fprintf (foutput, "%s\n", buffer);
 271           }
 272     }
 273   else
 274     for (i = 1; i < ntokens; i++)
 275       {
 276         buffer[0] = 0;
 277         column = strlen (tags[i]);
 278         fprintf (foutput, "%s", tags[i]);
 279         END_TEST (50);
 280         sprintf (buffer, " (%d)", i);
 281
 282         for (j = 1; j <= nrules; j++)
 283           {
 284             for (rule = &ritem[rrhs[j]]; *rule > 0; rule++)
 285               if (*rule == i)
 286                 {
 287                   END_TEST (65);
 288                   sprintf (buffer + strlen (buffer), " %d", j);
 289                   break;
 290                 }
 291           }
 292         fprintf (foutput, "%s\n", buffer);
 293       }
 294
 295   fputs ("\n", foutput);
 296   fputs (_("Nonterminals, with rules where they appear"), foutput);
 297   fputs ("\n\n", foutput);
 298   for (i = ntokens; i <= nsyms - 1; i++)
 299     {
 300       int left_count = 0, right_count = 0;
 301
 302       for (j = 1; j <= nrules; j++)
 303         {
 304           if (rlhs[j] == i)
 305             left_count++;
 306           for (rule = &ritem[rrhs[j]]; *rule > 0; rule++)
 307             if (*rule == i)
 308               {
 309                 right_count++;
 310                 break;
 311               }
 312         }
 313
 314       buffer[0] = 0;
 315       fprintf (foutput, "%s", tags[i]);
 316       column = strlen (tags[i]);
 317       sprintf (buffer, " (%d)", i);
 318       END_TEST (0);
 319
 320       if (left_count > 0)
 321         {
 322           END_TEST (50);
 323           sprintf (buffer + strlen (buffer), _(" on left:"));
 324
 325           for (j = 1; j <= nrules; j++)
 326             {
 327               END_TEST (65);
 328               if (rlhs[j] == i)
 329                 sprintf (buffer + strlen (buffer), " %d", j);
 330             }
 331         }
 332
 333       if (right_count > 0)
 334         {
 335           if (left_count > 0)
 336             sprintf (buffer + strlen (buffer), ",");
 337           END_TEST (50);
 338           sprintf (buffer + strlen (buffer), _(" on right:"));
 339           for (j = 1; j <= nrules; j++)
 340             {
 341               for (rule = &ritem[rrhs[j]]; *rule > 0; rule++)
 342                 if (*rule == i)
 343                   {
 344                     END_TEST (65);
 345                     sprintf (buffer + strlen (buffer), " %d", j);
 346                     break;
 347                   }
 348             }
 349         }
 350       fprintf (foutput, "%s\n", buffer);
 351     }
 352 }
 353 \f
 354 void
 355 print_results (void)
 356 {
 357   int i;
 358
 359   if (any_conflicts)
 360     print_conflicts ();
 361
 362   if (verbose_flag)
 363     print_grammar ();
 364
 365   if (verbose_flag)
 366     for (i = 0; i < nstates; i++)
 367       print_state (i);
 368 }