2002-04-09 Benjamin Kosnik <bkoz@redhat.com>

	libstdc++/6124
	* testsuite/23_containers/bitset_members.cc: New test.
	* include/std/std_bitset.h (_Bit_count::_S_bit_count): Move..
	(_S_bit_count): Here.
	(_First_one::_S_first_one): Move...
	(_S_first_one): Here.
	Format.
	* src/bitset.cc: Adjust.
	* config/linker-map.gnu: Export.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@52066 138bc75d-0d04-0410-961f-82ee72b054a4

5 files changed, 762 insertions, 649 deletions

diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog
index 64e40fae669..48e11112550 100644
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,3 +1,15 @@
+2002-04-09  Benjamin Kosnik  <bkoz@redhat.com>
+
+	libstdc++/6124
+	* testsuite/23_containers/bitset_members.cc: New test.
+	* include/std/std_bitset.h (_Bit_count::_S_bit_count): Move..
+	(_S_bit_count): Here.
+	(_First_one::_S_first_one): Move...
+	(_S_first_one): Here.
+	Format.
+	* src/bitset.cc: Adjust.
+	* config/linker-map.gnu: Export.
+	
 2002-04-08  Benjamin Kosnik  <bkoz@redhat.com>
 
 	libstdc++/5180
diff --git a/libstdc++-v3/config/linker-map.gnu b/libstdc++-v3/config/linker-map.gnu
index 7e0c8679e14..851ece555e0 100644
--- a/libstdc++-v3/config/linker-map.gnu
+++ b/libstdc++-v3/config/linker-map.gnu
@@ -34,7 +34,9 @@ GLIBCPP_3.1 {
       std::__basic_file*;
       std::__num_base*;
       std::__timepunct*;
-      std::__numeric_limits_base*
+      std::__numeric_limits_base*;
+      std::_S_bit_count;
+      std::_S_first_one
     };
 
     # Names not in an 'extern' block are mangled names.
diff --git a/libstdc++-v3/include/std/std_bitset.h b/libstdc++-v3/include/std/std_bitset.h
index a6134398130..a8aa319ab9f 100644
--- a/libstdc++-v3/include/std/std_bitset.h
+++ b/libstdc++-v3/include/std/std_bitset.h
@@ -60,7 +60,6 @@
 // individual bits.  This allows us to specialize _Base_bitset for the
 // important special case where the bitset is only a single word.
 
-
 #include <cstddef>     // for size_t
 #include <cstring>     // for memset
 #include <string>
@@ -75,739 +74,840 @@
 
 namespace std
 {
+  extern unsigned char 	_S_bit_count[256];
+  extern unsigned char 	_S_first_one[256];
+
+  // Base class: general case.
+  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;
+      }
 
-// structure to aid in counting bits
-template<bool __dummy> 
-struct _Bit_count {
-  static unsigned char _S_bit_count[256];
-};
+      static size_t 
+      _S_whichword(size_t __pos )
+      { return __pos / _GLIBCPP_BITSET_BITS_PER_WORD; }
 
-// Mapping from 8 bit unsigned integers to the index of the first one
-// bit:
-template<bool __dummy> 
-struct _First_one {
-  static unsigned char _S_first_one[256];
-};
+      static size_t 
+      _S_whichbyte(size_t __pos )
+      { return (__pos % _GLIBCPP_BITSET_BITS_PER_WORD) / CHAR_BIT; }
 
-//
-// Base class: general case.
-//
+      static size_t 
+      _S_whichbit(size_t __pos )
+      { return __pos % _GLIBCPP_BITSET_BITS_PER_WORD; }
 
-template<size_t _Nw>
-struct _Base_bitset {
-  typedef unsigned long _WordT;
+      static _WordT 
+      _S_maskbit(size_t __pos )
+      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
 
-  _WordT _M_w[_Nw];                // 0 is the least significant word.
+      _WordT& 
+      _M_getword(size_t __pos)       
+      { return _M_w[_S_whichword(__pos)]; }
 
-  _Base_bitset( void ) { _M_do_reset(); }
-  _Base_bitset(unsigned long __val) {
-    _M_do_reset();
-    _M_w[0] = __val;
-  }
+      _WordT  
+      _M_getword(size_t __pos) const 
+      { return _M_w[_S_whichword(__pos)]; }
 
-  static size_t _S_whichword( size_t __pos )
-    { return __pos / _GLIBCPP_BITSET_BITS_PER_WORD; }
-  static size_t _S_whichbyte( size_t __pos )
-    { return (__pos % _GLIBCPP_BITSET_BITS_PER_WORD) / CHAR_BIT; }
-  static size_t _S_whichbit( size_t __pos )
-    { return __pos % _GLIBCPP_BITSET_BITS_PER_WORD; }
-  static _WordT _S_maskbit( size_t __pos )
-    { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
+      _WordT& 
+      _M_hiword() { return _M_w[_Nw - 1]; }
 
-  _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() const { return _M_w[_Nw - 1]; }
 
-  _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_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_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_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_left_shift(size_t __shift);
-  void _M_do_right_shift(size_t __shift);
+      void 
+      _M_do_set() 
+      {
+	for (size_t __i = 0; __i < _Nw; __i++)
+	  _M_w[__i] = ~static_cast<_WordT>(0);
+      }
 
-  void _M_do_flip() {
-    for ( size_t __i = 0; __i < _Nw; __i++ ) {
-      _M_w[__i] = ~_M_w[__i];
-    }
-  }
+      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;
+      }
 
-  void _M_do_set() {
-    for ( size_t __i = 0; __i < _Nw; __i++ ) {
-      _M_w[__i] = ~static_cast<_WordT>(0);
-    }
-  }
+      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;
+      }
 
