00001 
00002 
00003 
00004 
00005 
00006 
00007 
00008 
00009 
00010 
00011 
00012 
00013 
00014 
00015 
00016 
00017 
00018 
00019 
00020 
00021 
00022 
00023 
00024 
00025 
00026 
00027 
00028 
00029 
00030 
00031 
00032 
00033 
00034 
00035 
00036 
00037 
00038 
00039 
00040 
00041 
00042 
00048 #ifndef _GLIBCPP_BITSET_H
00049 #define _GLIBCPP_BITSET_H
00050 
00051 #pragma GCC system_header
00052 
00053 #include <cstddef>     
00054 #include <cstring>     
00055 #include <string>
00056 #include <bits/functexcept.h>   
00057                                 
00058 #include <ostream>     
00059 #include <istream>     
00060 
00061 
00062 #define _GLIBCPP_BITSET_BITS_PER_WORD (CHAR_BIT*sizeof(unsigned long))
00063 #define _GLIBCPP_BITSET_WORDS(__n) \
00064  ((__n) < 1 ? 1 : ((__n) + _GLIBCPP_BITSET_BITS_PER_WORD - 1)/_GLIBCPP_BITSET_BITS_PER_WORD)
00065 
00066 namespace std
00067 {
00068   extern unsigned char  _S_bit_count[256];
00069   extern unsigned char  _S_first_one[256];
00070 
00079   template<size_t _Nw>
00080     struct _Base_bitset
00081     {
00082       typedef unsigned long _WordT;
00083 
00085       _WordT        _M_w[_Nw];
00086 
00087       _Base_bitset() { _M_do_reset(); }
00088       _Base_bitset(unsigned long __val)
00089       {
00090     _M_do_reset();
00091     _M_w[0] = __val;
00092       }
00093 
00094       static size_t
00095       _S_whichword(size_t __pos )
00096       { return __pos / _GLIBCPP_BITSET_BITS_PER_WORD; }
00097 
00098       static size_t
00099       _S_whichbyte(size_t __pos )
00100       { return (__pos % _GLIBCPP_BITSET_BITS_PER_WORD) / CHAR_BIT; }
00101 
00102       static size_t
00103       _S_whichbit(size_t __pos )
00104       { return __pos % _GLIBCPP_BITSET_BITS_PER_WORD; }
00105 
00106       static _WordT
00107       _S_maskbit(size_t __pos )
00108       { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
00109 
00110       _WordT&
00111       _M_getword(size_t __pos)
00112       { return _M_w[_S_whichword(__pos)]; }
00113 
00114       _WordT
00115       _M_getword(size_t __pos) const
00116       { return _M_w[_S_whichword(__pos)]; }
00117 
00118       _WordT&
00119       _M_hiword() { return _M_w[_Nw - 1]; }
00120 
00121       _WordT
00122       _M_hiword() const { return _M_w[_Nw - 1]; }
00123 
00124       void
00125       _M_do_and(const _Base_bitset<_Nw>& __x)
00126       {
00127     for (size_t __i = 0; __i < _Nw; __i++)
00128       _M_w[__i] &= __x._M_w[__i];
00129       }
00130 
00131       void
00132       _M_do_or(const _Base_bitset<_Nw>& __x)
00133       {
00134     for (size_t __i = 0; __i < _Nw; __i++)
00135       _M_w[__i] |= __x._M_w[__i];
00136       }
00137 
00138       void
00139       _M_do_xor(const _Base_bitset<_Nw>& __x)
00140       {
00141     for (size_t __i = 0; __i < _Nw; __i++)
00142       _M_w[__i] ^= __x._M_w[__i];
00143       }
00144 
00145       void
00146       _M_do_left_shift(size_t __shift);
00147 
00148       void
00149       _M_do_right_shift(size_t __shift);
00150 
00151       void
00152       _M_do_flip()
00153       {
00154     for (size_t __i = 0; __i < _Nw; __i++)
00155       _M_w[__i] = ~_M_w[__i];
00156       }
00157 
00158       void
00159       _M_do_set()
00160       {
00161     for (size_t __i = 0; __i < _Nw; __i++)
00162       _M_w[__i] = ~static_cast<_WordT>(0);
00163       }
00164 
00165       void
00166       _M_do_reset() { memset(_M_w, 0, _Nw * sizeof(_WordT)); }
00167 
00168       bool
00169       _M_is_equal(const _Base_bitset<_Nw>& __x) const
00170       {
00171     for (size_t __i = 0; __i < _Nw; ++__i)
00172       {
00173         if (_M_w[__i] != __x._M_w[__i])
00174           return false;
00175       }
00176     return true;
00177       }
00178 
00179       bool
00180       _M_is_any() const
00181       {
00182     for (size_t __i = 0; __i < _Nw; __i++)
00183       {
00184         if (_M_w[__i] != static_cast<_WordT>(0))
00185           return true;
00186       }
00187     return false;
00188       }
00189 
00190       size_t
00191       _M_do_count() const
00192       {
00193     size_t __result = 0;
00194     const unsigned char* __byte_ptr = (const unsigned char*)_M_w;
00195     const unsigned char* __end_ptr = (const unsigned char*)(_M_w + _Nw);
00196 
00197     while ( __byte_ptr < __end_ptr )
00198       {
00199         __result += _S_bit_count[*__byte_ptr];
00200         __byte_ptr++;
00201       }
00202     return __result;
00203       }
00204 
00205       unsigned long
00206       _M_do_to_ulong() const;
00207 
00208       
00209       size_t
00210       _M_do_find_first(size_t __not_found) const;
00211 
00212       
00213       size_t
00214       _M_do_find_next(size_t __prev, size_t __not_found) const;
00215     };
00216 
00217   
00218   template<size_t _Nw>
00219     void
00220     _Base_bitset<_Nw>::_M_do_left_shift(size_t __shift)
00221     {
00222       if (__shift != 0)
00223     {
00224       const size_t __wshift = __shift / _GLIBCPP_BITSET_BITS_PER_WORD;
00225       const size_t __offset = __shift % _GLIBCPP_BITSET_BITS_PER_WORD;
00226 
00227       if (__offset == 0)
00228         for (size_t __n = _Nw - 1; __n >= __wshift; --__n)
00229           _M_w[__n] = _M_w[__n - __wshift];
00230       else
00231         {
00232           const size_t __sub_offset = _GLIBCPP_BITSET_BITS_PER_WORD - __offset;
00233           for (size_t __n = _Nw - 1; __n > __wshift; --__n)
00234         _M_w[__n] = (_M_w[__n - __wshift] << __offset) |
00235           (_M_w[__n - __wshift - 1] >> __sub_offset);
00236           _M_w[__wshift] = _M_w[0] << __offset;
00237         }
00238 
00239       fill(_M_w + 0, _M_w + __wshift, static_cast<_WordT>(0));
00240     }
00241     }
00242 
00243   template<size_t _Nw>
00244     void
00245     _Base_bitset<_Nw>::_M_do_right_shift(size_t __shift)
00246     {
00247       if (__shift != 0)
00248     {
00249       const size_t __wshift = __shift / _GLIBCPP_BITSET_BITS_PER_WORD;
00250       const size_t __offset = __shift % _GLIBCPP_BITSET_BITS_PER_WORD;
00251       const size_t __limit = _Nw - __wshift - 1;
00252 
00253       if (__offset == 0)
00254         for (size_t __n = 0; __n <= __limit; ++__n)
00255           _M_w[__n] = _M_w[__n + __wshift];
00256       else
00257         {
00258           const size_t __sub_offset = _GLIBCPP_BITSET_BITS_PER_WORD - __offset;
00259           for (size_t __n = 0; __n < __limit; ++__n)
00260         _M_w[__n] = (_M_w[__n + __wshift] >> __offset) |
00261           (_M_w[__n + __wshift + 1] << __sub_offset);
00262           _M_w[__limit] = _M_w[_Nw-1] >> __offset;
00263         }
00264 
00265       fill(_M_w + __limit + 1, _M_w + _Nw, static_cast<_WordT>(0));
00266     }
00267     }
00268 
00269   template<size_t _Nw>
00270     unsigned long
00271     _Base_bitset<_Nw>::_M_do_to_ulong() const
00272     {
00273       for (size_t __i = 1; __i < _Nw; ++__i)
00274     if (_M_w[__i])
00275       __throw_overflow_error("bitset -- too large to fit in unsigned long");
00276       return _M_w[0];
00277     }
00278 
00279   template<size_t _Nw>
00280     size_t
00281     _Base_bitset<_Nw>::_M_do_find_first(size_t __not_found) const
00282     {
00283       for (size_t __i = 0; __i < _Nw; __i++ )
00284     {
00285       _WordT __thisword = _M_w[__i];
00286       if ( __thisword != static_cast<_WordT>(0) )
00287         {
00288           
00289           for (size_t __j = 0; __j < sizeof(_WordT); __j++ )
00290         {
00291           unsigned char __this_byte
00292             = static_cast<unsigned char>(__thisword & (~(unsigned char)0));
00293           if (__this_byte)
00294             return __i*_GLIBCPP_BITSET_BITS_PER_WORD + __j*CHAR_BIT +
00295               _S_first_one[__this_byte];
00296 
00297           __thisword >>= CHAR_BIT;
00298         }
00299         }
00300     }
00301       
00302       return __not_found;
00303     }
00304 
00305   template<size_t _Nw>
00306     size_t
00307     _Base_bitset<_Nw>::_M_do_find_next(size_t __prev, size_t __not_found) const
00308     {
00309       
00310       ++__prev;
00311 
00312       
00313       if ( __prev >= _Nw * _GLIBCPP_BITSET_BITS_PER_WORD )
00314     return __not_found;
00315 
00316       
00317       size_t __i = _S_whichword(__prev);
00318       _WordT __thisword = _M_w[__i];
00319 
00320       
00321       __thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev);
00322 
00323       if ( __thisword != static_cast<_WordT>(0) )
00324     {
00325       
00326       
00327       __thisword >>= _S_whichbyte(__prev) * CHAR_BIT;
00328       for (size_t __j = _S_whichbyte(__prev); __j < sizeof(_WordT); __j++)
00329         {
00330           unsigned char __this_byte
00331         = static_cast<unsigned char>(__thisword & (~(unsigned char)0));
00332           if ( __this_byte )
00333         return __i*_GLIBCPP_BITSET_BITS_PER_WORD + __j*CHAR_BIT +
00334           _S_first_one[__this_byte];
00335 
00336           __thisword >>= CHAR_BIT;
00337         }
00338     }
00339 
00340       
00341       __i++;
00342       for ( ; __i < _Nw; __i++ )
00343     {
00344       __thisword = _M_w[__i];
00345       if ( __thisword != static_cast<_WordT>(0) )
00346         {
00347           
00348           for (size_t __j = 0; __j < sizeof(_WordT); __j++ )
00349         {
00350           unsigned char __this_byte
00351             = static_cast<unsigned char>(__thisword & (~(unsigned char)0));
00352           if ( __this_byte )
00353             return __i*_GLIBCPP_BITSET_BITS_PER_WORD + __j*CHAR_BIT +
00354               _S_first_one[__this_byte];
00355 
00356           __thisword >>= CHAR_BIT;
00357         }
00358         }
00359     }
00360       
00361       return __not_found;
00362     } 
00363 
00364 
00372   template<>
00373     struct _Base_bitset<1>
00374     {
00375       typedef unsigned long _WordT;
00376       _WordT _M_w;
00377 
00378       _Base_bitset( void ) : _M_w(0) {}
00379       _Base_bitset(unsigned long __val) : _M_w(__val) {}
00380 
00381       static size_t
00382       _S_whichword(size_t __pos )
00383       { return __pos / _GLIBCPP_BITSET_BITS_PER_WORD; }
00384 
00385       static size_t
00386       _S_whichbyte(size_t __pos )
00387       { return (__pos % _GLIBCPP_BITSET_BITS_PER_WORD) / CHAR_BIT; }
00388 
00389       static size_t
00390       _S_whichbit(size_t __pos )
00391       {  return __pos % _GLIBCPP_BITSET_BITS_PER_WORD; }
00392 
00393       static _WordT
00394       _S_maskbit(size_t __pos )
00395       { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
00396 
00397       _WordT&
00398       _M_getword(size_t) { return _M_w; }
00399 
00400       _WordT
00401       _M_getword(size_t) const { return _M_w; }
00402 
00403       _WordT&
00404       _M_hiword() { return _M_w; }
00405 
00406       _WordT
00407       _M_hiword() const { return _M_w; }
00408 
00409       void
00410       _M_do_and(const _Base_bitset<1>& __x) { _M_w &= __x._M_w; }
00411 
00412       void
00413       _M_do_or(const _Base_bitset<1>& __x)  { _M_w |= __x._M_w; }
00414 
00415       void
00416       _M_do_xor(const _Base_bitset<1>& __x) { _M_w ^= __x._M_w; }
00417 
00418       void
00419       _M_do_left_shift(size_t __shift) { _M_w <<= __shift; }
00420 
00421       void
00422       _M_do_right_shift(size_t __shift) { _M_w >>= __shift; }
00423 
00424       void
00425       _M_do_flip() { _M_w = ~_M_w; }
00426 
00427       void
00428       _M_do_set() { _M_w = ~static_cast<_WordT>(0); }
00429 
00430       void
00431       _M_do_reset() { _M_w = 0; }
00432 
00433       bool
00434       _M_is_equal(const _Base_bitset<1>& __x) const
00435       { return _M_w == __x._M_w; }
00436 
00437       bool
00438       _M_is_any() const { return _M_w != 0; }
00439 
00440       size_t
00441       _M_do_count() const
00442       {
00443     size_t __result = 0;
00444     const unsigned char* __byte_ptr = (const unsigned char*)&_M_w;
00445     const unsigned char* __end_ptr
00446       = ((const unsigned char*)&_M_w)+sizeof(_M_w);
00447     while ( __byte_ptr < __end_ptr )
00448       {
00449         __result += _S_bit_count[*__byte_ptr];
00450         __byte_ptr++;
00451       }
00452     return __result;
00453       }
00454 
00455       unsigned long
00456       _M_do_to_ulong() const { return _M_w; }
00457 
00458       size_t
00459       _M_do_find_first(size_t __not_found) const;
00460 
00461       
00462       size_t
00463       _M_do_find_next(size_t __prev, size_t __not_found) const;
00464     };
00465 
00466   
00467   template<size_t _Extrabits>
00468     struct _Sanitize
00469     {
00470       static void _S_do_sanitize(unsigned long& __val)
00471       { __val &= ~((~static_cast<unsigned long>(0)) << _Extrabits); }
00472     };
00473 
00474   template<>
00475     struct _Sanitize<0>
00476     { static void _S_do_sanitize(unsigned long) { } };
00477 
00539   template<size_t _Nb>
00540     class bitset : private _Base_bitset<_GLIBCPP_BITSET_WORDS(_Nb)>
00541   {
00542   private:
00543     typedef _Base_bitset<_GLIBCPP_BITSET_WORDS(_Nb)> _Base;
00544     typedef unsigned long _WordT;
00545 
00546     void
00547     _M_do_sanitize()
00548     {
00549       _Sanitize<_Nb%_GLIBCPP_BITSET_BITS_PER_WORD>::
00550           _S_do_sanitize(this->_M_hiword());
00551     }
00552 
00553   public:
00566     class reference
00567     {
00568       friend class bitset;
00569 
00570       _WordT *_M_wp;
00571       size_t _M_bpos;
00572 
00573       
00574       reference();
00575 
00576     public:
00577       reference(bitset& __b, size_t __pos)
00578       {
00579     _M_wp = &__b._M_getword(__pos);
00580     _M_bpos = _Base::_S_whichbit(__pos);
00581       }
00582 
00583       ~reference() { }
00584 
00585       
00586       reference&
00587       operator=(bool __x)
00588       {
00589     if ( __x )
00590       *_M_wp |= _Base::_S_maskbit(_M_bpos);
00591     else
00592       *_M_wp &= ~_Base::_S_maskbit(_M_bpos);
00593     return *this;
00594       }
00595 
00596       
00597       reference&
00598       operator=(const reference& __j)
00599       {
00600     if ( (*(__j._M_wp) & _Base::_S_maskbit(__j._M_bpos)) )
00601       *_M_wp |= _Base::_S_maskbit(_M_bpos);
00602     else
00603       *_M_wp &= ~_Base::_S_maskbit(_M_bpos);
00604     return *this;
00605       }
00606 
00607       
00608       bool
00609       operator~() const
00610       { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) == 0; }
00611 
00612       
00613       operator bool() const
00614       { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) != 0; }
00615 
00616       
00617       reference&
00618       flip()
00619       {
00620     *_M_wp ^= _Base::_S_maskbit(_M_bpos);
00621     return *this;
00622       }
00623     };
00624     friend class reference;
00625 
00626     
00628 
00629 
00631     bitset(unsigned long __val) : _Base(__val)
00632     { _M_do_sanitize(); }
00633 
00643     template<class _CharT, class _Traits, class _Alloc>
00644       explicit bitset(const basic_string<_CharT, _Traits, _Alloc>& __s,
00645               size_t __pos = 0) : _Base()
00646       {
00647     if (__pos > __s.size())
00648       __throw_out_of_range("bitset -- initial position is larger than "
00649                            "the string itself");
00650     _M_copy_from_string(__s, __pos,
00651                 basic_string<_CharT, _Traits, _Alloc>::npos);
00652       }
00653 
00663     template<class _CharT, class _Traits, class _Alloc>
00664       bitset(const basic_string<_CharT, _Traits, _Alloc>& __s,
00665          size_t __pos, size_t __n) : _Base()
00666       {
00667     if (__pos > __s.size())
00668       __throw_out_of_range("bitset -- initial position is larger than "
00669                            "the string itself");
00670     _M_copy_from_string(__s, __pos, __n);
00671       }
00672 
00673     
00675 
00681     bitset<_Nb>&
00682     operator&=(const bitset<_Nb>& __rhs)
00683     {
00684       this->_M_do_and(__rhs);
00685       return *this;
00686     }
00687 
00688     bitset<_Nb>&
00689     operator|=(const bitset<_Nb>& __rhs)
00690     {
00691       this->_M_do_or(__rhs);
00692       return *this;
00693     }
00694 
00695     bitset<_Nb>&
00696     operator^=(const bitset<_Nb>& __rhs)
00697     {
00698       this->_M_do_xor(__rhs);
00699       return *this;
00700     }
00702 
00704 
00710     bitset<_Nb>&
00711     operator<<=(size_t __pos)
00712     {
00713       this->_M_do_left_shift(__pos);
00714       this->_M_do_sanitize();
00715       return *this;
00716     }
00717 
00718     bitset<_Nb>&
00719     operator>>=(size_t __pos)
00720     {
00721       this->_M_do_right_shift(__pos);
00722       this->_M_do_sanitize();
00723       return *this;
00724     }
00726 
00728 
00733     bitset<_Nb>&
00734     _Unchecked_set(size_t __pos)
00735     {
00736       this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
00737       return *this;
00738     }
00739 
00740     bitset<_Nb>&
00741     _Unchecked_set(size_t __pos, int __val)
00742     {
00743       if (__val)
00744     this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
00745       else
00746     this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
00747       return *this;
00748     }
00749 
00750     bitset<_Nb>&
00751     _Unchecked_reset(size_t __pos)
00752     {
00753       this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
00754       return *this;
00755     }
00756 
00757     bitset<_Nb>&
00758     _Unchecked_flip(size_t __pos)
00759     {
00760       this->_M_getword(__pos) ^= _Base::_S_maskbit(__pos);
00761       return *this;
00762     }
00763 
00764     bool
00765     _Unchecked_test(size_t __pos) const
00766     {
00767       return (this->_M_getword(__pos) & _Base::_S_maskbit(__pos))
00768     != static_cast<_WordT>(0);
00769     }
00771 
00772     
00776     bitset<_Nb>&
00777     set()
00778     {
00779       this->_M_do_set();
00780       this->_M_do_sanitize();
00781       return *this;
00782     }
00783 
00790     bitset<_Nb>&
00791     set(size_t __pos, bool __val = true)
00792     {
00793       if (__pos >= _Nb)
00794     __throw_out_of_range("bitset -- set() argument too large");
00795       return _Unchecked_set(__pos, __val);
00796     }
00797 
00801     bitset<_Nb>&
00802     reset()
00803     {
00804       this->_M_do_reset();
00805       return *this;
00806     }
00807 
00815     bitset<_Nb>&
00816     reset(size_t __pos)
00817     {
00818       if (__pos >= _Nb)
00819     __throw_out_of_range("bitset -- reset() argument too large");
00820       return _Unchecked_reset(__pos);
00821     }
00822 
00826     bitset<_Nb>&
00827     flip()
00828     {
00829       this->_M_do_flip();
00830       this->_M_do_sanitize();
00831       return *this;
00832     }
00833 
00839     bitset<_Nb>&
00840     flip(size_t __pos)
00841     {
00842       if (__pos >= _Nb)
00843     __throw_out_of_range("bitset -- flip() argument too large");
00844       return _Unchecked_flip(__pos);
00845     }
00846 
00848     bitset<_Nb>
00849     operator~() const { return bitset<_Nb>(*this).flip(); }
00850 
00852 
00868     reference
00869     operator[](size_t __pos) { return reference(*this,__pos); }
00870 
00871     bool
00872     operator[](size_t __pos) const { return _Unchecked_test(__pos); }
00874 
00881     unsigned long
00882     to_ulong() const { return this->_M_do_to_ulong(); }
00883 
00898     template<class _CharT, class _Traits, class _Alloc>
00899       basic_string<_CharT, _Traits, _Alloc>
00900       to_string() const
00901       {
00902     basic_string<_CharT, _Traits, _Alloc> __result;
00903     _M_copy_to_string(__result);
00904     return __result;
00905       }
00906 
00907     
00908     template<class _CharT, class _Traits, class _Alloc>
00909       void
00910       _M_copy_from_string(const basic_string<_CharT,_Traits,_Alloc>& __s,
00911                           size_t, size_t);
00912 
00913     template<class _CharT, class _Traits, class _Alloc>
00914       void
00915       _M_copy_to_string(basic_string<_CharT,_Traits,_Alloc>&) const;
00916 
00918     size_t
00919     count() const { return this->_M_do_count(); }
00920 
00922     size_t
00923     size() const { return _Nb; }
00924 
00926 
00927     bool
00928     operator==(const bitset<_Nb>& __rhs) const
00929     { return this->_M_is_equal(__rhs); }
00930 
00931     bool
00932     operator!=(const bitset<_Nb>& __rhs) const
00933     { return !this->_M_is_equal(__rhs); }
00935 
00942     bool
00943     test(size_t __pos) const
00944     {
00945       if (__pos >= _Nb)
00946     __throw_out_of_range("bitset -- test() argument too large");
00947       return _Unchecked_test(__pos);
00948     }
00949 
00954     bool
00955     any() const { return this->_M_is_any(); }
00956 
00961     bool
00962     none() const { return !this->_M_is_any(); }
00963 
00965 
00966     bitset<_Nb>
00967     operator<<(size_t __pos) const
00968     { return bitset<_Nb>(*this) <<= __pos; }
00969 
00970     bitset<_Nb>
00971     operator>>(size_t __pos) const
00972     { return bitset<_Nb>(*this) >>= __pos; }
00974 
00981     size_t
00982     _Find_first() const
00983     { return this->_M_do_find_first(_Nb); }
00984 
00992     size_t
00993     _Find_next(size_t __prev ) const
00994     { return this->_M_do_find_next(__prev, _Nb); }
00995   };
00996 
00997   
00998   template<size_t _Nb>
00999     template<class _CharT, class _Traits, class _Alloc>
01000     void
01001     bitset<_Nb>::_M_copy_from_string(const basic_string<_CharT,_Traits,_Alloc>& __s, size_t __pos, size_t __n)
01002     {
01003       reset();
01004       const size_t __nbits = min(_Nb, min(__n, __s.size() - __pos));
01005       for (size_t __i = 0; __i < __nbits; ++__i)
01006     {
01007       switch(__s[__pos + __nbits - __i - 1])
01008         {
01009         case '0':
01010           break;
01011         case '1':
01012           set(__i);
01013           break;
01014         default:
01015           __throw_invalid_argument("bitset -- string contains characters "
01016                                    "which are neither 0 nor 1");
01017         }
01018     }
01019     }
01020 
01021   template<size_t _Nb>
01022     template<class _CharT, class _Traits, class _Alloc>
01023     void
01024     bitset<_Nb>::_M_copy_to_string(basic_string<_CharT, _Traits, _Alloc>& __s) const
01025     {
01026       __s.assign(_Nb, '0');
01027       for (size_t __i = 0; __i < _Nb; ++__i)
01028     if (_Unchecked_test(__i))
01029       __s[_Nb - 1 - __i] = '1';
01030     }
01031 
01032   
01034 
01042   template<size_t _Nb>
01043     inline bitset<_Nb>
01044     operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
01045     {
01046       bitset<_Nb> __result(__x);
01047       __result &= __y;
01048       return __result;
01049     }
01050 
01051   template<size_t _Nb>
01052     inline bitset<_Nb>
01053     operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
01054     {
01055       bitset<_Nb> __result(__x);
01056       __result |= __y;
01057       return __result;
01058     }
01059 
01060   template <size_t _Nb>
01061     inline bitset<_Nb>
01062     operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
01063     {
01064       bitset<_Nb> __result(__x);
01065       __result ^= __y;
01066       return __result;
01067     }
01069 
01071 
01079   template<class _CharT, class _Traits, size_t _Nb>
01080     basic_istream<_CharT, _Traits>&
01081     operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)
01082     {
01083       typedef typename _Traits::char_type char_type;
01084       basic_string<_CharT, _Traits> __tmp;
01085       __tmp.reserve(_Nb);
01086 
01087       
01088       typename basic_istream<_CharT, _Traits>::sentry __sentry(__is);
01089       if (__sentry)
01090     {
01091       basic_streambuf<_CharT, _Traits>* __buf = __is.rdbuf();
01092       for (size_t __i = 0; __i < _Nb; ++__i)
01093         {
01094           static typename _Traits::int_type __eof = _Traits::eof();
01095 
01096           typename _Traits::int_type __c1 = __buf->sbumpc();
01097           if (_Traits::eq_int_type(__c1, __eof))
01098         {
01099           __is.setstate(ios_base::eofbit);
01100           break;
01101         }
01102           else
01103         {
01104           char_type __c2 = _Traits::to_char_type(__c1);
01105           char_type __c  = __is.narrow(__c2, '*');
01106 
01107           if (__c == '0' || __c == '1')
01108             __tmp.push_back(__c);
01109           else if (_Traits::eq_int_type(__buf->sputbackc(__c2),
01110                         __eof))
01111             {
01112               __is.setstate(ios_base::failbit);
01113               break;
01114             }
01115         }
01116         }
01117 
01118       if (__tmp.empty())
01119         __is.setstate(ios_base::failbit);
01120       else
01121         __x._M_copy_from_string(__tmp, static_cast<size_t>(0), _Nb);
01122     }
01123 
01124       return __is;
01125     }
01126 
01127   template <class _CharT, class _Traits, size_t _Nb>
01128     basic_ostream<_CharT, _Traits>&
01129     operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Nb>& __x)
01130     {
01131       basic_string<_CharT, _Traits> __tmp;
01132       __x._M_copy_to_string(__tmp);
01133       return __os << __tmp;
01134     }
01136 } 
01137 
01138 #undef _GLIBCPP_BITSET_WORDS
01139 
01140 #endif