]> git.saurik.com Git - bison.git/blobdiff - src/LR0.c
Update
[bison.git] / src / LR0.c
index 9643ee8dc92e676c28eb65094e442ff5029ff757..b37594e6d47debe94a5a8e70ce88dd8c8638abd6 100644 (file)
--- a/src/LR0.c
+++ b/src/LR0.c
@@ -1,5 +1,5 @@
 /* Generate the nondeterministic finite state machine for bison,
 /* Generate the nondeterministic finite state machine for bison,
-   Copyright (C) 1984, 1986, 1989, 2000 Free Software Foundation, Inc.
+   Copyright 1984, 1986, 1989, 2000 Free Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
 
 
    This file is part of Bison, the GNU Compiler Compiler.
 
    The entry point is generate_states.  */
 
 #include "system.h"
    The entry point is generate_states.  */
 
 #include "system.h"
-#include "alloc.h"
+#include "xalloc.h"
 #include "gram.h"
 #include "state.h"
 #include "complain.h"
 #include "closure.h"
 #include "LR0.h"
 
 #include "gram.h"
 #include "state.h"
 #include "complain.h"
 #include "closure.h"
 #include "LR0.h"
 
-extern short *itemset;
-extern short *itemsetend;
 
 int nstates;
 int final_state;
 
 int nstates;
 int final_state;
@@ -70,7 +68,7 @@ allocate_itemsets (void)
   short *symbol_count;
 
   count = 0;
   short *symbol_count;
 
   count = 0;
-  symbol_count = NEW2 (nsyms, short);
+  symbol_count = XCALLOC (short, nsyms);
 
   itemp = ritem;
   symbol = *itemp++;
 
   itemp = ritem;
   symbol = *itemp++;
@@ -90,8 +88,8 @@ allocate_itemsets (void)
      appears as an item, which is symbol_count[symbol].
      We allocate that much space for each symbol.  */
 
      appears as an item, which is symbol_count[symbol].
      We allocate that much space for each symbol.  */
 
-  kernel_base = NEW2 (nsyms, short *);
-  kernel_items = NEW2 (count, short);
+  kernel_base = XCALLOC (short *, nsyms);
+  kernel_items = XCALLOC (short, count);
 
   count = 0;
   for (i = 0; i < nsyms; i++)
 
   count = 0;
   for (i = 0; i < nsyms; i++)
@@ -101,7 +99,7 @@ allocate_itemsets (void)
     }
 
   shift_symbol = symbol_count;
     }
 
   shift_symbol = symbol_count;
-  kernel_end = NEW2 (nsyms, short *);
+  kernel_end = XCALLOC (short *, nsyms);
 }
 
 
 }
 
 
@@ -110,22 +108,22 @@ allocate_storage (void)
 {
   allocate_itemsets ();
 
 {
   allocate_itemsets ();
 
-  shiftset = NEW2 (nsyms, short);
-  redset = NEW2 (nrules + 1, short);
-  state_table = NEW2 (STATE_TABLE_SIZE, core *);
+  shiftset = XCALLOC (short, nsyms);
+  redset = XCALLOC (short, nrules + 1);
+  state_table = XCALLOC (core *, STATE_TABLE_SIZE);
 }
 
 
 static void
 free_storage (void)
 {
 }
 
 
 static void
 free_storage (void)
 {
-  FREE (shift_symbol);
-  FREE (redset);
-  FREE (shiftset);
-  FREE (kernel_base);
-  FREE (kernel_end);
-  FREE (kernel_items);
-  FREE (state_table);
+  XFREE (shift_symbol);
+  XFREE (redset);
+  XFREE (shiftset);
+  XFREE (kernel_base);
+  XFREE (kernel_end);
+  XFREE (kernel_items);
+  XFREE (state_table);
 }
 
 
 }
 
 
@@ -213,7 +211,7 @@ new_state (int symbol)
   n = iend - isp1;
 
   p =
   n = iend - isp1;
 
   p =