-  void _M_do_reset() { memset(_M_w, 0, _Nw * sizeof(_WordT)); }
+      size_t 
+      _M_do_count() const 
+      {
+	size_t __result = 0;
+	const unsigned char* __byte_ptr = (const unsigned char*)_M_w;
+	const unsigned char* __end_ptr = (const unsigned char*)(_M_w + _Nw);
+	
+	while ( __byte_ptr < __end_ptr ) 
+	  {
+	    __result += _S_bit_count[*__byte_ptr];
+	    __byte_ptr++;
+	  }
+	return __result;
+      }
 
-  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;
+      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 (__shift != 0) 
+	{
+	  const size_t __wshift = __shift / _GLIBCPP_BITSET_BITS_PER_WORD;
+	  const size_t __offset = __shift % _GLIBCPP_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 = _GLIBCPP_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;
+	    }
+	  
+	  fill(_M_w + 0, _M_w + __wshift, static_cast<_WordT>(0));
+	}
     }
-    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;
+  
+  template<size_t _Nw>
+    void 
+    _Base_bitset<_Nw>::_M_do_right_shift(size_t __shift) 
+    {
+      if (__shift != 0) 
+	{
+	  const size_t __wshift = __shift / _GLIBCPP_BITSET_BITS_PER_WORD;
+	  const size_t __offset = __shift % _GLIBCPP_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 = _GLIBCPP_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;
+	    }
+	  
+	  fill(_M_w + __limit + 1, _M_w + _Nw, static_cast<_WordT>(0));
+	}
     }
-    return false;
-  }
 
-  size_t _M_do_count() const {
-    size_t __result = 0;
-    const unsigned char* __byte_ptr = (const unsigned char*)_M_w;
-    const unsigned char* __end_ptr = (const unsigned char*)(_M_w+_Nw);
-
-    while ( __byte_ptr < __end_ptr ) {
-      __result += _Bit_count<true>::_S_bit_count[*__byte_ptr];
-      __byte_ptr++;
+  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("bitset");
+      return _M_w[0];
     }
-    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 (__shift != 0) {
-    const size_t __wshift = __shift / _GLIBCPP_BITSET_BITS_PER_WORD;
-    const size_t __offset = __shift % _GLIBCPP_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 = _GLIBCPP_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;
+  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) ) 
+	    {
+	      // find byte within word
+	      for (size_t __j = 0; __j < sizeof(_WordT); __j++ ) 
+		{
+		  unsigned char __this_byte
+		    = static_cast<unsigned char>(__thisword & (~(unsigned char)0));
+		  if (__this_byte)
+		    return __i*_GLIBCPP_BITSET_BITS_PER_WORD + __j*CHAR_BIT +
+		      _S_first_one[__this_byte];
+
+		  __thisword >>= CHAR_BIT;
+		}
+	    }
+	}
+      // not found, so return an indication of failure.
+      return __not_found;
     }
 
-    fill(_M_w + 0, _M_w + __wshift, static_cast<_WordT>(0));
-  }
-}
+  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 * _GLIBCPP_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) ) 
+	{
+	  // find byte within word
+	  // get first byte into place
+	  __thisword >>= _S_whichbyte(__prev) * CHAR_BIT;
+	  for (size_t __j = _S_whichbyte(__prev); __j < sizeof(_WordT); __j++)
+	    {
+	      unsigned char __this_byte
+		= static_cast<unsigned char>(__thisword & (~(unsigned char)0));
+	      if ( __this_byte )
+		return __i*_GLIBCPP_BITSET_BITS_PER_WORD + __j*CHAR_BIT +
+		  _S_first_one[__this_byte];
+	      
+	      __thisword >>= CHAR_BIT;
+	    }
+	}
+      
+      // check subsequent words
+      __i++;
+      for ( ; __i < _Nw; __i++ ) 
+	{
+	  __thisword = _M_w[__i];
+	  if ( __thisword != static_cast<_WordT>(0) ) 
+	    {
+	      // find byte within word
+	      for (size_t __j = 0; __j < sizeof(_WordT); __j++ ) 
+		{
+		  unsigned char __this_byte
+		    = static_cast<unsigned char>(__thisword & (~(unsigned char)0));
+		  if ( __this_byte )
+		    return __i*_GLIBCPP_BITSET_BITS_PER_WORD + __j*CHAR_BIT +
+		      _S_first_one[__this_byte];
+		  
+		  __thisword >>= CHAR_BIT;
+		}
+	    }
+	}
+      // not found, so return an indication of failure.
+      return __not_found;
+    } // end _M_do_find_next
+  
 
-template<size_t _Nw>
-void _Base_bitset<_Nw>::_M_do_right_shift(size_t __shift) 
-{
-  if (__shift != 0) {
-    const size_t __wshift = __shift / _GLIBCPP_BITSET_BITS_PER_WORD;
-    const size_t __offset = __shift % _GLIBCPP_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 = _GLIBCPP_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;
-    }
+  // Base class: specialization for a single word.
+  template<> 
+    struct _Base_bitset<1> 
+    {
+      typedef unsigned long _WordT;
+      _WordT _M_w;
 
-    fill(_M_w + __limit + 1, _M_w + _Nw, static_cast<_WordT>(0));
-  }
-}
+      _Base_bitset( void ) : _M_w(0) {}
+      _Base_bitset(unsigned long __val) : _M_w(__val) {}
 
