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

// Copyright (C) 2001, 2002, 2003, 2004 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, 59 Temple Place - Suite 330, Boston, MA 02111-1307,

// 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.  You should @c #include this header

 *  in your programs, rather than any of the "st[dl]_*.h" implementation files.

 */

#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() { 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

    {