src/derives.c

   1 /* Match rules with nonterminals for bison,
   2    Copyright 1984, 1989, 2000, 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 "getargs.h"
  24 #include "symtab.h"
  25 #include "types.h"
  26 #include "reader.h"
  27 #include "gram.h"
  28 #include "derives.h"
  29
  30 rule_number_t **derives = NULL;
  31
  32 static void
  33 print_derives (void)
  34 {
  35   int i;
  36
  37   fputs ("DERIVES\n", stderr);
  38
  39   for (i = ntokens; i < nsyms; i++)
  40     {
  41       rule_number_t *rp;
  42       fprintf (stderr, "\t%s derives\n", symbols[i]->tag);
  43       for (rp = derives[i]; *rp > 0; rp++)
  44         {
  45           item_number_t *rhsp;
  46           fprintf (stderr, "\t\t%d:", *rp);
  47           for (rhsp = rules[*rp].rhs; *rhsp >= 0; ++rhsp)
  48             fprintf (stderr, " %s", symbol_tag_get (symbols[*rhsp]));
  49           fprintf (stderr, " (rule %d)\n",
  50                    rule_number_of_item_number (*rhsp) - 1);
  51         }
  52     }
  53
  54   fputs ("\n\n", stderr);
  55 }
  56
  57
  58 void
  59 set_derives (void)
  60 {
  61   symbol_number_t i;
  62   rule_number_t r;
  63   shorts *p;
  64   rule_number_t *q;
  65   shorts **dset;
  66   shorts *delts;
  67
  68   dset = XCALLOC (shorts *, nvars) - ntokens;
  69   delts = XCALLOC (shorts, nrules + 1);
  70
  71   p = delts;
  72   for (r = nrules; r > 0; r--)
  73     {
  74       symbol_number_t lhs = rules[r].lhs->number;
  75       p->next = dset[lhs];
  76       p->value = r;
  77       dset[lhs] = p;
  78       p++;
  79     }
  80
  81   derives = XCALLOC (rule_number_t *, nvars) - ntokens;
  82   q = XCALLOC (short, nvars + int_of_rule_number (nrules));
  83
  84   for (i = ntokens; i < nsyms; i++)
  85     {
  86       derives[i] = q;
  87       p = dset[i];
  88       while (p)
  89         {
  90           *q++ = p->value;
  91           p = p->next;
  92         }
  93       *q++ = -1;
  94     }
  95
  96   if (trace_flag)
  97     print_derives ();
  98
  99   XFREE (dset + ntokens);
 100   XFREE (delts);
 101 }
 102
 103 void
 104 free_derives (void)
 105 {
 106   XFREE (derives[ntokens]);
 107   XFREE (derives + ntokens);
 108 }