| /* |
| * Copyright (c) 1998 |
| * Silicon Graphics Computer Systems, Inc. |
| * |
| * Copyright (c) 1999 |
| * Boris Fomitchev |
| * |
| * This material is provided "as is", with absolutely no warranty expressed |
| * or implied. Any use is at your own risk. |
| * |
| * Permission to use or copy this software for any purpose is hereby granted |
| * without fee, provided the above notices are retained on all copies. |
| * Permission to modify the code and to distribute modified code is granted, |
| * provided the above notices are retained, and a notice that the code was |
| * modified is included with the above copyright notice. |
| * |
| */ |
| |
| #ifndef _STLP_BITSET_C |
| #define _STLP_BITSET_C |
| |
| #ifndef _STLP_BITSET_H |
| # include <stl/_bitset.h> |
| #endif |
| |
| #define __BITS_PER_WORD (CHAR_BIT * sizeof(unsigned long)) |
| |
| _STLP_BEGIN_NAMESPACE |
| |
| _STLP_MOVE_TO_PRIV_NAMESPACE |
| // |
| // 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 / __BITS_PER_WORD; |
| const size_t __offset = __shift % __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 = __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)); |
| } |
| } |
| |
| template<size_t _Nw> |
| void _Base_bitset<_Nw>::_M_do_right_shift(size_t __shift) { |
| if (__shift != 0) { |
| const size_t __wshift = __shift / __BITS_PER_WORD; |
| const size_t __offset = __shift % __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 = __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)); |
| } |
| } |
| |
| 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]) |
| __stl_throw_overflow_error("bitset"); |
| return _M_w[0]; |
| } // End _M_do_to_ulong |
| |
| 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*__BITS_PER_WORD + __j*CHAR_BIT + |
| _Bs_G::_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 * __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*__BITS_PER_WORD + __j*CHAR_BIT + |
| _Bs_G::_S_first_one(__this_byte); |
| |
| __thisword >>= CHAR_BIT; |
| } |
| } |
| |
| // check subsequent words |
| ++__i; |
| for ( ; __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*__BITS_PER_WORD + __j*CHAR_BIT + |
| _Bs_G::_S_first_one(__this_byte); |
| |
| __thisword >>= CHAR_BIT; |
| } |
| } |
| } |
| |
| // not found, so return an indication of failure. |
| return __not_found; |
| } // end _M_do_find_next |
| |
| _STLP_MOVE_TO_STD_NAMESPACE |
| |
| #if !defined (_STLP_NON_TYPE_TMPL_PARAM_BUG) |
| |
| # if !defined (_STLP_USE_NO_IOSTREAMS) |
| |
| _STLP_END_NAMESPACE |
| |
| #ifndef _STLP_STRING_IO_H |
| # include <stl/_string_io.h> //includes _istream.h and _ostream.h |
| #endif |
| |
| _STLP_BEGIN_NAMESPACE |
| |
| template <class _CharT, class _Traits, size_t _Nb> |
| basic_istream<_CharT, _Traits>& _STLP_CALL |
| operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x) { |
| 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 { |
| typename _Traits::char_type __c2 = _Traits::to_char_type(__c1); |
| char __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>& _STLP_CALL |
| operator<<(basic_ostream<_CharT, _Traits>& __os, |
| const bitset<_Nb>& __x) { |
| basic_string<_CharT, _Traits> __tmp; |
| __x._M_copy_to_string(__tmp); |
| return __os << __tmp; |
| } |
| |
| # endif /* !_STLP_USE_NO_IOSTREAMS */ |
| |
| #endif /* _STLP_NON_TYPE_TMPL_PARAM_BUG */ |
| |
| _STLP_END_NAMESPACE |
| |
| #undef __BITS_PER_WORD |
| #undef bitset |
| |
| #endif /* _STLP_BITSET_C */ |
