URL https://opencores.org/ocsvn/scarts/scarts/trunk

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-gcc/] [gcc-4.1.1/] [libstdc++-v3/] [include/] [debug/] [bitset] - Blame information for rev 17

Details | Compare with Previous | View Log


// Debugging bitset implementation -*- C++ -*-
 
// Copyright (C) 2003, 2004, 2005
// Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
 
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
 
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING.  If not, write to the Free
// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
// USA.
 
// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
 
#ifndef _GLIBCXX_DEBUG_BITSET
#define _GLIBCXX_DEBUG_BITSET
 
#include 
#include 
#include 
 
namespace __gnu_debug_def
{
  template
    class bitset
    : public _GLIBCXX_STD::bitset<_Nb>,
      public __gnu_debug::_Safe_sequence_base
    {
      typedef _GLIBCXX_STD::bitset<_Nb> _Base;
      typedef __gnu_debug::_Safe_sequence_base  _Safe_base;
 
    public:
      // bit reference:
      class reference
      : private _Base::reference, public __gnu_debug::_Safe_iterator_base
      {
        typedef typename _Base::reference _Base_ref;
 
        friend class bitset;
        reference();
 
        reference(const _Base_ref& __base, bitset* __seq)
        : _Base_ref(__base), _Safe_iterator_base(__seq, false)
        { }
 
      public:
        reference(const reference& __x)
        : _Base_ref(__x), _Safe_iterator_base(__x, false)
        { }
 
        reference&
        operator=(bool __x)
        {
          _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
                              _M_message(::__gnu_debug::__msg_bad_bitset_write)
                                ._M_iterator(*this));
          *static_cast<_Base_ref*>(this) = __x;
          return *this;
        }
 
        reference&
        operator=(const reference& __x)
        {
          _GLIBCXX_DEBUG_VERIFY(! __x._M_singular(),
                               _M_message(::__gnu_debug::__msg_bad_bitset_read)
                                ._M_iterator(__x));
          _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
                              _M_message(::__gnu_debug::__msg_bad_bitset_write)
                                ._M_iterator(*this));
          *static_cast<_Base_ref*>(this) = __x;
          return *this;
        }
 