-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("bitset");
-  
-  return _M_w[0];
-}
+      static size_t 
+      _S_whichword(size_t __pos )
+      { return __pos / _GLIBCPP_BITSET_BITS_PER_WORD; }
 
-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) ) {
-      // find byte within word
-      for ( size_t __j = 0; __j < sizeof(_WordT); __j++ ) {
-        unsigned char __this_byte
-          = static_cast<unsigned char>(__thisword & (~(unsigned char)0));
-        if ( __this_byte )
-          return __i*_GLIBCPP_BITSET_BITS_PER_WORD + __j*CHAR_BIT +
-            _First_one<true>::_S_first_one[__this_byte];
-
-        __thisword >>= CHAR_BIT;
-      }
-    }
-  }
-  // 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 * _GLIBCPP_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) ) {
-    // find byte within word
-    // get first byte into place
-    __thisword >>= _S_whichbyte(__prev) * CHAR_BIT;
-    for ( size_t __j = _S_whichbyte(__prev); __j < sizeof(_WordT); __j++ ) {
-      unsigned char __this_byte
-        = static_cast<unsigned char>(__thisword & (~(unsigned char)0));
-      if ( __this_byte )
-        return __i*_GLIBCPP_BITSET_BITS_PER_WORD + __j*CHAR_BIT +
-          _First_one<true>::_S_first_one[__this_byte];
-
-      __thisword >>= CHAR_BIT;
-    }
-  }
-
-  // check subsequent words
-  __i++;
-  for ( ; __i < _Nw; __i++ ) {
-    __thisword = _M_w[__i];
-    if ( __thisword != static_cast<_WordT>(0) ) {
-      // find byte within word
-      for ( size_t __j = 0; __j < sizeof(_WordT); __j++ ) {
-        unsigned char __this_byte
-          = static_cast<unsigned char>(__thisword & (~(unsigned char)0));
-        if ( __this_byte )
-          return __i*_GLIBCPP_BITSET_BITS_PER_WORD + __j*CHAR_BIT +
-            _First_one<true>::_S_first_one[__this_byte];
-
-        __thisword >>= CHAR_BIT;
-      }
-    }
-  }
+      static size_t 
+      _S_whichbyte(size_t __pos )
+      { return (__pos % _GLIBCPP_BITSET_BITS_PER_WORD) / CHAR_BIT; }
 
-  // not found, so return an indication of failure.
-  return __not_found;
-} // end _M_do_find_next
+      static size_t 
+      _S_whichbit(size_t __pos )
+      {  return __pos % _GLIBCPP_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; }
 
-//
-// Base class: specialization for a single word.
-//
+      _WordT  
+      _M_getword(size_t) const { return _M_w; }
 
-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 / _GLIBCPP_BITSET_BITS_PER_WORD; }
-  static size_t _S_whichbyte( size_t __pos )
-    { return (__pos % _GLIBCPP_BITSET_BITS_PER_WORD) / CHAR_BIT; }
-  static size_t _S_whichbit( size_t __pos )
-    {  return __pos % _GLIBCPP_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 {
-    size_t __result = 0;
-    const unsigned char* __byte_ptr = (const unsigned char*)&_M_w;
-    const unsigned char* __end_ptr
-      = ((const unsigned char*)&_M_w)+sizeof(_M_w);
-    while ( __byte_ptr < __end_ptr ) {
-      __result += _Bit_count<true>::_S_bit_count[*__byte_ptr];
-      __byte_ptr++;
-    }
-    return __result;
-  }
+      _WordT& 
+      _M_hiword() { return _M_w; }
 
-  unsigned long _M_do_to_ulong() const { return _M_w; }
+      _WordT  
+      _M_hiword() const { return _M_w; }
 
-  size_t _M_do_find_first(size_t __not_found) const;
+      void 
+      _M_do_and(const _Base_bitset<1>& __x) { _M_w &= __x._M_w; }
 
-  // find the next "on" bit that follows "prev"
-  size_t _M_do_find_next(size_t __prev, size_t __not_found) const; 
+      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; }
 
-// ------------------------------------------------------------
-// Helper class to zero out the unused high-order bits in the highest word.
+      void 
+      _M_do_right_shift(size_t __shift) { _M_w >>= __shift; }
 
-template <size_t _Extrabits> struct _Sanitize {
-  static void _M_do_sanitize(unsigned long& __val)
-    { __val &= ~((~static_cast<unsigned long>(0)) << _Extrabits); }
-};
+      void 
+      _M_do_flip() { _M_w = ~_M_w; }
 
-template<> struct _Sanitize<0> {
-  static void _M_do_sanitize(unsigned long) {}
-};
+      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; }
 
-// ------------------------------------------------------------
-// Class bitset.
-//   _Nb may be any nonzero number of type size_t.
+      bool 
+      _M_is_any() const { return _M_w != 0; }
 
