Java: Fix syntax error handling without error token.

[bison.git] / lib / abitset.c

diff --git a/lib/abitset.c b/lib/abitset.c
index 2d5ca293c7c4d516eafbe7d81ca0b0cfeb709480..5ffba830dc2fab9e7c5570574a7a67412e938f50 100644 (file)
--- a/lib/abitset.c
+++ b/lib/abitset.c
@@ -1,10 +1,13 @@
 /* Array bitsets.
 /* Array bitsets.

-   Copyright (C) 2002 Free Software Foundation, Inc.
+
+   Copyright (C) 2002-2003, 2006, 2009-2012 Free Software Foundation,
+   Inc.
+

    Contributed by Michael Hayes (m.hayes@elec.canterbury.ac.nz).
 
    Contributed by Michael Hayes (m.hayes@elec.canterbury.ac.nz).
 

-   This program is free software; you can redistribute it and/or modify
+   This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by
    it under the terms of the GNU General Public License as published by

-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation, either version 3 of the License, or

    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -13,13 +16,9 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License

-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-*/
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

 
 

-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
+#include <config.h>

 
 #include "abitset.h"
 #include <stddef.h>
 
 #include "abitset.h"
 #include <stddef.h>


@@ -31,16 +30,17 @@
 
 #define ABITSET_N_WORDS(N) (((N) + BITSET_WORD_BITS - 1) / BITSET_WORD_BITS)
 #define ABITSET_WORDS(X) ((X)->a.words)
 
 #define ABITSET_N_WORDS(N) (((N) + BITSET_WORD_BITS - 1) / BITSET_WORD_BITS)
 #define ABITSET_WORDS(X) ((X)->a.words)

-#define ABITSET_N_BITS(X) ((X)->a.n_bits)

 
 
 
 

-/* Return size in bits of bitset SRC.  */

 static bitset_bindex
 static bitset_bindex

-abitset_size (bitset src)
+abitset_resize (bitset src, bitset_bindex size)

 {
 {

-  return ABITSET_N_BITS (src);
-}
+    /* These bitsets have a fixed size.  */
+    if (BITSET_SIZE_ (src) != size)
+      abort ();

 
 

+    return size;
+}

 
 /* Find list of up to NUM bits set in BSET starting from and including
  *NEXT and store in array LIST.  Return with actual number of bits
 
 /* Find list of up to NUM bits set in BSET starting from and including
  *NEXT and store in array LIST.  Return with actual number of bits


@@ -60,7 +60,7 @@ abitset_small_list (bitset src, bitset_bindex *list,
   if (!word)
     return 0;
 
   if (!word)
     return 0;
 

-  size = ABITSET_N_BITS (src);
+  size = BITSET_SIZE_ (src);

   bitno = *next;
   if (bitno >= size)
     return 0;
   bitno = *next;
   if (bitno >= size)
     return 0;


@@ -105,8 +105,9 @@ abitset_small_list (bitset src, bitset_bindex *list,
 static void
 abitset_set (bitset dst ATTRIBUTE_UNUSED, bitset_bindex bitno ATTRIBUTE_UNUSED)
 {
 static void
 abitset_set (bitset dst ATTRIBUTE_UNUSED, bitset_bindex bitno ATTRIBUTE_UNUSED)
 {

-  /* This should never occur for abitsets since we should always
-     hit the cache.  */
+  /* This should never occur for abitsets since we should always hit
+     the cache.  It is likely someone is trying to access outside the
+     bounds of the bitset.  */

   abort ();
 }
 
   abort ();
 }
 


@@ -116,21 +117,20 @@ static void
 abitset_reset (bitset dst ATTRIBUTE_UNUSED,
               bitset_bindex bitno ATTRIBUTE_UNUSED)
 {
 abitset_reset (bitset dst ATTRIBUTE_UNUSED,
               bitset_bindex bitno ATTRIBUTE_UNUSED)
 {

-  /* This should never occur for abitsets since we should always
-     hit the cache.  */
-  abort ();
+  /* This should never occur for abitsets since we should always hit
+     the cache.  It is likely someone is trying to access outside the
+     bounds of the bitset.  Since the bit is zero anyway, let it pass.  */

 }
 
 
 /* Test bit BITNO in bitset SRC.  */
 }
 
 
 /* Test bit BITNO in bitset SRC.  */