        bool
        operator~() const
        {
          _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
                               _M_message(::__gnu_debug::__msg_bad_bitset_read)
                                ._M_iterator(*this));
          return ~(*static_cast(this));
        }
 
        operator bool() const
        {
          _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
                              _M_message(::__gnu_debug::__msg_bad_bitset_read)
                                ._M_iterator(*this));
          return *static_cast(this);
        }
 
        reference&
        flip()
        {
          _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
                              _M_message(::__gnu_debug::__msg_bad_bitset_flip)
                                ._M_iterator(*this));
          _Base_ref::flip();
          return *this;
        }
      };
 
      // 23.3.5.1 constructors:
      bitset() : _Base() { }
 
      bitset(unsigned long __val) : _Base(__val) { }
 
      template
        explicit
        bitset(const std::basic_string<_CharT,_Traits,_Allocator>& __str,
               typename std::basic_string<_CharT,_Traits,_Allocator>::size_type
               __pos = 0,
               typename std::basic_string<_CharT,_Traits,_Allocator>::size_type
               __n = (std::basic_string<_CharT,_Traits,_Allocator>::npos))
        : _Base(__str, __pos, __n) { }
 
      bitset(const _Base& __x) : _Base(__x), _Safe_base() { }
 
      // 23.3.5.2 bitset operations:
      bitset<_Nb>&
      operator&=(const bitset<_Nb>& __rhs)
      {
        _M_base() &= __rhs;
        return *this;
      }
 
      bitset<_Nb>&
      operator|=(const bitset<_Nb>& __rhs)
      {
        _M_base() |= __rhs;
        return *this;
      }
 
      bitset<_Nb>&
      operator^=(const bitset<_Nb>& __rhs)
      {
        _M_base() ^= __rhs;
        return *this;
      }
 
      bitset<_Nb>&
      operator<<=(size_t __pos)
      {
        _M_base() <<= __pos;
        return *this;
      }
 
      bitset<_Nb>&
      operator>>=(size_t __pos)
      {
        _M_base() >>= __pos;
        return *this;
      }
 
      bitset<_Nb>&
      set()
      {
        _Base::set();
        return *this;
      }
 
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 186. bitset::set() second parameter should be bool
      bitset<_Nb>&
      set(size_t __pos, bool __val = true)
      {
        _Base::set(__pos, __val);
        return *this;
      }
 
      bitset<_Nb>&
      reset()
      {
        _Base::reset();
        return *this;
      }
 
      bitset<_Nb>&
      reset(size_t __pos)
      {
        _Base::reset(__pos);
        return *this;
      }
 
      bitset<_Nb> operator~() const { return bitset(~_M_base()); }
 
      bitset<_Nb>&
      flip()
      {
        _Base::flip();
        return *this;
      }
 
      bitset<_Nb>&
      flip(size_t __pos)
      {
        _Base::flip(__pos);
        return *this;
      }
 
      // element access:
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 11. Bitset minor problems
      reference
      operator[](size_t __pos)
      {
        __glibcxx_check_subscript(__pos);
        return reference(_M_base()[__pos], this);
      }
 
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 11. Bitset minor problems
      bool
      operator[](size_t __pos) const
      {
        __glibcxx_check_subscript(__pos);
        return _M_base()[__pos];
      }
 
      using _Base::to_ulong;
 
      template 
        std::basic_string<_CharT, _Traits, _Allocator>
        to_string() const
        { return _M_base().template to_string<_CharT, _Traits, _Allocator>(); }
 
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 434. bitset::to_string() hard to use.
      template
        std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
        to_string() const
        { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); }
 
      template
        std::basic_string<_CharT, std::char_traits<_CharT>,
                          std::allocator<_CharT> >
        to_string() const
        {
          return to_string<_CharT, std::char_traits<_CharT>,
                           std::allocator<_CharT> >();
        }
 
      std::basic_string, std::allocator >
        to_string() const
        {
          return to_string,std::allocator >();
        }
 
      using _Base::count;
      using _Base::size;
 
      bool
      operator==(const bitset<_Nb>& __rhs) const
      { return _M_base() == __rhs; }
 
      bool
      operator!=(const bitset<_Nb>& __rhs) const
      { return _M_base() != __rhs; }
 
      using _Base::test;
      using _Base::any;
      using _Base::none;
 
      bitset<_Nb>
      operator<<(size_t __pos) const
      { return bitset<_Nb>(_M_base() << __pos); }
 
      bitset<_Nb>
      operator>>(size_t __pos) const
      { return bitset<_Nb>(_M_base() >> __pos); }
 
      _Base&
      _M_base() { return *this; }
 
      const _Base&
      _M_base() const { return *this; }
    };
 
  template
    bitset<_Nb>
    operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
    { return bitset<_Nb>(__x) &= __y; }
 
  template
    bitset<_Nb>
    operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
    { return bitset<_Nb>(__x) |= __y; }
 
  template
    bitset<_Nb>
    operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
    { return bitset<_Nb>(__x) ^= __y; }
 
  template
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)
    { return __is >> __x._M_base(); }
 
  template
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
               const bitset<_Nb>& __x)
    { return __os << __x._M_base(); }
} // namespace __gnu_debug_def
 
#endif

Browse

Tools

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-gcc/] [gcc-4.1.1/] [libstdc++-v3/] [include/] [debug/] [bitset] - Blame information for rev 17