-template<size_t _Nb>
-class bitset : private _Base_bitset<__BITSET_WORDS(_Nb)>
-{
-private:
-  typedef _Base_bitset<__BITSET_WORDS(_Nb)> _Base;
-  typedef unsigned long _WordT;
+      size_t 
+      _M_do_count() const 
+      {
+	size_t __result = 0;
+	const unsigned char* __byte_ptr = (const unsigned char*)&_M_w;
+	const unsigned char* __end_ptr
+	  = ((const unsigned char*)&_M_w)+sizeof(_M_w);
+	while ( __byte_ptr < __end_ptr ) 
+	  {
+	    __result += _S_bit_count[*__byte_ptr];
+	    __byte_ptr++;
+	  }
+	return __result;
+      }
 
-private:
-  void _M_do_sanitize() {
-    _Sanitize<_Nb%_GLIBCPP_BITSET_BITS_PER_WORD>::_M_do_sanitize(this->_M_hiword());
-  }
+      unsigned long 
+      _M_do_to_ulong() const { return _M_w; }
+
+      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; 
+    };
+
+  // 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) { } };
+
+  // Class bitset.
+  // _Nb may be any nonzero number of type size_t.
+  template<size_t _Nb>
+    class bitset : private _Base_bitset<__BITSET_WORDS(_Nb)>
+  {
+  private:
+    typedef _Base_bitset<__BITSET_WORDS(_Nb)> _Base;
+    typedef unsigned long _WordT;
+    
+    void 
+    _M_do_sanitize() 
+    {
+    _Sanitize<_Nb%_GLIBCPP_BITSET_BITS_PER_WORD>::_S_do_sanitize(this->_M_hiword());
+    }
 
-public:
+  public:
+    // bit reference:
+    class reference;
+    friend class reference;
+    
+    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);
+      }
 
-  // bit reference:
-  class reference;
-  friend class reference;
+      ~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;
+      }
 
-  class reference {
-    friend class bitset;
+      // flips the bit
+      bool 
+      operator~() const
+      { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) == 0; }
 
-    _WordT *_M_wp;
-    size_t _M_bpos;
+      // for __x = b[i];
+      operator bool() const
+      { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) != 0; }
 
-    // left undefined
-    reference();
+      // for b[i].flip();
+      reference& 
+      flip() 
+      {
+	*_M_wp ^= _Base::_S_maskbit(_M_bpos);
+	return *this;
+      }
+    };
+    
+    // 23.3.5.1 constructors:
+    bitset() { }
 
-  public:
-    reference( bitset& __b, size_t __pos ) {
-      _M_wp = &__b._M_getword(__pos);
-      _M_bpos = _Base::_S_whichbit(__pos);
-    }
+    bitset(unsigned long __val) : _Base_bitset<__BITSET_WORDS(_Nb)>(__val) 
+    { _M_do_sanitize(); }
 
-    ~reference() {}
+    template<class _CharT, class _Traits, class _Alloc>
+      explicit bitset(const basic_string<_CharT, _Traits, _Alloc>& __s,
+		      size_t __pos = 0) : _Base() 
+      {
+	if (__pos > __s.size()) 
+	  __throw_out_of_range("bitset");
+	_M_copy_from_string(__s, __pos,
+			    basic_string<_CharT, _Traits, _Alloc>::npos);
+      }
 
-    // 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);
+    template<class _CharT, class _Traits, class _Alloc>
+      bitset(const basic_string<_CharT, _Traits, _Alloc>& __s,
+	     size_t __pos, size_t __n) : _Base() 
+      {
+	if (__pos > __s.size()) 
+	  __throw_out_of_range("bitset");
+	_M_copy_from_string(__s, __pos, __n);
+      }
 
+    // 23.3.5.2 bitset operations:
+    bitset<_Nb>& 
+    operator&=(const bitset<_Nb>& __rhs) 
+    {
+      this->_M_do_and(__rhs);
       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);
-
+    bitset<_Nb>& 
+    operator|=(const bitset<_Nb>& __rhs) 
+    {
+      this->_M_do_or(__rhs);
       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; }
+    bitset<_Nb>& 
+    operator^=(const bitset<_Nb>& __rhs) 
+    {
+      this->_M_do_xor(__rhs);
+      return *this;
+    }
 
-    // for b[i].flip();
-    reference& flip() {
-      *_M_wp ^= _Base::_S_maskbit(_M_bpos);
+    bitset<_Nb>& 
+    operator<<=(size_t __pos) 
+    {
+      this->_M_do_left_shift(__pos);
+      this->_M_do_sanitize();
       return *this;
     }
-  };
 
-  // 23.3.5.1 constructors:
-  bitset() {}
-  bitset(unsigned long __val) : _Base_bitset<__BITSET_WORDS(_Nb)>(__val) 
-    { _M_do_sanitize(); }
+    bitset<_Nb>& 
+    operator>>=(size_t __pos) 
+    {
+      this->_M_do_right_shift(__pos);
+      this->_M_do_sanitize();
+      return *this;
+    }
 
