c++: rename b4_semantic_type_declare as b4_value_type_declare

[bison.git] / lib / abitset.c

diff --git a/lib/abitset.c b/lib/abitset.c
index 40ed871db7272c039199b67726677d173e86592d..f876996bcfdb63a2c9e1fc4472879608fd251b7f 100644 (file)
--- a/lib/abitset.c
+++ b/lib/abitset.c
@@ -1,10 +1,13 @@
 /* Array bitsets.
 /* Array bitsets.

-   Copyright (C) 2002, 2003, 2006 Free Software Foundation, Inc.
+
+   Copyright (C) 2002-2003, 2006, 2009-2013 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,8 +16,7 @@
    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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

 
 #include <config.h>
 
 
 #include <config.h>
 


@@ -45,7 +47,7 @@ abitset_resize (bitset src, bitset_bindex size)
  found and with *NEXT indicating where search stopped.  */
 static bitset_bindex
 abitset_small_list (bitset src, bitset_bindex *list,
  found and with *NEXT indicating where search stopped.  */
 static bitset_bindex
 abitset_small_list (bitset src, bitset_bindex *list,

-                   bitset_bindex num, bitset_bindex *next)
+                    bitset_bindex num, bitset_bindex *next)

 {
   bitset_bindex bitno;
   bitset_bindex count;
 {
   bitset_bindex bitno;
   bitset_bindex count;


@@ -71,27 +73,27 @@ abitset_small_list (bitset src, bitset_bindex *list,
   if (num >= BITSET_WORD_BITS)
     {
       for (count = 0; word; bitno++)
   if (num >= BITSET_WORD_BITS)
     {
       for (count = 0; word; bitno++)

-       {
-         if (word & 1)
-           list[count++] = bitno;
-         word >>= 1;
-       }
+        {
+          if (word & 1)
+            list[count++] = bitno;
+          word >>= 1;
+        }

     }
   else
     {
       for (count = 0; word; bitno++)
     }
   else
     {
       for (count = 0; word; bitno++)

-       {
-         if (word & 1)
-           {
-             list[count++] = bitno;
-             if (count >= num)
-               {
-                 bitno++;
-                 break;
-               }
-           }
-         word >>= 1;
-       }
+        {
+          if (word & 1)
+            {
+              list[count++] = bitno;
+              if (count >= num)
+                {
+                  bitno++;
+                  break;
+                }
+            }
+          word >>= 1;
+        }

     }
 
   *next = bitno;
     }
 
   *next = bitno;


@@ -113,7 +115,7 @@ abitset_set (bitset dst ATTRIBUTE_UNUSED, bitset_bindex bitno ATTRIBUTE_UNUSED)
 /* Reset bit BITNO in bitset DST.  */
 static void
 abitset_reset (bitset dst ATTRIBUTE_UNUSED,
 /* Reset bit BITNO in bitset DST.  */
 static void
 abitset_reset (bitset dst ATTRIBUTE_UNUSED,

-              bitset_bindex bitno ATTRIBUTE_UNUSED)
+               bitset_bindex bitno ATTRIBUTE_UNUSED)

 {
   /* This should never occur for abitsets since we should always hit
      the cache.  It is likely someone is trying to access outside the
 {
   /* This should never occur for abitsets since we should always hit
      the cache.  It is likely someone is trying to access outside the


@@ -124,7 +126,7 @@ abitset_reset (bitset dst ATTRIBUTE_UNUSED,
 /* Test bit BITNO in bitset SRC.  */
 static bool
 abitset_test (bitset src ATTRIBUTE_UNUSED,
 /* Test bit BITNO in bitset SRC.  */
 static bool
 abitset_test (bitset src ATTRIBUTE_UNUSED,

-             bitset_bindex bitno 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.  */


@@ -138,7 +140,7 @@ abitset_test (bitset src ATTRIBUTE_UNUSED,
    stopped.  */
 static bitset_bindex
 abitset_list_reverse (bitset src, bitset_bindex *list,
    stopped.  */
 static bitset_bindex
 abitset_list_reverse (bitset src, bitset_bindex *list,

-                     bitset_bindex num, bitset_bindex *next)
+                      bitset_bindex num, bitset_bindex *next)

 {
   bitset_bindex bitno;
   bitset_bindex rbitno;
 {
   bitset_bindex bitno;
   bitset_bindex rbitno;


@@ -171,18 +173,18 @@ abitset_list_reverse (bitset src, bitset_bindex *list,
 
       word = srcp[windex] << (BITSET_WORD_BITS - 1 - bitcnt);
       for (; word; bitcnt--)
 
       word = srcp[windex] << (BITSET_WORD_BITS - 1 - bitcnt);
       for (; word; bitcnt--)

-       {
-         if (word & BITSET_MSB)
-           {
-             list[count++] = bitoff + bitcnt;
-             if (count >= num)
-               {
-                 *next = n_bits - (bitoff + bitcnt);
-                 return count;
-               }
-           }
-         word <<= 1;
-       }
+        {
+          if (word & BITSET_MSB)
+            {
+              list[count++] = bitoff + bitcnt;
+              if (count >= num)
+                {
+                  *next = n_bits - (bitoff + bitcnt);
+                  return count;
+                }
+            }
+          word <<= 1;
+        }

       bitoff -= BITSET_WORD_BITS;
       bitcnt = BITSET_WORD_BITS - 1;
     }
       bitoff -= BITSET_WORD_BITS;
       bitcnt = BITSET_WORD_BITS - 1;
     }


@@ -198,7 +200,7 @@ abitset_list_reverse (bitset src, bitset_bindex *list,
  found and with *NEXT indicating where search stopped.  */
 static bitset_bindex
 abitset_list (bitset src, bitset_bindex *list,
  found and with *NEXT indicating where search stopped.  */
 static bitset_bindex
 abitset_list (bitset src, bitset_bindex *list,

-             bitset_bindex num, bitset_bindex *next)
+              bitset_bindex num, bitset_bindex *next)

 {
   bitset_bindex bitno;
   bitset_bindex count;
 {
   bitset_bindex bitno;
   bitset_bindex count;


@@ -215,80 +217,80 @@ abitset_list (bitset src, bitset_bindex *list,
     {
       /* Many bitsets are zero, so make this common case fast.  */
       for (windex = 0; windex < size && !srcp[windex]; windex++)
     {
       /* Many bitsets are zero, so make this common case fast.  */
       for (windex = 0; windex < size && !srcp[windex]; windex++)

-       continue;
+        continue;

       if (windex >= size)
       if (windex >= size)

-       return 0;
+        return 0;

 
       /* If num is 1, we could speed things up with a binary search
 
       /* If num is 1, we could speed things up with a binary search

-        of the current word.  */
+         of the current word.  */

 
       bitoff = windex * BITSET_WORD_BITS;
     }
   else
     {
       if (bitno >= BITSET_SIZE_ (src))
 
       bitoff = windex * BITSET_WORD_BITS;
     }
   else
     {
       if (bitno >= BITSET_SIZE_ (src))

-       return 0;
+        return 0;

 
       windex = bitno / BITSET_WORD_BITS;
       bitno = bitno % BITSET_WORD_BITS;
 
       if (bitno)
 
       windex = bitno / BITSET_WORD_BITS;
       bitno = bitno % BITSET_WORD_BITS;
 
       if (bitno)

-       {
-         /* Handle the case where we start within a word.
-            Most often, this is executed with large bitsets
-            with many set bits where we filled the array
-            on the previous call to this function.  */
-
-         bitoff = windex * BITSET_WORD_BITS;
-         word = srcp[windex] >> bitno;
-         for (bitno = bitoff + bitno; word; bitno++)
-           {
-             if (word & 1)
-               {
-                 list[count++] = bitno;
-                 if (count >= num)
-                   {
-                     *next = bitno + 1;
-                     return count;
-                   }
-               }
-             word >>= 1;
-           }
-         windex++;
-       }
+        {
+          /* Handle the case where we start within a word.
+             Most often, this is executed with large bitsets
+             with many set bits where we filled the array
+             on the previous call to this function.  */
+
+          bitoff = windex * BITSET_WORD_BITS;
+          word = srcp[windex] >> bitno;
+          for (bitno = bitoff + bitno; word; bitno++)
+            {
+              if (word & 1)
+                {
+                  list[count++] = bitno;
+                  if (count >= num)
+                    {
+                      *next = bitno + 1;
+                      return count;
+                    }
+                }
+              word >>= 1;
+            }
+          windex++;
+        }

       bitoff = windex * BITSET_WORD_BITS;
     }
 
   for (; windex < size; windex++, bitoff += BITSET_WORD_BITS)
     {
       if (!(word = srcp[windex]))
       bitoff = windex * BITSET_WORD_BITS;
     }
 
   for (; windex < size; windex++, bitoff += BITSET_WORD_BITS)
     {
       if (!(word = srcp[windex]))

-       continue;
+        continue;

 
       if ((count + BITSET_WORD_BITS) < num)
 
       if ((count + BITSET_WORD_BITS) < num)

-       {
-         for (bitno = bitoff; word; bitno++)
-           {
-             if (word & 1)
-               list[count++] = bitno;
-             word >>= 1;
-           }
-       }
+        {
+          for (bitno = bitoff; word; bitno++)
+            {
+              if (word & 1)
+                list[count++] = bitno;
+              word >>= 1;
+            }
+        }

       else
       else

-       {
-         for (bitno = bitoff; word; bitno++)
-           {
-             if (word & 1)
-               {
-                 list[count++] = bitno;
-                 if (count >= num)
-                   {
-                     *next = bitno + 1;
-                     return count;
-                   }
-               }
-             word >>= 1;
-           }
-       }
+        {
+          for (bitno = bitoff; word; bitno++)
+            {
+              if (word & 1)
+                {
+                  list[count++] = bitno;
+                  if (count >= num)
+                    {
+                      *next = bitno + 1;
+                      return count;
+                    }
+                }
+              word >>= 1;
+            }
+        }

     }
 
   *next = bitoff;
     }
 
   *next = bitoff;


@@ -385,7 +387,7 @@ 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 false;
+          return false;

   return true;
 }
 
   return true;
 }
 


@@ -400,7 +402,7 @@ 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 false;
+          return false;

   return true;
 }
 
   return true;
 }
 


@@ -415,7 +417,7 @@ 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 false;
+          return false;

 
   return true;
 }
 
   return true;
 }


@@ -450,10 +452,10 @@ abitset_and_cmp (bitset dst, bitset src1, bitset src2)
       bitset_word tmp = *src1p++ & *src2p++;
 
       if (*dstp != tmp)
       bitset_word tmp = *src1p++ & *src2p++;
 
       if (*dstp != tmp)

-       {
-         changed = true;
-         *dstp = tmp;
-       }
+        {
+          changed = true;
+          *dstp = tmp;
+        }

     }
   return changed;
 }
     }
   return changed;
 }


@@ -488,10 +490,10 @@ abitset_andn_cmp (bitset dst, bitset src1, bitset src2)
       bitset_word tmp = *src1p++ & ~(*src2p++);
 
       if (*dstp != tmp)
       bitset_word tmp = *src1p++ & ~(*src2p++);
 
       if (*dstp != tmp)

-       {
-         changed = true;
-         *dstp = tmp;
-       }
+        {
+          changed = true;
+          *dstp = tmp;
+        }

     }
   return changed;
 }
     }
   return changed;
 }