-    (core *) xmalloc ((unsigned) (sizeof (core) + (n - 1) * sizeof (short)));
+    (core *) xcalloc ((unsigned) (sizeof (core) + (n - 1) * sizeof (short)), 1);
   p->accessing_symbol = symbol;
   p->number = nstates;
   p->nitems = n;
   p->accessing_symbol = symbol;
   p->number = nstates;
   p->nitems = n;
@@ -351,7 +349,7 @@ new_states (void)
 {
   core *p;
 
 {
   core *p;
 
-  p = (core *) xmalloc ((unsigned) (sizeof (core) - sizeof (short)));
+  p = (core *) xcalloc ((unsigned) (sizeof (core) - sizeof (short)), 1);
   first_state = last_state = this_state = p;
   nstates = 1;
 }
   first_state = last_state = this_state = p;
   nstates = 1;
 }
@@ -365,8 +363,8 @@ save_shifts (void)
   short *sp2;
   short *send;
 
   short *sp2;
   short *send;
 
-  p = (shifts *) xmalloc ((unsigned) (sizeof (shifts) +
-                                     (nshifts - 1) * sizeof (short)));
+  p = (shifts *) xcalloc ((unsigned) (sizeof (shifts) +
+                                     (nshifts - 1) * sizeof (short)), 1);
 
   p->number = this_state->number;
   p->nshifts = nshifts;
 
   p->number = this_state->number;
   p->nshifts = nshifts;
@@ -402,7 +400,7 @@ insert_start_shift (void)
   core *statep;
   shifts *sp;
 
   core *statep;
   shifts *sp;
 
-  statep = (core *) xmalloc ((unsigned) (sizeof (core) - sizeof (short)));
+  statep = (core *) xcalloc ((unsigned) (sizeof (core) - sizeof (short)), 1);
   statep->number = nstates;
   statep->accessing_symbol = start_symbol;
 
   statep->number = nstates;
   statep->accessing_symbol = start_symbol;
 
@@ -410,7 +408,7 @@ insert_start_shift (void)
   last_state = statep;
 
   /* Make a shift from this state to (what will be) the final state.  */
   last_state = statep;
 
   /* Make a shift from this state to (what will be) the final state.  */
-  sp = NEW (shifts);
+  sp = XCALLOC (shifts, 1);
   sp->number = nstates++;
   sp->nshifts = 1;
   sp->shifts[0] = nstates;
   sp->number = nstates++;
   sp->nshifts = 1;
   sp->shifts[0] = nstates;