-  template<class _CharT, class _Traits, class _Alloc>
-  explicit bitset(const basic_string<_CharT, _Traits, _Alloc>& __s,
-                  size_t __pos = 0)
-    : _Base() 
-  {
-    if (__pos > __s.size()) 
-      __throw_out_of_range("bitset");
-    _M_copy_from_string(__s, __pos,
-                        basic_string<_CharT, _Traits, _Alloc>::npos);
-  }
-  template<class _CharT, class _Traits, class _Alloc>
-  bitset(const basic_string<_CharT, _Traits, _Alloc>& __s,
-         size_t __pos,
-         size_t __n)
-    : _Base() 
-  {
-    if (__pos > __s.size()) 
-      __throw_out_of_range("bitset");
-    _M_copy_from_string(__s, __pos, __n);
-  }
-
-  // 23.3.5.2 bitset operations:
-  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;
-  }
-
-  bitset<_Nb>& operator<<=(size_t __pos) {
-    this->_M_do_left_shift(__pos);
-    this->_M_do_sanitize();
-    return *this;
-  }
-
-  bitset<_Nb>& operator>>=(size_t __pos) {
-    this->_M_do_right_shift(__pos);
-    this->_M_do_sanitize();
-    return *this;
-  }
-
-  //
-  // Extension:
-  // Versions of single-bit set, reset, flip, test with no range checking.
-  //
-
-  bitset<_Nb>& _Unchecked_set(size_t __pos) {
-    this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
-    return *this;
-  }
-
-  bitset<_Nb>& _Unchecked_set(size_t __pos, int __val) {
-    if (__val)
+    // Extension:
+    // Versions of single-bit set, reset, flip, test with no range checking.
+    bitset<_Nb>& 
+    _Unchecked_set(size_t __pos) 
+    {
       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) {
-    this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
-    return *this;
-  }
-
-  bitset<_Nb>& _Unchecked_flip(size_t __pos) {
-    this->_M_getword(__pos) ^= _Base::_S_maskbit(__pos);
-    return *this;
-  }
+      return *this;
+    }
 
-  bool _Unchecked_test(size_t __pos) const {
-    return (this->_M_getword(__pos) & _Base::_S_maskbit(__pos))
-      != static_cast<_WordT>(0);
-  }
+    bitset<_Nb>& 
+    _Unchecked_set(size_t __pos, int __val) 
+    {
+      if (__val)
+	this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
+      else
+	this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
+      return *this;
+    }
 
-  // Set, reset, and flip.
+    bitset<_Nb>& 
+    _Unchecked_reset(size_t __pos) 
+    {
+      this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
+      return *this;
+    }
 
-  bitset<_Nb>& set() {
-    this->_M_do_set();
-    this->_M_do_sanitize();
-    return *this;
-  }
+    bitset<_Nb>& 
+    _Unchecked_flip(size_t __pos) 
+    {
+      this->_M_getword(__pos) ^= _Base::_S_maskbit(__pos);
+      return *this;
+    }
 
-  bitset<_Nb>& set(size_t __pos, bool __val = true) {
-    if (__pos >= _Nb)
-      __throw_out_of_range("bitset");
+    bool 
+    _Unchecked_test(size_t __pos) const 
+    {
+      return (this->_M_getword(__pos) & _Base::_S_maskbit(__pos)) 
+	!= static_cast<_WordT>(0);
+    }
 
-    return _Unchecked_set(__pos, __val);
-  }
+    // Set, reset, and flip.
+    bitset<_Nb>& 
+    set() 
+    {
+      this->_M_do_set();
+      this->_M_do_sanitize();
+      return *this;
+    }
 
-  bitset<_Nb>& reset() {
-    this->_M_do_reset();
-    return *this;
-  }
+    bitset<_Nb>& 
+    set(size_t __pos, bool __val = true) 
+    {
+      if (__pos >= _Nb)
+	__throw_out_of_range("bitset");
+      return _Unchecked_set(__pos, __val);
+    }
 
-  bitset<_Nb>& reset(size_t __pos) {
-    if (__pos >= _Nb)
-      __throw_out_of_range("bitset");
+    bitset<_Nb>& 
+    reset() 
+    {
+      this->_M_do_reset();
+      return *this;
+    }
 
-    return _Unchecked_reset(__pos);
-  }
+    bitset<_Nb>& 
+    reset(size_t __pos) 
+    {
+      if (__pos >= _Nb)
+	__throw_out_of_range("bitset");
+      return _Unchecked_reset(__pos);
+    }
 
-  bitset<_Nb>& flip() {
-    this->_M_do_flip();
-    this->_M_do_sanitize();
-    return *this;
-  }
+    bitset<_Nb>& 
+    flip() 
+    {
+      this->_M_do_flip();
+      this->_M_do_sanitize();
+      return *this;
+    }
 
-  bitset<_Nb>& flip(size_t __pos) {
-    if (__pos >= _Nb)
-      __throw_out_of_range("bitset");
+    bitset<_Nb>& 
+    flip(size_t __pos) 
+    {
+      if (__pos >= _Nb)
+	__throw_out_of_range("bitset");
+      return _Unchecked_flip(__pos);
+    }
 
-    return _Unchecked_flip(__pos);
-  }
+    bitset<_Nb> 
+    operator~() const { return bitset<_Nb>(*this).flip(); }
+
+    // element access:
+    //for b[i];
+    // _GLIBCPP_RESOLVE_LIB_DEFECTS Note that this implementation already
+    // resolves DR 11 (items 1 and 2), but does not do the range-checking
+    // required by that DR's resolution.  -pme
+    reference 
+    operator[](size_t __pos) { return reference(*this,__pos); }
+
+    bool 
+    operator[](size_t __pos) const { return _Unchecked_test(__pos); }
+
+    unsigned long 
+    to_ulong() const { return this->_M_do_to_ulong(); }
+
+    template<class _CharT, class _Traits, class _Alloc>
+      basic_string<_CharT, _Traits, _Alloc> 
+      to_string() const 
+      {
+	basic_string<_CharT, _Traits, _Alloc> __result;
+	_M_copy_to_string(__result);
+	return __result;
+      }
 
