[pygccxml-commit] SF.net SVN: pygccxml: [1141] gccxml_bin/v09/win32/share/gccxml-0.9/Vc71/ Include

[<rom...@us...>]

Revision: 1141
          http://pygccxml.svn.sourceforge.net/pygccxml/?rev=1141&view=rev
Author:   roman_yakovenko
Date:     2007-11-12 03:38:54 -0800 (Mon, 12 Nov 2007)

Log Message:
-----------
updating to new gccxml build

Added Paths:
-----------
    gccxml_bin/v09/win32/share/gccxml-0.9/Vc71/Include/functional
    gccxml_bin/v09/win32/share/gccxml-0.9/Vc71/Include/limits
    gccxml_bin/v09/win32/share/gccxml-0.9/Vc71/Include/valarray
    gccxml_bin/v09/win32/share/gccxml-0.9/Vc71/Include/vector
    gccxml_bin/v09/win32/share/gccxml-0.9/Vc71/Include/xdebug
    gccxml_bin/v09/win32/share/gccxml-0.9/Vc71/Include/xstring

Added: gccxml_bin/v09/win32/share/gccxml-0.9/Vc71/Include/functional
===================================================================
--- gccxml_bin/v09/win32/share/gccxml-0.9/Vc71/Include/functional	                        (rev 0)
+++ gccxml_bin/v09/win32/share/gccxml-0.9/Vc71/Include/functional	2007-11-12 11:38:54 UTC (rev 1141)
@@ -0,0 +1,687 @@
+// functional standard header
+#pragma once
+#ifndef _FUNCTIONAL_
+#define _FUNCTIONAL_
+#include <xstddef>
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+
+ #pragma warning(disable: 4244)
+_STD_BEGIN
+
+		// TEMPLATE STRUCT unary_function
+template<class _Arg,
+	class _Result>
+	struct unary_function
+	{	// base class for unary functions
+	typedef _Arg argument_type;
+	typedef _Result result_type;
+	};
+
+		// TEMPLATE STRUCT binary_function
+template<class _Arg1,
+	class _Arg2,
+	class _Result>
+	struct binary_function
+	{	// base class for binary functions
+	typedef _Arg1 first_argument_type;
+	typedef _Arg2 second_argument_type;
+	typedef _Result result_type;
+	};
+
+		// TEMPLATE STRUCT plus
+template<class _Ty>
+	struct plus
+		: public binary_function<_Ty, _Ty, _Ty>
+	{	// functor for operator+
+	_Ty operator()(const _Ty& _Left, const _Ty& _Right) const
+		{	// apply operator+ to operands
+		return (_Left + _Right);
+		}
+	};
+
+		// TEMPLATE STRUCT minus
+template<class _Ty>
+	struct minus
+		: public binary_function<_Ty, _Ty, _Ty>
+	{	// functor for operator-
+	_Ty operator()(const _Ty& _Left, const _Ty& _Right) const
+		{	// apply operator- to operands
+		return (_Left - _Right);
+		}
+	};
+
+		// TEMPLATE STRUCT multiplies
+template<class _Ty>
+	struct multiplies
+		: public binary_function<_Ty, _Ty, _Ty>
+	{	// functor for operator*
+	_Ty operator()(const _Ty& _Left, const _Ty& _Right) const
+		{	// apply operator* to operands
+		return (_Left * _Right);
+		}
+	};
+
+		// TEMPLATE STRUCT divides
+template<class _Ty>
+	struct divides
+		: public binary_function<_Ty, _Ty, _Ty>
+	{	// functor for operator/
+	_Ty operator()(const _Ty& _Left, const _Ty& _Right) const
+		{	// apply operator/ to operands
+		return (_Left / _Right);
+		}
+	};
+
+		// TEMPLATE STRUCT modulus
+template<class _Ty>
+	struct modulus
+		: public binary_function<_Ty, _Ty, _Ty>
+	{	// functor for operator%
+	_Ty operator()(const _Ty& _Left, const _Ty& _Right) const
+		{	// apply operator% to operands
+		return (_Left % _Right);
+		}
+	};
+
+		// TEMPLATE STRUCT negate
+template<class _Ty>
+	struct negate
+		: public unary_function<_Ty, _Ty>
+	{	// functor for unary operator-
+	_Ty operator()(const _Ty& _Left) const
+		{	// apply operator- to operand
+		return (-_Left);
+		}
+	};
+
+		// TEMPLATE STRUCT equal_to
+template<class _Ty>
+	struct equal_to
+		: public binary_function<_Ty, _Ty, bool>
+	{	// functor for operator==
+	bool operator()(const _Ty& _Left, const _Ty& _Right) const
+		{	// apply operator== to operands
+		return (_Left == _Right);
+		}
+	};
+
+		// TEMPLATE STRUCT not_equal_to
+template<class _Ty>
+	struct not_equal_to
+		: public binary_function<_Ty, _Ty, bool>
+	{	// functor for operator!=
+	bool operator()(const _Ty& _Left, const _Ty& _Right) const
+		{	// apply operator= to operands
+		return (_Left != _Right);
+		}
+	};
+
+		// TEMPLATE STRUCT greater
+template<class _Ty>
+	struct greater
+		: public binary_function<_Ty, _Ty, bool>
+	{	// functor for operator>
+	bool operator()(const _Ty& _Left, const _Ty& _Right) const
+		{	// apply operator> to operands
+		return (_Left > _Right);
+		}
+	};
+
+		// TEMPLATE STRUCT less
+template<class _Ty>
+	struct less
+		: public binary_function<_Ty, _Ty, bool>
+	{	// functor for operator<
+	bool operator()(const _Ty& _Left, const _Ty& _Right) const
+		{	// apply operator< to operands
+		return (_Left < _Right);
+		}
+	};
+
+		// TEMPLATE STRUCT greater_equal
+template<class _Ty>
+	struct greater_equal
+		: public binary_function<_Ty, _Ty, bool>
+	{	// functor for operator>=
+	bool operator()(const _Ty& _Left, const _Ty& _Right) const
+		{	// apply operator>= to operands
+		return (_Left >= _Right);
+		}
+	};
+
+		// TEMPLATE STRUCT less_equal
+template<class _Ty>
+	struct less_equal
+		: public binary_function<_Ty, _Ty, bool>
+	{	// functor for operator<=
+	bool operator()(const _Ty& _Left, const _Ty& _Right) const
+		{	// apply operator<= to operands
+		return (_Left <= _Right);
+		}
+	};
+
+		// TEMPLATE STRUCT logical_and
+template<class _Ty>
+	struct logical_and
+		: public binary_function<_Ty, _Ty, bool>
+	{	// functor for operator&&
+	bool operator()(const _Ty& _Left, const _Ty& _Right) const
+		{	// apply operator&& to operands
+		return (_Left && _Right);
+		}
+	};
+
+		// TEMPLATE STRUCT logical_or
+template<class _Ty>
+	struct logical_or
+		: public binary_function<_Ty, _Ty, bool>
+	{	// functor for operator||
+	bool operator()(const _Ty& _Left, const _Ty& _Right) const
+		{	// apply operator|| to operands
+		return (_Left || _Right);
+		}
+	};
+
+		// TEMPLATE STRUCT logical_not
+template<class _Ty>
+	struct logical_not
+		: public unary_function<_Ty, bool>
+	{	// functor for unary operator!
+	bool operator()(const _Ty& _Left) const
+		{	// apply operator! to operand
+		return (!_Left);
+		}
+	};
+
+		// TEMPLATE CLASS unary_negate
+template<class _Fn1>
+	class unary_negate
+	: public unary_function<typename _Fn1::argument_type, bool>
+	{	// functor adapter !_Func(left)
+public:
+	explicit unary_negate(const _Fn1& _Func)
+		: _Functor(_Func)
+		{	// construct from functor
+		}
+
+	bool operator()(const typename _Fn1::argument_type& _Left) const
+		{	// apply functor to operand
+		return (!_Functor(_Left));
+		}
+
+protected:
+	_Fn1 _Functor;	// the functor to apply
+	};
+
+		// TEMPLATE FUNCTION not1
+template<class _Fn1> inline
+	unary_negate<_Fn1> not1(const _Fn1& _Func)
+	{	// return a unary_negate functor adapter
+	return (std::unary_negate<_Fn1>(_Func));
+	}
+
+		// TEMPLATE CLASS binary_negate
+template<class _Fn2>
+	class binary_negate
+		: public binary_function<typename _Fn2::first_argument_type,
+			typename _Fn2::second_argument_type, bool>
+	{	// functor adapter !_Func(left, right)
+public:
+	explicit binary_negate(const _Fn2& _Func)
+		: _Functor(_Func)
+		{	// construct from functor
+		}
+
+	bool operator()(const typename _Fn2::first_argument_type& _Left,
+		const typename _Fn2::second_argument_type& _Right) const
+		{	// apply functor to operands
+		return (!_Functor(_Left, _Right));
+		}
+
+protected:
+	_Fn2 _Functor;	// the functor to apply
+	};
+
+		// TEMPLATE FUNCTION not2
+template<class _Fn2> inline
+	binary_negate<_Fn2> not2(const _Fn2& _Func)
+	{	// return a binary_negate functor adapter
+	return (std::binary_negate<_Fn2>(_Func));
+	}
+
+		// TEMPLATE CLASS binder1st
+template<class _Fn2>
+	class binder1st
+		: public unary_function<typename _Fn2::second_argument_type,
+			typename _Fn2::result_type>
+	{	// functor adapter _Func(stored, right)
+public:
+	typedef unary_function<typename _Fn2::second_argument_type,
+		typename _Fn2::result_type> _Base;
+	typedef typename _Base::argument_type argument_type;
+	typedef typename _Base::result_type result_type;
+
+	binder1st(const _Fn2& _Func,
+		const typename _Fn2::first_argument_type& _Left)
+		: op(_Func), value(_Left)
+		{	// construct from functor and left operand
+		}
+
+	result_type operator()(const argument_type& _Right) const
+		{	// apply functor to operands
+		return (op(value, _Right));
+		}
+
+	result_type operator()(argument_type& _Right) const
+		{	// apply functor to operands
+		return (op(value, _Right));
+		}
+
+protected:
+	_Fn2 op;	// the functor to apply
+	typename _Fn2::first_argument_type value;	// the left operand
+	};
+
+		// TEMPLATE FUNCTION bind1st
+template<class _Fn2,
+	class _Ty> inline
+	binder1st<_Fn2> bind1st(const _Fn2& _Func, const _Ty& _Left)
+		{	// return a binder1st functor adapter
+		typename _Fn2::first_argument_type _Val(_Left);
+		return (std::binder1st<_Fn2>(_Func, _Val));
+		}
+
+		// TEMPLATE CLASS binder2nd
+template<class _Fn2>
+	class binder2nd
+		: public unary_function<typename _Fn2::first_argument_type,
+			typename _Fn2::result_type>
+	{	// functor adapter _Func(left, stored)
+public:
+	typedef unary_function<typename _Fn2::first_argument_type,
+		typename _Fn2::result_type> _Base;
+	typedef typename _Base::argument_type argument_type;
+	typedef typename _Base::result_type result_type;
+
+	binder2nd(const _Fn2& _Func,
+		const typename _Fn2::second_argument_type& _Right)
+		: op(_Func), value(_Right)
+		{	// construct from functor and right operand
+		}
+
+	result_type operator()(const argument_type& _Left) const
+		{	// apply functor to operands
+		return (op(_Left, value));
+		}
+
+	result_type operator()(argument_type& _Left) const
+		{	// apply functor to operands
+		return (op(_Left, value));
+		}
+
+protected:
+	_Fn2 op;	// the functor to apply
+	typename _Fn2::second_argument_type value;	// the right operand
+	};
+
+		// TEMPLATE FUNCTION bind2nd
+template<class _Fn2,
+	class _Ty> inline
+	binder2nd<_Fn2> bind2nd(const _Fn2& _Func, const _Ty& _Right)
+	{	// return a binder2nd functor adapter
+	typename _Fn2::second_argument_type _Val(_Right);
+	return (std::binder2nd<_Fn2>(_Func, _Val));
+	}
+
+		// TEMPLATE CLASS pointer_to_unary_function
+template<class _Arg,
+	class _Result>
+	class pointer_to_unary_function
+		: public unary_function<_Arg, _Result>
+	{	// functor adapter (*pfunc)(left)
+public:
+	explicit pointer_to_unary_function(_Result (__cdecl *_Left)(_Arg))
+		: _Pfun(_Left)
+		{	// construct from pointer
+		}
+
+	_Result operator()(_Arg _Left) const
+		{	// call function with operand
+		return (_Pfun(_Left));
+		}
+
+protected:
+	typedef _Result (__cdecl *_PfunType)(_Arg);
+        _PfunType _Pfun;  // the function pointer
+	};
+
+		// TEMPLATE CLASS pointer_to_binary_function
+template<class _Arg1,
+	class _Arg2,
+	class _Result>
+	class pointer_to_binary_function
+		: public binary_function<_Arg1, _Arg2, _Result>
+	{	// functor adapter (*pfunc)(left, right)
+public:
+	explicit pointer_to_binary_function(
+		_Result (__cdecl *_Left)(_Arg1, _Arg2))
+		: _Pfun(_Left)
+		{	// construct from pointer
+		}
+
+	_Result operator()(_Arg1 _Left, _Arg2 _Right) const
+		{	// call function with operands
+		return (_Pfun(_Left, _Right));
+		}
+
+protected:
+	typedef _Result (__cdecl *_PfunType)(_Arg1, _Arg2);
+        _PfunType _Pfun;  // the function pointer
+	};
+
+		// TEMPLATE FUNCTION ptr_fun
+template<class _Arg,
+	class _Result> inline
+	pointer_to_unary_function<_Arg, _Result>
+		ptr_fun(_Result (__cdecl *_Left)(_Arg))
+	{	// return pointer_to_unary_function functor adapter
+	return (std::pointer_to_unary_function<_Arg, _Result>(_Left));
+	}
+
+template<class _Arg1,
+	class _Arg2,
+	class _Result> inline
+	pointer_to_binary_function<_Arg1, _Arg2, _Result>
+		ptr_fun(_Result (__cdecl *_Left)(_Arg1, _Arg2))
+	{	// return pointer_to_binary_function functor adapter
+	return (std::pointer_to_binary_function<_Arg1, _Arg2, _Result>(_Left));
+	}
+
+		// TEMPLATE CLASS mem_fun_t
+template<class _Result,
+	class _Ty>
+	class mem_fun_t
+		: public unary_function<_Ty *, _Result>
+	{	// functor adapter (*p->*pfunc)(), non-const *pfunc
+public:
+	explicit mem_fun_t(_Result (_Ty::*_Pm)())
+		: _Pmemfun(_Pm)
+		{	// construct from pointer
+		}
+
+	_Result operator()(_Ty *_Pleft) const
+		{	// call function
+		return ((_Pleft->*_Pmemfun)());
+		}
+
+private:
+	_Result (_Ty::*_Pmemfun)();	// the member function pointer
+	};
+
+		// TEMPLATE CLASS mem_fun1_t
+template<class _Result,
+	class _Ty,
+	class _Arg>
+	class mem_fun1_t
+		: public binary_function<_Ty *, _Arg, _Result>
+	{	// functor adapter (*p->*pfunc)(val), non-const *pfunc
+public:
+	explicit mem_fun1_t(_Result (_Ty::*_Pm)(_Arg))
+		: _Pmemfun(_Pm)
+		{	// construct from pointer
+		}
+
+	_Result operator()(_Ty *_Pleft, _Arg _Right) const
+		{	// call function with operand
+		return ((_Pleft->*_Pmemfun)(_Right));
+		}
+
+private:
+	_Result (_Ty::*_Pmemfun)(_Arg);	// the member function pointer
+	};
+
+		// TEMPLATE CLASS const_mem_fun_t
+template<class _Result,
+	class _Ty>
+	class const_mem_fun_t
+		: public unary_function<const _Ty *, _Result>
+	{	// functor adapter (*p->*pfunc)(), const *pfunc
+public:
+	explicit const_mem_fun_t(_Result (_Ty::*_Pm)() const)
+		: _Pmemfun(_Pm)
+		{	// construct from pointer
+		}
+
+	_Result operator()(const _Ty *_Pleft) const
+		{	// call function
+		return ((_Pleft->*_Pmemfun)());
+		}
+
+private:
+	_Result (_Ty::*_Pmemfun)() const;	// the member function pointer
+	};
+
+		// TEMPLATE CLASS const_mem_fun1_t
+template<class _Result,
+	class _Ty,
+	class _Arg>
+	class const_mem_fun1_t
+		: public binary_function<const _Ty *, _Arg, _Result>
+	{	// functor adapter (*p->*pfunc)(val), const *pfunc
+public:
+	explicit const_mem_fun1_t(_Result (_Ty::*_Pm)(_Arg) const)
+		: _Pmemfun(_Pm)
+		{	// construct from pointer
+		}
+
+	_Result operator()(const _Ty *_Pleft, _Arg _Right) const
+		{	// call function with operand
+		return ((_Pleft->*_Pmemfun)(_Right));
+		}
+
+private:
+	_Result (_Ty::*_Pmemfun)(_Arg) const;	// the member function pointer
+	};
+
+		// TEMPLATE FUNCTION mem_fun
+template<class _Result,
+	class _Ty> inline
+	mem_fun_t<_Result, _Ty> mem_fun(_Result (_Ty::*_Pm)())
+	{	// return a mem_fun_t functor adapter
+	return (std::mem_fun_t<_Result, _Ty>(_Pm));
+	}
+
+template<class _Result,
+	class _Ty,
+	class _Arg> inline
+	mem_fun1_t<_Result, _Ty, _Arg> mem_fun(_Result (_Ty::*_Pm)(_Arg))
+	{	// return a mem_fun1_t functor adapter
+	return (std::mem_fun1_t<_Result, _Ty, _Arg>(_Pm));
+	}
+
+template<class _Result,
+	class _Ty> inline
+	const_mem_fun_t<_Result, _Ty>
+		mem_fun(_Result (_Ty::*_Pm)() const)
+	{	// return a const_mem_fun_t functor adapter
+	return (std::const_mem_fun_t<_Result, _Ty>(_Pm));
+	}
+
+template<class _Result,
+	class _Ty,
+	class _Arg> inline
+	const_mem_fun1_t<_Result, _Ty, _Arg>
+		mem_fun(_Result (_Ty::*_Pm)(_Arg) const)
+	{	// return a const_mem_fun1_t functor adapter
+	return (std::const_mem_fun1_t<_Result, _Ty, _Arg>(_Pm));
+	}
+
+		// TEMPLATE FUNCTION mem_fun1 (retained)
+template<class _Result,
+	class _Ty,
+	class _Arg> inline
+	mem_fun1_t<_Result, _Ty, _Arg> mem_fun1(_Result (_Ty::*_Pm)(_Arg))
+	{	// return a mem_fun1_t functor adapter
+	return (std::mem_fun1_t<_Result, _Ty, _Arg>(_Pm));
+	}
+
+		// TEMPLATE CLASS mem_fun_ref_t
+template<class _Result,
+	class _Ty>
+	class mem_fun_ref_t
+		: public unary_function<_Ty, _Result>
+	{	// functor adapter (*left.*pfunc)(), non-const *pfunc
+public:
+	explicit mem_fun_ref_t(_Result (_Ty::*_Pm)())
+		: _Pmemfun(_Pm)
+		{	// construct from pointer
+		}
+
+	_Result operator()(_Ty& _Left) const
+		{	// call function
+		return ((_Left.*_Pmemfun)());
+		}
+
+private:
+	_Result (_Ty::*_Pmemfun)();	// the member function pointer
+	};
+
+		// TEMPLATE CLASS mem_fun1_ref_t
+template<class _Result,
+	class _Ty,
+	class _Arg>
+	class mem_fun1_ref_t
+		: public binary_function<_Ty, _Arg, _Result>
+	{	// functor adapter (*left.*pfunc)(val), non-const *pfunc
+public:
+	explicit mem_fun1_ref_t(_Result (_Ty::*_Pm)(_Arg))
+		: _Pmemfun(_Pm)
+		{	// construct from pointer
+		}
+
+	_Result operator()(_Ty& _Left, _Arg _Right) const
+		{	// call function with operand
+		return ((_Left.*_Pmemfun)(_Right));
+		}
+
+private:
+	_Result (_Ty::*_Pmemfun)(_Arg);	// the member function pointer
+	};
+
+		// TEMPLATE CLASS const_mem_fun_ref_t
+template<class _Result,
+	class _Ty>
+	class const_mem_fun_ref_t
+		: public unary_function<_Ty, _Result>
+	{	// functor adapter (*left.*pfunc)(), const *pfunc
+public:
+	explicit const_mem_fun_ref_t(_Result (_Ty::*_Pm)() const)
+		: _Pmemfun(_Pm)
+		{	// construct from pointer
+		}
+
+	_Result operator()(const _Ty& _Left) const
+		{	// call function
+		return ((_Left.*_Pmemfun)());
+		}
+
+private:
+	_Result (_Ty::*_Pmemfun)() const;	// the member function pointer
+	};
+
+		// TEMPLATE CLASS const_mem_fun1_ref_t
+template<class _Result,
+	class _Ty,
+	class _Arg>
+	class const_mem_fun1_ref_t
+		: public binary_function<_Ty, _Arg, _Result>
+	{	// functor adapter (*left.*pfunc)(val), const *pfunc
+public:
+	explicit const_mem_fun1_ref_t(_Result (_Ty::*_Pm)(_Arg) const)
+		: _Pmemfun(_Pm)
+		{	// construct from pointer
+		}
+
+	_Result operator()(const _Ty& _Left, _Arg _Right) const
+		{	// call function with operand
+		return ((_Left.*_Pmemfun)(_Right));
+		}
+
+private:
+	_Result (_Ty::*_Pmemfun)(_Arg) const;	// the member function pointer
+	};
+
+		// TEMPLATE FUNCTION mem_fun_ref
+template<class _Result,
+	class _Ty> inline
+	mem_fun_ref_t<_Result, _Ty> mem_fun_ref(_Result (_Ty::*_Pm)())
+	{	// return a mem_fun_ref_t functor adapter
+	return (std::mem_fun_ref_t<_Result, _Ty>(_Pm));
+	}
+
+template<class _Result,
+	class _Ty,
+	class _Arg> inline
+	mem_fun1_ref_t<_Result, _Ty, _Arg>
+		mem_fun_ref(_Result (_Ty::*_Pm)(_Arg))
+	{	// return a mem_fun1_ref_t functor adapter
+	return (std::mem_fun1_ref_t<_Result, _Ty, _Arg>(_Pm));
+	}
+
+template<class _Result,
+	class _Ty> inline
+	const_mem_fun_ref_t<_Result, _Ty>
+		mem_fun_ref(_Result (_Ty::*_Pm)() const)
+	{	// return a const_mem_fun_ref_t functor adapter
+	return (std::const_mem_fun_ref_t<_Result, _Ty>(_Pm));
+	}
+
+template<class _Result,
+	class _Ty,
+	class _Arg> inline
+	const_mem_fun1_ref_t<_Result, _Ty, _Arg>
+		mem_fun_ref(_Result (_Ty::*_Pm)(_Arg) const)
+	{	// return a const_mem_fun1_ref_t functor adapter
+	return (std::const_mem_fun1_ref_t<_Result, _Ty, _Arg>(_Pm));
+	}
+
+		// TEMPLATE FUNCTION mem_fun1_ref (retained)
+template<class _Result,
+	class _Ty,
+	class _Arg> inline
+	mem_fun1_ref_t<_Result, _Ty, _Arg> mem_fun1_ref(_Result (_Ty::*_Pm)(_Arg))
+	{	// return a mem_fun1_ref_t functor adapter
+	return (std::mem_fun1_ref_t<_Result, _Ty, _Arg>(_Pm));
+	}
+_STD_END
+
+  #pragma warning(default: 4244)
+
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif /* _FUNCTIONAL_ */
+
+/*
+ * Copyright (c) 1992-2002 by P.J. Plauger.  ALL RIGHTS RESERVED.
+ * Consult your license regarding permissions and restrictions.
+ */
+
+/*
+ * This file is derived from software bearing the following
+ * restrictions:
+ *
+ * Copyright (c) 1994
+ * Hewlett-Packard Company
+ *
+ * Permission to use, copy, modify, distribute and sell this
+ * software and its documentation for any purpose is hereby
+ * granted without fee, provided that the above copyright notice
+ * appear in all copies and that both that copyright notice and
+ * this permission notice appear in supporting documentation.
+ * Hewlett-Packard Company makes no representations about the
+ * suitability of this software for any purpose. It is provided
+ * "as is" without express or implied warranty.
+ V3.13:0009 */