@@ -467,10 +465,10 @@ augment_automaton (void)
 
              if (sp && sp->number == k)
                {
 
              if (sp && sp->number == k)
                {
-                 sp2 = (shifts *) xmalloc ((unsigned) (sizeof (shifts)
+                 sp2 = (shifts *) xcalloc ((unsigned) (sizeof (shifts)
                                                        +
                                                        sp->nshifts *
                                                        +
                                                        sp->nshifts *
-                                                       sizeof (short)));
+                                                       sizeof (short)), 1);
                  sp2->number = k;
                  sp2->nshifts = sp->nshifts + 1;
                  sp2->shifts[0] = nstates;
                  sp2->number = k;
                  sp2->nshifts = sp->nshifts + 1;
                  sp2->shifts[0] = nstates;
@@ -483,11 +481,11 @@ augment_automaton (void)
                  sp1->next = sp2;
                  if (sp == last_shift)
                    last_shift = sp2;
                  sp1->next = sp2;
                  if (sp == last_shift)
                    last_shift = sp2;
-                 FREE (sp);
+                 XFREE (sp);
                }
              else
                {
                }
              else
                {
-                 sp2 = NEW (shifts);
+                 sp2 = XCALLOC (shifts, 1);
                  sp2->number = k;
                  sp2->nshifts = 1;
                  sp2->shifts[0] = nstates;
                  sp2->number = k;
                  sp2->nshifts = 1;
                  sp2->shifts[0] = nstates;
@@ -506,8 +504,8 @@ augment_automaton (void)
                 going to the next-to-final state (yet to be made).  */
              sp = first_shift;
 
                 going to the next-to-final state (yet to be made).  */
              sp = first_shift;
 
-             sp2 = (shifts *) xmalloc (sizeof (shifts)
-                                       + sp->nshifts * sizeof (short));
+             sp2 = (shifts *) xcalloc (sizeof (shifts)
+                                       + sp->nshifts * sizeof (short), 1);
              sp2->nshifts = sp->nshifts + 1;
 
              /* Stick this shift into the vector at the proper place.  */
              sp2->nshifts = sp->nshifts + 1;
 
              /* Stick this shift into the vector at the proper place.  */
@@ -529,7 +527,7 @@ augment_automaton (void)
              if (last_shift == sp)
                last_shift = sp2;
 
              if (last_shift == sp)
                last_shift = sp2;
 
-             FREE (sp);
+             XFREE (sp);
 
              /* Create the next-to-final state, with shift to
                 what will be the final state.  */
 
              /* Create the next-to-final state, with shift to
                 what will be the final state.  */
@@ -540,7 +538,7 @@ augment_automaton (void)
        {
          /* The initial state didn't even have any shifts.
             Give it one shift, to the next-to-final state.  */
        {
          /* The initial state didn't even have any shifts.
             Give it one shift, to the next-to-final state.  */
-         sp = NEW (shifts);
+         sp = XCALLOC (shifts, 1);
          sp->nshifts = 1;
          sp->shifts[0] = nstates;
 
          sp->nshifts = 1;
          sp->shifts[0] = nstates;
 
@@ -558,7 +556,7 @@ augment_automaton (void)
       /* There are no shifts for any state.
          Make one shift, from the initial state to the next-to-final state.  */
 
       /* There are no shifts for any state.
          Make one shift, from the initial state to the next-to-final state.  */
 
-      sp = NEW (shifts);
+      sp = XCALLOC (shifts, 1);
       sp->nshifts = 1;
       sp->shifts[0] = nstates;
 
       sp->nshifts = 1;
       sp->shifts[0] = nstates;
 
@@ -574,13 +572,13 @@ augment_automaton (void)
   /* Make the final state--the one that follows a shift from the
      next-to-final state.
      The symbol for that shift is 0 (end-of-file).  */
   /* Make the final state--the one that follows a shift from the
      next-to-final state.
      The symbol for that shift is 0 (end-of-file).  */
-  statep = (core *) xmalloc ((unsigned) (sizeof (core) - sizeof (short)));
+  statep = (core *) xcalloc ((unsigned) (sizeof (core) - sizeof (short)), 1);
   statep->number = nstates;
   last_state->next = statep;
   last_state = statep;
 
   /* Make the shift from the final state to the termination state.  */
   statep->number = nstates;
   last_state->next = statep;
   last_state = statep;
 
   /* Make the shift from the final state to the termination state.  */
-  sp = NEW (shifts);
+  sp = XCALLOC (shifts, 1);
   sp->number = nstates++;
   sp->nshifts = 1;
   sp->shifts[0] = nstates;
   sp->number = nstates++;
   sp->nshifts = 1;
   sp->shifts[0] = nstates;
@@ -592,7 +590,7 @@ augment_automaton (void)
   final_state = nstates;
 
   /* Make the termination state.  */
   final_state = nstates;
 
   /* Make the termination state.  */
-  statep = (core *) xmalloc ((unsigned) (sizeof (core) - sizeof (short)));
+  statep = (core *) xcalloc ((unsigned) (sizeof (core) - sizeof (short)), 1);
   statep->number = nstates++;
   last_state->next = statep;
   last_state = statep;
   statep->number = nstates++;
   last_state->next = statep;
   last_state = statep;
@@ -631,8 +629,8 @@ save_reductions (void)
 
   if (count)
     {
 
   if (count)
     {
-      p = (reductions *) xmalloc ((unsigned) (sizeof (reductions) +
-                                             (count - 1) * sizeof (short)));
+      p = (reductions *) xcalloc ((unsigned) (sizeof (reductions) +
+                                             (count - 1) * sizeof (short)), 1);
 
       p->number = this_state->number;
       p->nreds = count;
 
       p->number = this_state->number;
       p->nreds = count;