-static int
+static bool

 abitset_test (bitset src ATTRIBUTE_UNUSED,
              bitset_bindex bitno ATTRIBUTE_UNUSED)
 {
   /* This should never occur for abitsets since we should always
      hit the cache.  */
 abitset_test (bitset src ATTRIBUTE_UNUSED,
              bitset_bindex bitno ATTRIBUTE_UNUSED)
 {
   /* This should never occur for abitsets since we should always
      hit the cache.  */

-  abort ();
-  return 0;
+  return false;

 }
 
 
 }
 
 


@@ -149,7 +149,7 @@ abitset_list_reverse (bitset src, bitset_bindex *list,
   unsigned int bitcnt;
   bitset_bindex bitoff;
   bitset_word *srcp = ABITSET_WORDS (src);
   unsigned int bitcnt;
   bitset_bindex bitoff;
   bitset_word *srcp = ABITSET_WORDS (src);

-  bitset_bindex n_bits = ABITSET_N_BITS (src);
+  bitset_bindex n_bits = BITSET_SIZE_ (src);

 
   rbitno = *next;
 
 
   rbitno = *next;
 


@@ -228,7 +228,7 @@ abitset_list (bitset src, bitset_bindex *list,
     }
   else
     {
     }
   else
     {

-      if (bitno >= ABITSET_N_BITS (src))
+      if (bitno >= BITSET_SIZE_ (src))

        return 0;
 
       windex = bitno / BITSET_WORD_BITS;
        return 0;
 
       windex = bitno / BITSET_WORD_BITS;


@@ -304,7 +304,7 @@ abitset_unused_clear (bitset dst)
 {
   unsigned int last_bit;
 
 {
   unsigned int last_bit;
 

-  last_bit = ABITSET_N_BITS (dst) % BITSET_WORD_BITS;
+  last_bit = BITSET_SIZE_ (dst) % BITSET_WORD_BITS;

   if (last_bit)
     ABITSET_WORDS (dst)[dst->b.csize - 1] &=
       ((bitset_word) 1 << last_bit) - 1;
   if (last_bit)
     ABITSET_WORDS (dst)[dst->b.csize - 1] &=
       ((bitset_word) 1 << last_bit) - 1;


@@ -336,7 +336,7 @@ abitset_zero (bitset dst)
 }
 
 
 }
 
 

-static int
+static bool

 abitset_empty_p (bitset dst)
 {
   bitset_windex i;
 abitset_empty_p (bitset dst)
 {
   bitset_windex i;


@@ -344,9 +344,9 @@ abitset_empty_p (bitset dst)
 
   for (i = 0; i < dst->b.csize; i++)
     if (dstp[i])
 
   for (i = 0; i < dst->b.csize; i++)
     if (dstp[i])

-      return 0;
+      return false;

 
 

-  return 1;
+  return true;

 }
 
 
 }
 
 


@@ -377,7 +377,7 @@ abitset_not (bitset dst, bitset src)
 }
 
 
 }
 
 

-static int
+static bool

 abitset_equal_p (bitset dst, bitset src)
 {
   bitset_windex i;
 abitset_equal_p (bitset dst, bitset src)
 {
   bitset_windex i;


@@ -387,12 +387,12 @@ abitset_equal_p (bitset dst, bitset src)
 
   for (i = 0; i < size; i++)
       if (*srcp++ != *dstp++)
 
   for (i = 0; i < size; i++)
       if (*srcp++ != *dstp++)

-         return 0;
-  return 1;
+         return false;
+  return true;

 }
 
 
 }
 
 

-static int
+static bool

 abitset_subset_p (bitset dst, bitset src)
 {
   bitset_windex i;
 abitset_subset_p (bitset dst, bitset src)
 {
   bitset_windex i;


@@ -402,12 +402,12 @@ abitset_subset_p (bitset dst, bitset src)
 
   for (i = 0; i < size; i++, dstp++, srcp++)
       if (*dstp != (*srcp | *dstp))
 
   for (i = 0; i < size; i++, dstp++, srcp++)
       if (*dstp != (*srcp | *dstp))

-         return 0;
-  return 1;
+         return false;
+  return true;

 }
 
 
 }
 
 

