Subversion Repositories openrisc

//  -*- C++ -*-

// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010

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

#include 

#include    // For invalid_argument, out_of_range,

                                // overflow_error

#include 

#include 

#define _GLIBCXX_BITSET_BITS_PER_WORD  (__CHAR_BIT__ * sizeof(unsigned long))

#define _GLIBCXX_BITSET_WORDS(__n) \

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

                  / _GLIBCXX_BITSET_BITS_PER_WORD)

_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD_D)

  /**

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

      _Base_bitset()

      { _M_do_reset(); }

#ifdef __GXX_EXPERIMENTAL_CXX0X__

      _Base_bitset(unsigned long long __val)

#else

      _Base_bitset(unsigned long __val)

#endif

      {

        _M_do_reset();

        _M_w[0] = __val;

#ifdef __GXX_EXPERIMENTAL_CXX0X__

        if (sizeof(unsigned long long) > sizeof(unsigned long))

          _M_w[1] = __val >> _GLIBCXX_BITSET_BITS_PER_WORD;

#endif

      }

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

#ifdef __GXX_EXPERIMENTAL_CXX0X__

      const _WordT*

      _M_getdata() const

      { return _M_w; }

#endif

      _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()

      { __builtin_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;

      }

      size_t

      _M_are_all_aux() const

      {

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

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

            return 0;

        return ((_Nw - 1) * _GLIBCXX_BITSET_BITS_PER_WORD

                + __builtin_popcountl(_M_hiword()));

      }

      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;

#ifdef __GXX_EXPERIMENTAL_CXX0X__

      unsigned long long

      _M_do_to_ullong() const;

#endif

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

    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

    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

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

    }

#ifdef __GXX_EXPERIMENTAL_CXX0X__

  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

    {

      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

    {

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

      _Base_bitset(void)

      : _M_w(0)

      { }

#ifdef __GXX_EXPERIMENTAL_CXX0X__

      _Base_bitset(unsigned long long __val)

#else

      _Base_bitset(unsigned long __val)

#endif

      : _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; }

#ifdef __GXX_EXPERIMENTAL_CXX0X__

      const _WordT*

      _M_getdata() const

      { return &_M_w; }

#endif

      _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; }

      size_t

      _M_are_all_aux() const

      { return __builtin_popcountl(_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; }

#ifdef __GXX_EXPERIMENTAL_CXX0X__

      unsigned long long

      _M_do_to_ullong() const

      { return _M_w; }

#endif

      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;

      }

    };

  /**

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

   *

   *  See documentation for bitset.

  */

  template<>

    struct _Base_bitset<0>

    {

      typedef unsigned long _WordT;

      _Base_bitset()

      { }

#ifdef __GXX_EXPERIMENTAL_CXX0X__

      _Base_bitset(unsigned long long)

#else

      _Base_bitset(unsigned long)

#endif

      { }

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

      size_t

      _M_are_all_aux() const

      { return 0; }

      bool

      _M_is_any() const

      { return false; }

      size_t

      _M_do_count() const

      { return 0; }

      unsigned long

      _M_do_to_ulong() const

      { return 0; }

#ifdef __GXX_EXPERIMENTAL_CXX0X__

      unsigned long long

      _M_do_to_ullong() const

      { 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

      { 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

    struct _Sanitize

    {

      static void _S_do_sanitize(unsigned long& __val)

      { __val &= ~((~static_cast(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

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

   *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt12ch33s02.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;

      void

        _M_do_sanitize()

        {

          _Sanitize<_Nb % _GLIBCXX_BITSET_BITS_PER_WORD>::

            _S_do_sanitize(this->_M_hiword());

        }

#ifdef __GXX_EXPERIMENTAL_CXX0X__

      template friend class 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)

        {

          _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; }

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

        reference&

        flip()

        {

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

          return *this;

        }

      };

      friend class reference;

      // 23.3.5.1 constructors:

      /// All bits set to zero.

      bitset()

      { }

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

#ifdef __GXX_EXPERIMENTAL_CXX0X__

      bitset(unsigned long long __val)

#else

      bitset(unsigned long __val)

#endif

      : _Base(__val)

      { _M_do_sanitize(); }

      /**

       *  @brief  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()

        {

          if (__position > __s.size())

            __throw_out_of_range(__N("bitset::bitset initial position "

                                     "not valid"));

          _M_copy_from_string(__s, __position,

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

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

        }

      /**

       *  @brief  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 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

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

               size_t __position, size_t __n)

        : _Base()

        {

          if (__position > __s.size())

            __throw_out_of_range(__N("bitset::bitset initial position "

                                     "not valid"));

          _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()

        {

          if (__position > __s.size())

            __throw_out_of_range(__N("bitset::bitset initial position "

                                     "not valid"));

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

        }

#ifdef __GXX_EXPERIMENTAL_CXX0X__

      /**

       *  @brief  Construct from a string.

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

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

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

       */

      explicit

      bitset(const char* __str)

      : _Base()

      {

        if (!__str)

          __throw_logic_error(__N("bitset::bitset(const char*)"));

        const size_t __len = __builtin_strlen(__str);

        _M_copy_from_ptr>(__str, __len, 0,

                                                       __len, '0', '1');

      }

#endif

      // 23.3.5.2 bitset operations:

      //@{

      /**

       *  @brief  Operations on bitsets.

       *  @param  rhs  A same-sized bitset.

       *

       *  These should be self-explanatory.

       */

      bitset<_Nb>&

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

      {

        this->_M_do_and(__rhs);

        return *this;

      }

      bitset<_Nb>&

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

      {

        this->_M_do_or(__rhs);

        return *this;

      }

      bitset<_Nb>&

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

      {

        this->_M_do_xor(__rhs);

        return *this;

      }

      //@}

      //@{

      /**

       *  @brief  Operations on bitsets.

       *  @param  position  The number of places to shift.

       *

       *  These should be self-explanatory.

       */

      bitset<_Nb>&

      operator<<=(size_t __position)

      {

        if (__builtin_expect(__position < _Nb, 1))

          {

            this->_M_do_left_shift(__position);

            this->_M_do_sanitize();