-  bitset<_Nb> operator~() const { 
-    return bitset<_Nb>(*this).flip();
-  }
+    // Helper functions for string operations.
+    template<class _CharT, class _Traits, class _Alloc>
+      void 
+      _M_copy_from_string(const basic_string<_CharT,_Traits,_Alloc>& __s,
+                          size_t, size_t);
 
-  // element access:
-  //for b[i];
-  // _GLIBCPP_RESOLVE_LIB_DEFECTS Note that this implementation already
-  // resolves DR 11 (items 1 and 2), but does not do the range-checking
-  // required by that DR's resolution.  -pme
-  reference operator[](size_t __pos) { return reference(*this,__pos); }
-  bool operator[](size_t __pos) const { return _Unchecked_test(__pos); }
+    template<class _CharT, class _Traits, class _Alloc>
+      void 
+      _M_copy_to_string(basic_string<_CharT,_Traits,_Alloc>&) const;
 
-  unsigned long to_ulong() const { return this->_M_do_to_ulong(); }
+    size_t 
+    count() const { return this->_M_do_count(); }
 
-  template <class _CharT, class _Traits, class _Alloc>
-  basic_string<_CharT, _Traits, _Alloc> to_string() const {
-    basic_string<_CharT, _Traits, _Alloc> __result;
-    _M_copy_to_string(__result);
-    return __result;
-  }
+    size_t 
+    size() const { return _Nb; }
 
-  // Helper functions for string operations.
-  template<class _CharT, class _Traits, class _Alloc>
-  void _M_copy_from_string(const basic_string<_CharT,_Traits,_Alloc>& __s,
-                          size_t,
-                          size_t);
+    bool 
+    operator==(const bitset<_Nb>& __rhs) const 
+    { return this->_M_is_equal(__rhs); }
 
-  template<class _CharT, class _Traits, class _Alloc>
-  void _M_copy_to_string(basic_string<_CharT,_Traits,_Alloc>&) const;
+    bool 
+    operator!=(const bitset<_Nb>& __rhs) const 
+    { return !this->_M_is_equal(__rhs); }
 
-  size_t count() const { return this->_M_do_count(); }
+    bool 
+    test(size_t __pos) const 
+    {
+      if (__pos >= _Nb)
+	__throw_out_of_range("bitset");
+      return _Unchecked_test(__pos);
+    }
 
-  size_t size() const { return _Nb; }
+    bool 
+    any() const { return this->_M_is_any(); }
 
-  bool operator==(const bitset<_Nb>& __rhs) const {
-    return this->_M_is_equal(__rhs);
-  }
-  bool operator!=(const bitset<_Nb>& __rhs) const {
-    return !this->_M_is_equal(__rhs);
-  }
+    bool 
+    none() const { return !this->_M_is_any(); }
 
-  bool test(size_t __pos) const {
-    if (__pos >= _Nb)
-      __throw_out_of_range("bitset");
-
-    return _Unchecked_test(__pos);
-  }
-
-  bool any() const { return this->_M_is_any(); }
-  bool none() const { return !this->_M_is_any(); }
-
-  bitset<_Nb> operator<<(size_t __pos) const
+    bitset<_Nb> 
+    operator<<(size_t __pos) const
     { return bitset<_Nb>(*this) <<= __pos; }
-  bitset<_Nb> operator>>(size_t __pos) const
+
+    bitset<_Nb> 
+    operator>>(size_t __pos) const
     { return bitset<_Nb>(*this) >>= __pos; }
 
-  //
-  // EXTENSIONS: bit-find operations.  These operations are
-  // experimental, and are subject to change or removal in future
-  // versions.
-  // 
+    // EXTENSIONS: bit-find operations.  These operations are
+    // experimental, and are subject to change or removal in future
+    // versions.
 
-  // find the index of the first "on" bit
-  size_t _Find_first() const 
+    // find the index of the first "on" bit
+    size_t 
+    _Find_first() const 
     { return this->_M_do_find_first(_Nb); }
 
-  // find the index of the next "on" bit after prev
-  size_t _Find_next( size_t __prev ) const 
+    // find the index of the next "on" bit after prev
+    size_t 
+    _Find_next(size_t __prev ) const 
     { return this->_M_do_find_next(__prev, _Nb); }
+  };
 
