|
From: <rom...@us...> - 2007-11-12 11:36:37
|
Revision: 1140
http://pygccxml.svn.sourceforge.net/pygccxml/?rev=1140&view=rev
Author: roman_yakovenko
Date: 2007-11-12 03:36:40 -0800 (Mon, 12 Nov 2007)
Log Message:
-----------
updating to new gccxml build
Modified Paths:
--------------
gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/deque
gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/fstream
gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/functional
gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/istream
gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/list
gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/map
gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/ostream
gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/sstream
gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/string
gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/vector
gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/xstring
gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/xtree
Added Paths:
-----------
gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/complex
gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/limits
gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/set
gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/valarray
gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/xlocale
Added: gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/complex
===================================================================
--- gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/complex (rev 0)
+++ gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/complex 2007-11-12 11:36:40 UTC (rev 1140)
@@ -0,0 +1,373 @@
+// complex standard header
+
+#if _MSC_VER > 1000
+#pragma once
+#endif
+
+#ifndef _COMPLEX_
+#define _COMPLEX_
+#include <ymath.h>
+#include <cmath>
+#include <sstream>
+#include <xutility>
+
+#ifdef _MSC_VER
+#pragma pack(push,8)
+#endif /* _MSC_VER */
+_STD_BEGIN
+#define __STD_COMPLEX
+ // TEMPLATE CLASS _Ctr
+template<class _Ty> class _Ctr {
+public:
+ static _Ty _Cosh(_Ty _X, _Ty _Y)
+ {return (::_Cosh((double)_X, (double)_Y)); }
+ static short _Exp(_Ty *_P, _Ty _Y, short _E)
+ {double _W = (double)*_P;
+ short _Ans = ::_Exp(&_W, (double)_Y, _E);
+ *_P = (_Ty)_W;
+ return (_Ans); }
+ static _Ty _Infv(_Ty)
+ {return (_Inf._D); }
+ static bool _Isinf(_Ty _X)
+ {double _W = (double)_X;
+ return (_Dtest(&_W) == _INFCODE); }
+ static bool _Isnan(_Ty _X)
+ {double _W = (double)_X;
+ return (_Dtest(&_W) == _NANCODE); }
+ static _Ty _Nanv(_Ty)
+ {return (_Nan._D); }
+ static _Ty _Sinh(_Ty _X, _Ty _Y)
+ {return (::_Sinh((double)_X, (double)_Y)); }
+ static _Ty atan2(_Ty _Y, _Ty _X)
+ {return (::atan2((double)_Y, (double)_X)); }
+ static _Ty cos(_Ty _X)
+ {return (::cos((double)_X)); }
+ static _Ty exp(_Ty _X)
+ {return (::exp((double)_X)); }
+ static _Ty ldexp(_Ty _R, int _E)
+ {return (::ldexp((double)_R, _E)); }
+ static _Ty log(_Ty _X)
+ {return (::log((double)_X)); }
+ static _Ty pow(_Ty _X, _Ty _Y)
+ {return (::pow((double)_X, (double)_Y)); }
+ static _Ty sin(_Ty _X)
+ {return (::sin((double)_X)); }
+ static _Ty sqrt(_Ty _X)
+ {return (::sqrt((double)_X)); }
+ };
+ // CLASS _Ctr<long double>
+template<>
+class _CRTIMP _Ctr<long double> {
+public:
+ typedef long double _Ty;
+ static _Ty _Cosh(_Ty _X, _Ty _Y)
+ {return (_LCosh(_X, _Y)); }
+ static short _Exp(_Ty *_P, _Ty _Y, short _E)
+ {return (_LExp(_P, _Y, _E)); }
+ static _Ty _Infv(_Ty)
+ {return (_LInf._L); }
+ static bool _Isinf(_Ty _X)
+ {return (_LDtest(&_X) == _INFCODE); }
+ static bool _Isnan(_Ty _X)
+ {return (_LDtest(&_X) == _NANCODE); }
+ static _Ty _Nanv(_Ty)
+ {return (_LNan._L); }
+ static _Ty _Sinh(_Ty _X, _Ty _Y)
+ {return (_LSinh(_X, _Y)); }
+ static _Ty atan2(_Ty _Y, _Ty _X)
+ {return (atan2l(_Y, _X)); }
+ static _Ty cos(_Ty _X)
+ {return (cosl(_X)); }
+ static _Ty exp(_Ty _X)
+ {return (expl(_X)); }
+ static _Ty ldexp(_Ty _R, int _E)
+ {return (ldexpl(_R, _E)); }
+ static _Ty log(_Ty _X)
+ {return (logl(_X)); }
+ static _Ty pow(_Ty _X, _Ty _Y)
+ {return (powl(_X, _Y)); }
+ static _Ty sin(_Ty _X)
+ {return (sinl(_X)); }
+ static _Ty sqrt(_Ty _X)
+ {return (sqrtl(_X)); }
+ };
+ // CLASS _Ctr<double>
+template<>
+class _CRTIMP _Ctr<double> {
+public:
+ typedef double _Ty;
+ static _Ty _Cosh(_Ty _X, _Ty _Y)
+ {return (::_Cosh(_X, _Y)); }
+ static short _Exp(_Ty *_P, _Ty _Y, short _E)
+ {return (::_Exp(_P, _Y, _E)); }
+ static _Ty _Infv(_Ty)
+ {return (_Inf._D); }
+ static bool _Isinf(_Ty _X)
+ {return (_Dtest(&_X) == _INFCODE); }
+ static bool _Isnan(_Ty _X)
+ {return (_Dtest(&_X) == _NANCODE); }
+ static _Ty _Nanv(_Ty)
+ {return (_Nan._D); }
+ static _Ty _Sinh(_Ty _X, _Ty _Y)
+ {return (::_Sinh(_X, _Y)); }
+ static _Ty atan2(_Ty _Y, _Ty _X)
+ {return (::atan2(_Y, _X)); }
+ static _Ty cos(_Ty _X)
+ {return (::cos(_X)); }
+ static _Ty exp(_Ty _X)
+ {return (::exp(_X)); }
+ static _Ty ldexp(_Ty _R, int _E)
+ {return (::ldexp(_R, _E)); }
+ static _Ty log(_Ty _X)
+ {return (::log(_X)); }
+ static _Ty pow(_Ty _X, _Ty _Y)
+ {return (::pow(_X, _Y)); }
+ static _Ty sin(_Ty _X)
+ {return (::sin(_X)); }
+ static _Ty sqrt(_Ty _X)
+ {return (::sqrt(_X)); }
+ };
+template<>
+class _CRTIMP _Ctr<float> {
+public:
+ typedef float _Ty;
+ static _Ty _Cosh(_Ty _X, _Ty _Y)
+ {return (_FCosh(_X, _Y)); }
+ static short _Exp(_Ty *_P, _Ty _Y, short _E)
+ {return (_FExp(_P, _Y, _E)); }
+ static _Ty _Infv(_Ty)
+ {return (_FInf._F); }
+ static bool _Isinf(_Ty _X)
+ {return (_FDtest(&_X) == _INFCODE); }
+ static bool _Isnan(_Ty _X)
+ {return (_FDtest(&_X) == _NANCODE); }
+ static _Ty _Nanv(_Ty)
+ {return (_FNan._F); }
+ static _Ty _Sinh(_Ty _X, _Ty _Y)
+ {return (_FSinh(_X, _Y)); }
+ static _Ty atan2(_Ty _Y, _Ty _X)
+ {return (atan2f(_Y, _X)); }
+ static _Ty cos(_Ty _X)
+ {return (cosf(_X)); }
+ static _Ty exp(_Ty _X)
+ {return (expf(_X)); }
+ static _Ty ldexp(_Ty _R, int _E)
+ {return (ldexpf(_R, _E)); }
+ static _Ty log(_Ty _X)
+ {return (logf(_X)); }
+ static _Ty pow(_Ty _X, _Ty _Y)
+ {return (powf(_X, _Y)); }
+ static _Ty sin(_Ty _X)
+ {return (sinf(_X)); }
+ static _Ty sqrt(_Ty _X)
+ {return (sqrtf(_X)); }
+ };
+ // TEMPLATE CLASS _Complex_base
+template<class _Ty> class complex;
+class _CRTIMP complex<float>;
+class _CRTIMP complex<double>;
+class _CRTIMP complex<long double>;
+template<class _Ty>
+ class _Complex_base {
+public:
+ typedef _Complex_base<_Ty> _Myt;
+ typedef _Ctr<_Ty> _Myctr;
+ typedef _Ty value_type;
+ _Complex_base(const _Ty& _R, const _Ty& _I)
+ : _Re(_R), _Im(_I) {}
+ _Myt& operator+=(const _Ty& _X)
+ {_Re = _Re + _X;
+ return (*this); }
+ _Myt& operator-=(const _Ty& _X)
+ {_Re = _Re - _X;
+ return (*this); }
+ _Myt& operator*=(const _Ty& _X)
+ {_Re = _Re * _X;
+ _Im = _Im * _X;
+ return (*this); }
+ _Myt& operator/=(const _Ty& _X)
+ {_Re = _Re / _X;
+ _Im = _Im / _X;
+ return (*this); }
+ _Ty real(const _Ty& _X)
+ {return (_Re = _X); }
+ _Ty imag(const _Ty& _X)
+ {return (_Im = _X); }
+ _Ty real() const
+ {return (_Re); }
+ _Ty imag() const
+ {return (_Im); }
+protected:
+ _Ty _Re, _Im;
+ };
+
+
+ // CLASS complex<float>
+template<>
+class _CRTIMP complex<float> : public _Complex_base<float> {
+public:
+ typedef float _Ty;
+ explicit complex(const complex<double>&);
+ explicit complex(const complex<long double>&);
+ complex(const _Ty& _R = 0, const _Ty& _I = 0)
+ : _Complex_base<_Ty>(_R, _I) {}
+ complex<_Ty>& operator=(const _Ty& _X)
+ {_Re = _X;
+ _Im = 0;
+ return (*this); }
+ };
+ // CLASS complex<double>
+template<>
+class _CRTIMP complex<double> : public _Complex_base<double> {
+public:
+ typedef double _Ty;
+ complex(const complex<float>&);
+ explicit complex(const complex<long double>&);
+ complex(const _Ty& _R = 0, const _Ty& _I = 0)
+ : _Complex_base<_Ty>(_R, _I) {}
+ complex<_Ty>& operator=(const _Ty& _X)
+ {_Re = _X;
+ _Im = 0;
+ return (*this); }
+ };
+ // CLASS complex<long double>
+template<>
+class _CRTIMP complex<long double> : public _Complex_base<long double> {
+public:
+ typedef long double _Ty;
+ complex(const complex<float>&);
+ complex(const complex<double>&);
+ complex(const _Ty& _R = 0, const _Ty& _I = 0)
+ : _Complex_base<_Ty>(_R, _I) {}
+ complex<_Ty>& operator=(const _Ty& _X)
+ {_Re = _X;
+ _Im = 0;
+ return (*this); }
+ };
+ // CONSTRUCTORS FOR complex SPECIALIZATIONS
+inline complex<float>::complex(const complex<double>& _X)
+ : _Complex_base<float>((_Ty)_X.real(), (_Ty)_X.imag()) {}
+inline complex<float>::complex(const complex<long double>& _X)
+ : _Complex_base<float>((_Ty)_X.real(), (_Ty)_X.imag()) {}
+inline complex<double>::complex(const complex<float>& _X)
+ : _Complex_base<double>((_Ty)_X.real(), (_Ty)_X.imag()) {}
+inline complex<double>::complex(const complex<long double>& _X)
+ : _Complex_base<double>((_Ty)_X.real(), (_Ty)_X.imag()) {}
+inline complex<long double>::complex(const complex<float>& _X)
+ : _Complex_base<long double>((_Ty)_X.real(), (_Ty)_X.imag()) {}
+inline complex<long double>::complex(const complex<double>& _X)
+ : _Complex_base<long double>((_Ty)_X.real(), (_Ty)_X.imag()) {}
+ // TEMPLATE CLASS complex
+template<class _Ty>
+ class complex : public _Complex_base<_Ty> {
+public:
+ complex(const _Ty& _R = 0, const _Ty& _I = 0)
+ : _Complex_base<_Ty>(_R, _I) {}
+ typedef _Ty _U;
+ complex(const complex<_U>& _X)
+ : _Complex_base<_Ty>((_Ty)_X.real(), (_Ty)_X.imag()) {}
+ complex<_Ty>& operator=(const complex<_U>& _X)
+ {this->_Re = (_Ty)_X.real();
+ this->_Im = (_Ty)_X.imag();
+ return (*this); }
+ };
+ // TEMPLATE complex OPERATORS
+template<class _Ty, class _U> inline
+ complex<_Ty>& __cdecl operator+=(
+ complex<_Ty>& _X,
+ const complex<_U>& _Y)
+ {_X.real(_X.real() + (_Ty)_Y.real());
+ _X.imag(_X.imag() + (_Ty)_Y.imag());
+ return (_X); }
+template<class _Ty, class _U> inline
+ complex<_Ty>& __cdecl operator-=(
+ complex<_Ty>& _X,
+ const complex<_U>& _Y)
+ {_X.real(_X.real() - (_Ty)_Y.real());
+ _X.imag(_X.imag() - (_Ty)_Y.imag());
+ return (_X); }
+template<class _Ty, class _U> inline
+ complex<_Ty>& __cdecl operator*=(
+ complex<_Ty>& _X,
+ const complex<_U>& _Y)
+ {_Ty _Yre = (_Ty)_Y.real();
+ _Ty _Yim = (_Ty)_Y.imag();
+ _Ty _W = _X.real() * _Yre - _X.imag() * _Yim;
+ _X.imag(_X.real() * _Yim + _X.imag() * _Yre);
+ _X.real(_W);
+ return (_X); }
+template<class _Ty, class _U> inline
+ complex<_Ty>& __cdecl operator/=(
+ complex<_Ty>& _X,
+ const complex<_U>& _Y)
+ {typedef _Ctr<_Ty> _Myctr;
+ _Ty _Yre = (_Ty)_Y.real();
+ _Ty _Yim = (_Ty)_Y.imag();
+ if (_Myctr::_Isnan(_Yre) || _Myctr::_Isnan(_Yim))
+ _X.real(_Myctr::_Nanv(_Yre)), _X.imag(_X.real());
+ else if ((_Yim < 0 ? -_Yim : +_Yim)
+ < (_Yre < 0 ? -_Yre : +_Yre))
+ {_Ty _Wr = _Yim / _Yre;
+ _Ty _Wd = _Yre + _Wr * _Yim;
+ if (_Myctr::_Isnan(_Wd) || _Wd == 0)
+ _X.real(_Myctr::_Nanv(_Yre)), _X.imag(_X.real());
+ else
+ {_Ty _W = (_X.real() + _X.imag() * _Wr) / _Wd;
+ _X.imag((_X.imag() - _X.real() * _Wr) / _Wd);
+ _X.real(_W); }}
+ else if (_Yim == 0)
+ _X.real(_Myctr::_Nanv(_Yre)), _X.imag(_X.real());
+ else
+ {_Ty _Wr = _Yre / _Yim;
+ _Ty _Wd = _Yim + _Wr * _Yre;
+ if (_Myctr::_Isnan(_Wd) || _Wd == 0)
+ _X.real(_Myctr::_Nanv(_Yre)), _X.imag(_X.real());
+ else
+ {_Ty _W = (_X.real() * _Wr + _X.imag()) / _Wd;
+ _X.imag((_X.imag() * _Wr - _X.real()) / _Wd);
+ _X.real(_W); }}
+ return (_X); }
+ // TEMPLATE FUNCTION operator>>
+template<class _E, class _Tr, class _U> inline
+ basic_istream<_E, _Tr>& __cdecl operator>>(
+ basic_istream<_E, _Tr>& _I, complex<_U>& _X)
+ {typedef complex<_U> _Myt;
+ _E _Ch;
+ long double _Re, _Im;
+ if (_I >> _Ch && _Ch != '(')
+ _I.putback(_Ch), _I >> _Re, _Im = 0;
+ else if (_I >> _Re >> _Ch && _Ch != ',')
+ if (_Ch == ')')
+ _Im = 0;
+ else
+ _I.putback(_Ch), _I.setstate(ios_base::failbit);
+ else if (_I >> _Im >> _Ch && _Ch != ')')
+ _I.putback(_Ch), _I.setstate(ios_base::failbit);
+ if (!_I.fail())
+ _X = _Myt((_U)_Re, (_U)_Im);
+ return (_I); }
+ // TEMPLATE FUNCTION operator<<
+template<class _E, class _Tr, class _U> inline
+ basic_ostream<_E, _Tr>& __cdecl operator<<(
+ basic_ostream<_E, _Tr>& _O, const complex<_U>& _X)
+ {basic_ostringstream<_E, _Tr, allocator<_E> > _S;
+ _S.flags(_O.flags());
+ _S.imbue(_O.getloc());
+ _S.precision(_O.precision());
+ _S << '(' << real(_X) << ',' << imag(_X) << ')';
+ return (_O << _S.str().c_str()); }
+ #define _CMPLX(T) complex<T >
+ #define _CTR(T) _Ctr<T >
+ #define _TMPLT(T) template<class T >
+ #include <xcomplex>
+_STD_END
+#ifdef _MSC_VER
+#pragma pack(pop)
+#endif /* _MSC_VER */
+
+#endif /* _COMPLEX_ */
+
+/*
+ * Copyright (c) 1994 by P.J. Plauger. ALL RIGHTS RESERVED.
+ * Consult your license regarding permissions and restrictions.
+ */
Modified: gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/deque
===================================================================
--- gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/deque 2007-11-12 10:33:26 UTC (rev 1139)
+++ gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/deque 2007-11-12 11:36:40 UTC (rev 1140)
@@ -124,25 +124,25 @@
iterator(_Tptr _P, _Mapptr _M)
: const_iterator(_P, _M) {}
reference operator*() const
- {return (*_Next); }
+ {return (*this->_Next); }
_Tptr operator->() const
{return (&**this); }
iterator& operator++()
- {if (++_Next == _Last)
+ {if (++this->_Next == _Last)
{_First = *++_Map;
_Last = _First + _DEQUESIZ;
- _Next = _First; }
+ this->_Next = _First; }
return (*this); }
iterator operator++(int)
{iterator _Tmp = *this;
++*this;
return (_Tmp); }
iterator& operator--()
- {if (_Next == _First)
+ {if (this->_Next == _First)
{_First = *--_Map;
_Last = _First + _DEQUESIZ;
- _Next = _Last; }
- --_Next;
+ this->_Next = _Last; }
+ --this->_Next;
return (*this); }
iterator operator--(int)
{iterator _Tmp = *this;
@@ -160,18 +160,18 @@
{iterator _Tmp = *this;
return (_Tmp -= _N); }
difference_type operator-(const iterator& _X) const
- {return (_Map == _X._Map ? _Next - _X._Next
+ {return (_Map == _X._Map ? this->_Next - _X._Next
: _DEQUESIZ * (_Map - _X._Map - 1)
- + (_Next - _First) + (_X._Last - _X._Next)); }
+ + (this->_Next - _First) + (_X._Last - _X._Next)); }
reference operator[](difference_type _N) const
{return (*(*this + _N)); }
bool operator==(const iterator& _X) const
- {return (_Next == _X._Next); }
+ {return (this->_Next == _X._Next); }
bool operator!=(const iterator& _X) const
{return (!(*this == _X)); }
bool operator<(const iterator& _X) const
{return (_Map < _X._Map
- || _Map == _X._Map && _Next < _X._Next); }
+ || _Map == _X._Map && this->_Next < _X._Next); }
bool operator<=(const iterator& _X) const
{return (!(_X < *this)); }
bool operator>(const iterator& _X) const
Modified: gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/fstream
===================================================================
--- gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/fstream 2007-11-12 10:33:26 UTC (rev 1139)
+++ gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/fstream 2007-11-12 11:36:40 UTC (rev 1140)
@@ -67,6 +67,9 @@
public:
typedef basic_filebuf<_E, _Tr> _Myt;
typedef basic_streambuf<_E, _Tr> _Mysb;
+ typedef typename _Mysb::int_type int_type;
+ typedef typename _Mysb::pos_type pos_type;
+ typedef typename _Mysb::off_type off_type;
typedef codecvt<_E, char, typename _Tr::state_type> _Cvt;
basic_filebuf(_Filet *_F = 0)
: _Loc(), _Mysb() {_Init(_F, _Newfl); }
@@ -98,8 +101,8 @@
virtual int_type overflow(int_type _C = _Tr::eof())
{if (_Tr::eq_int_type(_Tr::eof(), _C))
return (_Tr::not_eof(_C));
- else if (pptr() != 0 && pptr() < epptr())
- {*_Pninc() = _Tr::to_char_type(_C);
+ else if (this->pptr() != 0 && this->pptr() < this->epptr())
+ {*this->_Pninc() = _Tr::to_char_type(_C);
return (_C); }
else if (_File == 0)
return (_Tr::eof());
@@ -122,18 +125,18 @@
return (_Tr::eof());
case codecvt_base::ok: // can fall through
{size_t _N = _D - _Str->begin();
- return (fwrite(_Str->begin(), _N, 1, _File)
+ return (fwrite(_Str->begin(), 1, _N, _File)
== _N ? _C : _Tr::eof()); }
case codecvt_base::noconv:
return (_Fputc(_X, _File) ? _C : _Tr::eof());
default:
return (_Tr::eof()); }}}}
virtual int_type pbackfail(int_type _C = _Tr::eof())
- {if (gptr() != 0 && eback() < gptr()
+ {if (this->gptr() != 0 && this->eback() < this->gptr()
&& (_Tr::eq_int_type(_Tr::eof(), _C)
- || _Tr::eq_int_type(_Tr::to_int_type(gptr()[-1]),
+ || _Tr::eq_int_type(_Tr::to_int_type(this->gptr()[-1]),
_C)))
- {_Gndec();
+ {this->_Gndec();
return (_Tr::not_eof(_C)); }
else if (_File == 0 || _Tr::eq_int_type(_Tr::eof(), _C))
return (_Tr::eof());
@@ -148,13 +151,13 @@
else
return (_Tr::eof()); }
virtual int_type underflow()
- {if (gptr() != 0 && gptr() < egptr())
- return (_Tr::to_int_type(*gptr()));
+ {if (this->gptr() != 0 && this->gptr() < this->egptr())
+ return (_Tr::to_int_type(*this->gptr()));
else
return (pbackfail(uflow())); }
virtual int_type uflow()
- {if (gptr() != 0 && gptr() < egptr())
- return (_Tr::to_int_type(*_Gninc()));
+ {if (this->gptr() != 0 && this->gptr() < this->egptr())
+ return (_Tr::to_int_type(*this->_Gninc()));
else if (_File == 0)
return (_Tr::eof());
else if (_Pcvt == 0)
@@ -227,7 +230,7 @@
_State0 = _Stinit;
_Pcvt = 0; }
void _Initcvt()
- {_Pcvt = (_Cvt *)&_USE(getloc(), _Cvt);
+ {_Pcvt = (_Cvt *)&_USE(this->getloc(), _Cvt);
_Loc = _ADDFAC(_Loc, _Pcvt);
if (_Pcvt->always_noconv())
_Pcvt = 0;
@@ -259,24 +262,24 @@
basic_ifstream()
: basic_istream<_E, _Tr>(&_Fb) {}
explicit basic_ifstream(const char *_S,
- ios_base::openmode _M = in)
+ ios_base::openmode _M = ios_base::in)
: basic_istream<_E, _Tr>(&_Fb)
- {if (_Fb.open(_S, _M | in) == 0)
- setstate(failbit); }
+ {if (_Fb.open(_S, _M | ios_base::in) == 0)
+ this->setstate(ios::failbit); }
virtual ~basic_ifstream()
{}
_Myfb *rdbuf() const
{return ((_Myfb *)&_Fb); }
bool is_open() const
{return (_Fb.is_open()); }
- void open(const char *_S, ios_base::openmode _M = in)
- {if (_Fb.open(_S, _M | in) == 0)
- setstate(failbit); }
+ void open(const char *_S, ios_base::openmode _M = ios_base::in)
+ {if (_Fb.open(_S, _M | ios_base::in) == 0)
+ this->setstate(ios::failbit); }
void open(const char *_S, ios_base::open_mode _M)
- {open(_S, (openmode)_M); }
+ {open(_S, (ios_base::openmode)_M); }
void close()
{if (_Fb.close() == 0)
- setstate(failbit); }
+ this->setstate(ios::failbit); }
private:
_Myfb _Fb;
};
@@ -297,24 +300,24 @@
basic_ofstream()
: basic_ostream<_E, _Tr>(&_Fb) {}
explicit basic_ofstream(const char *_S,
- ios_base::openmode _M = out | trunc)
+ ios_base::openmode _M = ios_base::out | ios_base::trunc)
: basic_ostream<_E, _Tr>(&_Fb)
- {if (_Fb.open(_S, _M | out) == 0)
- setstate(failbit); }
+ {if (_Fb.open(_S, _M | ios_base::out) == 0)
+ this->setstate(ios_base::failbit); }
virtual ~basic_ofstream()
{}
_Myfb *rdbuf() const
{return ((_Myfb *)&_Fb); }
bool is_open() const
{return (_Fb.is_open()); }
- void open(const char *_S, ios_base::openmode _M = out | trunc)
- {if (_Fb.open(_S, _M | out) == 0)
- setstate(failbit); }
+ void open(const char *_S, ios_base::openmode _M = ios_base::out | ios_base::trunc)
+ {if (_Fb.open(_S, _M | ios_base::out) == 0)
+ this->setstate(ios_base::failbit); }
void open(const char *_S, ios_base::open_mode _M)
- {open(_S, (openmode)_M); }
+ {open(_S, (ios_base::openmode)_M); }
void close()
{if (_Fb.close() == 0)
- setstate(failbit); }
+ this->setstate(ios_base::failbit); }
private:
_Myfb _Fb;
};
@@ -334,24 +337,24 @@
basic_fstream()
: basic_iostream<_E, _Tr>(&_Fb) {}
explicit basic_fstream(const char *_S,
- ios_base::openmode _M = in | out)
+ ios_base::openmode _M = ios_base::in | ios_base::out)
: basic_iostream<_E, _Tr>(&_Fb)
{if (_Fb.open(_S, _M) == 0)
- setstate(failbit); }
+ this->setstate(ios::failbit); }
virtual ~basic_fstream()
{}
basic_filebuf<_E, _Tr> *rdbuf() const
{return ((basic_filebuf<_E, _Tr> *)&_Fb); }
bool is_open() const
{return (_Fb.is_open()); }
- void open(const char *_S, ios_base::openmode _M = in | out)
+ void open(const char *_S, ios_base::openmode _M = ios_base::in | ios_base::out)
{if (_Fb.open(_S, _M) == 0)
- setstate(failbit); }
+ this->setstate(ios::failbit); }
void open(const char *_S, ios_base::open_mode _M)
- {open(_S, (openmode)_M); }
+ {open(_S, (ios_base::openmode)_M); }
void close()
{if (_Fb.close() == 0)
- setstate(failbit); }
+ this->setstate(ios::failbit); }
private:
basic_filebuf<_E, _Tr> _Fb;
};
Modified: gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/functional
===================================================================
--- gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/functional 2007-11-12 10:33:26 UTC (rev 1139)
+++ gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/functional 2007-11-12 11:36:40 UTC (rev 1140)
@@ -155,6 +155,10 @@
: public unary_function<typename _Bfn::second_argument_type,
typename _Bfn::result_type> {
public:
+ typedef typename unary_function<typename _Bfn::second_argument_type,
+ typename _Bfn::result_type>::argument_type argument_type;
+ typedef typename unary_function<typename _Bfn::second_argument_type,
+ typename _Bfn::result_type>::result_type result_type;
binder1st(const _Bfn& _X,
const typename _Bfn::first_argument_type& _Y)
: op(_X), value(_Y) {}
@@ -175,6 +179,10 @@
: public unary_function<typename _Bfn::first_argument_type,
typename _Bfn::result_type> {
public:
+ typedef typename unary_function<typename _Bfn::first_argument_type,
+ typename _Bfn::result_type>::argument_type argument_type;
+ typedef typename unary_function<typename _Bfn::first_argument_type,
+ typename _Bfn::result_type>::result_type result_type;
binder2nd(const _Bfn& _X,
const typename _Bfn::second_argument_type& _Y)
: op(_X), value(_Y) {}
@@ -199,7 +207,8 @@
_R operator()(_A _X) const
{return (_Fn(_X)); }
protected:
- _R (__cdecl *_Fn)(_A);
+ typedef _R (__cdecl *_FnType)(_A);
+ _FnType _Fn;
};
// TEMPLATE CLASS pointer_to_binary_function
template<class _A1, class _A2, class _R>
@@ -212,7 +221,8 @@
_R operator()(_A1 _X, _A2 _Y) const
{return (_Fn(_X, _Y)); }
protected:
- _R (__cdecl *_Fn)(_A1, _A2);
+ typedef _R (__cdecl *_FnType)(_A1, _A2);
+ _FnType _Fn;
};
// TEMPLATE FUNCTION ptr_fun
template<class _A, class _R> inline
Modified: gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/istream
===================================================================
--- gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/istream 2007-11-12 10:33:26 UTC (rev 1139)
+++ gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/istream 2007-11-12 11:36:40 UTC (rev 1140)
@@ -22,10 +22,14 @@
typedef istreambuf_iterator<_E, _Tr> _Iter;
typedef ctype<_E> _Ctype;
typedef num_get<_E, _Iter> _Nget;
+ typedef typename _Myios::pos_type pos_type;
+ typedef typename _Myios::off_type off_type;
+ typedef typename _Myios::iostate iostate;
+ typedef typename _Myios::int_type int_type;
explicit basic_istream(_Mysb *_S, bool _Isstd = false)
: _Chcount(0) {init(_S, _Isstd); }
basic_istream(_Uninitialized)
- {_Addstd(); }
+ {this->_Addstd(); }
virtual ~basic_istream()
{}
class sentry {
@@ -38,21 +42,21 @@
bool _Ok;
};
bool ipfx(bool _Noskip = false)
- {if (good())
- {if (tie() != 0)
- tie()->flush();
- if (!_Noskip && flags() & skipws)
- {const _Ctype& _Fac = _USE(getloc(), _Ctype);
+ {if (this->good())
+ {if (this->tie() != 0)
+ this->tie()->flush();
+ if (!_Noskip && this->flags() & ios_base::skipws)
+ {const _Ctype& _Fac = _USE(this->getloc(), _Ctype);
_TRY_IO_BEGIN
- int_type _C = rdbuf()->sgetc();
+ int_type _C = this->rdbuf()->sgetc();
while (!_Tr::eq_int_type(_Tr::eof(), _C)
&& _Fac.is(_Ctype::space,
_Tr::to_char_type(_C)))
- _C = rdbuf()->snextc();
+ _C = this->rdbuf()->snextc();
_CATCH_IO_END }
- if (good())
+ if (this->good())
return (true); }
- setstate(failbit);
+ this->setstate(ios_base::failbit);
return (false); }
void isfx()
{}
@@ -65,135 +69,135 @@
{(*_F)(*(ios_base *)this);
return (*this); }
_Myt& operator>>(_Bool& _X)
- {iostate _St = goodbit;
+ {iostate _St = ios_base::goodbit;
const sentry _Ok(*this);
if (_Ok)
- {const _Nget& _Fac = _USE(getloc(), _Nget);
+ {const _Nget& _Fac = _USE(this->getloc(), _Nget);
_TRY_IO_BEGIN
- _Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
+ _Fac.get(_Iter(this->rdbuf()), _Iter(0), *this, _St, _X);
_CATCH_IO_END }
setstate(_St);
return (*this); }
_Myt& operator>>(short& _X)
- {iostate _St = goodbit;
+ {iostate _St = ios_base::goodbit;
const sentry _Ok(*this);
if (_Ok)
{long _Y;
- const _Nget& _Fac = _USE(getloc(), _Nget);
+ const _Nget& _Fac = _USE(this->getloc(), _Nget);
_TRY_IO_BEGIN
- _Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _Y);
+ _Fac.get(_Iter(this->rdbuf()), _Iter(0), *this, _St, _Y);
_CATCH_IO_END
- if (_St & failbit || _Y < SHRT_MIN || SHRT_MAX < _Y)
- _St |= failbit;
+ if (_St & ios_base::failbit || _Y < SHRT_MIN || SHRT_MAX < _Y)
+ _St |= ios_base::failbit;
else
_X = (short)_Y; }
setstate(_St);
return (*this); }
_Myt& operator>>(unsigned short& _X)
- {iostate _St = goodbit;
+ {iostate _St = ios_base::goodbit;
const sentry _Ok(*this);
if (_Ok)
- {const _Nget& _Fac = _USE(getloc(), _Nget);
+ {const _Nget& _Fac = _USE(this->getloc(), _Nget);
_TRY_IO_BEGIN
- _Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
+ _Fac.get(_Iter(this->rdbuf()), _Iter(0), *this, _St, _X);
_CATCH_IO_END }
setstate(_St);
return (*this); }
_Myt& operator>>(int& _X)
- {iostate _St = goodbit;
+ {iostate _St = ios_base::goodbit;
const sentry _Ok(*this);
if (_Ok)
{long _Y;
- const _Nget& _Fac = _USE(getloc(), _Nget);
+ const _Nget& _Fac = _USE(this->getloc(), _Nget);
_TRY_IO_BEGIN
- _Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _Y);
+ _Fac.get(_Iter(this->rdbuf()), _Iter(0), *this, _St, _Y);
_CATCH_IO_END
- if (_St & failbit || _Y < INT_MIN || INT_MAX < _Y)
- _St |= failbit;
+ if (_St & ios_base::failbit || _Y < INT_MIN || INT_MAX < _Y)
+ _St |= ios_base::failbit;
else
_X = _Y; }
setstate(_St);
return (*this); }
_Myt& operator>>(unsigned int& _X)
- {iostate _St = goodbit;
+ {iostate _St = ios_base::goodbit;
const sentry _Ok(*this);
if (_Ok)
- {const _Nget& _Fac = _USE(getloc(), _Nget);
+ {const _Nget& _Fac = _USE(this->getloc(), _Nget);
_TRY_IO_BEGIN
- _Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
+ _Fac.get(_Iter(this->rdbuf()), _Iter(0), *this, _St, _X);
_CATCH_IO_END }
setstate(_St);
return (*this); }
_Myt& operator>>(long& _X)
- {iostate _St = goodbit;
+ {iostate _St = ios_base::goodbit;
const sentry _Ok(*this);
if (_Ok)
- {const _Nget& _Fac = _USE(getloc(), _Nget);
+ {const _Nget& _Fac = _USE(this->getloc(), _Nget);
_TRY_IO_BEGIN
- _Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
+ _Fac.get(_Iter(this->rdbuf()), _Iter(0), *this, _St, _X);
_CATCH_IO_END }
setstate(_St);
return (*this); }
_Myt& operator>>(unsigned long& _X)
- {iostate _St = goodbit;
+ {iostate _St = ios_base::goodbit;
const sentry _Ok(*this);
if (_Ok)
- {const _Nget& _Fac = _USE(getloc(), _Nget);
+ {const _Nget& _Fac = _USE(this->getloc(), _Nget);
_TRY_IO_BEGIN
- _Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
+ _Fac.get(_Iter(this->rdbuf()), _Iter(0), *this, _St, _X);
_CATCH_IO_END }
setstate(_St);
return (*this); }
_Myt& operator>>(float& _X)
- {iostate _St = goodbit;
+ {iostate _St = ios_base::goodbit;
const sentry _Ok(*this);
if (_Ok)
- {const _Nget& _Fac = _USE(getloc(), _Nget);
+ {const _Nget& _Fac = _USE(this->getloc(), _Nget);
_TRY_IO_BEGIN
- _Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
+ _Fac.get(_Iter(this->rdbuf()), _Iter(0), *this, _St, _X);
_CATCH_IO_END }
setstate(_St);
return (*this); }
_Myt& operator>>(double& _X)
- {iostate _St = goodbit;
+ {iostate _St = ios_base::goodbit;
const sentry _Ok(*this);
if (_Ok)
- {const _Nget& _Fac = _USE(getloc(), _Nget);
+ {const _Nget& _Fac = _USE(this->getloc(), _Nget);
_TRY_IO_BEGIN
- _Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
+ _Fac.get(_Iter(this->rdbuf()), _Iter(0), *this, _St, _X);
_CATCH_IO_END }
setstate(_St);
return (*this); }
_Myt& operator>>(long double& _X)
- {iostate _St = goodbit;
+ {iostate _St = ios_base::goodbit;
const sentry _Ok(*this);
if (_Ok)
- {const _Nget& _Fac = _USE(getloc(), _Nget);
+ {const _Nget& _Fac = _USE(this->getloc(), _Nget);
_TRY_IO_BEGIN
- _Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
+ _Fac.get(_Iter(this->rdbuf()), _Iter(0), *this, _St, _X);
_CATCH_IO_END }
setstate(_St);
return (*this); }
_Myt& operator>>(void *& _X)
- {iostate _St = goodbit;
+ {iostate _St = ios_base::goodbit;
const sentry _Ok(*this);
if (_Ok)
- {const _Nget& _Fac = _USE(getloc(), _Nget);
+ {const _Nget& _Fac = _USE(this->getloc(), _Nget);
_TRY_IO_BEGIN
- _Fac.get(_Iter(rdbuf()), _Iter(0), *this, _St, _X);
+ _Fac.get(_Iter(this->rdbuf()), _Iter(0), *this, _St, _X);
_CATCH_IO_END }
setstate(_St);
return (*this); }
_Myt& operator>>(_Mysb *_Pb)
- {iostate _St = goodbit;
+ {iostate _St = ios_base::goodbit;
bool _Copied = false;
const sentry _Ok(*this);
if (_Ok && _Pb != 0)
{_TRY_IO_BEGIN
- int_type _C = rdbuf()->sgetc();
- for (; ; _C = rdbuf()->snextc())
+ int_type _C = this->rdbuf()->sgetc();
+ for (; ; _C = this->rdbuf()->snextc())
if (_Tr::eq_int_type(_Tr::eof(), _C))
- {_St |= eofbit;
+ {_St |= ios_base::eofbit;
break; }
else
{_TRY_BEGIN
@@ -205,44 +209,44 @@
_CATCH_END
_Copied = true; }
_CATCH_IO_END }
- setstate(!_Copied ? _St | failbit : _St);
+ setstate(!_Copied ? _St | ios_base::failbit : _St);
return (*this); }
int_type get()
{int_type _C;
- iostate _St = goodbit;
+ iostate _St = ios_base::goodbit;
_Chcount = 0;
const sentry _Ok(*this, true);
if (!_Ok)
_C = _Tr::eof();
else
{_TRY_IO_BEGIN
- _C = rdbuf()->sbumpc();
+ _C = this->rdbuf()->sbumpc();
if (_Tr::eq_int_type(_Tr::eof(), _C))
- _St |= eofbit | failbit;
+ _St |= ios_base::eofbit | ios_base::failbit;
else
++_Chcount;
_CATCH_IO_END }
setstate(_St);
return (_C); }
_Myt& get(_E *_S, streamsize _N)
- {return (get(_S, _N, widen('\n'))); }
+ {return (get(_S, _N, this->widen('\n'))); }
_Myt& get(_E *_S, streamsize _N, _E _D)
- {iostate _St = goodbit;
+ {iostate _St = ios_base::goodbit;
_Chcount = 0;
const sentry _Ok(*this, true);
if (_Ok && 0 < _N)
{_TRY_IO_BEGIN
- int_type _C = rdbuf()->sgetc();
- for (; 0 < --_N; _C = rdbuf()->snextc())
+ int_type _C = this->rdbuf()->sgetc();
+ for (; 0 < --_N; _C = this->rdbuf()->snextc())
if (_Tr::eq_int_type(_Tr::eof(), _C))
- {_St |= eofbit;
+ {_St |= ios_base::eofbit;
break; }
else if (_Tr::to_char_type(_C) == _D)
break;
else
*_S++ = _Tr::to_char_type(_C), ++_Chcount;
_CATCH_IO_END }
- setstate(_Chcount == 0 ? _St | failbit : _St);
+ setstate(_Chcount == 0 ? _St | ios_base::failbit : _St);
*_S = _E(0);
return (*this); }
_Myt& get(_E& _X)
@@ -251,17 +255,17 @@
_X = _Tr::to_char_type(_C);
return (*this); }
_Myt& get(_Mysb& _Sb)
- {return (get(_Sb, widen('\n'))); }
+ {return (get(_Sb, this->widen('\n'))); }
_Myt& get(_Mysb& _Sb, _E _D)
- {iostate _St = goodbit;
+ {iostate _St = ios_base::goodbit;
_Chcount = 0;
const sentry _Ok(*this, true);
if (_Ok)
{_TRY_IO_BEGIN
- int_type _C = rdbuf()->sgetc();
- for (; ; _C = rdbuf()->snextc())
+ int_type _C = this->rdbuf()->sgetc();
+ for (; ; _C = this->rdbuf()->snextc())
if (_Tr::eq_int_type(_Tr::eof(), _C))
- {_St |= eofbit;
+ {_St |= ios_base::eofbit;
break; }
else
{_TRY_BEGIN
@@ -276,39 +280,39 @@
++_Chcount; }
_CATCH_IO_END }
if (_Chcount == 0)
- _St |= failbit;
+ _St |= ios_base::failbit;
setstate(_St);
return (*this); }
_Myt& getline(_E *_S, streamsize _N)
- {return (getline(_S, _N, widen('\n'))); }
+ {return (getline(_S, _N, this->widen('\n'))); }
_Myt& getline(_E *_S, streamsize _N, _E _D)
- {iostate _St = goodbit;
+ {iostate _St = ios_base::goodbit;
_Chcount = 0;
const sentry _Ok(*this, true);
if (_Ok && 0 < _N)
{int_type _Di = _Tr::to_int_type(_D);
_TRY_IO_BEGIN
- int_type _C = rdbuf()->sgetc();
- for (; ; _C = rdbuf()->snextc())
+ int_type _C = this->rdbuf()->sgetc();
+ for (; ; _C = this->rdbuf()->snextc())
if (_Tr::eq_int_type(_Tr::eof(), _C))
- {_St |= eofbit;
+ {_St |= ios_base::eofbit;
break; }
else if (_C == _Di)
{++_Chcount;
- rdbuf()->stossc();
+ this->rdbuf()->stossc();
break; }
else if (--_N <= 0)
- {_St |= failbit;
+ {_St |= ios_base::failbit;
break; }
else
{++_Chcount;
*_S++ = _Tr::to_char_type(_C); }
_CATCH_IO_END }
*_S = _E(0);
- setstate(_Chcount == 0 ? _St | failbit : _St);
+ setstate(_Chcount == 0 ? _St | ios_base::failbit : _St);
return (*this); }
_Myt& ignore(streamsize _N = 1, int_type _Di = _Tr::eof())
- {iostate _St = goodbit;
+ {iostate _St = ios_base::goodbit;
_Chcount = 0;
const sentry _Ok(*this, true);
if (_Ok && 0 < _N)
@@ -318,8 +322,8 @@
if (_N != INT_MAX && --_N < 0)
break;
else if (_Tr::eq_int_type(_Tr::eof(),
- _C = rdbuf()->sbumpc()))
- {_St |= eofbit;
+ _C = this->rdbuf()->sbumpc()))
+ {_St |= ios_base::eofbit;
break; }
else
{++_Chcount;
@@ -329,32 +333,32 @@
setstate(_St);
return (*this); }
_Myt& read(_E *_S, streamsize _N)
- {iostate _St = goodbit;
+ {iostate _St = ios_base::goodbit;
_Chcount = 0;
const sentry _Ok(*this, true);
if (_Ok)
{_TRY_IO_BEGIN
- const streamsize _M = rdbuf()->sgetn(_S, _N);
+ const streamsize _M = this->rdbuf()->sgetn(_S, _N);
_Chcount += _M;
if (_M != _N)
- _St |= eofbit | failbit;
+ _St |= ios_base::eofbit | ios_base::failbit;
_CATCH_IO_END }
setstate(_St);
return (*this); }
streamsize readsome(_E *_S, streamsize _N)
- {iostate _St = goodbit;
+ {iostate _St = ios_base::goodbit;
_Chcount = 0;
int _M;
- if (rdbuf() == 0)
- _St |= failbit;
- else if ((_M = rdbuf()->in_avail()) < 0)
- _St |= eofbit;
+ if (this->rdbuf() == 0)
+ _St |= this->ios_base::failbit;
+ else if ((_M = this->rdbuf()->in_avail()) < 0)
+ _St |= ios_base::eofbit;
else if (0 < _M)
read(_S, _M < _N ? _M : _N);
setstate(_St);
return (gcount()); }
int_type peek()
- {iostate _St = goodbit;
+ {iostate _St = ios_base::goodbit;
_Chcount = 0;
int_type _C;
const sentry _Ok(*this, true);
@@ -363,59 +367,59 @@
else
{_TRY_IO_BEGIN
if (_Tr::eq_int_type(_Tr::eof(),
- _C = rdbuf()->sgetc()))
- _St |= eofbit;
+ _C = this->rdbuf()->sgetc()))
+ _St |= ios_base::eofbit;
_CATCH_IO_END }
setstate(_St);
return (_C); }
_Myt& putback(_E _X)
- {iostate _St = goodbit;
+ {iostate _St = ios_base::goodbit;
_Chcount = 0;
const sentry _Ok(*this, true);
if (_Ok)
{_TRY_IO_BEGIN
if (_Tr::eq_int_type(_Tr::eof(),
- rdbuf()->sputbackc(_X)))
- _St |= badbit;
+ this->rdbuf()->sputbackc(_X)))
+ _St |= ios_base::badbit;
_CATCH_IO_END }
setstate(_St);
return (*this); }
_Myt& unget()
- {iostate _St = goodbit;
+ {iostate _St = ios_base::goodbit;
_Chcount = 0;
const sentry _Ok(*this, true);
if (_Ok)
{_TRY_IO_BEGIN
if (_Tr::eq_int_type(_Tr::eof(),
- rdbuf()->sungetc()))
- _St |= badbit;
+ this->rdbuf()->sungetc()))
+ _St |= ios_base::badbit;
_CATCH_IO_END }
setstate(_St);
return (*this); }
streamsize gcount() const
{return (_Chcount); }
int sync()
- {iostate _St = goodbit;
+ {iostate _St = ios_base::goodbit;
int _Ans;
- if (rdbuf() == 0)
+ if (this->rdbuf() == 0)
_Ans = -1;
- else if (rdbuf()->pubsync() == -1)
- _St |= badbit, _Ans = -1;
+ else if (this->rdbuf()->pubsync() == -1)
+ _St |= ios_base::badbit, _Ans = -1;
else
_Ans = 0;
setstate(_St);
return (_Ans); }
_Myt& seekg(pos_type _P)
- {if (!fail())
- rdbuf()->pubseekpos(_P, in);
+ {if (!this->fail())
+ this->rdbuf()->pubseekpos(_P, ios_base::in);
return (*this); }
_Myt& seekg(off_type _O, ios_base::seekdir _W)
- {if (!fail())
- rdbuf()->pubseekoff(_O, _W, in);
+ {if (!this->fail())
+ this->rdbuf()->pubseekoff(_O, _W, ios_base::in);
return (*this); }
pos_type tellg()
- {if (!fail())
- return (rdbuf()->pubseekoff(0, cur, in));
+ {if (!this->fail())
+ return (this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in));
else
return (streampos(_BADOFF)); }
private:
@@ -458,12 +462,12 @@
typedef ctype<_E> _Ctype;
ios_base::iostate _St = ios_base::goodbit;
_E *_S = _X;
- const _Myis::sentry _Ok(_I);
+ const typename _Myis::sentry _Ok(_I);
if (_Ok)
{const _Ctype& _Fac = _USE(_I.getloc(), _Ctype);
_TRY_IO_BEGIN
int _N = 0 < _I.width() ? _I.width() : INT_MAX;
- _Myis::int_type _C = _I.rdbuf()->sgetc();
+ typename _Myis::int_type _C = _I.rdbuf()->sgetc();
for (; 0 < --_N; _C = _I.rdbuf()->snextc())
if (_Tr::eq_int_type(_Tr::eof(), _C))
{_St |= ios_base::eofbit;
@@ -482,9 +486,9 @@
basic_istream<_E, _Tr>& __cdecl operator>>(
basic_istream<_E, _Tr>& _I, _E& _X)
{typedef basic_istream<_E, _Tr> _Myis;
- _Myis::int_type _C;
- ios_base::iostate _St = ios_base::goodbit;
- const _Myis::sentry _Ok(_I);
+ typename _Myis::int_type _C;
+ typename ios_base::iostate _St = ios_base::goodbit;
+ const typename _Myis::sentry _Ok(_I);
if (_Ok)
{_TRY_IO_BEGIN
_C = _I.rdbuf()->sbumpc();
@@ -521,7 +525,7 @@
{typedef basic_istream<_E, _Tr> _Myis;
typedef ctype<_E> _Ctype;
ios_base::iostate _St = ios_base::goodbit;
- const _Myis::sentry _Ok(_I, true);
+ const typename _Myis::sentry _Ok(_I, true);
if (_Ok)
{const _Ctype& _Fac = _USE(_I.getloc(), _Ctype);
_TRY_IO_BEGIN
Added: gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/limits
===================================================================
--- gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/limits (rev 0)
+++ gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/limits 2007-11-12 11:36:40 UTC (rev 1140)
@@ -0,0 +1,456 @@
+// limits standard header
+
+#if _MSC_VER > 1000
+#pragma once
+#endif
+
+#ifndef _LIMITS_
+#define _LIMITS_
+#include <ymath.h>
+#include <cfloat>
+#include <climits>
+#include <cmath>
+#include <cwchar>
+#include <xstddef>
+
+#ifdef _MSC_VER
+#pragma pack(push,8)
+#endif /* _MSC_VER */
+// ASSUMES:
+// wraparound 2's complement integer arithmetic w/o traps
+// all CHAR_BITs of each byte used by integers
+// IEC559 (IEEE 754) floating-point arithmetic
+// floating-point errors can trap
+// tinyness detected before floating-point rounding
+_STD_BEGIN
+ // ENUM float_round_style
+typedef enum {
+ round_indeterminate = -1, round_toward_zero = 0,
+ round_to_nearest = 1, round_toward_infinity = 2,
+ round_toward_neg_infinity = 3} float_round_style;
+ // STRUCT _Num_base
+struct _CRTIMP _Num_base {
+ _STCONS(bool, has_denorm, false);
+ _STCONS(bool, has_denorm_loss, false);
+ _STCONS(bool, has_infinity, false);
+ _STCONS(bool, has_quiet_NaN, false);
+ _STCONS(bool, has_signaling_NaN, false);
+ _STCONS(bool, is_bounded, false);
+ _STCONS(bool, is_exact, false);
+ _STCONS(bool, is_iec559, false);
+ _STCONS(bool, is_integer, false);
+ _STCONS(bool, is_modulo, false);
+ _STCONS(bool, is_signed, false);
+ _STCONS(bool, is_specialized, false);
+ _STCONS(bool, tinyness_before, false);
+ _STCONS(bool, traps, false);
+ _STCONS(float_round_style, round_style, round_toward_zero);
+ _STCONS(int, digits, 0);
+ _STCONS(int, digits10, 0);
+ _STCONS(int, max_exponent, 0);
+ _STCONS(int, max_exponent10, 0);
+ _STCONS(int, min_exponent, 0);
+ _STCONS(int, min_exponent10, 0);
+ _STCONS(int, radix, 0);
+ };
+#define __GCCXML_AVOID_MACRO_EXPANSION
+ // TEMPLATE CLASS numeric_limits
+template<class _Ty> class numeric_limits : public _Num_base {
+public:
+ static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (_Ty(0)); }
+ static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (_Ty(0)); }
+ static _Ty __cdecl epsilon() _THROW0()
+ {return (_Ty(0)); }
+ static _Ty __cdecl round_error() _THROW0()
+ {return (_Ty(0)); }
+ static _Ty __cdecl denorm_min() _THROW0()
+ {return (_Ty(0)); }
+ static _Ty __cdecl infinity() _THROW0()
+ {return (_Ty(0)); }
+ static _Ty __cdecl quiet_NaN() _THROW0()
+ {return (_Ty(0)); }
+ static _Ty __cdecl signaling_NaN() _THROW0()
+ {return (_Ty(0)); }
+ };
+ // STRUCT _Num_int_base
+struct _CRTIMP _Num_int_base : public _Num_base {
+ _STCONS(bool, is_bounded, true);
+ _STCONS(bool, is_exact, true);
+ _STCONS(bool, is_integer, true);
+ _STCONS(bool, is_modulo, true);
+ _STCONS(bool, is_specialized, true);
+ _STCONS(int, radix, 2);
+ };
+ // STRUCT _Num_float_base
+struct _CRTIMP _Num_float_base : public _Num_base {
+ _STCONS(bool, has_denorm, true);
+ _STCONS(bool, has_denorm_loss, true);
+ _STCONS(bool, has_infinity, true);
+ _STCONS(bool, has_quiet_NaN, true);
+ _STCONS(bool, has_signaling_NaN, true);
+ _STCONS(bool, is_bounded, true);
+ _STCONS(bool, is_exact, false);
+ _STCONS(bool, is_iec559, true);
+ _STCONS(bool, is_integer, false);
+ _STCONS(bool, is_modulo, false);
+ _STCONS(bool, is_signed, true);
+ _STCONS(bool, is_specialized, true);
+ _STCONS(bool, tinyness_before, true);
+ _STCONS(bool, traps, true);
+ _STCONS(float_round_style, round_style, round_to_nearest);
+ _STCONS(int, radix, FLT_RADIX);
+ };
+ // CLASS numeric_limits<char>
+template <>
+class _CRTIMP numeric_limits<char> : public _Num_int_base {
+public:
+ typedef char _Ty;
+ static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (CHAR_MIN); }
+ static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (CHAR_MAX); }
+ static _Ty __cdecl epsilon() _THROW0()
+ {return (0); }
+ static _Ty __cdecl round_error() _THROW0()
+ {return (0); }
+ static _Ty __cdecl denorm_min() _THROW0()
+ {return (0); }
+ static _Ty __cdecl infinity() _THROW0()
+ {return (0); }
+ static _Ty __cdecl quiet_NaN() _THROW0()
+ {return (0); }
+ static _Ty __cdecl signaling_NaN() _THROW0()
+ {return (0); }
+ _STCONS(bool, is_signed, CHAR_MIN < 0);
+ _STCONS(int, digits, CHAR_BIT - (CHAR_MIN < 0 ? 1 : 0));
+ _STCONS(int, digits10, (CHAR_BIT - (CHAR_MIN < 0 ? 1 : 0))
+ * 301L / 1000);
+ };
+ // CLASS numeric_limits<_Bool>
+template<>
+class _CRTIMP numeric_limits<_Bool> : public _Num_int_base {
+public:
+ typedef bool _Ty;
+ static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (false); }
+ static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (true); }
+ static _Ty __cdecl epsilon() _THROW0()
+ {return (0); }
+ static _Ty __cdecl round_error() _THROW0()
+ {return (0); }
+ static _Ty __cdecl denorm_min() _THROW0()
+ {return (0); }
+ static _Ty __cdecl infinity() _THROW0()
+ {return (0); }
+ static _Ty __cdecl quiet_NaN() _THROW0()
+ {return (0); }
+ static _Ty __cdecl signaling_NaN() _THROW0()
+ {return (0); }
+ _STCONS(bool, is_signed, false);
+ _STCONS(int, digits, 1);
+ _STCONS(int, digits10, 0);
+ };
+ // CLASS numeric_limits<signed char>
+template<>
+class _CRTIMP numeric_limits<signed char> : public _Num_int_base {
+public:
+ typedef signed char _Ty;
+ static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (SCHAR_MIN); }
+ static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (SCHAR_MAX); }
+ static _Ty __cdecl epsilon() _THROW0()
+ {return (0); }
+ static _Ty __cdecl round_error() _THROW0()
+ {return (0); }
+ static _Ty __cdecl denorm_min() _THROW0()
+ {return (0); }
+ static _Ty __cdecl infinity() _THROW0()
+ {return (0); }
+ static _Ty __cdecl quiet_NaN() _THROW0()
+ {return (0); }
+ static _Ty __cdecl signaling_NaN() _THROW0()
+ {return (0); }
+ _STCONS(bool, is_signed, true);
+ _STCONS(int, digits, CHAR_BIT - 1);
+ _STCONS(int, digits10, (CHAR_BIT - 1) * 301L / 1000);
+ };
+ // CLASS numeric_limits<unsigned char>
+template<>
+class _CRTIMP numeric_limits<unsigned char> : public _Num_int_base {
+public:
+ typedef unsigned char _Ty;
+ static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (0); }
+ static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (UCHAR_MAX); }
+ static _Ty __cdecl epsilon() _THROW0()
+ {return (0); }
+ static _Ty __cdecl round_error() _THROW0()
+ {return (0); }
+ static _Ty __cdecl denorm_min() _THROW0()
+ {return (0); }
+ static _Ty __cdecl infinity() _THROW0()
+ {return (0); }
+ static _Ty __cdecl quiet_NaN() _THROW0()
+ {return (0); }
+ static _Ty __cdecl signaling_NaN() _THROW0()
+ {return (0); }
+ _STCONS(bool, is_signed, false);
+ _STCONS(int, digits, CHAR_BIT);
+ _STCONS(int, digits10, (CHAR_BIT) * 301L / 1000);
+ };
+ // CLASS numeric_limits<short>
+template<>
+class _CRTIMP numeric_limits<short> : public _Num_int_base {
+public:
+ typedef short _Ty;
+ static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (SHRT_MIN); }
+ static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (SHRT_MAX); }
+ static _Ty __cdecl epsilon() _THROW0()
+ {return (0); }
+ static _Ty __cdecl round_error() _THROW0()
+ {return (0); }
+ static _Ty __cdecl denorm_min() _THROW0()
+ {return (0); }
+ static _Ty __cdecl infinity() _THROW0()
+ {return (0); }
+ static _Ty __cdecl quiet_NaN() _THROW0()
+ {return (0); }
+ static _Ty __cdecl signaling_NaN() _THROW0()
+ {return (0); }
+ _STCONS(bool, is_signed, true);
+ _STCONS(int, digits, CHAR_BIT * sizeof (short) - 1);
+ _STCONS(int, digits10, (CHAR_BIT * sizeof (short) - 1)
+ * 301L / 1000);
+ };
+ // CLASS numeric_limits<unsigned short>
+template<>
+class _CRTIMP numeric_limits<unsigned short> : public _Num_int_base {
+public:
+ typedef unsigned short _Ty;
+ static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (0); }
+ static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (USHRT_MAX); }
+ static _Ty __cdecl epsilon() _THROW0()
+ {return (0); }
+ static _Ty __cdecl round_error() _THROW0()
+ {return (0); }
+ static _Ty __cdecl denorm_min() _THROW0()
+ {return (0); }
+ static _Ty __cdecl infinity() _THROW0()
+ {return (0); }
+ static _Ty __cdecl quiet_NaN() _THROW0()
+ {return (0); }
+ static _Ty __cdecl signaling_NaN() _THROW0()
+ {return (0); }
+ _STCONS(bool, is_signed, false);
+ _STCONS(int, digits, CHAR_BIT * sizeof (unsigned short));
+ _STCONS(int, digits10, (CHAR_BIT * sizeof (unsigned short))
+ * 301L / 1000);
+ };
+ // CLASS numeric_limits<int>
+template<>
+class _CRTIMP numeric_limits<int> : public _Num_int_base {
+public:
+ typedef int _Ty;
+ static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (INT_MIN); }
+ static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (INT_MAX); }
+ static _Ty __cdecl epsilon() _THROW0()
+ {return (0); }
+ static _Ty __cdecl round_error() _THROW0()
+ {return (0); }
+ static _Ty __cdecl denorm_min() _THROW0()
+ {return (0); }
+ static _Ty __cdecl infinity() _THROW0()
+ {return (0); }
+ static _Ty __cdecl quiet_NaN() _THROW0()
+ {return (0); }
+ static _Ty __cdecl signaling_NaN() _THROW0()
+ {return (0); }
+ _STCONS(bool, is_signed, true);
+ _STCONS(int, digits, CHAR_BIT * sizeof (int) - 1);
+ _STCONS(int, digits10, (CHAR_BIT * sizeof (int) - 1)
+ * 301L / 1000);
+ };
+ // CLASS numeric_limits<unsigned int>
+template<>
+class _CRTIMP numeric_limits<unsigned int> : public _Num_int_base {
+public:
+ typedef unsigned int _Ty;
+ static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (0); }
+ static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (UINT_MAX); }
+ static _Ty __cdecl epsilon() _THROW0()
+ {return (0); }
+ static _Ty __cdecl round_error() _THROW0()
+ {return (0); }
+ static _Ty __cdecl denorm_min() _THROW0()
+ {return (0); }
+ static _Ty __cdecl infinity() _THROW0()
+ {return (0); }
+ static _Ty __cdecl quiet_NaN() _THROW0()
+ {return (0); }
+ static _Ty __cdecl signaling_NaN() _THROW0()
+ {return (0); }
+ _STCONS(bool, is_signed, false);
+ _STCONS(int, digits, CHAR_BIT * sizeof (unsigned int));
+ _STCONS(int, digits10, (CHAR_BIT * sizeof (unsigned int))
+ * 301L / 1000);
+ };
+ // CLASS numeric_limits<long>
+template<>
+class _CRTIMP numeric_limits<long> : public _Num_int_base {
+public:
+ typedef long _Ty;
+ static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (LONG_MIN); }
+ static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (LONG_MAX); }
+ static _Ty __cdecl epsilon() _THROW0()
+ {return (0); }
+ static _Ty __cdecl round_error() _THROW0()
+ {return (0); }
+ static _Ty __cdecl denorm_min() _THROW0()
+ {return (0); }
+ static _Ty __cdecl infinity() _THROW0()
+ {return (0); }
+ static _Ty __cdecl quiet_NaN() _THROW0()
+ {return (0); }
+ static _Ty __cdecl signaling_NaN() _THROW0()
+ {return (0); }
+ _STCONS(bool, is_signed, true);
+ _STCONS(int, digits, CHAR_BIT * sizeof (long) - 1);
+ _STCONS(int, digits10, (CHAR_BIT * sizeof (long) - 1)
+ * 301L / 1000);
+ };
+ // CLASS numeric_limits<unsigned long>
+template<>
+class _CRTIMP numeric_limits<unsigned long> : public _Num_int_base {
+public:
+ typedef unsigned long _Ty;
+ static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (0); }
+ static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (ULONG_MAX); }
+ static _Ty __cdecl epsilon() _THROW0()
+ {return (0); }
+ static _Ty __cdecl round_error() _THROW0()
+ {return (0); }
+ static _Ty __cdecl denorm_min() _THROW0()
+ {return (0); }
+ static _Ty __cdecl infinity() _THROW0()
+ {return (0); }
+ static _Ty __cdecl quiet_NaN() _THROW0()
+ {return (0); }
+ static _Ty __cdecl signaling_NaN() _THROW0()
+ {return (0); }
+ _STCONS(bool, is_signed, false);
+ _STCONS(int, digits, CHAR_BIT * sizeof (unsigned long));
+ _STCONS(int, digits10, (CHAR_BIT * sizeof (unsigned long))
+ * 301L / 1000);
+ };
+ // CLASS numeric_limits<float>
+template<>
+class _CRTIMP numeric_limits<float> : public _Num_float_base {
+public:
+ typedef float _Ty;
+ static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (FLT_MIN); }
+ static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (FLT_MAX); }
+ static _Ty __cdecl epsilon() _THROW0()
+ {return (FLT_EPSILON); }
+ static _Ty __cdecl round_error() _THROW0()
+ {return (0.5); }
+ static _Ty __cdecl denorm_min() _THROW0()
+ {return (_FDenorm._F); }
+ static _Ty __cdecl infinity() _THROW0()
+ {return (_FInf._F); }
+ static _Ty __cdecl quiet_NaN() _THROW0()
+ {return (_FNan._F); }
+ static _Ty __cdecl signaling_NaN() _THROW0()
+ {return (_FSnan._F); }
+ _STCONS(int, digits, FLT_MANT_DIG);
+ _STCONS(int, digits10, FLT_DIG);
+ _STCONS(int, max_exponent, FLT_MAX_EXP);
+ _STCONS(int, max_exponent10, FLT_MAX_10_EXP);
+ _STCONS(int, min_exponent, FLT_MIN_EXP);
+ _STCONS(int, min_exponent10, FLT_MIN_10_EXP);
+ };
+ // CLASS numeric_limits<double>
+template<>
+class _CRTIMP numeric_limits<double> : public _Num_float_base {
+public:
+ typedef double _Ty;
+ static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (DBL_MIN); }
+ static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (DBL_MAX); }
+ static _Ty __cdecl epsilon() _THROW0()
+ {return (DBL_EPSILON); }
+ static _Ty __cdecl round_error() _THROW0()
+ {return (0.5); }
+ static _Ty __cdecl denorm_min() _THROW0()
+ {return (_Denorm._D); }
+ static _Ty __cdecl infinity() _THROW0()
+ {return (_Inf._D); }
+ static _Ty __cdecl quiet_NaN() _THROW0()
+ {return (_Nan._D); }
+ static _Ty __cdecl signaling_NaN() _THROW0()
+ {return (_Snan._D); }
+ _STCONS(int, digits, DBL_MANT_DIG);
+ _STCONS(int, digits10, DBL_DIG);
+ _STCONS(int, max_exponent, DBL_MAX_EXP);
+ _STCONS(int, max_exponent10, DBL_MAX_10_EXP);
+ _STCONS(int, min_exponent, DBL_MIN_EXP);
+ _STCONS(int, min_exponent10, DBL_MIN_10_EXP);
+ };
+ // CLASS numeric_limits<long double>
+template<>
+class _CRTIMP numeric_limits<long double> : public _Num_float_base {
+public:
+ typedef long double _Ty;
+ static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (LDBL_MIN); }
+ static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+ {return (LDBL_MAX); }
+ static _Ty __cdecl epsilon() _THROW0()
+ {return (LDBL_EPSILON); }
+ static _Ty __cdecl round_error() _THROW0()
+ {return (0.5); }
+ static _Ty __cdecl denorm_min() _THROW0()
+ {return (_LDenorm._L); }
+ static _Ty __cdecl infinity() _THROW0()
+ {return (_LInf._L); }
+ static _Ty __cdecl quiet_NaN() _THROW0()
+ {return (_LNan._L); }
+ static _Ty __cdecl signaling_NaN() _THROW0()
+ {return (_LSnan._L); }
+ _STCONS(int, digits, LDBL_MANT_DIG);
+ _STCONS(int, digits10, LDBL_DIG);
+ _STCONS(int, max_exponent, LDBL_MAX_EXP);
+ _STCONS(int, max_exponent10, LDBL_MAX_10_EXP);
+ _STCONS(int, min_exponent, LDBL_MIN_EXP);
+ _STCONS(int, min_exponent10, LDBL_MIN_10_EXP);
+ };
+_STD_END
+#ifdef _MSC_VER
+#pragma pack(pop)
+#endif /* _MSC_VER */
+
+#endif /* _LIMITS_ */
+
+/*
+ * Copyright (c) 1995 by P.J. Plauger. ALL RIGHTS RESERVED.
+ * Consult your license regarding permissions and restrictions.
+ */
Modified: gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/list
===================================================================
--- gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/list 2007-11-12 10:33:26 UTC (rev 1139)
+++ gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/list 2007-11-12 11:36:40 UTC (rev 1140)
@@ -98,25 +98,25 @@
iterator(_Nodeptr _P)
: const_iterator(_P) {}
reference operator*() const
- {return (_Acc::_Value(_Ptr)); }
+ {return (_Acc::_Value(this->_Ptr)); }
_Tptr operator->() const
{return (&**this); }
iterator& operator++()
- {_Ptr = _Acc::_Next(_Ptr);
+ {this->_Ptr = _Acc::_Next(this->_Ptr);
return (*this); }
iterator operator++(int)
{iterator _Tmp = *this;
++*this;
return (_Tmp); }
iterator& operator--()
- {_Ptr = _Acc::_Prev(_Ptr);
+ {this->_Ptr = _Acc::_Prev(this->_Ptr);
return (*this); }
iterator operator--(int)
{iterator _Tmp = *this;
--*this;
return (_Tmp); }
bool operator==(const iterator& _X) const
- {return (_Ptr == _X._Ptr); }
+ {return (this->_Ptr == _X._Ptr); }
bool operator!=(const iterator& _X) const
{return (!(*this == _X)); }
};
Modified: gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/map
===================================================================
--- gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/map 2007-11-12 10:33:26 UTC (rev 1139)
+++ gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/map 2007-11-12 11:36:40 UTC (rev 1140)
@@ -43,14 +43,14 @@
typedef _A allocator_type;
typedef typename _A::reference _Tref;
typedef _Tree<_K, value_type, _Kfn, _Pr, _A> _Imp;
- typedef _Imp::size_type size_type;
- typedef _Imp::difference_type difference_type;
- typedef _Imp::reference reference;
- typedef _Imp::const_reference const_reference;
- typedef _Imp::iterator iterator;
- typedef _Imp::const_iterator const_iterator;
- typedef _Imp::reverse_iterator reverse_iterator;
- typedef _Imp::const_reverse_iterator const_reverse_iterator;
+ typedef typename _Imp::size_type size_type;
+ typedef typename _Imp::difference_type difference_type;
+ typedef typename _Imp::reference reference;
+ typedef typename _Imp::const_reference const_reference;
+ typedef typename _Imp::iterator iterator;
+ typedef typename _Imp::const_iterator const_iterator;
+ typedef typename _Imp::reverse_iterator reverse_iterator;
+ typedef typename _Imp::const_reverse_iterator const_reverse_iterator;
typedef pair<iterator, bool> _Pairib;
typedef pair<iterator, iterator> _Pairii;
typedef pair<const_iterator, const_iterator> _Paircc;
@@ -93,18 +93,18 @@
{iterator _P = insert(value_type(_Kv, _Ty())).first;
return ((*_P).second); }
_Pairib insert(const value_type& _X)
- {_Imp::_Pairib _Ans = _Tr.insert(_X);
+ {typename _Imp::_Pairib _Ans = _Tr.insert(_X);
return (_Pairib(_Ans.first, _Ans.second)); }
iterator insert(iterator _P, const value_type& _X)
- {return (_Tr.insert((_Imp::iterator&)_P, _X)); }
+ {return (_Tr.insert((typename _Imp::iterator&)_P, _X)); }
void insert(_It _F, _It _L)
{for (; _F != _L; ++_F)
_Tr.insert(*_F); }
iterator erase(iterator _P)
- {return (_Tr.erase((_Imp::iterator&)_P)); }
+ {return (_Tr.erase((typename _Imp::iterator&)_P)); }
iterator erase(iterator _F, iterator _L)
- {return (_Tr.erase((_Imp::iterator&)_F,
- (_Imp::iterator&)_L)); }
+ {return (_Tr.erase((typename _Imp::iterator&)_F,
+ (typename _Imp::iterator&)_L)); }
size_type erase(const _K& _Kv)
{return (_Tr.erase(_Kv)); }
void clear()
@@ -193,14 +193,14 @@
typedef _Pr key_compare;
typedef _A allocator_type;
typedef _Tree<_K, value_type, _Kfn, _Pr, _A> _Imp;
- typedef _Imp::size_type size_type;
- typedef _Imp::difference_type difference_type;
- typedef _Imp::reference reference;
- typedef _Imp::const_reference const_reference;
- typedef _Imp::iterator iterator;
- typedef _Imp::const_iterator const_iterator;
- typedef _Imp::reverse_iterator reverse_iterator;
- typedef _Imp::const_reverse_iterator const_reverse_iterator;
+ typedef typename _Imp::size_type size_type;
+ typedef typename _Imp::difference_type difference_type;
+ typedef typename _Imp::reference reference;
+ typedef typename _Imp::const_reference const_reference;
+ typedef typename _Imp::iterator iterator;
+ typedef typename _Imp::const_iterator const_iterator;
+ typedef typename _Imp::reverse_iterator reverse_iterator;
+ typedef typename _Imp::const_reverse_iterator const_reverse_iterator;
typedef pair<iterator, iterator> _Pairii;
typedef pair<const_iterator, const_iterator> _Paircc;
explicit multimap(const _Pr& _Pred = _Pr(),
@@ -242,15 +242,15 @@
iterator insert(const value_type& _X)
{return (_Tr.insert(_X).first); }
iterator insert(iterator _P, const value_type& _X)
- {return (_Tr.insert((_Imp::iterator&)_P, _X)); }
+ {return (_Tr.insert((typename _Imp::iterator&)_P, _X)); }
void insert(_It _F, _It _L)
{for (; _F != _L; ++_F)
_Tr.insert(*_F); }
iterator erase(iterator _P)
- {return (_Tr.erase((_Imp::iterator&)_P)); }
+ {return (_Tr.erase((typename _Imp::iterator&)_P)); }
iterator erase(iterator _F, iterator _L)
- {return (_Tr.erase((_Imp::iterator&)_F,
- (_Imp::iterator&)_L)); }
+ {return (_Tr.erase((typename _Imp::iterator&)_F,
+ (typename _Imp::iterator&)_L)); }
size_type erase(const _K& _Kv = _K())
{return (_Tr.erase(_Kv)); }
void clear()
Modified: gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/ostream
===================================================================
--- gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/ostream 2007-11-12 10:33:26 UTC (rev 1139)
+++ gccxml_bin/v09/win32/share/gccxml-0.9/Vc6/Include/ostream 2007-11-12 11:36:40 UTC (rev 1140)
@@ -14,7 +14,7 @@
// I/O exception macros
#define _TRY_IO_BEGIN _TRY_BEGIN
#define _CATCH_IO_END _CATCH_ALL \
- setstate(ios_base::badbit, true); _CATCH_END
+ this->setstate(ios_base::badbit, true); _CATCH_END
#define _CATCH_IO_(x) _CATCH_ALL \
(x).setstate(ios_base::badbit, true); _CATCH_END
_STD_BEGIN
@@ -27,12 +27,17 @@
typedef basic_streambuf<_E, _Tr> _Mysb;
typedef ostreambuf_iterator<_E, _Tr> _Iter;
typedef num_put<_E, _Iter> _Nput;
+ typedef typename _Myios::pos_type pos_type;
+ typedef typename _Myios::off_type off_type;
+ typedef typename _Myios::iostate iostate;
+ typedef typename _Myios::fmtf...
[truncated message content] |