@@ -526,10 +528,10 @@ abitset_or_cmp (bitset dst, bitset src1, bitset src2)
       bitset_word tmp = *src1p++ | *src2p++;
 
       if (*dstp != tmp)
       bitset_word tmp = *src1p++ | *src2p++;
 
       if (*dstp != tmp)

-       {
-         changed = true;
-         *dstp = tmp;
-       }
+        {
+          changed = true;
+          *dstp = tmp;
+        }

     }
   return changed;
 }
     }
   return changed;
 }


@@ -564,10 +566,10 @@ abitset_xor_cmp (bitset dst, bitset src1, bitset src2)
       bitset_word tmp = *src1p++ ^ *src2p++;
 
       if (*dstp != tmp)
       bitset_word tmp = *src1p++ ^ *src2p++;
 
       if (*dstp != tmp)

-       {
-         changed = true;
-         *dstp = tmp;
-       }
+        {
+          changed = true;
+          *dstp = tmp;
+        }

     }
   return changed;
 }
     }
   return changed;
 }


@@ -604,10 +606,10 @@ abitset_and_or_cmp (bitset dst, bitset src1, bitset src2, bitset src3)
       bitset_word tmp = (*src1p++ & *src2p++) | *src3p++;
 
       if (*dstp != tmp)
       bitset_word tmp = (*src1p++ & *src2p++) | *src3p++;
 
       if (*dstp != tmp)