-static int
+static bool

 abitset_disjoint_p (bitset dst, bitset src)
 {
   bitset_windex i;
 abitset_disjoint_p (bitset dst, bitset src)
 {
   bitset_windex i;


@@ -417,9 +417,9 @@ abitset_disjoint_p (bitset dst, bitset src)
 
   for (i = 0; i < size; i++)
       if (*srcp++ & *dstp++)
 
   for (i = 0; i < size; i++)
       if (*srcp++ & *dstp++)

-         return 0;
+         return false;

 
 

-  return 1;
+  return true;

 }
 
 
 }
 
 


@@ -437,11 +437,11 @@ abitset_and (bitset dst, bitset src1, bitset src2)
 }
 
 
 }
 
 

-static int
+static bool

 abitset_and_cmp (bitset dst, bitset src1, bitset src2)
 {
   bitset_windex i;
 abitset_and_cmp (bitset dst, bitset src1, bitset src2)
 {
   bitset_windex i;

-  int changed = 0;
+  bool changed = false;

   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *dstp = ABITSET_WORDS (dst);
   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *dstp = ABITSET_WORDS (dst);


@@ -453,7 +453,7 @@ abitset_and_cmp (bitset dst, bitset src1, bitset src2)
 
       if (*dstp != tmp)
        {
 
       if (*dstp != tmp)
        {

-         changed = 1;
+         changed = true;

          *dstp = tmp;
        }
     }
          *dstp = tmp;
        }
     }


@@ -475,11 +475,11 @@ abitset_andn (bitset dst, bitset src1, bitset src2)
 }
 
 
 }
 
 

-static int
+static bool

 abitset_andn_cmp (bitset dst, bitset src1, bitset src2)
 {
   bitset_windex i;
 abitset_andn_cmp (bitset dst, bitset src1, bitset src2)
 {
   bitset_windex i;

-  int changed = 0;
+  bool changed = false;

   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *dstp = ABITSET_WORDS (dst);
   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *dstp = ABITSET_WORDS (dst);


@@ -491,7 +491,7 @@ abitset_andn_cmp (bitset dst, bitset src1, bitset src2)
 
       if (*dstp != tmp)
        {
 
       if (*dstp != tmp)
        {

-         changed = 1;
+         changed = true;

          *dstp = tmp;
        }
     }
          *dstp = tmp;
        }
     }


@@ -513,11 +513,11 @@ abitset_or (bitset dst, bitset src1, bitset src2)
 }
 
 
 }
 
 

-static int
+static bool

 abitset_or_cmp (bitset dst, bitset src1, bitset src2)
 {
   bitset_windex i;
 abitset_or_cmp (bitset dst, bitset src1, bitset src2)
 {
   bitset_windex i;

-  int changed = 0;
+  bool changed = false;

   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *dstp = ABITSET_WORDS (dst);
   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *dstp = ABITSET_WORDS (dst);


@@ -529,7 +529,7 @@ abitset_or_cmp (bitset dst, bitset src1, bitset src2)
 
       if (*dstp != tmp)
        {
 
       if (*dstp != tmp)
        {

-         changed = 1;
+         changed = true;

          *dstp = tmp;
        }
     }
          *dstp = tmp;
        }
     }


@@ -551,11 +551,11 @@ abitset_xor (bitset dst, bitset src1, bitset src2)
 }
 
 
 }
 
 

-static int
+static bool

 abitset_xor_cmp (bitset dst, bitset src1, bitset src2)
 {
   bitset_windex i;
 abitset_xor_cmp (bitset dst, bitset src1, bitset src2)
 {
   bitset_windex i;

-  int changed = 0;
+  bool changed = false;

   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *dstp = ABITSET_WORDS (dst);
   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *dstp = ABITSET_WORDS (dst);


@@ -567,7 +567,7 @@ abitset_xor_cmp (bitset dst, bitset src1, bitset src2)
 
       if (*dstp != tmp)
        {
 
       if (*dstp != tmp)
        {

-         changed = 1;
+         changed = true;

          *dstp = tmp;
        }
     }
          *dstp = tmp;
        }
     }


@@ -590,11 +590,11 @@ abitset_and_or (bitset dst, bitset src1, bitset src2, bitset src3)
 }
 
 
 }
 
 

