Subversion Repositories Kolibri OS

//  -*- C++ -*-

// Copyright (C) 2001-2015 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 3, 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.

// Under Section 7 of GPL version 3, you are granted additional

// permissions described in the GCC Runtime Library Exception, version

// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and

// a copy of the GCC Runtime Library Exception along with this program;

// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see

// .

/*

 * 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 include/bitset

 *  This is a Standard C++ Library header.

 */

#ifndef _GLIBCXX_BITSET

#define _GLIBCXX_BITSET 1

#pragma GCC system_header

#include 

#include    // For invalid_argument, out_of_range,

                                // overflow_error

#include 

#include 

#define _GLIBCXX_BITSET_BITS_PER_WORD  (__CHAR_BIT__ * __SIZEOF_LONG__)

#define _GLIBCXX_BITSET_WORDS(__n) \

  ((__n) / _GLIBCXX_BITSET_BITS_PER_WORD + \

   ((__n) % _GLIBCXX_BITSET_BITS_PER_WORD == 0 ? 0 : 1))

#define _GLIBCXX_BITSET_BITS_PER_ULL (__CHAR_BIT__ * __SIZEOF_LONG_LONG__)

namespace std _GLIBCXX_VISIBILITY(default)

{

_GLIBCXX_BEGIN_NAMESPACE_CONTAINER

  /**

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

   *  nonnegative.

   *

   *  See documentation for bitset.

  */

  template

    struct _Base_bitset

    {

      typedef unsigned long _WordT;

      /// 0 is the least significant word.

      _WordT 		_M_w[_Nw];

      _GLIBCXX_CONSTEXPR _Base_bitset() _GLIBCXX_NOEXCEPT

      : _M_w() { }

#if __cplusplus >= 201103L

      constexpr _Base_bitset(unsigned long long __val) noexcept

      : _M_w{ _WordT(__val)

#if __SIZEOF_LONG_LONG__ > __SIZEOF_LONG__

	       , _WordT(__val >> _GLIBCXX_BITSET_BITS_PER_WORD)

#endif

       } { }

#else

      _Base_bitset(unsigned long __val)

      : _M_w()

      { _M_w[0] = __val; }

#endif

      static _GLIBCXX_CONSTEXPR size_t

      _S_whichword(size_t __pos) _GLIBCXX_NOEXCEPT

      { return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; }

      static _GLIBCXX_CONSTEXPR size_t

      _S_whichbyte(size_t __pos) _GLIBCXX_NOEXCEPT

      { return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; }

      static _GLIBCXX_CONSTEXPR size_t

      _S_whichbit(size_t __pos) _GLIBCXX_NOEXCEPT

      { return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; }

      static _GLIBCXX_CONSTEXPR _WordT

      _S_maskbit(size_t __pos) _GLIBCXX_NOEXCEPT

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

      _WordT&

      _M_getword(size_t __pos) _GLIBCXX_NOEXCEPT

      { return _M_w[_S_whichword(__pos)]; }

      _GLIBCXX_CONSTEXPR _WordT

      _M_getword(size_t __pos) const _GLIBCXX_NOEXCEPT

      { return _M_w[_S_whichword(__pos)]; }

#if __cplusplus >= 201103L

      const _WordT*

      _M_getdata() const noexcept

      { return _M_w; }

#endif

      _WordT&

      _M_hiword() _GLIBCXX_NOEXCEPT

      { return _M_w[_Nw - 1]; }

      _GLIBCXX_CONSTEXPR _WordT

      _M_hiword() const _GLIBCXX_NOEXCEPT

      { return _M_w[_Nw - 1]; }

      void

      _M_do_and(const _Base_bitset<_Nw>& __x) _GLIBCXX_NOEXCEPT

      {

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

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

      }

      void

      _M_do_or(const _Base_bitset<_Nw>& __x) _GLIBCXX_NOEXCEPT

      {

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

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

      }

      void

      _M_do_xor(const _Base_bitset<_Nw>& __x) _GLIBCXX_NOEXCEPT

      {

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

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

      }

      void

      _M_do_left_shift(size_t __shift) _GLIBCXX_NOEXCEPT;

      void

