Cosmetic changes

[libfirm] / ir / adt / bitset.h

diff --git a/ir/adt/bitset.h b/ir/adt/bitset.h
index 4f249be..a3f737e 100644 (file)
--- a/ir/adt/bitset.h
+++ b/ir/adt/bitset.h
@@ -8,12 +8,20 @@
 #ifndef __FIRM_BITSET_H
 #define __FIRM_BITSET_H
 
+#include "firm_config.h"
+
 #include <stdlib.h>
 #include <stdio.h>
 #include <assert.h>
 #include <string.h>
 
-#include "firm_config.h"
+#ifdef _WIN32
+#include <malloc.h>
+#else
+#include <alloca.h>
+#endif
+
+#include "xmalloc.h"
 #include "bitfiddle.h"
 
 typedef unsigned int bitset_pos_t;
@@ -28,7 +36,7 @@ typedef unsigned int bitset_pos_t;
 
 typedef struct _bitset_t {
        bitset_pos_t units;
-  bitset_pos_t size;
+       bitset_pos_t size;
        bitset_unit_t *data;
 } bitset_t;
 
@@ -60,7 +68,7 @@ static INLINE bitset_t *_bitset_prepare(void *area, bitset_pos_t size)
        bitset_t *ptr = area;
        memset(area, 0, _bitset_overall_size(sizeof(bitset_t), size));
        ptr->units = _bitset_units(size);
-  ptr->size = size;
+       ptr->size = size;
        ptr->data = _bitset_data_ptr(area, sizeof(bitset_t), size);
        return ptr;
 }
@@ -73,8 +81,10 @@ static INLINE bitset_t *_bitset_prepare(void *area, bitset_pos_t size)
  */
 static INLINE bitset_t *_bitset_mask_highest(bitset_t *bs)
 {
-  bs->data[bs->units - 1] &= (1 << (bs->size & BS_UNIT_MASK)) - 1;
-  return bs;
+       bitset_pos_t rest = bs->size & BS_UNIT_MASK;
+       if (rest)
+               bs->data[bs->units - 1] &= (1 << rest) - 1;
+       return bs;
 }
 
 /**
@@ -90,7 +100,7 @@ static INLINE bitset_t *_bitset_mask_highest(bitset_t *bs)
  * @param bs The bitset.
  * @return The highest bit which can be set or cleared plus 1.
  */
-#define bistet_size(bs)  ((bs)->size)
+#define bitset_size(bs)  ((bs)->size)
 
 /**
  * Allocate a bitset on an obstack.
@@ -99,7 +109,7 @@ static INLINE bitset_t *_bitset_mask_highest(bitset_t *bs)
  * @return A pointer to an empty initialized bitset.
  */
 #define bitset_obstack_alloc(obst,size) \
-  _bitset_prepare(obstack_alloc(obst, _bitset_overall_size(sizeof(bitset_t), size)), size)
+       _bitset_prepare(obstack_alloc(obst, _bitset_overall_size(sizeof(bitset_t), size)), size)
 
 /**
  * Allocate a bitset via malloc.
@@ -107,7 +117,7 @@ static INLINE bitset_t *_bitset_mask_highest(bitset_t *bs)
  * @return A pointer to an empty initialized bitset.
  */
 #define bitset_malloc(size) \
-       _bitset_prepare(malloc(_bitset_overall_size(sizeof(bitset_t), size)), size)
+       _bitset_prepare(xmalloc(_bitset_overall_size(sizeof(bitset_t), size)), size)
 
 /**
  * Free a bitset allocated with bitset_malloc().
@@ -134,7 +144,7 @@ static INLINE bitset_t *_bitset_mask_highest(bitset_t *bs)
 static INLINE bitset_unit_t *_bitset_get_unit(const bitset_t *bs, bitset_pos_t bit)
 {
        /* assert(bit < bs->units * BS_UNIT_SIZE_BITS && "Bit too large"); */
-  assert(bit <= bs->size && "Bit to large");
+       assert(bit <= bs->size && "Bit to large");
        return bs->data + bit / BS_UNIT_SIZE_BITS;
 }
 
@@ -183,6 +193,18 @@ static INLINE void bitset_flip(bitset_t *bs, bitset_pos_t bit)
        _bitset_inside_flip(unit, bit & BS_UNIT_MASK);
 }
 
