mirror of
https://github.com/reactos/reactos.git
synced 2024-08-26 05:08:39 +00:00
236 lines
6.6 KiB
C
236 lines
6.6 KiB
C
/*
|
|
* 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 */
|