      _M_do_right_shift(size_t __shift) _GLIBCXX_NOEXCEPT;

      void

      _M_do_flip() _GLIBCXX_NOEXCEPT

      {

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

	  _M_w[__i] = ~_M_w[__i];

      }

      void

      _M_do_set() _GLIBCXX_NOEXCEPT

      {

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

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

      }

      void

      _M_do_reset() _GLIBCXX_NOEXCEPT

      { __builtin_memset(_M_w, 0, _Nw * sizeof(_WordT)); }

      bool

      _M_is_equal(const _Base_bitset<_Nw>& __x) const _GLIBCXX_NOEXCEPT

      {

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

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

	    return false;

	return true;

      }

      template

        bool

        _M_are_all() const _GLIBCXX_NOEXCEPT

        {

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

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

	      return false;

	  return _M_hiword() == (~static_cast<_WordT>(0)

				 >> (_Nw * _GLIBCXX_BITSET_BITS_PER_WORD

				     - _Nb));

	}

      bool

      _M_is_any() const _GLIBCXX_NOEXCEPT

      {

	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 _GLIBCXX_NOEXCEPT

      {

	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;

#if __cplusplus >= 201103L

      unsigned long long

      _M_do_to_ullong() const;

#endif

      // find first "on" bit

      size_t

      _M_do_find_first(size_t) const _GLIBCXX_NOEXCEPT;

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

      size_t

      _M_do_find_next(size_t, size_t) const _GLIBCXX_NOEXCEPT;

    };

  // Definitions of non-inline functions from _Base_bitset.

  template

    void

    _Base_bitset<_Nw>::_M_do_left_shift(size_t __shift) _GLIBCXX_NOEXCEPT

    {

      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

    void

    _Base_bitset<_Nw>::_M_do_right_shift(size_t __shift) _GLIBCXX_NOEXCEPT

    {

      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

    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];

    }

#if __cplusplus >= 201103L

  template

    unsigned long long

    _Base_bitset<_Nw>::_M_do_to_ullong() const

    {

      const bool __dw = sizeof(unsigned long long) > sizeof(unsigned long);

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

	if (_M_w[__i])

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

      if (__dw)

	return _M_w[0] + (static_cast(_M_w[1])

			  << _GLIBCXX_BITSET_BITS_PER_WORD);

      return _M_w[0];

    }

#endif

  template

    size_t

    _Base_bitset<_Nw>::

    _M_do_find_first(size_t __not_found) const _GLIBCXX_NOEXCEPT

    {

      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

    _Base_bitset<_Nw>::

    _M_do_find_next(size_t __prev, size_t __not_found) const _GLIBCXX_NOEXCEPT

    {

      // 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

  /**

   *  Base class, specialization for a single word.

   *

   *  See documentation for bitset.

  */

  template<>

    struct _Base_bitset<1>

    {

      typedef unsigned long _WordT;

      _WordT _M_w;

      _GLIBCXX_CONSTEXPR _Base_bitset() _GLIBCXX_NOEXCEPT

      : _M_w(0)

      { }

#if __cplusplus >= 201103L

      constexpr _Base_bitset(unsigned long long __val) noexcept

#else

      _Base_bitset(unsigned long __val)

#endif

      : _M_w(__val)

      { }

      static _GLIBCXX_CONSTEXPR size_t

      _S_whichword(size_t __pos) _GLIBCXX_NOEXCEPT

      { return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; }

      static _GLIBCXX_CONSTEXPR size_t

      _S_whichbyte(size_t __pos) _GLIBCXX_NOEXCEPT

      { return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; }

      static _GLIBCXX_CONSTEXPR size_t

      _S_whichbit(size_t __pos) _GLIBCXX_NOEXCEPT

      {  return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; }

      static _GLIBCXX_CONSTEXPR _WordT

      _S_maskbit(size_t __pos) _GLIBCXX_NOEXCEPT

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

      _WordT&

      _M_getword(size_t) _GLIBCXX_NOEXCEPT

      { return _M_w; }

      _GLIBCXX_CONSTEXPR _WordT

      _M_getword(size_t) const _GLIBCXX_NOEXCEPT

      { return _M_w; }

#if __cplusplus >= 201103L

      const _WordT*

      _M_getdata() const noexcept

      { return &_M_w; }

#endif

      _WordT&

      _M_hiword() _GLIBCXX_NOEXCEPT

      { return _M_w; }

      _GLIBCXX_CONSTEXPR _WordT

      _M_hiword() const _GLIBCXX_NOEXCEPT

      { return _M_w; }

      void

      _M_do_and(const _Base_bitset<1>& __x) _GLIBCXX_NOEXCEPT

      { _M_w &= __x._M_w; }

      void

      _M_do_or(const _Base_bitset<1>& __x) _GLIBCXX_NOEXCEPT

      { _M_w |= __x._M_w; }

      void

      _M_do_xor(const _Base_bitset<1>& __x) _GLIBCXX_NOEXCEPT

      { _M_w ^= __x._M_w; }

      void

      _M_do_left_shift(size_t __shift) _GLIBCXX_NOEXCEPT

      { _M_w <<= __shift; }

      void

      _M_do_right_shift(size_t __shift) _GLIBCXX_NOEXCEPT

      { _M_w >>= __shift; }

      void

      _M_do_flip() _GLIBCXX_NOEXCEPT

      { _M_w = ~_M_w; }

      void

      _M_do_set() _GLIBCXX_NOEXCEPT

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

      void

      _M_do_reset() _GLIBCXX_NOEXCEPT

      { _M_w = 0; }

      bool

      _M_is_equal(const _Base_bitset<1>& __x) const _GLIBCXX_NOEXCEPT

      { return _M_w == __x._M_w; }

      template

        bool

        _M_are_all() const _GLIBCXX_NOEXCEPT

        { return _M_w == (~static_cast<_WordT>(0)

			  >> (_GLIBCXX_BITSET_BITS_PER_WORD - _Nb)); }

      bool

      _M_is_any() const _GLIBCXX_NOEXCEPT

      { return _M_w != 0; }

      size_t

      _M_do_count() const _GLIBCXX_NOEXCEPT

      { return __builtin_popcountl(_M_w); }

      unsigned long

      _M_do_to_ulong() const _GLIBCXX_NOEXCEPT

      { return _M_w; }

#if __cplusplus >= 201103L

      unsigned long long

      _M_do_to_ullong() const noexcept

      { return _M_w; }

#endif

      size_t

      _M_do_find_first(size_t __not_found) const _GLIBCXX_NOEXCEPT

      {

        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

	_GLIBCXX_NOEXCEPT

      {

	++__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;

      }

    };

  /**

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

   *

   *  See documentation for bitset.

  */

  template<>

    struct _Base_bitset<0>

    {

      typedef unsigned long _WordT;

      _GLIBCXX_CONSTEXPR _Base_bitset() _GLIBCXX_NOEXCEPT

      { }

#if __cplusplus >= 201103L

      constexpr _Base_bitset(unsigned long long) noexcept

#else

      _Base_bitset(unsigned long)

#endif

      { }

      static _GLIBCXX_CONSTEXPR size_t

      _S_whichword(size_t __pos) _GLIBCXX_NOEXCEPT

      { return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; }

      static _GLIBCXX_CONSTEXPR size_t

      _S_whichbyte(size_t __pos) _GLIBCXX_NOEXCEPT

      { return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; }

      static _GLIBCXX_CONSTEXPR size_t

      _S_whichbit(size_t __pos) _GLIBCXX_NOEXCEPT

      {  return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; }

      static _GLIBCXX_CONSTEXPR _WordT

      _S_maskbit(size_t __pos) _GLIBCXX_NOEXCEPT

      { 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) _GLIBCXX_NOEXCEPT

      {

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

	return *new _WordT;

      }

      _GLIBCXX_CONSTEXPR _WordT

      _M_getword(size_t __pos) const _GLIBCXX_NOEXCEPT

      { return 0; }

      _GLIBCXX_CONSTEXPR _WordT

      _M_hiword() const _GLIBCXX_NOEXCEPT

      { return 0; }

      void

      _M_do_and(const _Base_bitset<0>&) _GLIBCXX_NOEXCEPT

      { }

      void

      _M_do_or(const _Base_bitset<0>&) _GLIBCXX_NOEXCEPT

      { }

      void

      _M_do_xor(const _Base_bitset<0>&) _GLIBCXX_NOEXCEPT

      { }

      void

      _M_do_left_shift(size_t) _GLIBCXX_NOEXCEPT

      { }

      void

      _M_do_right_shift(size_t) _GLIBCXX_NOEXCEPT

      { }

      void

      _M_do_flip() _GLIBCXX_NOEXCEPT

      { }

      void

      _M_do_set() _GLIBCXX_NOEXCEPT

      { }

      void

      _M_do_reset() _GLIBCXX_NOEXCEPT

      { }

      // 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 _GLIBCXX_NOEXCEPT

      { return true; }

      template

        bool

        _M_are_all() const _GLIBCXX_NOEXCEPT

        { return true; }

      bool

      _M_is_any() const _GLIBCXX_NOEXCEPT

      { return false; }

      size_t

      _M_do_count() const _GLIBCXX_NOEXCEPT

      { return 0; }

      unsigned long

      _M_do_to_ulong() const _GLIBCXX_NOEXCEPT

      { return 0; }

#if __cplusplus >= 201103L

      unsigned long long

      _M_do_to_ullong() const noexcept

      { return 0; }

#endif

      // 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 _GLIBCXX_NOEXCEPT

      { return 0; }

      size_t

      _M_do_find_next(size_t, size_t) const _GLIBCXX_NOEXCEPT

      { return 0; }

    };

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

  template

    struct _Sanitize

    {

      typedef unsigned long _WordT;

      static void

      _S_do_sanitize(_WordT& __val) _GLIBCXX_NOEXCEPT

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

    };

  template<>

    struct _Sanitize<0>

    {

      typedef unsigned long _WordT;

      static void

      _S_do_sanitize(_WordT) _GLIBCXX_NOEXCEPT { }

    };

#if __cplusplus >= 201103L

  template

    struct _Sanitize_val

    {

      static constexpr unsigned long long

      _S_do_sanitize_val(unsigned long long __val)

      { return __val; }

    };

  template

    struct _Sanitize_val<_Nb, true>

    {

      static constexpr unsigned long long

      _S_do_sanitize_val(unsigned long long __val)

      { return __val & ~((~static_cast(0)) << _Nb); }

    };

#endif

  /**

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

   *  @ingroup utilities

   *

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

   *  container.  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 

   *     #include 

   *     #include 

   *

   *     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:

   *  https://gcc.gnu.org/onlinedocs/libstdc++/manual/ext_containers.html

   *  for a description of extensions.

   *

   *  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.

  */

  template

    class bitset

    : private _Base_bitset<_GLIBCXX_BITSET_WORDS(_Nb)>

    {

    private:

      typedef _Base_bitset<_GLIBCXX_BITSET_WORDS(_Nb)> _Base;

      typedef unsigned long _WordT;

      template

      void

      _M_check_initial_position(const std::basic_string<_CharT, _Traits, _Alloc>& __s,

				size_t __position) const

      {

	if (__position > __s.size())

	  __throw_out_of_range_fmt(__N("bitset::bitset: __position "

				       "(which is %zu) > __s.size() "

				       "(which is %zu)"),

				   __position, __s.size());

      }

      void _M_check(size_t __position, const char *__s) const

      {

	if (__position >= _Nb)

	  __throw_out_of_range_fmt(__N("%s: __position (which is %zu) "

				       ">= _Nb (which is %zu)"),

				   __s, __position, _Nb);

      }

      void

      _M_do_sanitize() _GLIBCXX_NOEXCEPT

      {

	typedef _Sanitize<_Nb % _GLIBCXX_BITSET_BITS_PER_WORD> __sanitize_type;

	__sanitize_type::_S_do_sanitize(this->_M_hiword());

      }

#if __cplusplus >= 201103L

      template friend struct hash;

#endif

    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) _GLIBCXX_NOEXCEPT

	{

	  _M_wp = &__b._M_getword(__pos);

	  _M_bpos = _Base::_S_whichbit(__pos);

	}

	~reference() _GLIBCXX_NOEXCEPT

	{ }

	// For b[i] = __x;

	reference&

	operator=(bool __x) _GLIBCXX_NOEXCEPT

	{

	  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) _GLIBCXX_NOEXCEPT

	{

	  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 _GLIBCXX_NOEXCEPT

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

	// For __x = b[i];

	operator bool() const _GLIBCXX_NOEXCEPT

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

	// For b[i].flip();

	reference&

	flip() _GLIBCXX_NOEXCEPT

	{

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

	  return *this;

	}

      };

      friend class reference;

      // 23.3.5.1 constructors:

      /// All bits set to zero.

      _GLIBCXX_CONSTEXPR bitset() _GLIBCXX_NOEXCEPT

      { }

      /// Initial bits bitwise-copied from a single word (others set to zero).

#if __cplusplus >= 201103L

      constexpr bitset(unsigned long long __val) noexcept

      : _Base(_Sanitize_val<_Nb>::_S_do_sanitize_val(__val)) { }

#else

      bitset(unsigned long __val)

      : _Base(__val)

      { _M_do_sanitize(); }

#endif

      /**

       *  Use a subset of a string.

       *  @param  __s  A string of @a 0 and @a 1 characters.

       *  @param  __position  Index of the first character in @a __s to use;

       *                    defaults to zero.

       *  @throw  std::out_of_range  If @a pos is bigger the size of @a __s.

       *  @throw  std::invalid_argument  If a character appears in the string

       *                                 which is neither @a 0 nor @a 1.

       */

      template

	explicit

	bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,

	       size_t __position = 0)

	: _Base()

	{

	  _M_check_initial_position(__s, __position);

	  _M_copy_from_string(__s, __position,

			      std::basic_string<_CharT, _Traits, _Alloc>::npos,

			      _CharT('0'), _CharT('1'));

	}

      /**

       *  Use a subset of a string.

       *  @param  __s  A string of @a 0 and @a 1 characters.

       *  @param  __position  Index of the first character in @a __s to use.

       *  @param  __n    The number of characters to copy.

       *  @throw std::out_of_range If @a __position is bigger the size

       *  of @a __s.

       *  @throw  std::invalid_argument  If a character appears in the string

       *                                 which is neither @a 0 nor @a 1.

       */

      template

	bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,

	       size_t __position, size_t __n)

	: _Base()

	{

	  _M_check_initial_position(__s, __position);

	  _M_copy_from_string(__s, __position, __n, _CharT('0'), _CharT('1'));

	}

      // _GLIBCXX_RESOLVE_LIB_DEFECTS

      // 396. what are characters zero and one.

      template

	bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s,

	       size_t __position, size_t __n,

	       _CharT __zero, _CharT __one = _CharT('1'))

	: _Base()

	{

	  _M_check_initial_position(__s, __position);

	  _M_copy_from_string(__s, __position, __n, __zero, __one);

	}

#if __cplusplus >= 201103L

      /**

       *  Construct from a character %array.

       *  @param  __str  An %array of characters @a zero and @a one.

       *  @param  __n    The number of characters to use.

       *  @param  __zero The character corresponding to the value 0.

       *  @param  __one  The character corresponding to the value 1.

       *  @throw  std::invalid_argument If a character appears in the string

       *                                which is neither @a __zero nor @a __one.

       */

      template

        explicit

        bitset(const _CharT* __str,

	       typename std::basic_string<_CharT>::size_type __n

	       = std::basic_string<_CharT>::npos,

	       _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'))

        : _Base()

        {

	  if (!__str)

	    __throw_logic_error(__N("bitset::bitset(const _CharT*, ...)"));

	  if (__n == std::basic_string<_CharT>::npos)

	    __n = std::char_traits<_CharT>::length(__str);

	  _M_copy_from_ptr<_CharT, std::char_traits<_CharT>>(__str, __n, 0,

							     __n, __zero,

							     __one);

	}

#endif

      // 23.3.5.2 bitset operations:

      //@{

      /**

       *  Operations on bitsets.

       *  @param  __rhs  A same-sized bitset.

       *

       *  These should be self-explanatory.

       */

      bitset<_Nb>&

      operator&=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT

      {

	this->_M_do_and(__rhs);

	return *this;

      }

      bitset<_Nb>&

      operator|=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT

      {

	this->_M_do_or(__rhs);

	return *this;

      }

      bitset<_Nb>&

      operator^=(const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT

      {

	this->_M_do_xor(__rhs);

	return *this;

      }

      //@}

      //@{

      /**

       *  Operations on bitsets.

       *  @param  __position  The number of places to shift.

       *

       *  These should be self-explanatory.

       */

      bitset<_Nb>&

      operator<<=(size_t __position) _GLIBCXX_NOEXCEPT

      {

	if (__builtin_expect(__position < _Nb, 1))

	  {

	    this->_M_do_left_shift(__position);

	    this->_M_do_sanitize();

	  }

	else

	  this->_M_do_reset();

	return *this;

      }

      bitset<_Nb>&

      operator>>=(size_t __position) _GLIBCXX_NOEXCEPT

      {

	if (__builtin_expect(__position < _Nb, 1))

	  {

	    this->_M_do_right_shift(__position);

	    this->_M_do_sanitize();

	  }

	else

	  this->_M_do_reset();

	return *this;

      }

      //@}

      //@{

      /**

       *  These versions of single-bit set, reset, flip, and test are

       *  extensions from the SGI version.  They do no range checking.

       *  @ingroup SGIextensions

       */

      bitset<_Nb>&

      _Unchecked_set(size_t __pos) _GLIBCXX_NOEXCEPT

      {

	this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);

	return *this;

      }

      bitset<_Nb>&

      _Unchecked_set(size_t __pos, int __val) _GLIBCXX_NOEXCEPT

      {

	if (__val)

	  this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);

	else

	  this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);

	return *this;

      }

