Subversion Repositories scarts

// <bitset> -*- C++ -*-

// Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.

//

// This file is part of the GNU ISO C++ Library.  This library 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 2, or (at your option)

// any later version.

// This library 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 library; see the file COPYING.  If not, write to the Free

// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,

// USA.

// As a special exception, you may use this file as part of a free software

// library without restriction.  Specifically, if other files instantiate

// templates or use macros or inline functions from this file, or you compile

// this file and link it with other files to produce an executable, this

// file does not by itself cause the resulting executable to be covered by

// the GNU General Public License.  This exception does not however

// invalidate any other reasons why the executable file might be covered by

// the GNU General Public License.

/*

 * Copyright (c) 1998

 * Silicon Graphics Computer Systems, Inc.

 *

 * Permission to use, copy, modify, distribute and sell this software

 * and its documentation for any purpose is hereby granted without fee,

 * provided that the above copyright notice appear in all copies and

 * that both that copyright notice and this permission notice appear

 * in supporting documentation.  Silicon Graphics makes no

 * representations about the suitability of this software for any

 * purpose.  It is provided "as is" without express or implied warranty.

 */

/** @file bitset

 *  This is a Standard C++ Library header.

 */

#ifndef _GLIBCXX_BITSET

#define _GLIBCXX_BITSET 1

#pragma GCC system_header

#include <cstddef>     // For size_t

#include <cstring>     // For memset

#include <limits>      // For numeric_limits

#include <string>

#include <bits/functexcept.h>   // For invalid_argument, out_of_range,

                                // overflow_error

#include <ostream>     // For ostream (operator<<)

#include <istream>     // For istream (operator>>)

#define _GLIBCXX_BITSET_BITS_PER_WORD  numeric_limits<unsigned long>::digits

#define _GLIBCXX_BITSET_WORDS(__n) \

 ((__n) < 1 ? 0 : ((__n) + _GLIBCXX_BITSET_BITS_PER_WORD - 1) \

                  / _GLIBCXX_BITSET_BITS_PER_WORD)

namespace _GLIBCXX_STD

{

  /**

   *  @if maint

   *  Base class, general case.  It is a class inveriant that _Nw will be

   *  nonnegative.

   *

   *  See documentation for bitset.

   *  @endif

  */

  template<size_t _Nw>

    struct _Base_bitset

    {

      typedef unsigned long _WordT;

      /// 0 is the least significant word.

      _WordT            _M_w[_Nw];

      _Base_bitset()

      { _M_do_reset(); }

      _Base_bitset(unsigned long __val)

      {

        _M_do_reset();

        _M_w[0] = __val;

      }

      static size_t

      _S_whichword(size_t __pos )

      { return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; }

      static size_t

      _S_whichbyte(size_t __pos )

      { return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; }

      static size_t

      _S_whichbit(size_t __pos )

      { return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; }

      static _WordT

      _S_maskbit(size_t __pos )

      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }

      _WordT&

      _M_getword(size_t __pos)

      { return _M_w[_S_whichword(__pos)]; }

      _WordT

      _M_getword(size_t __pos) const

      { return _M_w[_S_whichword(__pos)]; }

      _WordT&

      _M_hiword()

      { return _M_w[_Nw - 1]; }

      _WordT

      _M_hiword() const

      { return _M_w[_Nw - 1]; }

      void

      _M_do_and(const _Base_bitset<_Nw>& __x)

      {

        for (size_t __i = 0; __i < _Nw; __i++)

          _M_w[__i] &= __x._M_w[__i];

      }

      void

      _M_do_or(const _Base_bitset<_Nw>& __x)

      {

        for (size_t __i = 0; __i < _Nw; __i++)

          _M_w[__i] |= __x._M_w[__i];

      }

      void

      _M_do_xor(const _Base_bitset<_Nw>& __x)

      {

        for (size_t __i = 0; __i < _Nw; __i++)

          _M_w[__i] ^= __x._M_w[__i];

      }

      void

      _M_do_left_shift(size_t __shift);

