(EXTRA_DIST): Avoid +=, a GNU make extension.

[bison.git] / src / derives.c

diff --git a/src/derives.c b/src/derives.c
index 9bd37c92d02acb9efb023871fd97c615c7d24a5d..746929755855c07c41d397ac7395c936e6f9ed59 100644 (file)
--- a/src/derives.c
+++ b/src/derives.c
@@ -1,5 +1,5 @@
 /* Match rules with nonterminals for bison,
 /* Match rules with nonterminals for bison,

-   Copyright (C) 1984, 1989, 2000 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1989, 2000, 2001, 2002  Free Software Foundation, Inc.

 
    This file is part of Bison, the GNU Compiler Compiler.
 
 
    This file is part of Bison, the GNU Compiler Compiler.
 


@@ -19,96 +19,99 @@
    Boston, MA 02111-1307, USA.  */
 
 
    Boston, MA 02111-1307, USA.  */
 
 

-/* set_derives finds, for each variable (nonterminal), which rules can
-   derive it.  It sets up the value of derives so that derives[i -
-   ntokens] points to a vector of rule numbers, terminated with -1.
-   */
-

 #include "system.h"
 #include "system.h"

-#include "alloc.h"
-#include "types.h"
+#include "getargs.h"
+#include "symtab.h"
+#include "reader.h"

 #include "gram.h"
 #include "derives.h"
 
 #include "gram.h"
 #include "derives.h"
 

-short **derives;
+/* Linked list of rule numbers.  */
+typedef struct rule_list_s
+{
+  struct rule_list_s *next;
+  rule_t *value;
+} rule_list_t;

 
 

-#if DEBUG
+rule_t ***derives = NULL;

 
 static void
 print_derives (void)
 {
 
 static void
 print_derives (void)
 {

-  register int i;
-  register short *sp;
+  int i;

 
 

-  printf (_("\n\n\nDERIVES\n\n"));
+  fputs ("DERIVES\n", stderr);

 
   for (i = ntokens; i < nsyms; i++)
     {
 
   for (i = ntokens; i < nsyms; i++)
     {

-      printf (_("%s derives"), tags[i]);
-      for (sp = derives[i]; *sp > 0; sp++)
+      rule_t **rp;
+      fprintf (stderr, "\t%s derives\n", symbols[i]->tag);
+      for (rp = derives[i]; *rp; ++rp)

        {
        {

-         printf ("  %d", *sp);
+         fprintf (stderr, "\t\t%3d ", (*rp)->user_number);
+         rule_rhs_print (*rp, stderr);

        }
        }

-      putchar ('\n');

     }
 
     }
 

-  putchar ('\n');
+  fputs ("\n\n", stderr);

 }
 
 }
 

-#endif

 
 void
 
 void

-set_derives (void)
+derives_compute (void)

 {
 {

-  register int i;
-  register int lhs;
-  register shorts *p;
-  register short *q;
-  register shorts **dset;
-  register shorts *delts;
-
-  dset = NEW2 (nvars, shorts *) - ntokens;
-  delts = NEW2 (nrules + 1, shorts);
-
-  p = delts;
-  for (i = nrules; i > 0; i--)
+  symbol_number_t i;
+  int r;
+  rule_t **q;
+
+  /* DSET[NTERM] -- A linked list of the numbers of the rules whose
+     LHS is NTERM.  */
+  rule_list_t **dset = XCALLOC (rule_list_t *, nvars) - ntokens;
+
+  /* DELTS[RULE] -- There are NRULES rule number to attach to nterms.
+     Instead of performing NRULES allocations for each, have an array
+     indexed by rule numbers.  */
+  rule_list_t *delts = XCALLOC (rule_list_t, nrules);
+
+  for (r = nrules - 1; r >= 0; --r)

     {
     {

-      lhs = rlhs[i];
-      if (lhs >= 0)
-       {
-         p->next = dset[lhs];
-         p->value = i;
-         dset[lhs] = p;
-         p++;
-       }
+      symbol_number_t lhs = rules[r].lhs->number;
+      rule_list_t *p = &delts[r];
+      /* A new LHS is found.  */
+      p->next = dset[lhs];
+      p->value = &rules[r];
+      dset[lhs] = p;

     }
 
     }
 

-  derives = NEW2 (nvars, short *) - ntokens;
-  q = NEW2 (nvars + nrules, short);
+  /* DSET contains what we need under the form of a linked list.  Make
+     it a single array.  */
+
+  derives = XCALLOC (rule_t **, nvars) - ntokens;
+  q = XCALLOC (rule_t *, nvars + int_of_rule_number (nrules));

 
   for (i = ntokens; i < nsyms; i++)
     {
 
   for (i = ntokens; i < nsyms; i++)
     {

+      rule_list_t *p = dset[i];

       derives[i] = q;
       derives[i] = q;

-      p = dset[i];

       while (p)
        {
          *q++ = p->value;
          p = p->next;
        }
       while (p)
        {
          *q++ = p->value;
          p = p->next;
        }

-      *q++ = -1;
+      *q++ = NULL;

     }
 
     }
 

-#if DEBUG
-  print_derives ();
-#endif
+  if (trace_flag & trace_sets)
+    print_derives ();

 
 

-  FREE (dset + ntokens);
-  FREE (delts);
+  free (dset + ntokens);
+  free (delts);

 }
 
 }
 

+

 void
 void

-free_derives (void)
+derives_free (void)

 {
 {

-  FREE (derives[ntokens]);
-  FREE (derives + ntokens);
+  XFREE (derives[ntokens]);
+  XFREE (derives + ntokens);

 }
 }