14570f62d0
This is a -pedantic warning from gcc. * src/misc/bitvect.cc, src/misc/bitvect.hh (storage_): Remove. (storage): New method to access past the end of the struct.
515 lines
12 KiB
C++
515 lines
12 KiB
C++
// -*- coding: utf-8 -*-
|
|
// Copyright (C) 2013, 2014 Laboratoire de Recherche et Développement
|
|
// de l'Epita (LRDE).
|
|
//
|
|
// This file is part of Spot, a model checking library.
|
|
//
|
|
// Spot is free software; you can redistribute it and/or modify it
|
|
// under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation; either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// Spot is distributed in the hope that it will be useful, but WITHOUT
|
|
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
// or FITNESS FOR A PARTICULAR PURPOSE. See the 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, see <http://www.gnu.org/licenses/>.
|
|
|
|
#ifndef SPOT_MISC_BITVECT_HH
|
|
# define SPOT_MISC_BITVECT_HH
|
|
|
|
# include "common.hh"
|
|
# include <cstddef>
|
|
# include <cstdlib>
|
|
# include <cassert>
|
|
# include <iosfwd>
|
|
# include <iostream>
|
|
# include <algorithm>
|
|
|
|
namespace spot
|
|
{
|
|
/// \addtogroup misc_tools
|
|
/// @{
|
|
|
|
class bitvect;
|
|
class bitvect_array;
|
|
|
|
///\brief Allocate a bit-vector of \a bitcount bits.
|
|
///
|
|
/// The resulting object should be released with <code>delete</code>.
|
|
SPOT_API bitvect* make_bitvect(size_t bitcount);
|
|
|
|
/// \brief Allocate \a vectcount bit-vectors of \a bitcount bits.
|
|
///
|
|
/// The resulting bitvect_array should be released with <code>delete</code>.
|
|
SPOT_API bitvect_array* make_bitvect_array(size_t bitcount,
|
|
size_t vectcount);
|
|
|
|
/// \brief A bit vector
|
|
class SPOT_API bitvect
|
|
{
|
|
private:
|
|
// Used by make_bitvect to construct a large bitvect in place.
|
|
bitvect(size_t size, size_t block_count);
|
|
bitvect(size_t size, size_t block_count, bool);
|
|
|
|
public:
|
|
typedef unsigned long block_t;
|
|
|
|
bitvect():
|
|
size_(0),
|
|
block_count_(1),
|
|
storage_(&local_storage_),
|
|
local_storage_(0)
|
|
{
|
|
}
|
|
|
|
bitvect(const bitvect& other):
|
|
size_(other.size_),
|
|
block_count_(1),
|
|
storage_(&local_storage_)
|
|
{
|
|
*this = other;
|
|
}
|
|
|
|
bitvect* clone() const;
|
|
|
|
void make_empty()
|
|
{
|
|
size_ = 0;
|
|
}
|
|
|
|
bitvect& operator=(const bitvect& other)
|
|
{
|
|
reserve_blocks(other.block_count_);
|
|
size_ = other.size();
|
|
for (size_t i = 0; i < block_count_; ++i)
|
|
storage_[i] = other.storage_[i];
|
|
return *this;
|
|
}
|
|
|
|
~bitvect()
|
|
{
|
|
if (storage_ != &local_storage_)
|
|
free(storage_);
|
|
}
|
|
|
|
/// Grow the bitvector to \a new_block_count blocks.
|
|
///
|
|
/// This only changes the capacity of the bitvector, not its size.
|
|
void reserve_blocks(size_t new_block_count)
|
|
{
|
|
if (new_block_count < block_count_)
|
|
return;
|
|
if (storage_ == &local_storage_)
|
|
{
|
|
block_t* new_storage_ = static_cast<block_t*>
|
|
(malloc(new_block_count * sizeof(block_t)));
|
|
for (size_t i = 0; i < block_count_; ++i)
|
|
new_storage_[i] = storage_[i];
|
|
storage_ = new_storage_;
|
|
}
|
|
else
|
|
{
|
|
storage_ = static_cast<block_t*>
|
|
(realloc(storage_, new_block_count * sizeof(block_t)));
|
|
}
|
|
block_count_ = new_block_count;
|
|
}
|
|
|
|
private:
|
|
void grow()
|
|
{
|
|
size_t new_block_count_ = (block_count_ + 1) * 7 / 5;
|
|
reserve_blocks(new_block_count_);
|
|
}
|
|
|
|
public:
|
|
|
|
size_t used_blocks() const
|
|
{
|
|
const size_t bpb = 8 * sizeof(block_t);
|
|
return (size_ + bpb - 1) / bpb;
|
|
}
|
|
|
|
/// Append one bit.
|
|
void push_back(bool val)
|
|
{
|
|
if (size() == capacity())
|
|
grow();
|
|
size_t pos = size_++;
|
|
if (val)
|
|
set(pos);
|
|
else
|
|
clear(pos);
|
|
}
|
|
|
|
/// \brief Append the lowest \a count bits of \a data.
|
|
void push_back(block_t data, unsigned count)
|
|
{
|
|
if (size() + count > capacity())
|
|
grow();
|
|
const size_t bpb = 8 * sizeof(block_t);
|
|
|
|
// Clear the higher bits.
|
|
if (count != bpb)
|
|
data &= (1UL << count) - 1;
|
|
|
|
size_t n = size() % bpb;
|
|
size_t i = size_ / bpb;
|
|
size_ += count;
|
|
if (n == 0) // Aligned on block_t boundary
|
|
{
|
|
storage_[i] = data;
|
|
}
|
|
else // Only (bpb-n) bits free in this block.
|
|
{
|
|
// Take the lower bpb-n bits of data...
|
|
block_t mask = (1UL << (bpb - n)) - 1;
|
|
block_t data1 = (data & mask) << n;
|
|
mask <<= n;
|
|
// ... write them on the higher bpb-n bits of last block.
|
|
storage_[i] = (storage_[i] & ~mask) | data1;
|
|
// Write the remaining bits in the next block.
|
|
if (bpb - n < count)
|
|
storage_[i + 1] = data >> (bpb - n);
|
|
}
|
|
}
|
|
|
|
size_t size() const
|
|
{
|
|
return size_;
|
|
}
|
|
|
|
size_t capacity() const
|
|
{
|
|
return 8 * block_count_ * sizeof(block_t);
|
|
}
|
|
|
|
size_t hash() const;
|
|
|
|
bool get(size_t pos) const
|
|
{
|
|
assert(pos < size_);
|
|
const size_t bpb = 8 * sizeof(block_t);
|
|
return storage_[pos / bpb] & (1UL << (pos % bpb));
|
|
}
|
|
|
|
void clear_all()
|
|
{
|
|
for (size_t i = 0; i < block_count_; ++i)
|
|
storage_[i] = 0;
|
|
}
|
|
|
|
bool is_fully_clear() const
|
|
{
|
|
size_t i;
|
|
for (i = 0; i < block_count_ - 1; ++i)
|
|
if (storage_[i] != 0)
|
|
return false;
|
|
// The last block might not be fully used, compare only the
|
|
// relevant portion.
|
|
const size_t bpb = 8 * sizeof(bitvect::block_t);
|
|
block_t mask = (1UL << (size() % bpb)) - 1;
|
|
return (storage_[i] & mask) == 0;
|
|
}
|
|
|
|
bool is_fully_set() const
|
|
{
|
|
size_t i;
|
|
for (i = 0; i < block_count_ - 1; ++i)
|
|
if (storage_[i] != -1UL)
|
|
return false;
|
|
// The last block might not be fully used, compare only the
|
|
// relevant portion.
|
|
const size_t bpb = 8 * sizeof(bitvect::block_t);
|
|
block_t mask = (1UL << (size() % bpb)) - 1;
|
|
return ((~storage_[i]) & mask) == 0;
|
|
}
|
|
|
|
void set_all()
|
|
{
|
|
for (size_t i = 0; i < block_count_; ++i)
|
|
storage_[i] = -1UL;
|
|
}
|
|
|
|
void flip_all()
|
|
{
|
|
for (size_t i = 0; i < block_count_; ++i)
|
|
storage_[i] = ~storage_[i];
|
|
}
|
|
|
|
void set(size_t pos)
|
|
{
|
|
assert(pos < size_);
|
|
const size_t bpb = 8 * sizeof(block_t);
|
|
storage_[pos / bpb] |= 1UL << (pos % bpb);
|
|
}
|
|
|
|
void clear(size_t pos)
|
|
{
|
|
assert(pos < size_);
|
|
const size_t bpb = 8 * sizeof(block_t);
|
|
storage_[pos / bpb] &= ~(1UL << (pos % bpb));
|
|
}
|
|
|
|
void flip(size_t pos)
|
|
{
|
|
assert(pos < size_);
|
|
const size_t bpb = 8 * sizeof(block_t);
|
|
storage_[pos / bpb] ^= (1UL << (pos % bpb));
|
|
}
|
|
|
|
|
|
bitvect& operator|=(const bitvect& other)
|
|
{
|
|
assert(other.size_ <= size_);
|
|
unsigned m = std::min(other.block_count_, block_count_);
|
|
for (size_t i = 0; i < m; ++i)
|
|
storage_[i] |= other.storage_[i];
|
|
return *this;
|
|
}
|
|
|
|
bitvect& operator&=(const bitvect& other)
|
|
{
|
|
assert(other.size_ <= size_);
|
|
unsigned m = std::min(other.block_count_, block_count_);
|
|
for (size_t i = 0; i < m; ++i)
|
|
storage_[i] &= other.storage_[i];
|
|
return *this;
|
|
}
|
|
|
|
bitvect& operator^=(const bitvect& other)
|
|
{
|
|
assert(other.size_ <= size_);
|
|
unsigned m = std::min(other.block_count_, block_count_);
|
|
for (size_t i = 0; i < m; ++i)
|
|
storage_[i] ^= other.storage_[i];
|
|
return *this;
|
|
}
|
|
|
|
bitvect& operator-=(const bitvect& other)
|
|
{
|
|
assert(other.block_count_ <= block_count_);
|
|
for (size_t i = 0; i < other.block_count_; ++i)
|
|
storage_[i] &= ~other.storage_[i];
|
|
return *this;
|
|
}
|
|
|
|
bool is_subset_of(const bitvect& other) const
|
|
{
|
|
assert(other.block_count_ >= block_count_);
|
|
|
|
size_t i;
|
|
for (i = 0; i < block_count_ - 1; ++i)
|
|
if ((storage_[i] & other.storage_[i]) != other.storage_[i])
|
|
return false;
|
|
|
|
// The last block might not be fully used, compare only the
|
|
// relevant portion.
|
|
const size_t bpb = 8 * sizeof(bitvect::block_t);
|
|
block_t mask = (1UL << (size() % bpb)) - 1;
|
|
return ((storage_[i] & mask & other.storage_[i])
|
|
== (other.storage_[i] & mask));
|
|
}
|
|
|
|
bool operator==(const bitvect& other) const
|
|
{
|
|
if (other.size_ != size_)
|
|
return false;
|
|
if (size_ == 0)
|
|
return true;
|
|
size_t i;
|
|
size_t m = other.used_blocks();
|
|
for (i = 0; i < m - 1; ++i)
|
|
if (storage_[i] != other.storage_[i])
|
|
return false;
|
|
// The last block might not be fully used, compare only the
|
|
// relevant portion.
|
|
const size_t bpb = 8 * sizeof(bitvect::block_t);
|
|
block_t mask = (1UL << (size() % bpb)) - 1;
|
|
return (storage_[i] & mask) == (other.storage_[i] & mask);
|
|
}
|
|
|
|
bool operator!=(const bitvect& other) const
|
|
{
|
|
return !(*this == other);
|
|
}
|
|
|
|
bool operator<(const bitvect& other) const
|
|
{
|
|
if (size_ != other.size_)
|
|
return size_ < other.size_;
|
|
if (size_ == 0)
|
|
return false;
|
|
size_t i;
|
|
size_t m = other.used_blocks();
|
|
for (i = 0; i < m - 1; ++i)
|
|
if (storage_[i] > other.storage_[i])
|
|
return false;
|
|
// The last block might not be fully used, compare only the
|
|
// relevant portion.
|
|
const size_t bpb = 8 * sizeof(bitvect::block_t);
|
|
block_t mask = (1UL << (size() % bpb)) - 1;
|
|
return (storage_[i] & mask) < (other.storage_[i] & mask);
|
|
}
|
|
|
|
bool operator>=(const bitvect& other) const
|
|
{
|
|
return !(*this < other);
|
|
}
|
|
|
|
bool operator>(const bitvect& other) const
|
|
{
|
|
return other < *this;
|
|
}
|
|
|
|
bool operator<=(const bitvect& other) const
|
|
{
|
|
return !(other < *this);
|
|
}
|
|
|
|
// \brief Extract a range of bits.
|
|
//
|
|
// Build a new bit-vector using the bits from \a begin (included)
|
|
// to \a end (excluded).
|
|
bitvect* extract_range(size_t begin, size_t end)
|
|
{
|
|
assert(begin <= end);
|
|
assert(end <= size());
|
|
size_t count = end - begin;
|
|
bitvect* res = make_bitvect(count);
|
|
res->make_empty();
|
|
|
|
if (end == begin)
|
|
return res;
|
|
|
|
const size_t bpb = 8 * sizeof(bitvect::block_t);
|
|
|
|
size_t indexb = begin / bpb;
|
|
unsigned bitb = begin % bpb;
|
|
size_t indexe = (end - 1) / bpb;
|
|
|
|
if (indexb == indexe)
|
|
{
|
|
block_t data = storage_[indexb];
|
|
data >>= bitb;
|
|
res->push_back(data, count);
|
|
}
|
|
else
|
|
{
|
|
block_t data = storage_[indexb];
|
|
data >>= bitb;
|
|
res->push_back(data, bpb - bitb);
|
|
count -= bpb - bitb;
|
|
while (count >= bpb)
|
|
{
|
|
++indexb;
|
|
res->push_back(storage_[indexb], bpb);
|
|
count -= bpb;
|
|
assert(indexb != indexe || count == 0);
|
|
}
|
|
if (count > 0)
|
|
{
|
|
++indexb;
|
|
assert(indexb == indexe);
|
|
assert(count == end % bpb);
|
|
res->push_back(storage_[indexb], count);
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
friend SPOT_API bitvect*
|
|
::spot::make_bitvect(size_t bitcount);
|
|
|
|
/// Print a bitvect.
|
|
friend SPOT_API std::ostream& operator<<(std::ostream&,
|
|
const bitvect&);
|
|
|
|
private:
|
|
friend SPOT_API bitvect_array*
|
|
::spot::make_bitvect_array(size_t bitcount,
|
|
size_t vectcount);
|
|
|
|
size_t size_;
|
|
size_t block_count_;
|
|
// storage_ points to local_storage_ as long as size_ <= block_count_ * 8.
|
|
block_t* storage_;
|
|
// Keep this at the end of the structure: when make_bitvect is used,
|
|
// it may allocate more block_t at the end of this structure.
|
|
block_t local_storage_;
|
|
};
|
|
|
|
class SPOT_API bitvect_array
|
|
{
|
|
private:
|
|
/// Private constructor used by make_bitvect_array().
|
|
bitvect_array(size_t size, size_t bvsize):
|
|
size_(size),
|
|
bvsize_(bvsize)
|
|
{
|
|
}
|
|
|
|
SPOT_LOCAL bitvect_array(const bitvect_array&) SPOT_DELETED;
|
|
SPOT_LOCAL void operator=(const bitvect_array&) SPOT_DELETED;
|
|
|
|
// Extra storage has been allocated at the end of the struct.
|
|
char* storage()
|
|
{
|
|
return reinterpret_cast<char*>(this) + sizeof(*this);
|
|
}
|
|
|
|
const char* storage() const
|
|
{
|
|
return reinterpret_cast<const char*>(this) + sizeof(*this);
|
|
}
|
|
|
|
public:
|
|
~bitvect_array()
|
|
{
|
|
for (size_t i = 0; i < size_; ++i)
|
|
at(i).~bitvect();
|
|
}
|
|
|
|
/// The number of bitvect in the array.
|
|
size_t size() const
|
|
{
|
|
return size_;
|
|
}
|
|
|
|
/// Return the bit-vector at \a index.
|
|
bitvect& at(const size_t index)
|
|
{
|
|
assert(index < size_);
|
|
return *reinterpret_cast<bitvect*>(storage() + index * bvsize_);
|
|
}
|
|
|
|
/// Return the bit-vector at \a index.
|
|
const bitvect& at(const size_t index) const
|
|
{
|
|
assert(index < size_);
|
|
return *reinterpret_cast<const bitvect*>(storage() + index * bvsize_);
|
|
}
|
|
|
|
friend SPOT_API bitvect_array*
|
|
::spot::make_bitvect_array(size_t bitcount,
|
|
size_t vectcount);
|
|
|
|
|
|
/// Print a bitvect_array.
|
|
friend SPOT_API std::ostream& operator<<(std::ostream&,
|
|
const bitvect_array&);
|
|
|
|
private:
|
|
size_t size_;
|
|
size_t bvsize_;
|
|
};
|
|
|
|
/// @}
|
|
}
|
|
|
|
|
|
#endif // SPOT_MISC_BITVECT_HH
|