Added: gccxml_bin/v09/win32/share/gccxml-0.9/Vc71/Include/limits
===================================================================
--- gccxml_bin/v09/win32/share/gccxml-0.9/Vc71/Include/limits	                        (rev 0)
+++ gccxml_bin/v09/win32/share/gccxml-0.9/Vc71/Include/limits	2007-11-12 11:38:54 UTC (rev 1141)
@@ -0,0 +1,1016 @@
+// limits standard header
+#pragma once
+#ifndef _LIMITS_
+#define _LIMITS_
+#include <ymath.h>
+#include <cfloat>
+#include <climits>
+#include <cmath>
+#include <cwchar>
+#include <xstddef>
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+_STD_BEGIN
+
+//	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
+//	64-bit long long (if _LONGLONG defined)
+
+		// ENUM float_denorm_style
+typedef enum
+	{	// constants for different IEEE float denormalization styles
+	denorm_indeterminate = -1,
+	denorm_absent = 0,
+	denorm_present = 1}
+		float_denorm_style;
+
+		// ENUM float_round_style
+typedef enum
+	{	// constants for different IEEE rounding styles
+	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 _CRTIMP2 _Num_base
+	{	// base for all types, with common defaults
+	_STCONS(float_denorm_style, has_denorm, denorm_absent);
+	_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
+	{	// numeric limits for arbitrary type _Ty (say little or nothing)
+public:
+	static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return minimum value
+		return (_Ty(0));
+		}
+
+	static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return maximum value
+		return (_Ty(0));
+		}
+
+	static _Ty __cdecl epsilon() _THROW0()
+		{	// return smallest effective increment from 1.0
+		return (_Ty(0));
+		}
+
+	static _Ty __cdecl round_error() _THROW0()
+		{	// return largest rounding error
+		return (_Ty(0));
+		}
+
+	static _Ty __cdecl denorm_min() _THROW0()
+		{	// return minimum denormalized value
+		return (_Ty(0));
+		}
+
+	static _Ty __cdecl infinity() _THROW0()
+		{	// return positive infinity
+		return (_Ty(0));
+		}
+
+	static _Ty __cdecl quiet_NaN() _THROW0()
+		{	// return non-signaling NaN
+		return (_Ty(0));
+		}
+
+	static _Ty __cdecl signaling_NaN() _THROW0()
+		{	// return signaling NaN
+		return (_Ty(0));
+		}
+	};
+
+		// STRUCT _Num_int_base
+struct _CRTIMP2 _Num_int_base
+	: public _Num_base
+	{	// base for integer types
+	_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 _CRTIMP2 _Num_float_base
+	: public _Num_base
+	{	// base for floating-point types
+	_STCONS(float_denorm_style, has_denorm, denorm_present);
+	_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 _CRTIMP2 numeric_limits<char>
+	: public _Num_int_base
+	{	// limits for type char
+public:
+	typedef char _Ty;
+
+	static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return minimum value
+		return (CHAR_MIN);
+		}
+
+	static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return maximum value
+		return (CHAR_MAX);
+		}
+
+	static _Ty __cdecl epsilon() _THROW0()
+		{	// return smallest effective increment from 1.0
+		return (0);
+		}
+
+	static _Ty __cdecl round_error() _THROW0()
+		{	// return largest rounding error
+		return (0);
+		}
+
+	static _Ty __cdecl denorm_min() _THROW0()
+		{	// return minimum denormalized value
+		return (0);
+		}
+
+	static _Ty __cdecl infinity() _THROW0()
+		{	// return positive infinity
+		return (0);
+		}
+
+	static _Ty __cdecl quiet_NaN() _THROW0()
+		{	// return non-signaling NaN
+		return (0);
+		}
+
+	static _Ty __cdecl signaling_NaN() _THROW0()
+		{	// return signaling NaN
+		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);
+	};
+
+ #ifdef _NATIVE_WCHAR_T_DEFINED
+		// CLASS numeric_limits<wchar_t>
+template<> class _CRTIMP2 numeric_limits<wchar_t>
+	: public _Num_int_base
+	{	// limits for type wchar_t
+public:
+	typedef wchar_t _Ty;
+
+	static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return minimum value
+		return ((_Ty)WCHAR_MIN);
+		}
+
+	static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return maximum value
+		return ((_Ty)WCHAR_MAX);
+		}
+
+	static _Ty __cdecl epsilon() _THROW0()
+		{	// return smallest effective increment from 1.0
+		return (0);
+		}
+
+	static _Ty __cdecl round_error() _THROW0()
+		{	// return largest rounding error
+		return (0);
+		}
+
+	static _Ty __cdecl denorm_min() _THROW0()
+		{	// return minimum denormalized value
+		return (0);
+		}
+
+	static _Ty __cdecl infinity() _THROW0()
+		{	// return positive infinity
+		return (0);
+		}
+
+	static _Ty __cdecl quiet_NaN() _THROW0()
+		{	// return non-signaling NaN
+		return (0);
+		}
+
+	static _Ty __cdecl signaling_NaN() _THROW0()
+		{	// return signaling NaN
+		return (0);
+		}
+
+	_STCONS(bool, is_signed, WCHAR_MIN != 0);
+	_STCONS(int, digits, CHAR_BIT * sizeof (wchar_t)
+		- (WCHAR_MIN != 0 ? 1 : 0));
+	_STCONS(int, digits10, (CHAR_BIT * sizeof (wchar_t)
+		- (WCHAR_MIN != 0 ? 1 : 0)) * 301L / 1000);
+	};
+ #endif /* _NATIVE_WCHAR_T_DEFINED */
+
+		// CLASS numeric_limits<_Bool>
+template<> class _CRTIMP2 numeric_limits<_Bool>
+	: public _Num_int_base
+	{	// limits for type bool
+public:
+	typedef bool _Ty;
+
+	static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return minimum value
+		return (false);
+		}
+
+	static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return maximum value
+		return (true);
+		}
+
+	static _Ty __cdecl epsilon() _THROW0()
+		{	// return smallest effective increment from 1.0
+		return (0);
+		}
+
+	static _Ty __cdecl round_error() _THROW0()
+		{	// return largest rounding error
+		return (0);
+		}
+
+	static _Ty __cdecl denorm_min() _THROW0()
+		{	// return minimum denormalized value
+		return (0);
+		}
+
+	static _Ty __cdecl infinity() _THROW0()
+		{	// return positive infinity
+		return (0);
+		}
+
+	static _Ty __cdecl quiet_NaN() _THROW0()
+		{	// return non-signaling NaN
+		return (0);
+		}
+
+	static _Ty __cdecl signaling_NaN() _THROW0()
+		{	// return signaling NaN
+		return (0);
+		}
+
+	_STCONS(bool, is_modulo, false);
+	_STCONS(bool, is_signed, false);
+	_STCONS(int, digits, 1);
+	_STCONS(int, digits10, 0);
+	};
+
+		// CLASS numeric_limits<signed char>
+template<> class _CRTIMP2 numeric_limits<signed char>
+	: public _Num_int_base
+	{	// limits for type signed char
+public:
+	typedef signed char _Ty;
+
+	static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return minimum value
+		return (SCHAR_MIN);
+		}
+
+	static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return maximum value
+		return (SCHAR_MAX);
+		}
+
+	static _Ty __cdecl epsilon() _THROW0()
+		{	// return smallest effective increment from 1.0
+		return (0);
+		}
+
+	static _Ty __cdecl round_error() _THROW0()
+		{	// return largest rounding error
+		return (0);
+		}
+
+	static _Ty __cdecl denorm_min() _THROW0()
+		{	// return minimum denormalized value
+		return (0);
+		}
+
+	static _Ty __cdecl infinity() _THROW0()
+		{	// return positive infinity
+		return (0);
+		}
+
+	static _Ty __cdecl quiet_NaN() _THROW0()
+		{	// return non-signaling NaN
+		return (0);
+		}
+
+	static _Ty __cdecl signaling_NaN() _THROW0()
+		{	// return signaling NaN
+		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 _CRTIMP2 numeric_limits<unsigned char>
+	: public _Num_int_base
+	{	// limits for type unsigned char
+public:
+	typedef unsigned char _Ty;
+
+	static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return minimum value
+		return (0);
+		}
+
+	static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return maximum value
+		return (UCHAR_MAX);
+		}
+
+	static _Ty __cdecl epsilon() _THROW0()
+		{	// return smallest effective increment from 1.0
+		return (0);
+		}
+
+	static _Ty __cdecl round_error() _THROW0()
+		{	// return largest rounding error
+		return (0);
+		}
+
+	static _Ty __cdecl denorm_min() _THROW0()
+		{	// return minimum denormalized value
+		return (0);
+		}
+
+	static _Ty __cdecl infinity() _THROW0()
+		{	// return positive infinity
+		return (0);
+		}
+
+	static _Ty __cdecl quiet_NaN() _THROW0()
+		{	// return non-signaling NaN
+		return (0);
+		}
+
+	static _Ty __cdecl signaling_NaN() _THROW0()
+		{	// return signaling NaN
+		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 _CRTIMP2 numeric_limits<short>
+	: public _Num_int_base
+	{	// limits for type short
+public:
+	typedef short _Ty;
+
+	static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return minimum value
+		return (SHRT_MIN);
+		}
+
+	static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return maximum value
+		return (SHRT_MAX);
+		}
+
+	static _Ty __cdecl epsilon() _THROW0()
+		{	// return smallest effective increment from 1.0
+		return (0);
+		}
+
+	static _Ty __cdecl round_error() _THROW0()
+		{	// return largest rounding error
+		return (0);
+		}
+
+	static _Ty __cdecl denorm_min() _THROW0()
+		{	// return minimum denormalized value
+		return (0);
+		}
+
+	static _Ty __cdecl infinity() _THROW0()
+		{	// return positive infinity
+		return (0);
+		}
+
+	static _Ty __cdecl quiet_NaN() _THROW0()
+		{	// return non-signaling NaN
+		return (0);
+		}
+
+	static _Ty __cdecl signaling_NaN() _THROW0()
+		{	// return signaling NaN
+		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 _CRTIMP2 numeric_limits<unsigned short>
+	: public _Num_int_base
+	{	// limits for type unsigned short
+public:
+	typedef unsigned short _Ty;
+
+	static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return minimum value
+		return (0);
+		}
+
+	static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return maximum value
+		return (USHRT_MAX);
+		}
+
+	static _Ty __cdecl epsilon() _THROW0()
+		{	// return smallest effective increment from 1.0
+		return (0);
+		}
+
+	static _Ty __cdecl round_error() _THROW0()
+		{	// return largest rounding error
+		return (0);
+		}
+
+	static _Ty __cdecl denorm_min() _THROW0()
+		{	// return minimum denormalized value
+		return (0);
+		}
+
+	static _Ty __cdecl infinity() _THROW0()
+		{	// return positive infinity
+		return (0);
+		}
+
+	static _Ty __cdecl quiet_NaN() _THROW0()
+		{	// return non-signaling NaN
+		return (0);
+		}
+
+	static _Ty __cdecl signaling_NaN() _THROW0()
+		{	// return signaling NaN
+		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 _CRTIMP2 numeric_limits<int>
+	: public _Num_int_base
+	{	// limits for type int
+public:
+	typedef int _Ty;
+
+	static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return minimum value
+		return (INT_MIN);
+		}
+
+	static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return maximum value
+		return (INT_MAX);
+		}
+
+	static _Ty __cdecl epsilon() _THROW0()
+		{	// return smallest effective increment from 1.0
+		return (0);
+		}
+
+	static _Ty __cdecl round_error() _THROW0()
+		{	// return largest rounding error
+		return (0);
+		}
+
+	static _Ty __cdecl denorm_min() _THROW0()
+		{	// return minimum denormalized value
+		return (0);
+		}
+
+	static _Ty __cdecl infinity() _THROW0()
+		{	// return positive infinity
+		return (0);
+		}
+
+	static _Ty __cdecl quiet_NaN() _THROW0()
+		{	// return non-signaling NaN
+		return (0);
+		}
+
+	static _Ty __cdecl signaling_NaN() _THROW0()
+		{	// return signaling NaN
+		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 _CRTIMP2 numeric_limits<unsigned int>
+	: public _Num_int_base
+	{	// limits for type unsigned int
+public:
+	typedef unsigned int _Ty;
+
+	static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return minimum value
+		return (0);
+		}
+
+	static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return maximum value
+		return (UINT_MAX);
+		}
+
+	static _Ty __cdecl epsilon() _THROW0()
+		{	// return smallest effective increment from 1.0
+		return (0);
+		}
+
+	static _Ty __cdecl round_error() _THROW0()
+		{	// return largest rounding error
+		return (0);
+		}
+
+	static _Ty __cdecl denorm_min() _THROW0()
+		{	// return minimum denormalized value
+		return (0);
+		}
+
+	static _Ty __cdecl infinity() _THROW0()
+		{	// return positive infinity
+		return (0);
+		}
+
+	static _Ty __cdecl quiet_NaN() _THROW0()
+		{	// return non-signaling NaN
+		return (0);
+		}
+
+	static _Ty __cdecl signaling_NaN() _THROW0()
+		{	// return signaling NaN
+		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 _CRTIMP2 numeric_limits<long>
+	: public _Num_int_base
+	{	// limits for type long
+public:
+	typedef long _Ty;
+
+	static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return minimum value
+		return (LONG_MIN);
+		}
+
+	static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return maximum value
+		return (LONG_MAX);
+		}
+
+	static _Ty __cdecl epsilon() _THROW0()
+		{	// return smallest effective increment from 1.0
+		return (0);
+		}
+
+	static _Ty __cdecl round_error() _THROW0()
+		{	// return largest rounding error
+		return (0);
+		}
+
+	static _Ty __cdecl denorm_min() _THROW0()
+		{	// return minimum denormalized value
+		return (0);
+		}
+
+	static _Ty __cdecl infinity() _THROW0()
+		{	// return positive infinity
+		return (0);
+		}
+
+	static _Ty __cdecl quiet_NaN() _THROW0()
+		{	// return non-signaling NaN
+		return (0);
+		}
+
+	static _Ty __cdecl signaling_NaN() _THROW0()
+		{	// return signaling NaN
+		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 _CRTIMP2 numeric_limits<unsigned long>
+	: public _Num_int_base
+	{	// limits for type unsigned long
+public:
+	typedef unsigned long _Ty;
+
+	static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return minimum value
+		return (0);
+		}
+
+	static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return maximum value
+		return (ULONG_MAX);
+		}
+
+	static _Ty __cdecl epsilon() _THROW0()
+		{	// return smallest effective increment from 1.0
+		return (0);
+		}
+
+	static _Ty __cdecl round_error() _THROW0()
+		{	// return largest rounding error
+		return (0);
+		}
+
+	static _Ty __cdecl denorm_min() _THROW0()
+		{	// return minimum denormalized value
+		return (0);
+		}
+
+	static _Ty __cdecl infinity() _THROW0()
+		{	// return positive infinity
+		return (0);
+		}
+
+	static _Ty __cdecl quiet_NaN() _THROW0()
+		{	// return non-signaling NaN
+		return (0);
+		}
+
+	static _Ty __cdecl signaling_NaN() _THROW0()
+		{	// return signaling NaN
+		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);
+	};
+
+ #ifdef _LONGLONG
+		// CLASS numeric_limits<_LONGLONG>
+template<> class _CRTIMP2 numeric_limits<_LONGLONG>
+	: public _Num_int_base
+	{	// limits for type long long
+public:
+	typedef _LONGLONG _Ty;
+
+	static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return minimum value
+		return (-_LLONG_MAX - _C2);
+		}
+
+	static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return maximum value
+		return (_LLONG_MAX);
+		}
+
+	static _Ty __cdecl epsilon() _THROW0()
+		{	// return smallest effective increment from 1.0
+		return (0);
+		}
+
+	static _Ty __cdecl round_error() _THROW0()
+		{	// return largest rounding error
+		return (0);
+		}
+
+	static _Ty __cdecl denorm_min() _THROW0()
+		{	// return minimum denormalized value
+		return (0);
+		}
+
+	static _Ty __cdecl infinity() _THROW0()
+		{	// return positive infinity
+		return (0);
+		}
+
+	static _Ty __cdecl quiet_NaN() _THROW0()
+		{	// return non-signaling NaN
+		return (0);
+		}
+
+	static _Ty __cdecl signaling_NaN() _THROW0()
+		{	// return signaling NaN
+		return (0);
+		}
+
+	_STCONS(bool, is_signed, true);
+	_STCONS(int, digits, CHAR_BIT * sizeof (_LONGLONG) - 1);
+	_STCONS(int, digits10, (CHAR_BIT * sizeof (_LONGLONG) - 1)
+		* 301L / 1000);
+	};
+
+		// CLASS numeric_limits<_ULONGLONG>
+template<> class _CRTIMP2 numeric_limits<_ULONGLONG>
+	: public _Num_int_base
+	{	// limits for type unsigned long long
+public:
+	typedef _ULONGLONG _Ty;
+
+	static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return minimum value
+		return (0);
+		}
+
+	static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return maximum value
+		return (_ULLONG_MAX);
+		}
+
+	static _Ty __cdecl epsilon() _THROW0()
+		{	// return smallest effective increment from 1.0
+		return (0);
+		}
+
+	static _Ty __cdecl round_error() _THROW0()
+		{	// return largest rounding error
+		return (0);
+		}
+
+	static _Ty __cdecl denorm_min() _THROW0()
+		{	// return minimum denormalized value
+		return (0);
+		}
+
+	static _Ty __cdecl infinity() _THROW0()
+		{	// return positive infinity
+		return (0);
+		}
+
+	static _Ty __cdecl quiet_NaN() _THROW0()
+		{	// return non-signaling NaN
+		return (0);
+		}
+
+	static _Ty __cdecl signaling_NaN() _THROW0()
+		{	// return signaling NaN
+		return (0);
+		}
+
+	_STCONS(bool, is_signed, false);
+	_STCONS(int, digits, CHAR_BIT * sizeof (_ULONGLONG));
+	_STCONS(int, digits10, (CHAR_BIT * sizeof (_ULONGLONG))
+		* 301L / 1000);
+	};
+ #endif /* _LONGLONG */
+
+		// CLASS numeric_limits<float>
+template<> class _CRTIMP2 numeric_limits<float>
+	: public _Num_float_base
+	{	// limits for type float
+public:
+	typedef float _Ty;
+
+	static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return minimum value
+		return (FLT_MIN);
+		}
+
+	static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return maximum value
+		return (FLT_MAX);
+		}
+
+	static _Ty __cdecl epsilon() _THROW0()
+		{	// return smallest effective increment from 1.0
+		return (FLT_EPSILON);
+		}
+
+	static _Ty __cdecl round_error() _THROW0()
+		{	// return largest rounding error
+		return (0.5);
+		}
+
+	static _Ty __cdecl denorm_min() _THROW0()
+		{	// return minimum denormalized value
+		return (_FDenorm._Float);
+		}
+
+	static _Ty __cdecl infinity() _THROW0()
+		{	// return positive infinity
+		return (_FInf._Float);
+		}
+
+	static _Ty __cdecl quiet_NaN() _THROW0()
+		{	// return non-signaling NaN
+		return (_FNan._Float);
+		}
+
+	static _Ty __cdecl signaling_NaN() _THROW0()
+		{	// return signaling NaN
+		return (_FSnan._Float);
+		}
+
+	_STCONS(int, digits, FLT_MANT_DIG);
+	_STCONS(int, digits10, FLT_DIG);
+	_STCONS(int, max_exponent, (int)FLT_MAX_EXP);
+	_STCONS(int, max_exponent10, (int)FLT_MAX_10_EXP);
+	_STCONS(int, min_exponent, (int)FLT_MIN_EXP);
+	_STCONS(int, min_exponent10, (int)FLT_MIN_10_EXP);
+	};
+
+		// CLASS numeric_limits<double>
+template<> class _CRTIMP2 numeric_limits<double>
+	: public _Num_float_base
+	{	// limits for type double
+public:
+	typedef double _Ty;
+
+	static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return minimum value
+		return (DBL_MIN);
+		}
+
+	static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return maximum value
+		return (DBL_MAX);
+		}
+
+	static _Ty __cdecl epsilon() _THROW0()
+		{	// return smallest effective increment from 1.0
+		return (DBL_EPSILON);
+		}
+
+	static _Ty __cdecl round_error() _THROW0()
+		{	// return largest rounding error
+		return (0.5);
+		}
+
+	static _Ty __cdecl denorm_min() _THROW0()
+		{	// return minimum denormalized value
+		return (_Denorm._Double);
+		}
+
+	static _Ty __cdecl infinity() _THROW0()
+		{	// return positive infinity
+		return (_Inf._Double);
+		}
+
+	static _Ty __cdecl quiet_NaN() _THROW0()
+		{	// return non-signaling NaN
+		return (_Nan._Double);
+		}
+
+	static _Ty __cdecl signaling_NaN() _THROW0()
+		{	// return signaling NaN
+		return (_Snan._Double);
+		}
+
+	_STCONS(int, digits, DBL_MANT_DIG);
+	_STCONS(int, digits10, DBL_DIG);
+	_STCONS(int, max_exponent, (int)DBL_MAX_EXP);
+	_STCONS(int, max_exponent10, (int)DBL_MAX_10_EXP);
+	_STCONS(int, min_exponent, (int)DBL_MIN_EXP);
+	_STCONS(int, min_exponent10, (int)DBL_MIN_10_EXP);
+	};
+
+		// CLASS numeric_limits<long double>
+template<> class _CRTIMP2 numeric_limits<long double>
+	: public _Num_float_base
+	{	// limits for type long double
+public:
+	typedef long double _Ty;
+
+	static _Ty __cdecl min __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return minimum value
+		return (LDBL_MIN);
+		}
+
+	static _Ty __cdecl max __GCCXML_AVOID_MACRO_EXPANSION() _THROW0()
+		{	// return maximum value
+		return (LDBL_MAX);
+		}
+
+	static _Ty __cdecl epsilon() _THROW0()
+		{	// return smallest effective increment from 1.0
+		return (LDBL_EPSILON);
+		}
+
+	static _Ty __cdecl round_error() _THROW0()
+		{	// return largest rounding error
+		return (0.5);
+		}
+
+	static _Ty __cdecl denorm_min() _THROW0()
+		{	// return minimum denormalized value
+		return (_LDenorm._Long_double);
+		}
+
+	static _Ty __cdecl infinity() _THROW0()
+		{	// return positive infinity
+		return (_LInf._Long_double);
+		}
+
+	static _Ty __cdecl quiet_NaN() _THROW0()
+		{	// return non-signaling NaN
+		return (_LNan._Long_double);
+		}
+
+	static _Ty __cdecl signaling_NaN() _THROW0()
+		{	// return signaling NaN
+		return (_LSnan._Long_double);
+		}
+
+	_STCONS(int, digits, LDBL_MANT_DIG);
+	_STCONS(int, digits10, LDBL_DIG);
+	_STCONS(int, max_exponent, (int)LDBL_MAX_EXP);
+	_STCONS(int, max_exponent10, (int)LDBL_MAX_10_EXP);
+	_STCONS(int, min_exponent, (int)LDBL_MIN_EXP);
+	_STCONS(int, min_exponent10, (int)LDBL_MIN_10_EXP);
+	};
+_STD_END
+#pragma warning(pop)
+#pragma pack(pop)
+
+#endif /* _LIMITS_ */
+
+/*
+ * Copyright (c) 1992-2002 by P.J. Plauger.  ALL RIGHTS RESERVED.
+ * Consult your license regarding permissions and restrictions.
+ V3.13:0009 */