      void

      _M_do_right_shift(size_t __shift);

      void

      _M_do_flip()

      {

        for (size_t __i = 0; __i < _Nw; __i++)

          _M_w[__i] = ~_M_w[__i];

      }

      void

      _M_do_set()

      {

        for (size_t __i = 0; __i < _Nw; __i++)

          _M_w[__i] = ~static_cast<_WordT>(0);

      }

      void

      _M_do_reset()

      { std::memset(_M_w, 0, _Nw * sizeof(_WordT)); }

      bool

      _M_is_equal(const _Base_bitset<_Nw>& __x) const

      {

        for (size_t __i = 0; __i < _Nw; ++__i)

          {

            if (_M_w[__i] != __x._M_w[__i])

              return false;

          }

        return true;

      }

      bool

      _M_is_any() const

      {

        for (size_t __i = 0; __i < _Nw; __i++)

          {

            if (_M_w[__i] != static_cast<_WordT>(0))

              return true;

          }

        return false;

      }

      size_t

      _M_do_count() const

      {

        size_t __result = 0;

        for (size_t __i = 0; __i < _Nw; __i++)

          __result += __builtin_popcountl(_M_w[__i]);

        return __result;

      }

      unsigned long

      _M_do_to_ulong() const;

      // find first "on" bit

      size_t

      _M_do_find_first(size_t __not_found) const;

      // find the next "on" bit that follows "prev"

      size_t