-static int
+static bool

 abitset_and_or_cmp (bitset dst, bitset src1, bitset src2, bitset src3)
 {
   bitset_windex i;
 abitset_and_or_cmp (bitset dst, bitset src1, bitset src2, bitset src3)
 {
   bitset_windex i;

-  int changed = 0;
+  bool changed = false;

   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *src3p = ABITSET_WORDS (src3);
   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *src3p = ABITSET_WORDS (src3);


@@ -607,7 +607,7 @@ abitset_and_or_cmp (bitset dst, bitset src1, bitset src2, bitset src3)
 
       if (*dstp != tmp)
        {
 
       if (*dstp != tmp)
        {

-         changed = 1;
+         changed = true;

          *dstp = tmp;
        }
     }
          *dstp = tmp;
        }
     }


@@ -630,11 +630,11 @@ abitset_andn_or (bitset dst, bitset src1, bitset src2, bitset src3)
 }
 
 
 }
 
 

-static int
+static bool

 abitset_andn_or_cmp (bitset dst, bitset src1, bitset src2, bitset src3)
 {
   bitset_windex i;
 abitset_andn_or_cmp (bitset dst, bitset src1, bitset src2, bitset src3)
 {
   bitset_windex i;

-  int changed = 0;
+  bool changed = false;

   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *src3p = ABITSET_WORDS (src3);
   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *src3p = ABITSET_WORDS (src3);


@@ -647,7 +647,7 @@ abitset_andn_or_cmp (bitset dst, bitset src1, bitset src2, bitset src3)
 
       if (*dstp != tmp)
        {
 
       if (*dstp != tmp)
        {

-         changed = 1;
+         changed = true;

          *dstp = tmp;
        }
     }
          *dstp = tmp;
        }
     }


@@ -670,11 +670,11 @@ abitset_or_and (bitset dst, bitset src1, bitset src2, bitset src3)
 }
 
 
 }
 
 

-static int
+static bool

 abitset_or_and_cmp (bitset dst, bitset src1, bitset src2, bitset src3)
 {
   bitset_windex i;
 abitset_or_and_cmp (bitset dst, bitset src1, bitset src2, bitset src3)
 {
   bitset_windex i;

-  int changed = 0;
+  bool changed = false;

   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *src3p = ABITSET_WORDS (src3);
   bitset_word *src1p = ABITSET_WORDS (src1);
   bitset_word *src2p = ABITSET_WORDS (src2);
   bitset_word *src3p = ABITSET_WORDS (src3);


@@ -687,7 +687,7 @@ abitset_or_and_cmp (bitset dst, bitset src1, bitset src2, bitset src3)
 
       if (*dstp != tmp)
        {
 
       if (*dstp != tmp)
        {

-         changed = 1;
+         changed = true;

          *dstp = tmp;
        }
     }
          *dstp = tmp;
        }
     }


@@ -711,7 +711,8 @@ struct bitset_vtable abitset_small_vtable = {
   abitset_reset,
   bitset_toggle_,
   abitset_test,
   abitset_reset,
   bitset_toggle_,
   abitset_test,

-  abitset_size,
+  abitset_resize,
+  bitset_size_,

   bitset_count_,
   abitset_empty_p,
   abitset_ones,
   bitset_count_,
   abitset_empty_p,
   abitset_ones,


@@ -748,7 +749,8 @@ struct bitset_vtable abitset_vtable = {
   abitset_reset,
   bitset_toggle_,
   abitset_test,
   abitset_reset,
   bitset_toggle_,
   abitset_test,

-  abitset_size,
+  abitset_resize,
+  bitset_size_,

   bitset_count_,
   abitset_empty_p,
   abitset_ones,
   bitset_count_,
   abitset_empty_p,
   abitset_ones,


@@ -809,7 +811,7 @@ abitset_init (bitset bset, bitset_bindex n_bits)
   bitset_windex size;
 
   size = ABITSET_N_WORDS (n_bits);
   bitset_windex size;
 
   size = ABITSET_N_WORDS (n_bits);

-  ABITSET_N_BITS (bset) = n_bits;
+  BITSET_NBITS_ (bset) = n_bits;

 
   /* Use optimized routines if bitset fits within a single word.
      There is probably little merit if using caching since
 
   /* Use optimized routines if bitset fits within a single word.
      There is probably little merit if using caching since