-       {
-         changed = true;
-         *dstp = tmp;
-       }
+        {
+          changed = true;
+          *dstp = tmp;
+        }

     }
   return changed;
 }
     }
   return changed;
 }


@@ -644,10 +646,10 @@ abitset_andn_or_cmp (bitset dst, bitset src1, bitset src2, bitset src3)
       bitset_word tmp = (*src1p++ & ~(*src2p++)) | *src3p++;
 
       if (*dstp != tmp)
       bitset_word tmp = (*src1p++ & ~(*src2p++)) | *src3p++;
 
       if (*dstp != tmp)

-       {
-         changed = true;
-         *dstp = tmp;
-       }
+        {
+          changed = true;
+          *dstp = tmp;
+        }

     }
   return changed;
 }
     }
   return changed;
 }


@@ -684,10 +686,10 @@ abitset_or_and_cmp (bitset dst, bitset src1, bitset src2, bitset src3)
       bitset_word tmp = (*src1p++ | *src2p++) & *src3p++;
 
       if (*dstp != tmp)
       bitset_word tmp = (*src1p++ | *src2p++) & *src3p++;
 
       if (*dstp != tmp)

-       {
-         changed = true;
-         *dstp = tmp;
-       }
+        {
+          changed = true;
+          *dstp = tmp;
+        }

     }
   return changed;
 }
     }
   return changed;
 }