      bitset<_Nb>&

      _Unchecked_reset(size_t __pos) _GLIBCXX_NOEXCEPT

      {

	this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);

	return *this;

      }

      bitset<_Nb>&

      _Unchecked_flip(size_t __pos) _GLIBCXX_NOEXCEPT

      {

	this->_M_getword(__pos) ^= _Base::_S_maskbit(__pos);

	return *this;

      }

      _GLIBCXX_CONSTEXPR bool

      _Unchecked_test(size_t __pos) const _GLIBCXX_NOEXCEPT

      { return ((this->_M_getword(__pos) & _Base::_S_maskbit(__pos))

		!= static_cast<_WordT>(0)); }

      //@}

      // Set, reset, and flip.

      /**

       *  @brief Sets every bit to true.

       */

      bitset<_Nb>&

      set() _GLIBCXX_NOEXCEPT

      {

	this->_M_do_set();

	this->_M_do_sanitize();

	return *this;

      }

      /**

       *  @brief Sets a given bit to a particular value.

       *  @param  __position  The index of the bit.

       *  @param  __val  Either true or false, defaults to true.

       *  @throw  std::out_of_range  If @a pos is bigger the size of the %set.

       */

      bitset<_Nb>&

      set(size_t __position, bool __val = true)

      {

	this->_M_check(__position, __N("bitset::set"));

	return _Unchecked_set(__position, __val);

      }

      /**

       *  @brief Sets every bit to false.

       */

      bitset<_Nb>&

      reset() _GLIBCXX_NOEXCEPT

      {

	this->_M_do_reset();

	return *this;

      }

      /**

       *  @brief Sets a given bit to false.

       *  @param  __position  The index of the bit.

       *  @throw  std::out_of_range  If @a pos is bigger the size of the %set.

       *

       *  Same as writing @c set(pos,false).

       */

      bitset<_Nb>&

      reset(size_t __position)

      {

	this->_M_check(__position, __N("bitset::reset"));

	return _Unchecked_reset(__position);

      }

      /**

       *  @brief Toggles every bit to its opposite value.

       */

      bitset<_Nb>&

      flip() _GLIBCXX_NOEXCEPT

      {

	this->_M_do_flip();

	this->_M_do_sanitize();

	return *this;

      }

      /**

       *  @brief Toggles a given bit to its opposite value.

       *  @param  __position  The index of the bit.