-};
-
-//
-// Definitions of non-inline member functions.
-//
-
-template <size_t _Nb>
-template<class _CharT, class _Traits, class _Alloc>
-void bitset<_Nb>
-  ::_M_copy_from_string(const basic_string<_CharT,_Traits,_Alloc>& __s,
-                        size_t __pos,
-                        size_t __n)
-{
-  reset();
-  const size_t __nbits = min(_Nb, min(__n, __s.size() - __pos));
-  for (size_t __i = 0; __i < __nbits; ++__i) {
-    switch(__s[__pos + __nbits - __i - 1]) {
-    case '0':
-      break;
-    case '1':
-      set(__i);
-      break;
-    default:
-      __throw_invalid_argument("bitset");
+  // Definitions of non-inline member functions.
+  template<size_t _Nb>
+    template<class _CharT, class _Traits, class _Alloc>
+    void 
+    bitset<_Nb>::_M_copy_from_string(const basic_string<_CharT,_Traits,_Alloc>& __s, size_t __pos, size_t __n)
+    {  
+      reset();
+      const size_t __nbits = min(_Nb, min(__n, __s.size() - __pos));
+      for (size_t __i = 0; __i < __nbits; ++__i) 
+	{
+	  switch(__s[__pos + __nbits - __i - 1]) 
+	    {
+	    case '0':
+	      break;
+	    case '1':
+	      set(__i);
+	      break;
+	    default:
+	      __throw_invalid_argument("bitset");
+	    }
+	}
     }
-  }
-}
-
-template <size_t _Nb>
-template <class _CharT, class _Traits, class _Alloc>
-void bitset<_Nb>
-  ::_M_copy_to_string(basic_string<_CharT, _Traits, _Alloc>& __s) const
-{
-  __s.assign(_Nb, '0');
-  
-  for (size_t __i = 0; __i < _Nb; ++__i) 
-    if (_Unchecked_test(__i))
-      __s[_Nb - 1 - __i] = '1';
-}
 
-// ------------------------------------------------------------
-
-//
-// 23.3.5.3 bitset operations:
-//
+  template<size_t _Nb>
+    template<class _CharT, class _Traits, class _Alloc>
+    void 
+    bitset<_Nb>::_M_copy_to_string(basic_string<_CharT, _Traits, _Alloc>& __s) const
+    {
+      __s.assign(_Nb, '0');
+      for (size_t __i = 0; __i < _Nb; ++__i) 
+	if (_Unchecked_test(__i))
+	  __s[_Nb - 1 - __i] = '1';
+    }
 
-template <size_t _Nb>
-inline bitset<_Nb> operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y) {
-  bitset<_Nb> __result(__x);
-  __result &= __y;
-  return __result;
-}
-
-
-template <size_t _Nb>
-inline bitset<_Nb> operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y) {
-  bitset<_Nb> __result(__x);
-  __result |= __y;
-  return __result;
-}
-
-template <size_t _Nb>
-inline bitset<_Nb> operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y) {
-  bitset<_Nb> __result(__x);
-  __result ^= __y;
-  return __result;
-}
-
-template <class _CharT, class _Traits, size_t _Nb>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)
-{
-  typedef typename _Traits::char_type char_type;
-  basic_string<_CharT, _Traits> __tmp;
-  __tmp.reserve(_Nb);
-
-  // Skip whitespace
-  typename basic_istream<_CharT, _Traits>::sentry __sentry(__is);
-  if (__sentry) {
-    basic_streambuf<_CharT, _Traits>* __buf = __is.rdbuf();
-    for (size_t __i = 0; __i < _Nb; ++__i) {
-      static typename _Traits::int_type __eof = _Traits::eof();
-
-      typename _Traits::int_type __c1 = __buf->sbumpc();
-      if (_Traits::eq_int_type(__c1, __eof)) {
-        __is.setstate(ios_base::eofbit);
-        break;
-      }
-      else {
-        char_type __c2 = _Traits::to_char_type(__c1);
-        char_type __c  = __is.narrow(__c2, '*');
-
-        if (__c == '0' || __c == '1')
-          __tmp.push_back(__c);
-        else if (_Traits::eq_int_type(__buf->sputbackc(__c2), __eof)) {
-          __is.setstate(ios_base::failbit);
-          break;
-        }
-      }
+  // 23.3.5.3 bitset operations:
+  template<size_t _Nb>
+    inline bitset<_Nb> 
+    operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y) 
+    {
+      bitset<_Nb> __result(__x);
+      __result &= __y;
+      return __result;
     }
 
-    if (__tmp.empty())
-      __is.setstate(ios_base::failbit);
-    else
-      __x._M_copy_from_string(__tmp, static_cast<size_t>(0), _Nb);
-  }
+  template<size_t _Nb>
+    inline bitset<_Nb> 
+    operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y) 
+    {
+      bitset<_Nb> __result(__x);
+      __result |= __y;
+      return __result;
+    }
 
-  return __is;
-}
+  template <size_t _Nb>
+    inline bitset<_Nb> 
+    operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y) 
+    {
+      bitset<_Nb> __result(__x);
+      __result ^= __y;
+      return __result;
+    }
 
-template <class _CharT, class _Traits, size_t _Nb>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Nb>& __x)
-{
-  basic_string<_CharT, _Traits> __tmp;
-  __x._M_copy_to_string(__tmp);
-  return __os << __tmp;
-}
+  template<class _CharT, class _Traits, size_t _Nb>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)
+    {
+      typedef typename _Traits::char_type char_type;
+      basic_string<_CharT, _Traits> __tmp;
+      __tmp.reserve(_Nb);
+      
+      // Skip whitespace
+      typename basic_istream<_CharT, _Traits>::sentry __sentry(__is);
+      if (__sentry) 
+	{
+	  basic_streambuf<_CharT, _Traits>* __buf = __is.rdbuf();
+	  for (size_t __i = 0; __i < _Nb; ++__i) 
+	    {
+	      static typename _Traits::int_type __eof = _Traits::eof();
+	      
+	      typename _Traits::int_type __c1 = __buf->sbumpc();
+	      if (_Traits::eq_int_type(__c1, __eof)) 
+		{
+		  __is.setstate(ios_base::eofbit);
+		  break;
+		}
+	      else 
+		{
+		  char_type __c2 = _Traits::to_char_type(__c1);
+		  char_type __c  = __is.narrow(__c2, '*');
+		  
+		  if (__c == '0' || __c == '1')
+		    __tmp.push_back(__c);
+		  else if (_Traits::eq_int_type(__buf->sputbackc(__c2), 
+						__eof)) 
+		    {
+		      __is.setstate(ios_base::failbit);
+		      break;
+		    }
+		}
+	    }
+	  
+	  if (__tmp.empty())
+	    __is.setstate(ios_base::failbit);
+	  else
+	    __x._M_copy_from_string(__tmp, static_cast<size_t>(0), _Nb);
+	}
+
+      return __is;
+    }
 