+/**
+ * Flip the whole bitset.
+ * @param bs The bitset.
+ */
+static INLINE void bitset_flip_all(bitset_t *bs)
+{
+       bitset_pos_t i;
+       for(i = 0; i < bs->units; i++)
+               _bitset_inside_flip_unit(&bs->data[i]);
+       _bitset_mask_highest(bs);
+}
+
 /**
  * Copy a bitset to another.
  * @param tgt The target bitset.
@@ -252,8 +274,9 @@ static INLINE bitset_pos_t _bitset_next(const bitset_t *bs,
                bitset_pos_t pos, int set)
 {
        bitset_pos_t unit_number = pos / BS_UNIT_SIZE_BITS;
+       bitset_pos_t res;
 
-       if(unit_number >= bs->units)
+       if(pos >= bs->size)
                return -1;
 
        {
@@ -275,8 +298,10 @@ static INLINE bitset_pos_t _bitset_next(const bitset_t *bs,
                        _bitset_inside_ntz_value((set ? curr_unit : ~curr_unit) & ~in_unit_mask);
 
                /* If there is a bit set in the current unit, exit. */
-               if(next_in_this_unit < BS_UNIT_SIZE_BITS)
-                       return next_in_this_unit + unit_number * BS_UNIT_SIZE_BITS;
+               if (next_in_this_unit < BS_UNIT_SIZE_BITS) {
+                       res = next_in_this_unit + unit_number * BS_UNIT_SIZE_BITS;
+                       return res < bs->size ? res : -1;
+               }
 
                /* Else search for set bits in the next units. */
                else {
@@ -286,8 +311,10 @@ static INLINE bitset_pos_t _bitset_next(const bitset_t *bs,
                                bitset_pos_t first_set =
                                        _bitset_inside_ntz_value(set ? data : ~data);
 
-                               if(first_set < BS_UNIT_SIZE_BITS)
-                                       return first_set + i * BS_UNIT_SIZE_BITS;
+                               if (first_set < BS_UNIT_SIZE_BITS) {
+                                       res = first_set + i * BS_UNIT_SIZE_BITS;
+                                       return res < bs->size ? res : -1;
+                               }
                        }
                }
        }
@@ -304,11 +331,11 @@ static INLINE bitset_pos_t _bitset_next(const bitset_t *bs,
  * @param elm A unsigned long variable.
  */
 #define bitset_foreach(bitset,elm) \
-  for(elm = bitset_next_set(bitset,0); elm != -1; elm = bitset_next_set(bitset,elm+1))
+       for(elm = bitset_next_set(bitset,0); elm != -1; elm = bitset_next_set(bitset,elm+1))
 
 
 #define bitset_foreach_clear(bitset,elm) \
-  for(elm = bitset_next_clear(bitset,0); elm != -1; elm = bitset_next_clear(bitset,elm+1))
+       for(elm = bitset_next_clear(bitset,0); elm != -1; elm = bitset_next_clear(bitset,elm+1))
 
 /**
  * Count the bits set.
@@ -335,7 +362,7 @@ static INLINE bitset_pos_t bitset_popcnt(const bitset_t *bs)
 static INLINE bitset_t *bitset_clear_all(bitset_t *bs)
 {
        memset(bs->data, 0, BS_UNIT_SIZE * bs->units);
-  return bs;
+       return bs;
 }
 
 /**
@@ -346,7 +373,7 @@ static INLINE bitset_t *bitset_clear_all(bitset_t *bs)
 static INLINE bitset_t *bitset_set_all(bitset_t *bs)
 {
        memset(bs->data, -1, bs->units * BS_UNIT_SIZE);
-  return _bitset_mask_highest(bs);
+       return _bitset_mask_highest(bs);
 }
 
 /**
@@ -392,23 +419,23 @@ static INLINE void bitset_minus1(bitset_t *bs)
 {
 #define _SH (sizeof(bitset_unit_t) * 8 - 1)
 
-  bitset_pos_t i;
+       bitset_pos_t i;
 
-  for(i = 0; i < bs->units; ++i) {
-    bitset_unit_t unit = bs->data[i];
-    bitset_unit_t um1  = unit - 1;
+       for(i = 0; i < bs->units; ++i) {
+               bitset_unit_t unit = bs->data[i];
+               bitset_unit_t um1  = unit - 1;
 
-    bs->data[i] = um1;
+               bs->data[i] = um1;
 
-    if(((unit >> _SH) ^ (um1 >> _SH)) == 0)
-      break;
-  }
+               if(((unit >> _SH) ^ (um1 >> _SH)) == 0)
+                       break;
+       }
 #undef _SH
 }
 
 /**
  * Print a bitset to a stream.
- * The bitset is printed as a comma seperated list of bits set.
+ * The bitset is printed as a comma separated list of bits set.
  * @param file The stream.
  * @param bs The bitset.
  */
@@ -417,12 +444,12 @@ static INLINE void bitset_fprint(FILE *file, const bitset_t *bs)
        const char *prefix = "";
        int i;
 
-       putc('[', file);
+       putc('{', file);
        for(i = bitset_next_set(bs, 0); i != -1; i = bitset_next_set(bs, i + 1)) {
                fprintf(file, "%s%u", prefix, i);
                prefix = ",";
        }
-       putc(']', file);
+       putc('}', file);
 }
 
 static INLINE void bitset_debug_fprint(FILE *file, const bitset_t *bs)