Line No.	Rev	Author	Line
1	17	jlechner	`// Debugging bitset implementation -- C++ --`
2
3			`// Copyright (C) 2003, 2004, 2005`
4			`// Free Software Foundation, Inc.`
5			`//`
6			`// This file is part of the GNU ISO C++ Library. This library is free`
7			`// software; you can redistribute it and/or modify it under the`
8			`// terms of the GNU General Public License as published by the`
9			`// Free Software Foundation; either version 2, or (at your option)`
10			`// any later version.`
11
12			`// This library is distributed in the hope that it will be useful,`
13			`// but WITHOUT ANY WARRANTY; without even the implied warranty of`
14			`// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
15			`// GNU General Public License for more details.`
16
17			`// You should have received a copy of the GNU General Public License along`
18			`// with this library; see the file COPYING. If not, write to the Free`
19			`// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,`
20			`// USA.`
21
22			`// As a special exception, you may use this file as part of a free software`
23			`// library without restriction. Specifically, if other files instantiate`
24			`// templates or use macros or inline functions from this file, or you compile`
25			`// this file and link it with other files to produce an executable, this`
26			`// file does not by itself cause the resulting executable to be covered by`
27			`// the GNU General Public License. This exception does not however`
28			`// invalidate any other reasons why the executable file might be covered by`
29			`// the GNU General Public License.`
30
31			`#ifndef _GLIBCXX_DEBUG_BITSET`
32			`#define _GLIBCXX_DEBUG_BITSET`
33
34			`#include`
35			`#include`
36			`#include`
37
38			`namespace __gnu_debug_def`
39			`{`
40			`template`
41			`class bitset`
42			`: public _GLIBCXX_STD::bitset<_Nb>,`
43			`public __gnu_debug::_Safe_sequence_base`
44			`{`
45			`typedef _GLIBCXX_STD::bitset<_Nb> _Base;`
46			`typedef __gnu_debug::_Safe_sequence_base _Safe_base;`
47
48			`public:`
49			`// bit reference:`
50			`class reference`
51			`: private _Base::reference, public __gnu_debug::_Safe_iterator_base`
52			`{`
53			`typedef typename _Base::reference _Base_ref;`
54
55			`friend class bitset;`
56			`reference();`
57
58			`reference(const _Base_ref& __base, bitset* __seq)`
59			`: _Base_ref(__base), _Safe_iterator_base(__seq, false)`
60			`{ }`
61
62			`public:`
63			`reference(const reference& __x)`
64			`: _Base_ref(__x), _Safe_iterator_base(__x, false)`
65			`{ }`
66
67			`reference&`
68			`operator=(bool __x)`
69			`{`
70			`_GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),`
71			`_M_message(::__gnu_debug::__msg_bad_bitset_write)`
72			`._M_iterator(*this));`
73			`static_cast<_Base_ref>(this) = __x;`
74			`return *this;`
75			`}`
76
77			`reference&`
78			`operator=(const reference& __x)`
79			`{`
80			`_GLIBCXX_DEBUG_VERIFY(! __x._M_singular(),`
81			`_M_message(::__gnu_debug::__msg_bad_bitset_read)`
82			`._M_iterator(__x));`
83			`_GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),`
84			`_M_message(::__gnu_debug::__msg_bad_bitset_write)`
85			`._M_iterator(*this));`
86			`static_cast<_Base_ref>(this) = __x;`
87			`return *this;`
88			`}`
89
90			`bool`
91			`operator~() const`
92			`{`
93			`_GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),`
94			`_M_message(::__gnu_debug::__msg_bad_bitset_read)`
95			`._M_iterator(*this));`
96			`return ~(*static_cast(this));`
97			`}`
98
99			`operator bool() const`
100			`{`
101			`_GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),`
102			`_M_message(::__gnu_debug::__msg_bad_bitset_read)`
103			`._M_iterator(*this));`
104			`return *static_cast(this);`
105			`}`
106
107			`reference&`
108			`flip()`
109			`{`
110			`_GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),`
111			`_M_message(::__gnu_debug::__msg_bad_bitset_flip)`
112			`._M_iterator(*this));`
113			`_Base_ref::flip();`
114			`return *this;`
115			`}`
116			`};`
117
118			`// 23.3.5.1 constructors:`
119			`bitset() : _Base() { }`
120
121			`bitset(unsigned long __val) : _Base(__val) { }`
122
123			`template`
124			`explicit`
125			`bitset(const std::basic_string<_CharT,_Traits,_Allocator>& __str,`
126			`typename std::basic_string<_CharT,_Traits,_Allocator>::size_type`
127			`__pos = 0,`
128			`typename std::basic_string<_CharT,_Traits,_Allocator>::size_type`
129			`__n = (std::basic_string<_CharT,_Traits,_Allocator>::npos))`
130			`: _Base(__str, __pos, __n) { }`
131
132			`bitset(const _Base& __x) : _Base(__x), _Safe_base() { }`
133
134			`// 23.3.5.2 bitset operations:`
135			`bitset<_Nb>&`
136			`operator&=(const bitset<_Nb>& __rhs)`
137			`{`
138			`_M_base() &= __rhs;`
139			`return *this;`
140			`}`
141
142			`bitset<_Nb>&`
143			`operator\|=(const bitset<_Nb>& __rhs)`
144			`{`
145			`_M_base() \|= __rhs;`
146			`return *this;`
147			`}`
148
149			`bitset<_Nb>&`
150			`operator^=(const bitset<_Nb>& __rhs)`
151			`{`
152			`_M_base() ^= __rhs;`
153			`return *this;`
154			`}`
155
156			`bitset<_Nb>&`
157			`operator<<=(size_t __pos)`
158			`{`
159			`_M_base() <<= __pos;`
160			`return *this;`
161			`}`
162
163			`bitset<_Nb>&`
164			`operator>>=(size_t __pos)`
165			`{`
166			`_M_base() >>= __pos;`
167			`return *this;`
168			`}`
169
170			`bitset<_Nb>&`
171			`set()`
172			`{`
173			`_Base::set();`
174			`return *this;`
175			`}`
176
177			`// _GLIBCXX_RESOLVE_LIB_DEFECTS`
178			`// 186. bitset::set() second parameter should be bool`
179			`bitset<_Nb>&`
180			`set(size_t __pos, bool __val = true)`
181			`{`
182			`_Base::set(__pos, __val);`
183			`return *this;`
184			`}`
185
186			`bitset<_Nb>&`
187			`reset()`
188			`{`
189			`_Base::reset();`
190			`return *this;`
191			`}`
192
193			`bitset<_Nb>&`
194			`reset(size_t __pos)`
195			`{`
196			`_Base::reset(__pos);`
197			`return *this;`
198			`}`
199
200			`bitset<_Nb> operator~() const { return bitset(~_M_base()); }`
201
202			`bitset<_Nb>&`
203			`flip()`
204			`{`
205			`_Base::flip();`
206			`return *this;`
207			`}`
208
209			`bitset<_Nb>&`
210			`flip(size_t __pos)`
211			`{`
212			`_Base::flip(__pos);`
213			`return *this;`
214			`}`
215
216			`// element access:`
217			`// _GLIBCXX_RESOLVE_LIB_DEFECTS`
218			`// 11. Bitset minor problems`
219			`reference`
220			`operator[](size_t __pos)`
221			`{`
222			`__glibcxx_check_subscript(__pos);`
223			`return reference(_M_base()[__pos], this);`
224			`}`
225
226			`// _GLIBCXX_RESOLVE_LIB_DEFECTS`
227			`// 11. Bitset minor problems`
228			`bool`
229			`operator[](size_t __pos) const`
230			`{`
231			`__glibcxx_check_subscript(__pos);`
232			`return _M_base()[__pos];`
233			`}`
234
235			`using _Base::to_ulong;`
236
237			`template`
238			`std::basic_string<_CharT, _Traits, _Allocator>`
239			`to_string() const`
240			`{ return _M_base().template to_string<_CharT, _Traits, _Allocator>(); }`
241
242			`// _GLIBCXX_RESOLVE_LIB_DEFECTS`
243			`// 434. bitset::to_string() hard to use.`
244			`template`
245			`std::basic_string<_CharT, _Traits, std::allocator<_CharT> >`
246			`to_string() const`
247			`{ return to_string<_CharT, _Traits, std::allocator<_CharT> >(); }`
248
249			`template`
250			`std::basic_string<_CharT, std::char_traits<_CharT>,`
251			`std::allocator<_CharT> >`
252			`to_string() const`
253			`{`
254			`return to_string<_CharT, std::char_traits<_CharT>,`
255			`std::allocator<_CharT> >();`
256			`}`
257
258			`std::basic_string, std::allocator >`
259			`to_string() const`
260			`{`
261			`return to_string,std::allocator >();`
262			`}`
263
264			`using _Base::count;`
265			`using _Base::size;`
266
267			`bool`
268			`operator==(const bitset<_Nb>& __rhs) const`
269			`{ return _M_base() == __rhs; }`
270
271			`bool`
272			`operator!=(const bitset<_Nb>& __rhs) const`
273			`{ return _M_base() != __rhs; }`
274
275			`using _Base::test;`
276			`using _Base::any;`
277			`using _Base::none;`
278
279			`bitset<_Nb>`
280			`operator<<(size_t __pos) const`
281			`{ return bitset<_Nb>(_M_base() << __pos); }`
282
283			`bitset<_Nb>`
284			`operator>>(size_t __pos) const`
285			`{ return bitset<_Nb>(_M_base() >> __pos); }`
286
287			`_Base&`
288			`_M_base() { return *this; }`
289
290			`const _Base&`
291			`_M_base() const { return *this; }`
292			`};`
293
294			`template`
295			`bitset<_Nb>`
296			`operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y)`
297			`{ return bitset<_Nb>(__x) &= __y; }`
298
299			`template`
300			`bitset<_Nb>`
301			`operator\|(const bitset<_Nb>& __x, const bitset<_Nb>& __y)`
302			`{ return bitset<_Nb>(__x) \|= __y; }`
303
304			`template`
305			`bitset<_Nb>`
306			`operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y)`
307			`{ return bitset<_Nb>(__x) ^= __y; }`
308
309			`template`
310			`std::basic_istream<_CharT, _Traits>&`
311			`operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)`
312			`{ return __is >> __x._M_base(); }`
313
314			`template`
315			`std::basic_ostream<_CharT, _Traits>&`
316			`operator<<(std::basic_ostream<_CharT, _Traits>& __os,`
317			`const bitset<_Nb>& __x)`
318			`{ return __os << __x._M_base(); }`
319			`} // namespace __gnu_debug_def`
320
321			`#endif`