+  template <class _CharT, class _Traits, size_t _Nb>
+    basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Nb>& __x)
+    {
+      basic_string<_CharT, _Traits> __tmp;
+      __x._M_copy_to_string(__tmp);
+      return __os << __tmp;
+    }
 } // namespace std
 
 #undef __BITSET_WORDS
 
-#endif /* __GLIBCPP_BITSET */
-
-
-// Local Variables:
-// mode:C++
-// End:
-
+#endif 
diff --git a/libstdc++-v3/src/bitset.cc b/libstdc++-v3/src/bitset.cc
index c0bec5d5b34..244f308924f 100644
--- a/libstdc++-v3/src/bitset.cc
+++ b/libstdc++-v3/src/bitset.cc
@@ -1,6 +1,6 @@
 // Bitset definitions -*- C++ -*-
 
-// Copyright (C) 2001 Free Software Foundation
+// Copyright (C) 2001, 2002 Free Software Foundation
 //
 // This file is part of GNU CC.
 //
@@ -59,7 +59,7 @@ std::_Base_bitset<1>::_M_do_find_first(std::size_t __not_found) const
       unsigned char __this_byte
         = static_cast<unsigned char>(__thisword & (~(unsigned char)0));
       if ( __this_byte )
-        return __j*CHAR_BIT + _First_one<true>::_S_first_one[__this_byte];
+        return __j * CHAR_BIT + _S_first_one[__this_byte];
 
       __thisword >>= CHAR_BIT;
     }
@@ -93,7 +93,7 @@ std::_Base_bitset<1>::_M_do_find_next(std::size_t __prev,
       unsigned char __this_byte
         = static_cast<unsigned char>(__thisword & (~(unsigned char)0));
       if ( __this_byte )
-        return __j*CHAR_BIT + _First_one<true>::_S_first_one[__this_byte];
+        return __j * CHAR_BIT + _S_first_one[__this_byte];
 
       __thisword >>= CHAR_BIT;
     }
@@ -103,11 +103,10 @@ std::_Base_bitset<1>::_M_do_find_next(std::size_t __prev,
   return __not_found;
 } // end _M_do_find_next
 
-// ------------------------------------------------------------
-// Lookup tables for find and count operations.
 
-template<bool __dummy>
-unsigned char std::_Bit_count<__dummy>::_S_bit_count[] = {
+// Lookup tables for find and count operations.
+unsigned char std::_S_bit_count[256] = 
+{
   0, /*   0 */ 1, /*   1 */ 1, /*   2 */ 2, /*   3 */ 1, /*   4 */
   2, /*   5 */ 2, /*   6 */ 3, /*   7 */ 1, /*   8 */ 2, /*   9 */
   2, /*  10 */ 3, /*  11 */ 2, /*  12 */ 3, /*  13 */ 3, /*  14 */
@@ -160,10 +159,10 @@ unsigned char std::_Bit_count<__dummy>::_S_bit_count[] = {
   6, /* 245 */ 6, /* 246 */ 7, /* 247 */ 5, /* 248 */ 6, /* 249 */
   6, /* 250 */ 7, /* 251 */ 6, /* 252 */ 7, /* 253 */ 7, /* 254 */
   8  /* 255 */
-}; // end _Bit_count
+}; // end _S_bit_count
 
-template<bool __dummy>
-unsigned char std::_First_one<__dummy>::_S_first_one[] = {
+unsigned char std::_S_first_one[256] = 
+{
   0, /*   0 */ 0, /*   1 */ 1, /*   2 */ 0, /*   3 */ 2, /*   4 */
   0, /*   5 */ 1, /*   6 */ 0, /*   7 */ 3, /*   8 */ 0, /*   9 */
   1, /*  10 */ 0, /*  11 */ 2, /*  12 */ 0, /*  13 */ 1, /*  14 */
@@ -216,12 +215,5 @@ unsigned char std::_First_one<__dummy>::_S_first_one[] = {
   0, /* 245 */ 1, /* 246 */ 0, /* 247 */ 3, /* 248 */ 0, /* 249 */
   1, /* 250 */ 0, /* 251 */ 2, /* 252 */ 0, /* 253 */ 1, /* 254 */
   0, /* 255 */
-}; // end _First_one
-
-// Explicitly instantiate them.
-
-template unsigned char std::_Bit_count<false>::_S_bit_count[];
-template unsigned char std::_Bit_count<true>::_S_bit_count[];
+}; // end _S_first_one
 
-template unsigned char std::_First_one<false>::_S_first_one[];
-template unsigned char std::_First_one<true>::_S_first_one[];
diff --git a/libstdc++-v3/testsuite/23_containers/bitset_members.cc b/libstdc++-v3/testsuite/23_containers/bitset_members.cc
index a87b88db649..30e0ab6e063 100644
--- a/libstdc++-v3/testsuite/23_containers/bitset_members.cc
+++ b/libstdc++-v3/testsuite/23_containers/bitset_members.cc
@@ -45,9 +45,16 @@ test01(void)
   VERIFY( test );
 }
 
+// libstdc++/6124
+void test02()
+{
+  std::bitset<1> bs;
+  bs.count();
+}
+
 int main()
 {
   test01();
-
+  test02();
   return 0;
 }