src/gram.c

   1 /* Allocate input grammar variables for bison,
   2    Copyright (C) 1984, 1986, 1989, 2001, 2002 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 "quotearg.h"
  24 #include "symtab.h"
  25 #include "gram.h"
  26 #include "reduce.h"
  27 #include "reader.h"
  28
  29 /* Comments for these variables are in gram.h.  */
  30
  31 item_number_t *ritem = NULL;
  32 unsigned int nritems = 0;
  33
  34 rule_t *rules = NULL;
  35 rule_number_t nrules = 0;
  36
  37 symbol_t **symbols = NULL;
  38 int nsyms = 0;
  39 int ntokens = 1;
  40 int nvars = 0;
  41
  42 symbol_number_t *token_translations = NULL;
  43
  44 int max_user_token_number = 256;
  45
  46 int glr_parser = 0;
  47 int pure_parser = 0;
  48
  49
  50 /*--------------------------------------------------------------.
  51 | Return true IFF the rule has a `number' smaller than NRULES.  |
  52 `--------------------------------------------------------------*/
  53
  54 bool
  55 rule_useful_p (rule_t *r)
  56 {
  57   return r->number < nrules;
  58 }
  59
  60
  61 /*-------------------------------------------------------------.
  62 | Return true IFF the rule has a `number' higher than NRULES.  |
  63 `-------------------------------------------------------------*/
  64
  65 bool
  66 rule_useless_p (rule_t *r)
  67 {
  68   return r->number >= nrules;
  69 }
  70
  71
  72 /*--------------------------------------------------------------------.
  73 | Return true IFF the rule is not flagged as useful *and* is useful.  |
  74 | In other words, it was discarded because of conflicts.              |
  75 `--------------------------------------------------------------------*/
  76
  77 bool
  78 rule_never_reduced_p (rule_t *r)
  79 {
  80   return !r->useful && r->number < nrules;
  81 }
  82
  83
  84 /*----------------------------------------------------------------.
  85 | Print this RULE's number and lhs on OUT.  If a PREVIOUS_LHS was |
  86 | already displayed (by a previous call for another rule), avoid  |
  87 | useless repetitions.                                            |
  88 `----------------------------------------------------------------*/
  89
  90 void
  91 rule_lhs_print (rule_t *rule, symbol_t *previous_lhs, FILE *out)
  92 {
  93   fprintf (out, "  %3d ", rule->number);
  94   if (previous_lhs != rule->lhs)
  95     {
  96       fprintf (out, "%s:", rule->lhs->tag);
  97     }
  98   else
  99     {
 100       int n;
 101       for (n = strlen (previous_lhs->tag); n > 0; --n)
 102         fputc (' ', out);
 103       fputc ('|', out);
 104     }
 105 }
 106
 107
 108 /*--------------------------------------.
 109 | Return the number of symbols in RHS.  |
 110 `--------------------------------------*/
 111
 112 int
 113 rule_rhs_length (rule_t *rule)
 114 {
 115   int res = 0;
 116   item_number_t *rhsp;
 117   for (rhsp = rule->rhs; *rhsp >= 0; ++rhsp)
 118     ++res;
 119   return res;
 120 }
 121
 122
 123 /*-------------------------------.
 124 | Print this RULE's RHS on OUT.  |
 125 `-------------------------------*/
 126
 127 void
 128 rule_rhs_print (rule_t *rule, FILE *out)
 129 {
 130   if (*rule->rhs >= 0)
 131     {
 132       item_number_t *r;
 133       for (r = rule->rhs; *r >= 0; r++)
 134         fprintf (out, " %s", symbols[*r]->tag);
 135       fputc ('\n', out);
 136     }
 137   else
 138     {
 139       fprintf (out, " /* %s */\n", _("empty"));
 140     }
 141 }
 142
 143
 144 /*-------------------------.
 145 | Print this RULE on OUT.  |
 146 `-------------------------*/
 147
 148 void
 149 rule_print (rule_t *rule, FILE *out)
 150 {
 151   fprintf (out, "%s:", rule->lhs->tag);
 152   rule_rhs_print (rule, out);
 153 }
 154
 155
 156 /*------------------------.
 157 | Dump RITEM for traces.  |
 158 `------------------------*/
 159
 160 void
 161 ritem_print (FILE *out)
 162 {
 163   unsigned int i;
 164   fputs ("RITEM\n", out);
 165   for (i = 0; i < nritems; ++i)
 166     if (ritem[i] >= 0)
 167       fprintf (out, "  %s", symbols[ritem[i]]->tag);
 168     else
 169       fprintf (out, "  (rule %d)\n", item_number_as_rule_number (ritem[i]));
 170   fputs ("\n\n", out);
 171 }
 172
 173
 174 /*------------------------------------------.
 175 | Return the size of the longest rule RHS.  |
 176 `------------------------------------------*/
 177
 178 size_t
 179 ritem_longest_rhs (void)
 180 {
 181   int max = 0;
 182   rule_number_t r;
 183
 184   for (r = 0; r < nrules; ++r)
 185     {
 186       int length = rule_rhs_length (&rules[r]);
 187       if (length > max)
 188         max = length;
 189     }
 190
 191   return max;
 192 }
 193
 194
 195 /*-----------------------------------------------------------------.
 196 | Print the grammar's rules that match FILTER on OUT under TITLE.  |
 197 `-----------------------------------------------------------------*/
 198
 199 void
 200 grammar_rules_partial_print (FILE *out, const char *title,
 201                              rule_filter_t filter)
 202 {
 203   int r;
 204   bool first = true;
 205   symbol_t *previous_lhs = NULL;
 206
 207   /* rule # : LHS -> RHS */
 208   for (r = 0; r < nrules + nuseless_productions; r++)
 209     {
 210       if (filter && !filter (&rules[r]))
 211         continue;
 212       if (first)
 213         fprintf (out, "%s\n\n", title);
 214       else if (previous_lhs && previous_lhs != rules[r].lhs)
 215         fputc ('\n', out);
 216       first = false;
 217       rule_lhs_print (&rules[r], previous_lhs, out);
 218       rule_rhs_print (&rules[r], out);
 219       previous_lhs = rules[r].lhs;
 220     }
 221   if (!first)
 222     fputs ("\n\n", out);
 223 }
 224
 225
 226 /*------------------------------------------.
 227 | Print the grammar's useful rules on OUT.  |
 228 `------------------------------------------*/
 229
 230 void
 231 grammar_rules_print (FILE *out)
 232 {
 233   grammar_rules_partial_print (out, _("Grammar"), rule_useful_p);
 234 }
 235
 236
 237 /*-------------------.
 238 | Dump the grammar.  |
 239 `-------------------*/
 240
 241 void
 242 grammar_dump (FILE *out, const char *title)
 243 {
 244   fprintf (out, "%s\n\n", title);
 245   fprintf (out,
 246            "ntokens = %d, nvars = %d, nsyms = %d, nrules = %d, nritems = %d\n\n",
 247            ntokens, nvars, nsyms, nrules, nritems);
 248
 249
 250   fprintf (out, "Variables\n---------\n\n");
 251   {
 252     symbol_number_t i;
 253     fprintf (out, "Value  Sprec  Sassoc  Tag\n");
 254
 255     for (i = ntokens; i < nsyms; i++)
 256       fprintf (out, "%5d  %5d   %5d  %s\n",
 257                i,
 258                symbols[i]->prec, symbols[i]->assoc,
 259                symbols[i]->tag);
 260     fprintf (out, "\n\n");
 261   }
 262
 263   fprintf (out, "Rules\n-----\n\n");
 264   {
 265     rule_number_t i;
 266     fprintf (out, "Num (Prec, Assoc, Useful, Ritem Range) Lhs -> Rhs (Ritem range) [Num]\n");
 267     for (i = 0; i < nrules + nuseless_productions; i++)
 268       {
 269         rule_t *rule = &rules[i];
 270         item_number_t *r = NULL;
 271         unsigned int rhs_itemno = rule->rhs - ritem;
 272         unsigned int rhs_count = 0;
 273         /* Find the last RHS index in ritems. */
 274         for (r = rule->rhs; *r >= 0; ++r)
 275           ++rhs_count;
 276         fprintf (out, "%3d (%2d, %2d, %2d, %2u-%2u)   %2d ->",
 277                  i,
 278                  rule->prec ? rule->prec->prec : 0,
 279                  rule->prec ? rule->prec->assoc : 0,
 280                  rule->useful,
 281                  rhs_itemno,
 282                  rhs_itemno + rhs_count - 1,
 283                  rule->lhs->number);
 284         /* Dumped the RHS. */
 285         for (r = rule->rhs; *r >= 0; r++)
 286           fprintf (out, " %3d", *r);
 287         fprintf (out, "  [%d]\n", item_number_as_rule_number (*r));
 288       }
 289   }
 290   fprintf (out, "\n\n");
 291
 292   fprintf (out, "Rules interpreted\n-----------------\n\n");
 293   {
 294     rule_number_t r;
 295     for (r = 0; r < nrules + nuseless_productions; r++)
 296       {
 297         fprintf (out, "%-5d  ", r);
 298         rule_print (&rules[r], out);
 299       }
 300   }
 301   fprintf (out, "\n\n");
 302 }
 303
 304
 305 /*------------------------------------------------------------------.
 306 | Report on STDERR the rules that are not flagged USEFUL, using the |
 307 | MESSAGE (which can be `useless rule' when invoked after grammar   |
 308 | reduction, or `never reduced' after conflicts were taken into     |
 309 | account).                                                         |
 310 `------------------------------------------------------------------*/
 311
 312 void
 313 grammar_rules_never_reduced_report (const char *message)
 314 {
 315   rule_number_t r;
 316   for (r = 0; r < nrules ; ++r)
 317     if (!rules[r].useful)
 318       {
 319         LOCATION_PRINT (stderr, rules[r].location);
 320         fprintf (stderr, ": %s: %s: ",
 321                  _("warning"), message);
 322         rule_print (&rules[r], stderr);
 323       }
 324 }
 325
 326 void
 327 grammar_free (void)
 328 {
 329   XFREE (ritem);
 330   free (rules);
 331   XFREE (token_translations);
 332   /* Free the symbol table data structure.  */
 333   symbols_free ();
 334   free_merger_functions ();
 335 }