      _M_do_find_next(size_t __prev, size_t __not_found) const;

    };

  // Definitions of non-inline functions from _Base_bitset.

  template<size_t _Nw>

    void

    _Base_bitset<_Nw>::_M_do_left_shift(size_t __shift)

    {

      if (__builtin_expect(__shift != 0, 1))

        {

          const size_t __wshift = __shift / _GLIBCXX_BITSET_BITS_PER_WORD;

          const size_t __offset = __shift % _GLIBCXX_BITSET_BITS_PER_WORD;

          if (__offset == 0)

            for (size_t __n = _Nw - 1; __n >= __wshift; --__n)

              _M_w[__n] = _M_w[__n - __wshift];

          else

            {

              const size_t __sub_offset = (_GLIBCXX_BITSET_BITS_PER_WORD

                                           - __offset);

              for (size_t __n = _Nw - 1; __n > __wshift; --__n)

                _M_w[__n] = ((_M_w[__n - __wshift] << __offset)

                             | (_M_w[__n - __wshift - 1] >> __sub_offset));

              _M_w[__wshift] = _M_w[0] << __offset;

            }

          std::fill(_M_w + 0, _M_w + __wshift, static_cast<_WordT>(0));

        }

    }

  template<size_t _Nw>

    void

    _Base_bitset<_Nw>::_M_do_right_shift(size_t __shift)

    {

      if (__builtin_expect(__shift != 0, 1))

        {

          const size_t __wshift = __shift / _GLIBCXX_BITSET_BITS_PER_WORD;

          const size_t __offset = __shift % _GLIBCXX_BITSET_BITS_PER_WORD;

          const size_t __limit = _Nw - __wshift - 1;

          if (__offset == 0)

            for (size_t __n = 0; __n <= __limit; ++__n)

              _M_w[__n] = _M_w[__n + __wshift];

          else

            {

              const size_t __sub_offset = (_GLIBCXX_BITSET_BITS_PER_WORD

                                           - __offset);

              for (size_t __n = 0; __n < __limit; ++__n)

                _M_w[__n] = ((_M_w[__n + __wshift] >> __offset)

                             | (_M_w[__n + __wshift + 1] << __sub_offset));

              _M_w[__limit] = _M_w[_Nw-1] >> __offset;

            }

          std::fill(_M_w + __limit + 1, _M_w + _Nw, static_cast<_WordT>(0));

        }

    }

  template<size_t _Nw>

    unsigned long

    _Base_bitset<_Nw>::_M_do_to_ulong() const

    {

      for (size_t __i = 1; __i < _Nw; ++__i)

        if (_M_w[__i])

          __throw_overflow_error(__N("_Base_bitset::_M_do_to_ulong"));

      return _M_w[0];

    }

  template<size_t _Nw>

    size_t

    _Base_bitset<_Nw>::_M_do_find_first(size_t __not_found) const

    {

      for (size_t __i = 0; __i < _Nw; __i++)

        {

          _WordT __thisword = _M_w[__i];

          if (__thisword != static_cast<_WordT>(0))

            return (__i * _GLIBCXX_BITSET_BITS_PER_WORD

                    + __builtin_ctzl(__thisword));

        }

      // not found, so return an indication of failure.

      return __not_found;

    }

  template<size_t _Nw>

    size_t

    _Base_bitset<_Nw>::_M_do_find_next(size_t __prev, size_t __not_found) const

    {

      // make bound inclusive

      ++__prev;

      // check out of bounds

      if (__prev >= _Nw * _GLIBCXX_BITSET_BITS_PER_WORD)

        return __not_found;

      // search first word

      size_t __i = _S_whichword(__prev);

      _WordT __thisword = _M_w[__i];

      // mask off bits below bound

      __thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev);

      if (__thisword != static_cast<_WordT>(0))

        return (__i * _GLIBCXX_BITSET_BITS_PER_WORD

                + __builtin_ctzl(__thisword));

      // check subsequent words

      __i++;

      for (; __i < _Nw; __i++)

        {

          __thisword = _M_w[__i];

          if (__thisword != static_cast<_WordT>(0))

            return (__i * _GLIBCXX_BITSET_BITS_PER_WORD

                    + __builtin_ctzl(__thisword));

        }

      // not found, so return an indication of failure.

      return __not_found;

    } // end _M_do_find_next

  /**

   *  @if maint

   *  Base class, specialization for a single word.

   *

   *  See documentation for bitset.

   *  @endif

  */

  template<>

    struct _Base_bitset<1>

    {

      typedef unsigned long _WordT;

      _WordT _M_w;

      _Base_bitset(void)

      : _M_w(0)

      { }

      _Base_bitset(unsigned long __val)

      : _M_w(__val)

      { }

      static size_t

      _S_whichword(size_t __pos )

      { return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; }

      static size_t

      _S_whichbyte(size_t __pos )

      { return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; }

      static size_t

      _S_whichbit(size_t __pos )

      {  return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; }

      static _WordT

      _S_maskbit(size_t __pos )

      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }

      _WordT&

      _M_getword(size_t)

      { return _M_w; }

      _WordT

      _M_getword(size_t) const

      { return _M_w; }

      _WordT&

      _M_hiword()

      { return _M_w; }

      _WordT

      _M_hiword() const

      { return _M_w; }

      void

      _M_do_and(const _Base_bitset<1>& __x)

      { _M_w &= __x._M_w; }

      void

      _M_do_or(const _Base_bitset<1>& __x)

      { _M_w |= __x._M_w; }

      void

      _M_do_xor(const _Base_bitset<1>& __x)

      { _M_w ^= __x._M_w; }

      void

      _M_do_left_shift(size_t __shift)

      { _M_w <<= __shift; }

      void

      _M_do_right_shift(size_t __shift)

      { _M_w >>= __shift; }

      void

      _M_do_flip()

      { _M_w = ~_M_w; }

      void

      _M_do_set()

      { _M_w = ~static_cast<_WordT>(0); }

      void

      _M_do_reset()

      { _M_w = 0; }

      bool

      _M_is_equal(const _Base_bitset<1>& __x) const

      { return _M_w == __x._M_w; }

      bool

      _M_is_any() const

      { return _M_w != 0; }

      size_t

      _M_do_count() const

      { return __builtin_popcountl(_M_w); }

      unsigned long

      _M_do_to_ulong() const

      { return _M_w; }

      size_t

      _M_do_find_first(size_t __not_found) const

      {

        if (_M_w != 0)

          return __builtin_ctzl(_M_w);

        else

          return __not_found;

      }

      // find the next "on" bit that follows "prev"

      size_t

      _M_do_find_next(size_t __prev, size_t __not_found) const

      {

        ++__prev;

        if (__prev >= ((size_t) _GLIBCXX_BITSET_BITS_PER_WORD))

          return __not_found;

        _WordT __x = _M_w >> __prev;

        if (__x != 0)

          return __builtin_ctzl(__x) + __prev;

        else

          return __not_found;

      }

    };

  /**

   *  @if maint

   *  Base class, specialization for no storage (zero-length %bitset).

   *

   *  See documentation for bitset.

   *  @endif

  */

  template<>

    struct _Base_bitset<0>

    {

      typedef unsigned long _WordT;

      _Base_bitset()

      { }

      _Base_bitset(unsigned long)

      { }

      static size_t

      _S_whichword(size_t __pos )

      { return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; }

      static size_t

      _S_whichbyte(size_t __pos )

      { return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; }

      static size_t

      _S_whichbit(size_t __pos )

      {  return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; }

      static _WordT

      _S_maskbit(size_t __pos )

      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }

      // This would normally give access to the data.  The bounds-checking

      // in the bitset class will prevent the user from getting this far,

      // but (1) it must still return an lvalue to compile, and (2) the

      // user might call _Unchecked_set directly, in which case this /needs/

      // to fail.  Let's not penalize zero-length users unless they actually

      // make an unchecked call; all the memory ugliness is therefore

      // localized to this single should-never-get-this-far function.

      _WordT&

      _M_getword(size_t) const

      {

        __throw_out_of_range(__N("_Base_bitset::_M_getword"));

        return *new _WordT;

      }

      _WordT

      _M_hiword() const

      { return 0; }

      void

      _M_do_and(const _Base_bitset<0>&)

      { }

      void

      _M_do_or(const _Base_bitset<0>&)

      { }

      void

      _M_do_xor(const _Base_bitset<0>&)

      { }

      void

      _M_do_left_shift(size_t)

      { }

      void

      _M_do_right_shift(size_t)

      { }

      void

      _M_do_flip()

      { }

      void

      _M_do_set()

      { }

      void

      _M_do_reset()

      { }

      // Are all empty bitsets equal to each other?  Are they equal to

      // themselves?  How to compare a thing which has no state?  What is

      // the sound of one zero-length bitset clapping?

      bool

      _M_is_equal(const _Base_bitset<0>&) const

      { return true; }

      bool

      _M_is_any() const

      { return false; }

      size_t

      _M_do_count() const

      { return 0; }

      unsigned long

      _M_do_to_ulong() const

      { return 0; }

      // Normally "not found" is the size, but that could also be

      // misinterpreted as an index in this corner case.  Oh well.

      size_t

      _M_do_find_first(size_t) const

      { return 0; }

      size_t

      _M_do_find_next(size_t, size_t) const

      { return 0; }

    };

  // Helper class to zero out the unused high-order bits in the highest word.

  template<size_t _Extrabits>

    struct _Sanitize

    {

      static void _S_do_sanitize(unsigned long& __val)

      { __val &= ~((~static_cast<unsigned long>(0)) << _Extrabits); }

    };

  template<>

    struct _Sanitize<0>

    { static void _S_do_sanitize(unsigned long) {} };

  /**

   *  @brief  The %bitset class represents a @e fixed-size sequence of bits.

   *

   *  @ingroup Containers

   *

   *  (Note that %bitset does @e not meet the formal requirements of a

   *  <a href="tables.html#65">container</a>.  Mainly, it lacks iterators.)

   *

   *  The template argument, @a Nb, may be any non-negative number,

   *  specifying the number of bits (e.g., "0", "12", "1024*1024").

   *

   *  In the general unoptimized case, storage is allocated in word-sized

   *  blocks.  Let B be the number of bits in a word, then (Nb+(B-1))/B

   *  words will be used for storage.  B - Nb%B bits are unused.  (They are

   *  the high-order bits in the highest word.)  It is a class invariant

   *  that those unused bits are always zero.

   *

   *  If you think of %bitset as "a simple array of bits," be aware that

   *  your mental picture is reversed:  a %bitset behaves the same way as

   *  bits in integers do, with the bit at index 0 in the "least significant

   *  / right-hand" position, and the bit at index Nb-1 in the "most

   *  significant / left-hand" position.  Thus, unlike other containers, a

   *  %bitset's index "counts from right to left," to put it very loosely.

   *

   *  This behavior is preserved when translating to and from strings.  For

   *  example, the first line of the following program probably prints

   *  "b('a') is 0001100001" on a modern ASCII system.

   *

   *  @code

   *     #include <bitset>

   *     #include <iostream>

   *     #include <sstream>

   *

   *     using namespace std;

   *

   *     int main()

   *     {

   *         long         a = 'a';

   *         bitset<10>   b(a);

   *

   *         cout << "b('a') is " << b << endl;

   *

   *         ostringstream s;

   *         s << b;

   *         string  str = s.str();

   *         cout << "index 3 in the string is " << str[3] << " but\n"

   *              << "index 3 in the bitset is " << b[3] << endl;

   *     }

   *  @endcode

   *

   *  Also see http://gcc.gnu.org/onlinedocs/libstdc++/ext/sgiexts.html#ch23

   *  for a description of extensions.

   *

   *  @if maint

   *  Most of the actual code isn't contained in %bitset<> itself, but in the

   *  base class _Base_bitset.  The base class works with whole words, not with

   *  individual bits.  This allows us to specialize _Base_bitset for the

   *  important special case where the %bitset is only a single word.

   *

   *  Extra confusion can result due to the fact that the storage for

   *  _Base_bitset @e is a regular array, and is indexed as such.  This is

   *  carefully encapsulated.

   *  @endif

  */

  template<size_t _Nb>

    class bitset

    : private _Base_bitset<_GLIBCXX_BITSET_WORDS(_Nb)>

    {

    private:

      typedef _Base_bitset<_GLIBCXX_BITSET_WORDS(_Nb)> _Base;

      typedef unsigned long _WordT;

      void

        _M_do_sanitize()

        {

          _Sanitize<_Nb % _GLIBCXX_BITSET_BITS_PER_WORD>::

            _S_do_sanitize(this->_M_hiword());

        }

    public:

      /**

       *  This encapsulates the concept of a single bit.  An instance of this

       *  class is a proxy for an actual bit; this way the individual bit

       *  operations are done as faster word-size bitwise instructions.

       *

       *  Most users will never need to use this class directly; conversions

       *  to and from bool are automatic and should be transparent.  Overloaded

       *  operators help to preserve the illusion.

       *

       *  (On a typical system, this "bit %reference" is 64 times the size of

       *  an actual bit.  Ha.)

       */

      class reference

      {

        friend class bitset;

        _WordT *_M_wp;

        size_t _M_bpos;

        // left undefined

        reference();

      public:

        reference(bitset& __b, size_t __pos)

        {

          _M_wp = &__b._M_getword(__pos);

          _M_bpos = _Base::_S_whichbit(__pos);

        }

        ~reference()

        { }

        // For b[i] = __x;

        reference&

        operator=(bool __x)

        {

          if (__x)

            *_M_wp |= _Base::_S_maskbit(_M_bpos);

          else

            *_M_wp &= ~_Base::_S_maskbit(_M_bpos);

          return *this;

        }

        // For b[i] = b[__j];

        reference&

        operator=(const reference& __j)

        {

          if ((*(__j._M_wp) & _Base::_S_maskbit(__j._M_bpos)))

            *_M_wp |= _Base::_S_maskbit(_M_bpos);

          else

            *_M_wp &= ~_Base::_S_maskbit(_M_bpos);

          return *this;

        }

        // Flips the bit

        bool

        operator~() const

        { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) == 0; }

        // For __x = b[i];

        operator bool() const

        { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) != 0; }