Added: gccxml_bin/v09/win32/share/gccxml-0.9/Vc71/Include/valarray
===================================================================
--- gccxml_bin/v09/win32/share/gccxml-0.9/Vc71/Include/valarray	                        (rev 0)
+++ gccxml_bin/v09/win32/share/gccxml-0.9/Vc71/Include/valarray	2007-11-12 11:38:54 UTC (rev 1141)
@@ -0,0 +1,1550 @@
+// valarray standard header
+#pragma once
+#ifndef _VALARRAY_
+#define _VALARRAY_
+#include <cmath>
+#include <xstddef>
+
+#define __GCCXML_AVOID_MACRO_EXPANSION
+
+#pragma pack(push,8)
+#pragma warning(push,3)
+
+ #pragma warning(disable: 4244 4700)
+_STD_BEGIN
+
+		// FORWARD REFERENCES
+class gslice;
+class slice;
+
+template<class _Ty>
+	class gslice_array;
+template<class _Ty>
+	class indirect_array;
+template<class _Ty>
+	class mask_array;
+template<class _Ty>
+	class slice_array;
+template<class _Ty>
+	class valarray;
+
+typedef valarray<_Bool> _Boolarray;
+typedef valarray<size_t> _Sizarray;
+
+		// MACROS FOR valarray
+#define _VALOP(TYPE, LENGTH, RHS)	/* assign RHS(_Idx) to new valarray */ \
+	valarray<TYPE> _Ans(LENGTH); \
+	for (size_t _Idx = 0; _Idx < _Ans.size(); ++_Idx) \
+		_Ans[_Idx] = RHS; \
+	return _Ans
+
+#define _VALGOP(RHS)	/* apply RHS(_Idx) to valarray */ \
+	for (size_t _Idx = 0; _Idx < size(); ++_Idx) \
+		_Myptr[_Idx] RHS; \
+	return *this
+
+		// TEMPLATE CLASS valarray
+template<class _Ty>
+	class valarray
+	{	// store array with various indexing options
+public:
+	typedef _Ty value_type;
+
+	explicit valarray(size_t _Count = 0)
+		{	// construct with _Count * _Ty()
+		_Tidy();
+		_Myres = _Count;
+		_Grow(_Count);
+		}
+
+	valarray(const _Ty& _Val, size_t _Count)
+		{	// construct with _Count * _Val
+		_Tidy();
+		_Grow(_Count, &_Val);
+		}
+
+	valarray(const _Ty *_Ptr, size_t _Count)
+		{	// construct with [_Ptr, _Ptr + _Count)
+		_Tidy();
+		_Grow(_Count, _Ptr, 1);
+		}
+
+	valarray(const valarray<_Ty>& _Right)
+		{	// construct from valarray
+		_Tidy();
+		_Grow(_Right.size(), _Right._Myptr, 1);
+		}
+
+	valarray(const slice_array<_Ty>& _Slicearr)
+		{	// construct from slice_array
+		_Tidy();
+		*this = _Slicearr;
+		}
+
+	valarray(const gslice_array<_Ty>& _Gslicearr)
+		{	// construct from gslice_array
+		_Tidy();
+		*this = _Gslicearr;
+		}
+
+	valarray(const mask_array<_Ty>& _Maskarr)
+		{	// construct from mask_array
+		_Tidy();
+		*this = _Maskarr;
+		}
+
+	valarray(const indirect_array<_Ty>& _Indarr)
+		{	// construct from indirect_array
+		_Tidy();
+		*this = _Indarr;
+		}
+
+	~valarray()
+		{	// destroy the object
+		_Tidy(true);
+		}
+
+	valarray<_Ty>& operator=(const valarray<_Ty>& _Right)
+		{	// assign valarray _Right
+		if (this == &_Right)
+			;	// do nothing
+		else if (size() == _Right.size())
+			for (size_t _Idx = 0; _Idx < size(); ++_Idx)
+				_Myptr[_Idx] = _Right[_Idx];
+		else
+			{	// resize and copy
+			_Tidy(true);
+			_Grow(_Right.size(), _Right._Myptr, 1);
+			}
+		return (*this);
+		}
+
+	valarray<_Ty>& operator=(const _Ty& _Val)
+		{	// assign _Val to each element
+		_VALGOP(= _Val);
+		}
+
+	void resize(size_t _Newsize)
+		{	// determine new length, padding with _Ty() elements as needed
+		resize(_Newsize, _Ty());
+		}
+
+	void resize(size_t _Newsize, const _Ty _Val)
+		{	// determine new length, padding with _Val elements as needed
+		_Grow(_Newsize, &_Val, 0, true);
+		}
+
+	valarray<_Ty>& operator=(
+		const slice_array<_Ty>& _Slicearr);	// defined below
+
+	valarray<_Ty>& operator=(
+		const gslice_array<_Ty>& _Gslicearr);	// defined below
+
+	valarray<_Ty>& operator=(
+		const mask_array<_Ty>& _Maskarr);	// defined below
+
+	valarray<_Ty>& operator=(
+		const indirect_array<_Ty>& _Indarr);	// defined below
+
+	valarray<_Ty> operator+() const
+		{	// return +valarray
+		_VALOP(_Ty, size(), +_Myptr[_Idx]);
+		}
+
+	valarray<_Ty> operator-() const
+		{	// return -valarray
+		_VALOP(_Ty, size(), -_Myptr[_Idx]);
+		}
+
+	valarray<_Ty> operator~() const
+		{	// return ~valarray
+		_VALOP(_Ty, size(), ~_Myptr[_Idx]);
+		}
+
+	_Boolarray  operator!() const
+		{	// return !valarray
+		_VALOP(_Bool, size(), !_Myptr[_Idx]);
+		}
+
+	valarray<_Ty>& operator*=(const _Ty& _Right)
+		{	// multiply valarray elements by _Right
+		_VALGOP(*= _Right);
+		}
+
+	valarray<_Ty>& operator/=(const _Ty& _Right)
+		{	// divide valarray elements by _Right
+		_VALGOP(/= _Right);
+		}
+
+	valarray<_Ty>& operator%=(const _Ty& _Right)
+		{	// remainder valarray elements by _Right
+		_VALGOP(%= _Right);
+		}
+
+	valarray<_Ty>& operator+=(const _Ty& _Right)
+		{	// add _Right to valarray elements
+		_VALGOP(+= _Right);
+		}
+
+	valarray<_Ty>& operator-=(const _Ty& _Right)
+		{	// subtract _Right from valarray elements
+		_VALGOP(-= _Right);
+		}
+
+	valarray<_Ty>& operator^=(const _Ty& _Right)
+		{	// XOR _Right into valarray elements
+		_VALGOP(^= _Right);
+		}
+
+	valarray<_Ty>& operator&=(const _Ty& _Right)
+		{	// AND _Right into valarray elements
+		_VALGOP(&= _Right);
+		}
+
+	valarray<_Ty>& operator|=(const _Ty& _Right)
+		{	// OR _Right into valarray elements
+		_VALGOP(|= _Right);
+		}
+
+	valarray<_Ty>& operator<<=(const _Ty& _Right)
+		{	// left shift valarray elements by _Right
+		_VALGOP(<<= _Right);
+		}
+
+	valarray<_Ty>& operator>>=(const _Ty& _Right)
+		{	// right shift valarray elements by _Right
+		_VALGOP(>>= _Right);
+		}
+
+	valarray<_Ty>& operator*=(const valarray<_Ty>& _Right)
+		{	// multiply valarray elements by valarray _Right elements
+		_VALGOP(*= _Right[_Idx]);
+		}
+
+	valarray<_Ty>& operator/=(const valarray<_Ty>& _Right)
+		{	// divide valarray elements by valarray _Right elements
+		_VALGOP(/= _Right[_Idx]);
+		}
+
+	valarray<_Ty>& operator%=(const valarray<_Ty>& _Right)
+		{	// remainder valarray elements by valarray _Right elements
+		_VALGOP(%= _Right[_Idx]);
+		}
+
+	valarray<_Ty>& operator+=(const valarray<_Ty>& _Right)
+		{	// add valarray _Right elements to valarray elements
+		_VALGOP(+= _Right[_Idx]);
+		}
+
+	valarray<_Ty>& operator-=(const valarray<_Ty>& _Right)
+		{	// subtract valarray _Right elements from valarray elements
+		_VALGOP(-= _Right[_Idx]);
+		}
+
+	valarray<_Ty>& operator^=(const valarray<_Ty>& _Right)
+		{	// XOR valarray _Right elements into valarray elements
+		_VALGOP(^= _Right[_Idx]);
+		}
+
+	valarray<_Ty>& operator|=(const valarray<_Ty>& _Right)
+		{	// OR valarray _Right elements into valarray elements
+		_VALGOP(|= _Right[_Idx]);
+		}
+
+	valarray<_Ty>& operator&=(const valarray<_Ty>& _Right)
+		{	// AND valarray _Right elements into valarray elements
+		_VALGOP(&= _Right[_Idx]);
+		}
+
+	valarray<_Ty>& operator<<=(const valarray<_Ty>& _Right)
+		{	// left shift valarray elements by valarray _Right elements
+		_VALGOP(<<= _Right[_Idx]);
+		}
+
+	valarray<_Ty>& operator>>=(const valarray<_Ty>& _Right)
+		{	// right shift valarray elements by valarray _Right elements
+		_VALGOP(>>= _Right[_Idx]);
+		}
+
+	size_t size() const
+		{	// return length of sequence
+		return (_Mysize);
+		}
+
+	_Ty operator[](size_t _Off) const
+		{	// subscript nonmutable sequence
+		return (_Myptr[_Off]);
+		}
+
+	_Ty& operator[](size_t _Off)
+		{	// subscript mutable sequence
+		return (_Myptr[_Off]);
+		}
+
+	valarray<_Ty> operator[](
+		slice _Slicearr) const;	// defined below
+
+	slice_array<_Ty> operator[](
+		slice _Slicearr);	// defined below
+
+	valarray<_Ty> operator[](
+		const gslice& _Gslicearr) const;	// defined below
+
+	gslice_array<_Ty> operator[](
+		const gslice& _Gslicearr);	// defined below
+
+	valarray<_Ty> operator[](
+		const _Boolarray& _Boolarr) const;	// defined below
+
+	mask_array<_Ty> operator[](
+		const _Boolarray& _Boolarr);	// defined below
+
+	valarray<_Ty> operator[](
+		const _Sizarray& _Indarr) const;	// defined below
+
+	indirect_array<_Ty> operator[](
+		const _Sizarray& _Indarr);	// defined below
+
+	_Ty sum() const
+		{	// return sum all elements
+		_Ty _Sum = _Myptr[0];
+		for (size_t _Idx = 0; ++_Idx < size(); )
+			_Sum += _Myptr[_Idx];
+		return (_Sum);
+		}
+
+	_Ty min __GCCXML_AVOID_MACRO_EXPANSION() const
+		{	// return smallest of all elements
+		_Ty _Min = _Myptr[0];
+		for (size_t _Idx = 0; ++_Idx < size(); )
+			if (_Myptr[_Idx] < _Min)
+				_Min = _Myptr[_Idx];
+		return (_Min);
+		}
+
+	_Ty max __GCCXML_AVOID_MACRO_EXPANSION() const
+		{	// return largest of all elements
+		_Ty _Max = _Myptr[0];
+		for (size_t _Idx = 0; ++_Idx < size(); )
+			if (_Max < _Myptr[_Idx])
+				_Max = _Myptr[_Idx];
+		return (_Max);
+		}
+
+	valarray<_Ty> shift(int _Count) const
+		{	// return valarray left shifted
+		static _Ty _Dflt;
+		_VALOP(_Ty, size(),
+			0 < _Count && size() - _Idx <= (size_t)_Count
+				|| _Count < 0 && _Idx  < (size_t)-_Count
+					? _Dflt : _Myptr[_Idx + _Count]);
+		}
+
+	valarray<_Ty> cshift(int _Count) const
+		{	// return valarray left rotated
+		if (size() == 0)
+			;	// no shift
+		else if (_Count < 0)
+			{	// right shift
+			if ((_Count += size()) < 0)
+				_Count = size() - (-_Count) % size();
+			}
+		else if (size() <= (size_t)_Count)
+			_Count %= size();
+
+		_VALOP(_Ty, size(), size() - _Idx <= (size_t)_Count
+			? _Myptr[_Idx - size() + _Count] : _Myptr[_Idx + _Count]);
+		}
+
+	valarray<_Ty> apply(_Ty _Func(_Ty)) const
+		{	// return valarray transformed by _Func, value argument
+		_VALOP(_Ty, size(), _Func(_Myptr[_Idx]));
+		}
+
+	valarray<_Ty> apply(_Ty _Func(const _Ty&)) const
+		{	// return valarray transformed by _Func, nonmutable argument
+		_VALOP(_Ty, size(), _Func(_Myptr[_Idx]));
+		}
+
+	void free()	// retained
+		{	// erase all elements
+		_Tidy(true);
+		}
+
+private:
+	void _Grow(size_t _Count,
+		const _Ty *_Ptr = 0,
+		size_t _Inc = 0,
+		bool _Trim = false)
+		{	// grow to _Count elements and pad, trim if _Trim is true
+		size_t _Oldsize = _Myptr == 0 ? 0 : _Myres;
+
+		if (_Count == 0)
+			{	// new sequence empty
+			if (_Trim)
+				_Tidy(true);
+			}
+		else if (_Count == _Oldsize || _Count < _Oldsize && !_Trim)
+			;	// big enough, no need to pad or trim
+		else
+			{	// allocate new array, copy and pad
+			size_t _Idx;
+			size_t _Newsize = _Myptr == 0 && _Count < _Myres
+				? _Myres : _Count;
+			_Ty *_Newptr = 0;
+			size_t _Nm = _Count < _Mysize ? _Count : _Mysize;
+
+			_TRY_BEGIN
+			_Newptr = new _Ty[_Newsize];
+			_CATCH_ALL
+			_Tidy(true);	// allocation failed, discard storage and reraise
+			_RERAISE;
+			_CATCH_END
+
+			for (_Idx = 0; _Idx < _Nm; ++_Idx)
+				_Newptr[_Idx] = _Myptr[_Idx];
+			if (_Ptr != 0)
+				for (; _Idx < _Newsize; ++_Idx, _Ptr += _Inc)
+					_Newptr[_Idx] = *_Ptr;
+
+			_Tidy(true);
+			_Myptr = _Newptr;
+			_Myres = _Newsize;
+			}
+		_Mysize = _Count;
+		}
+
+	void _Tidy(bool _Constructed = false)
+		{	// initialize the object, freeing any allocated storage
+		if (_Constructed && _Myptr != 0)
+			delete[] _Myptr;
+		_Mysize = 0;
+		_Myptr = 0;
+		_Myres = 0;
+		}
+
+	_Ty *_Myptr;	// current storage reserved for array
+	size_t _Mysize;	// current length of sequence
+	size_t _Myres;	// length of array
+	};
+
+		// valarray TEMPLATE FUNCTIONS
+template<class _Ty> inline
+	valarray<_Ty> operator*(const valarray<_Ty>& _Left,
+		const _Ty& _Right)
+	{	// return valarray * scalar
+	_VALOP(_Ty, _Left.size(), _Left[_Idx] * _Right);
+	}
+
+template<class _Ty> inline
+	valarray<_Ty> operator*(const _Ty& _Left,
+		const valarray<_Ty>& _Right)
+	{	// return scalar * valarray
+	_VALOP(_Ty, _Right.size(), _Left * _Right[_Idx]);
+	}
+
+template<class _Ty> inline
+	valarray<_Ty> operator/(const valarray<_Ty>& _Left,
+		const _Ty& _Right)
+	{	// return valarray / scalar
+	_VALOP(_Ty, _Left.size(), _Left[_Idx] / _Right);
+	}
+
+template<class _Ty> inline
+	valarray<_Ty> operator/(const _Ty& _Left,
+		const valarray<_Ty>& _Right)
+	{	// return scalar / valarray
+	_VALOP(_Ty, _Right.size(), _Left / _Right[_Idx]);
+	}
+
+template<class _Ty> inline
+	valarray<_Ty> operator%(const valarray<_Ty>& _Left,
+		const _Ty& _Right)
+	{	// return valarray % scalar
+	_VALOP(_Ty, _Left.size(), _Left[_Idx] % _Right);
+	}
+
+template<class _Ty> inline
+	valarray<_Ty> operator%(const _Ty& _Left,
+		const valarray<_Ty>& _Right)
+	{	// return scalar % valarray
+	_VALOP(_Ty, _Right.size(), _Left % _Right[_Idx]);
+	}
+
+template<class _Ty> inline
+	valarray<_Ty> operator+(const valarray<_Ty>& _Left,
+		const _Ty& _Right)
+	{	// return valarray + scalar
+	_VALOP(_Ty, _Left.size(), _Left[_Idx] + _Right);
+	}
+
+template<class _Ty> inline
+	valarray<_Ty> operator+(const _Ty& _Left,
+		const valarray<_Ty>& _Right)
+	{	// return scalar + valarray
+	_VALOP(_Ty, _Right.size(), _Left + _Right[_Idx]);
+	}
+
+template<class _Ty> inline
+	valarray<_Ty> operator-(const valarray<_Ty>& _Left,
+		const _Ty& _Right)
+	{	// return valarray - scalar
+	_VALOP(_Ty, _Left.size(), _Left[_Idx] - _Right);
+	}
+
+template<class _Ty> inline
+	valarray<_Ty> operator-(const _Ty& _Left,
+		const valarray<_Ty>& _Right)
+	{	// return scalar - valarray
+	_VALOP(_Ty, _Right.size(), _Left - _Right[_Idx]);
+	}
+
+template<class _Ty> inline
+	valarray<_Ty> operator^(const valarray<_Ty>& _Left,
+		const _Ty& _Right)
+	{	// return valarray ^ scalar
+	_VALOP(_Ty, _Left.size(), _Left[_Idx] ^ _Right);
+	}
+
+template<class _Ty> inline
+	valarray<_Ty> operator^(const _Ty& _Left,
+		const valarray<_Ty>& _Right)
+	{	// return scalar ^ valarray
+	_VALOP(_Ty, _Right.size(), _Left ^ _Right[_Idx]);
+	}
+
+template<class _Ty> inline
+	valarray<_Ty> operator&(const valarray<_Ty>& _Left,
+		const _Ty& _Right)
+	{	// return valarray & scalar
+	_VALOP(_Ty, _Left.size(), _Left[_Idx] & _Right);
+	}
+
+template<class _Ty> inline
+	valarray<_Ty> operator&(const _Ty& _Left,
+		const valarray<_Ty>& _Right)
+	{	// return scalar & valarray
+	_VALOP(_Ty, _Right.size(), _Left & _Right[_Idx]);
+	}
+
+template<class _Ty> inline
+	valarray<_Ty> operator|(const valarray<_Ty>& _Left,
+		const _Ty& _Right)
+	{	// return valarray | scalar
+	_VALOP(_Ty, _Left.size(), _Left[_Idx] | _Right);
+	}
+
+template<class _Ty> inline
+	valarray<_Ty> operator|(const _Ty& _Left,
+		const valarray<_Ty>& _Right)
+	{	// return scalar | valarray
+	_VALOP(_Ty, _Right.size(), _Left | _Right[_Idx]);
+	}
+
+template<class _Ty> inline
+	valarray<_Ty> operator<<(const valarray<_Ty>& _Left,
+		const _Ty& _Right)
+	{	// return valarray << scalar
+	_VALOP(_Ty, _Left.size(), _Left[_Idx] << _Right);
+	}
+
+template<class _Ty> inline
+	valarray<_Ty> operator<<(const _Ty& _Left,
+		const valarray<_Ty>& _Right)
+	{	// return scalar << valarray
+	_VALOP(_Ty, _Right.size(), _Left << _Right[_Idx]);
+	}
+
+template<class _Ty> inline
+	valarray<_Ty> operator>>(const valarray<_Ty>& _Left,
+		const _Ty& _Right)
+	{	// return valarray >> scalar
+	_VALOP(_Ty, _Left.size(), _Left[_Idx] >> _Right);
+	}
+
+template<class _Ty> inline
+	valarray<_Ty> operator>>(const _Ty& _Left,
+		const valarray<_Ty>& _Right)
+	{	// return scalar >> valarray
+	_VALOP(_Ty, _Right.size(), _Left >> _Right[_Idx]);
+	}
+
+template<class _Ty> inline
+	_Boolarray operator&&(const valarray<_Ty>& _Left,
+		const _Ty& _Right)
+	{	// return valarray && scalar
+	_VALOP(_Bool, _Left.size(), _Left[_Idx] && _Right);
+	}
+
+template<class _Ty> inline
+	_Boolarray operator&&(const _Ty& _Left,
+		const valarray<_Ty>& _Right)
+	{	// return scalar && valarray
+	_VALOP(_Bool, _Right.size(), _Left && _Right[_Idx]);
+	}
+
+template<class _Ty> inline
+	_Boolarray operator||(const valarray<_Ty>& _Left,
+		const _Ty& _Right)
+	{	// return valarray || scalar
+	_VALOP(_Bool, _Left.size(), _Left[_Idx] || _Right);
+	}
+
+template<class _Ty> inline
+	_Boolarray operator||(const _Ty& _Left,
+		const valarray<_Ty>& _Right)
+	{	// return scalar || valarray
+	_VALOP(_Bool, _Right.size(), _Left || _Right[_Idx]);
+	}
+
+template<class _Ty> inline
+	valarray<_Ty> operator*(const valarray<_Ty>& _Left,
+		const valarray<_Ty>& _Right)
+	{	// return valarray * valarray
+	_VALOP(_Ty, _Left.size(), _Left[_Idx] * _Right[_Idx]);
+	}
+
+template<class _Ty> inline
+	valarray<_Ty> operator/(const valarray<_Ty>& _Left,
+		const valarray<_Ty>& _Right)
+	{	// return valarray ? valarray
+	_VALOP(_Ty, _Left.size(), _Left[_Idx] / _Right[_Idx]);
+	}
+
+template<class _Ty> inline
+	valarray<_Ty> operator%(const valarray<_Ty>& _Left,
+		const valarray<_Ty>& _Right)
+	{	// return valarray % valarray
+	_VALOP(_Ty, _Left.size(), _Left[_Idx] % _Right[_Idx]);
+	}
+
+template<class _Ty> inline
+	valarray<_Ty> operator+(const valarray<_Ty>& _Left,
+		const valarray<...
 
[truncated message content]