OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

std_bitset.h: Trivial formatting fixes. 

2004-05-15  Paolo Carlini  <pcarlini@suse.de>

	* include/std/std_bitset.h: Trivial formatting fixes.

From-SVN: r81878
This commit is contained in:
Paolo Carlini 2004-05-15 11:43:03 +00:00 committed by Paolo Carlini
parent aaa6750272
commit 5c33bb6218
2 changed files with 589 additions and 529 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
libstdc++-v3/ChangeLog
View File

@ -1,3 +1,7 @@
2004-05-15 Paolo Carlini <pcarlini@suse.de>
* include/std/std_bitset.h: Trivial formatting fixes.
2004-05-14 Paolo Carlini <pcarlini@suse.de>
Ivan Godard <igodard@pacbell.net>

208
libstdc++-v3/include/std/std_bitset.h
View File

@ -61,7 +61,8 @@
#define _GLIBCXX_BITSET_BITS_PER_WORD numeric_limits<unsigned long>::digits
#define _GLIBCXX_BITSET_WORDS(__n) \
((__n) < 1 ? 0 : ((__n) + _GLIBCXX_BITSET_BITS_PER_WORD - 1)/_GLIBCXX_BITSET_BITS_PER_WORD)
((__n) < 1 ? 0 : ((__n) + _GLIBCXX_BITSET_BITS_PER_WORD - 1) \
/ _GLIBCXX_BITSET_BITS_PER_WORD)
namespace _GLIBCXX_STD
{
@ -81,7 +82,9 @@ namespace _GLIBCXX_STD
/// 0 is the least significant word.
_WordT _M_w[_Nw];
_Base_bitset() { _M_do_reset(); }
_Base_bitset()
{ _M_do_reset(); }
_Base_bitset(unsigned long __val)
{
_M_do_reset();
@ -113,10 +116,12 @@ namespace _GLIBCXX_STD
{ return _M_w[_S_whichword(__pos)]; }
_WordT&
_M_hiword() { return _M_w[_Nw - 1]; }
_M_hiword()
{ return _M_w[_Nw - 1]; }
_WordT
_M_hiword() const { return _M_w[_Nw - 1]; }
_M_hiword() const
{ return _M_w[_Nw - 1]; }
void
_M_do_and(const _Base_bitset<_Nw>& __x)
@ -160,7 +165,8 @@ namespace _GLIBCXX_STD
}
void
_M_do_reset() { memset(_M_w, 0, _Nw * sizeof(_WordT)); }
_M_do_reset()
{ std::memset(_M_w, 0, _Nw * sizeof(_WordT)); }
bool
_M_is_equal(const _Base_bitset<_Nw>& __x) const
@ -220,10 +226,11 @@ namespace _GLIBCXX_STD
_M_w[__n] = _M_w[__n - __wshift];
else
{
const size_t __sub_offset = _GLIBCXX_BITSET_BITS_PER_WORD - __offset;
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[__n] = ((_M_w[__n - __wshift] << __offset)
| (_M_w[__n - __wshift - 1] >> __sub_offset));
_M_w[__wshift] = _M_w[0] << __offset;
}
@ -246,10 +253,11 @@ namespace _GLIBCXX_STD
_M_w[__n] = _M_w[__n + __wshift];
else
{
const size_t __sub_offset = _GLIBCXX_BITSET_BITS_PER_WORD - __offset;
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[__n] = ((_M_w[__n + __wshift] >> __offset)
| (_M_w[__n + __wshift + 1] << __sub_offset));
_M_w[__limit] = _M_w[_Nw-1] >> __offset;
}
@ -275,8 +283,8 @@ namespace _GLIBCXX_STD
{
_WordT __thisword = _M_w[__i];
if (__thisword != static_cast<_WordT>(0))
return __i * _GLIBCXX_BITSET_BITS_PER_WORD
+ __builtin_ctzl(__thisword);
return (__i * _GLIBCXX_BITSET_BITS_PER_WORD
+ __builtin_ctzl(__thisword));
}
// not found, so return an indication of failure.
return __not_found;
@ -301,8 +309,8 @@ namespace _GLIBCXX_STD
__thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev);
if (__thisword != static_cast<_WordT>(0))
return __i * _GLIBCXX_BITSET_BITS_PER_WORD
+ __builtin_ctzl(__thisword);
return (__i * _GLIBCXX_BITSET_BITS_PER_WORD
+ __builtin_ctzl(__thisword));
// check subsequent words
__i++;
@ -310,14 +318,13 @@ namespace _GLIBCXX_STD
{
__thisword = _M_w[__i];
if (__thisword != static_cast<_WordT>(0))
return __i * _GLIBCXX_BITSET_BITS_PER_WORD
+ __builtin_ctzl(__thisword);
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
/**
* @if maint
* Base class, specialization for a single word.
@ -331,8 +338,13 @@ namespace _GLIBCXX_STD
typedef unsigned long _WordT;
_WordT _M_w;
_Base_bitset( void ) : _M_w(0) {}
_Base_bitset(unsigned long __val) : _M_w(__val) {}
_Base_bitset(void)
: _M_w(0)
{}
_Base_bitset(unsigned long __val)
: _M_w(__val)
{}
static size_t
_S_whichword(size_t __pos )
@ -351,53 +363,68 @@ namespace _GLIBCXX_STD
{ return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
_WordT&
_M_getword(size_t) { return _M_w; }
_M_getword(size_t)
{ return _M_w; }
_WordT
_M_getword(size_t) const { return _M_w; }
_M_getword(size_t) const
{ return _M_w; }
_WordT&
_M_hiword() { return _M_w; }
_M_hiword()
{ return _M_w; }
_WordT
_M_hiword() const { return _M_w; }
_M_hiword() const
{ return _M_w; }
void
_M_do_and(const _Base_bitset<1>& __x) { _M_w &= __x._M_w; }
_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; }
_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; }
_M_do_xor(const _Base_bitset<1>& __x)
{ _M_w ^= __x._M_w; }
void
_M_do_left_shift(size_t __shift) { _M_w <<= __shift; }
_M_do_left_shift(size_t __shift)
{ _M_w <<= __shift; }
void
_M_do_right_shift(size_t __shift) { _M_w >>= __shift; }
_M_do_right_shift(size_t __shift)
{ _M_w >>= __shift; }
void
_M_do_flip() { _M_w = ~_M_w; }
_M_do_flip()
{ _M_w = ~_M_w; }
void
_M_do_set() { _M_w = ~static_cast<_WordT>(0); }
_M_do_set()
{ _M_w = ~static_cast<_WordT>(0); }
void
_M_do_reset() { _M_w = 0; }
_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; }
_M_is_any() const
{ return _M_w != 0; }
size_t
_M_do_count() const { return __builtin_popcountl(_M_w); }
_M_do_count() const
{ return __builtin_popcountl(_M_w); }
unsigned long
_M_do_to_ulong() const { return _M_w; }
_M_do_to_ulong() const
{ return _M_w; }
size_t
_M_do_find_first(size_t __not_found) const
@ -424,7 +451,6 @@ namespace _GLIBCXX_STD
}
};
/**
* @if maint
* Base class, specialization for no storage (zero-length %bitset).
@ -437,8 +463,11 @@ namespace _GLIBCXX_STD
{
typedef unsigned long _WordT;
_Base_bitset() {}
_Base_bitset(unsigned long) {}
_Base_bitset()
{}
_Base_bitset(unsigned long)
{}
static size_t
_S_whichword(size_t __pos )
@ -471,54 +500,69 @@ namespace _GLIBCXX_STD
}
_WordT
_M_hiword() const { return 0; }
_M_hiword() const
{ return 0; }
void
_M_do_and(const _Base_bitset<0>&) { }
_M_do_and(const _Base_bitset<0>&)
{}
void
_M_do_or(const _Base_bitset<0>&) { }
_M_do_or(const _Base_bitset<0>&)
{}
void
_M_do_xor(const _Base_bitset<0>&) { }
_M_do_xor(const _Base_bitset<0>&)
{}
void
_M_do_left_shift(size_t) { }
_M_do_left_shift(size_t)
{}
void
_M_do_right_shift(size_t) { }
_M_do_right_shift(size_t)
{}
void
_M_do_flip() { }
_M_do_flip()
{}
void
_M_do_set() { }
_M_do_set()
{}
void
_M_do_reset() { }
_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; }
_M_is_equal(const _Base_bitset<0>&) const
{ return true; }
bool
_M_is_any() const { return false; }
_M_is_any() const
{ return false; }
size_t
_M_do_count() const { return 0; }
_M_do_count() const
{ return 0; }
unsigned long
_M_do_to_ulong() const { return 0; }
_M_do_to_ulong() const
{ return 0; }
// 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; }
_M_do_find_first(size_t) const
{ return 0; }
size_t
_M_do_find_next(size_t, size_t) const { return 0; }
_M_do_find_next(size_t, size_t) const
{ return 0; }
};
@ -534,7 +578,6 @@ namespace _GLIBCXX_STD
struct _Sanitize<0>
{ static void _S_do_sanitize(unsigned long) {} };
/**
* @brief The %bitset class represents a @e fixed-size sequence of bits.
*
@ -600,7 +643,8 @@ namespace _GLIBCXX_STD
* @endif
*/
template<size_t _Nb>
class bitset : private _Base_bitset<_GLIBCXX_BITSET_WORDS(_Nb)>
class bitset
: private _Base_bitset<_GLIBCXX_BITSET_WORDS(_Nb)>
{
private:
typedef _Base_bitset<_GLIBCXX_BITSET_WORDS(_Nb)> _Base;
@ -643,7 +687,8 @@ namespace _GLIBCXX_STD
_M_bpos = _Base::_S_whichbit(__pos);
}
~reference() { }
~reference()
{ }
// For b[i] = __x;
reference&
@ -688,24 +733,28 @@ namespace _GLIBCXX_STD
// 23.3.5.1 constructors:
/// All bits set to zero.
bitset() { }
bitset()
{ }
/// Initial bits bitwise-copied from a single word (others set to zero).
bitset(unsigned long __val) : _Base(__val)
bitset(unsigned long __val)
: _Base(__val)
{ _M_do_sanitize(); }
/**
* @brief Use a subset of a string.
* @param s A string of '0' and '1' characters.
* @param position Index of the first character in @a s to use; defaults
* to zero.
* @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 '0' nor '1'.
*/
template<class _CharT, class _Traits, class _Alloc>
explicit bitset(const basic_string<_CharT, _Traits, _Alloc>& __s,
size_t __position = 0) : _Base()
explicit
bitset(const basic_string<_CharT, _Traits, _Alloc>& __s,
size_t __position = 0)
: _Base()
{
if (__position > __s.size())
__throw_out_of_range(__N("bitset::bitset initial position "
@ -725,7 +774,8 @@ namespace _GLIBCXX_STD
*/
template<class _CharT, class _Traits, class _Alloc>
bitset(const basic_string<_CharT, _Traits, _Alloc>& __s,
size_t __position, size_t __n) : _Base()
size_t __position, size_t __n)
: _Base()
{
if (__position > __s.size())
__throw_out_of_range(__N("bitset::bitset initial position "
@ -836,10 +886,8 @@ namespace _GLIBCXX_STD
bool
_Unchecked_test(size_t __pos) const
{
return (this->_M_getword(__pos) & _Base::_S_maskbit(__pos))
!= static_cast<_WordT>(0);
}
{ return ((this->_M_getword(__pos) & _Base::_S_maskbit(__pos))
!= static_cast<_WordT>(0)); }
//@}
// Set, reset, and flip.
@ -919,7 +967,8 @@ namespace _GLIBCXX_STD
/// See the no-argument flip().
bitset<_Nb>
operator~() const { return bitset<_Nb>(*this).flip(); }
operator~() const
{ return bitset<_Nb>(*this).flip(); }
//@{
/**
@ -939,10 +988,12 @@ namespace _GLIBCXX_STD
* @endif
*/
reference
operator[](size_t __position) { return reference(*this,__position); }
operator[](size_t __position)
{ return reference(*this,__position); }
bool
operator[](size_t __position) const { return _Unchecked_test(__position); }
operator[](size_t __position) const
{ return _Unchecked_test(__position); }
//@}
/**
@ -952,7 +1003,8 @@ namespace _GLIBCXX_STD
* represented in an @c unsigned @c long.
*/
unsigned long
to_ulong() const { return this->_M_do_to_ulong(); }
to_ulong() const
{ return this->_M_do_to_ulong(); }
/**
* @brief Retuns a character interpretation of the %bitset.
@ -989,11 +1041,13 @@ namespace _GLIBCXX_STD
/// Returns the number of bits which are set.
size_t
count() const { return this->_M_do_count(); }
count() const
{ return this->_M_do_count(); }
/// Returns the total number of bits.
size_t
size() const { return _Nb; }
size() const
{ return _Nb; }
//@{
/// These comparisons for equality/inequality are, well, @e bitwise.
@ -1025,14 +1079,16 @@ namespace _GLIBCXX_STD
* @return True if at least one bit is set.
*/
bool
any() const { return this->_M_is_any(); }
any() const
{ return this->_M_is_any(); }
/**
* @brief Tests whether any of the bits are on.
* @return True if none of the bits are set.
*/
bool
none() const { return !this->_M_is_any(); }
none() const
{ return !this->_M_is_any(); }
//@{
/// Self-explanatory.
@ -1181,7 +1237,7 @@ namespace _GLIBCXX_STD
}
else
{
char_type __c2 = _Traits::to_char_type(__c1);
const char_type __c2 = _Traits::to_char_type(__c1);
if (__c2 == __zero)
__tmp.push_back('0');
else if (__c2 == __one)