zorba-coders team mailing list archive
-
zorba-coders team
-
Mailing list archive
-
Message #07973
[Merge] lp:~paul-lucas/zorba/bug-983628 into lp:zorba
Paul J. Lucas has proposed merging lp:~paul-lucas/zorba/bug-983628 into lp:zorba.
Requested reviews:
Rodolfo Ochoa (rodolfo-ochoa)
Paul J. Lucas (paul-lucas)
Related bugs:
Bug #983628 in Zorba: "Latest Integer/Decimal/Float changes break Windows build"
https://bugs.launchpad.net/zorba/+bug/983628
For more details, see:
https://code.launchpad.net/~paul-lucas/zorba/bug-983628/+merge/102367
Removed use of is_arithmetic for Windows and "unrolled" all the types.
--
https://code.launchpad.net/~paul-lucas/zorba/bug-983628/+merge/102367
Your team Zorba Coders is subscribed to branch lp:zorba.
=== modified file 'src/zorbatypes/decimal.cpp'
--- src/zorbatypes/decimal.cpp 2012-04-16 20:56:43 +0000
+++ src/zorbatypes/decimal.cpp 2012-04-17 18:33:19 +0000
@@ -31,10 +31,10 @@
#ifdef ZORBA_WITH_BIG_INTEGER
# define TEMPLATE_DECL(T) /* nothing */
-# define INTEGER_IMPL(T) IntegerImpl
+# define INTEGER_IMPL(I) IntegerImpl
#else
-# define TEMPLATE_DECL(T) template<typename T>
-# define INTEGER_IMPL(T) IntegerImpl<T>
+# define TEMPLATE_DECL(T) template<typename T> /* spacer */
+# define INTEGER_IMPL(I) IntegerImpl<I> /* spacer */
#endif /* ZORBA_WITH_BIG_INTEGER */
#define INTEGER_IMPL_LL INTEGER_IMPL(long long)
#define INTEGER_IMPL_ULL INTEGER_IMPL(unsigned long long)
@@ -229,8 +229,8 @@
value_ = f.getNumber();
}
-TEMPLATE_DECL(T)
-Decimal::Decimal( INTEGER_IMPL(T) const &i ) : value_( i.itod() ) {
+TEMPLATE_DECL(I)
+Decimal::Decimal( INTEGER_IMPL(I) const &i ) : value_( i.itod() ) {
}
#ifndef ZORBA_WITH_BIG_INTEGER
template Decimal::Decimal( INTEGER_IMPL_LL const& );
@@ -251,8 +251,8 @@
return *this;
}
-TEMPLATE_DECL(T)
-Decimal& Decimal::operator=( INTEGER_IMPL(T) const &i ) {
+TEMPLATE_DECL(I)
+Decimal& Decimal::operator=( INTEGER_IMPL(I) const &i ) {
value_ = i.itod();
return *this;
}
@@ -286,8 +286,8 @@
#endif /* ZORBA_WITH_BIG_INTEGER */
#define ZORBA_DECIMAL_OP(OP) \
- TEMPLATE_DECL(T) \
- Decimal operator OP( Decimal const &d, INTEGER_IMPL(T) const &i ) { \
+ TEMPLATE_DECL(I) \
+ Decimal operator OP( Decimal const &d, INTEGER_IMPL(I) const &i ) { \
return d.value_ OP i.itod(); \
} \
ZORBA_INSTANTIATE(OP)
@@ -311,8 +311,8 @@
#endif /* ZORBA_WITH_BIG_INTEGER */
#define ZORBA_DECIMAL_OP(OP) \
- TEMPLATE_DECL(T) \
- bool operator OP( Decimal const &d, INTEGER_IMPL(T) const &i ) { \
+ TEMPLATE_DECL(I) \
+ bool operator OP( Decimal const &d, INTEGER_IMPL(I) const &i ) { \
return d.value_ OP i.itod(); \
} \
ZORBA_INSTANTIATE(OP)
@@ -332,8 +332,8 @@
return round( INTEGER_IMPL_LL::zero() );
}
-TEMPLATE_DECL(T)
-Decimal Decimal::round( INTEGER_IMPL(T) const &precision ) const {
+TEMPLATE_DECL(I)
+Decimal Decimal::round( INTEGER_IMPL(I) const &precision ) const {
return round2( value_, precision.itod() );
}
#ifndef ZORBA_WITH_BIG_INTEGER
@@ -351,8 +351,8 @@
return result;
}
-TEMPLATE_DECL(T)
-Decimal Decimal::roundHalfToEven( INTEGER_IMPL(T) const &precision ) const {
+TEMPLATE_DECL(I)
+Decimal Decimal::roundHalfToEven( INTEGER_IMPL(I) const &precision ) const {
return roundHalfToEven2( value_, precision.itod() );
}
#ifndef ZORBA_WITH_BIG_INTEGER
=== modified file 'src/zorbatypes/decimal.h'
--- src/zorbatypes/decimal.h 2012-04-16 20:56:43 +0000
+++ src/zorbatypes/decimal.h 2012-04-17 18:33:19 +0000
@@ -34,8 +34,8 @@
# define TEMPLATE_DECL(I) /* nothing */
# define INTEGER_IMPL(I) IntegerImpl
#else
-# define TEMPLATE_DECL(I) template<typename I>
-# define INTEGER_IMPL(I) IntegerImpl<I>
+# define TEMPLATE_DECL(I) template<typename I> /* spacer */
+# define INTEGER_IMPL(I) IntegerImpl<I> /* spacer */
#endif /* ZORBA_WITH_BIG_INTEGER */
namespace zorba {
@@ -106,19 +106,16 @@
*/
Decimal& operator=( Decimal const &d );
- /**
- * For every built-in arithmetic type A, assign to this %Decimal.
- *
- * @tparam A The built-in arithmetic type.
- * @param n The arithmetic value to assign.
- * @return Returns \c *this.
- */
- template<typename A>
- typename std::enable_if<ZORBA_TR1_NS::is_arithmetic<A>::value,Decimal&>::type
- operator=( A n );
-
- // These arithmetic types have to be special-cased.
+ Decimal& operator=( signed char c );
+ Decimal& operator=( char c );
+ Decimal& operator=( short n );
+ Decimal& operator=( int n );
+ Decimal& operator=( long n );
Decimal& operator=( long long n );
+ Decimal& operator=( unsigned char c );
+ Decimal& operator=( unsigned short n );
+ Decimal& operator=( unsigned int n );
+ Decimal& operator=( unsigned long n );
Decimal& operator=( unsigned long long n );
Decimal& operator=( char const *s );
@@ -222,6 +219,8 @@
private:
typedef MAPM value_type;
+ typedef long int_cast_type;
+
value_type value_;
Decimal( value_type const &v ) : value_( v ) { }
@@ -256,29 +255,18 @@
////////// constructors ///////////////////////////////////////////////////////
-inline Decimal::Decimal( char c ) : value_( static_cast<long>( c ) ) {
-}
-
-inline Decimal::Decimal( signed char c ) : value_( static_cast<long>( c ) ) {
-}
-
-inline Decimal::Decimal( short n ) : value_( static_cast<long>( n ) ) {
-}
-
-inline Decimal::Decimal( int n ) : value_( static_cast<long>( n ) ) {
-}
-
-inline Decimal::Decimal( long n ) : value_( n ) {
-}
-
-inline Decimal::Decimal( unsigned char c ) : value_( static_cast<long>( c ) ) {
-}
-
-inline Decimal::Decimal( unsigned short n ) : value_( static_cast<long>( n ) ) {
-}
-
-inline Decimal::Decimal( unsigned int n ) : value_( static_cast<long>( n ) ) {
-}
+#define ZORBA_DECIMAL_CTOR(T) \
+ inline Decimal::Decimal( T n ) : value_( static_cast<int_cast_type>( n ) ) { }
+
+ZORBA_DECIMAL_CTOR(char)
+ZORBA_DECIMAL_CTOR(signed char)
+ZORBA_DECIMAL_CTOR(short)
+ZORBA_DECIMAL_CTOR(int)
+ZORBA_DECIMAL_CTOR(long)
+ZORBA_DECIMAL_CTOR(unsigned char)
+ZORBA_DECIMAL_CTOR(unsigned short)
+ZORBA_DECIMAL_CTOR(unsigned int)
+#undef ZORBA_DECIMAL_CTOR
inline Decimal::Decimal( char const *s ) {
parse( s, &value_ );
@@ -296,12 +284,22 @@
return *this;
}
-template<typename A> inline
-typename std::enable_if<ZORBA_TR1_NS::is_arithmetic<A>::value,Decimal&>::type
-Decimal::operator=( A n ) {
- value_ = static_cast<long>( n );
- return *this;
-}
+#define ZORBA_DECIMAL_OP(T) \
+ inline Decimal& Decimal::operator=( T n ) { \
+ value_ = static_cast<int_cast_type>( n ); \
+ return *this; \
+ }
+
+ZORBA_DECIMAL_OP(signed char)
+ZORBA_DECIMAL_OP(char)
+ZORBA_DECIMAL_OP(short)
+ZORBA_DECIMAL_OP(int)
+ZORBA_DECIMAL_OP(long)
+ZORBA_DECIMAL_OP(unsigned char)
+ZORBA_DECIMAL_OP(unsigned short)
+ZORBA_DECIMAL_OP(unsigned int)
+ZORBA_DECIMAL_OP(unsigned long)
+#undef ZORBA_DECIMAL_OP
inline Decimal& Decimal::operator=( char const *s ) {
parse( s, &value_ );
=== modified file 'src/zorbatypes/floatimpl.cpp'
--- src/zorbatypes/floatimpl.cpp 2012-04-16 20:56:43 +0000
+++ src/zorbatypes/floatimpl.cpp 2012-04-17 18:33:19 +0000
@@ -32,10 +32,10 @@
#ifdef ZORBA_WITH_BIG_INTEGER
# define TEMPLATE_DECL(T) /* nothing */
-# define INTEGER_IMPL(T) IntegerImpl
+# define INTEGER_IMPL(I) IntegerImpl
#else
-# define TEMPLATE_DECL(T) template<typename T>
-# define INTEGER_IMPL(T) IntegerImpl<T>
+# define TEMPLATE_DECL(T) template<typename T> /* spacer */
+# define INTEGER_IMPL(I) IntegerImpl<I> /* spacer */
#endif /* ZORBA_WITH_BIG_INTEGER */
#define INTEGER_IMPL_LL INTEGER_IMPL(long long)
#define INTEGER_IMPL_ULL INTEGER_IMPL(unsigned long long)
=== modified file 'src/zorbatypes/floatimpl.h'
--- src/zorbatypes/floatimpl.h 2012-04-16 20:56:43 +0000
+++ src/zorbatypes/floatimpl.h 2012-04-17 18:33:19 +0000
@@ -33,8 +33,8 @@
# define TEMPLATE_DECL(I) /* nothing */
# define INTEGER_IMPL(I) IntegerImpl
#else
-# define TEMPLATE_DECL(I) template<typename I>
-# define INTEGER_IMPL(I) IntegerImpl<I>
+# define TEMPLATE_DECL(I) template<typename I> /* spacer */
+# define INTEGER_IMPL(I) IntegerImpl<I> /* spacer */
#endif /* ZORBA_WITH_BIG_INTEGER */
namespace zorba {
@@ -109,17 +109,19 @@
template<typename FloatType2>
FloatImpl& operator=( FloatImpl<FloatType2> const &f );
- /**
- * For every built-in arithmetic type A, assign to this %FloatImpl.
- *
- * @tparam A The built-in arithmetic type.
- * @param n The arithmetic value to assign.
- * @return Returns \c *this.
- */
- template<typename A>
- typename std::enable_if<ZORBA_TR1_NS::is_arithmetic<A>::value,
- FloatImpl&>::type
- operator=( A n );
+ FloatImpl& operator=( char c );
+ FloatImpl& operator=( signed char c );
+ FloatImpl& operator=( short n );
+ FloatImpl& operator=( int n );
+ FloatImpl& operator=( long n );
+ FloatImpl& operator=( long long n );
+ FloatImpl& operator=( unsigned char c );
+ FloatImpl& operator=( unsigned short n );
+ FloatImpl& operator=( unsigned int n );
+ FloatImpl& operator=( unsigned long n );
+ FloatImpl& operator=( unsigned long long n );
+ FloatImpl& operator=( float n );
+ FloatImpl& operator=( double n );
FloatImpl& operator=( char const *s );
FloatImpl& operator=( Decimal const &d );
@@ -129,17 +131,74 @@
////////// arithmetic operators /////////////////////////////////////////////
-#define ZORBA_FLOAT_OP(OP) \
- template<typename A> \
- typename std::enable_if<ZORBA_TR1_NS::is_arithmetic<A>::value, \
- FloatImpl&>::type \
- operator OP( A n )
+#define ZORBA_FLOAT_OP(OP,T) \
+ FloatImpl& operator OP( T n )
- ZORBA_FLOAT_OP(+=);
- ZORBA_FLOAT_OP(-=);
- ZORBA_FLOAT_OP(*=);
- ZORBA_FLOAT_OP(/=);
- ZORBA_FLOAT_OP(%=);
+ ZORBA_FLOAT_OP(+=,char);
+ ZORBA_FLOAT_OP(-=,char);
+ ZORBA_FLOAT_OP(*=,char);
+ ZORBA_FLOAT_OP(/=,char);
+ ZORBA_FLOAT_OP(%=,char);
+ ZORBA_FLOAT_OP(+=,signed char);
+ ZORBA_FLOAT_OP(-=,signed char);
+ ZORBA_FLOAT_OP(*=,signed char);
+ ZORBA_FLOAT_OP(/=,signed char);
+ ZORBA_FLOAT_OP(%=,signed char);
+ ZORBA_FLOAT_OP(+=,short);
+ ZORBA_FLOAT_OP(-=,short);
+ ZORBA_FLOAT_OP(*=,short);
+ ZORBA_FLOAT_OP(/=,short);
+ ZORBA_FLOAT_OP(%=,short);
+ ZORBA_FLOAT_OP(+=,int);
+ ZORBA_FLOAT_OP(-=,int);
+ ZORBA_FLOAT_OP(*=,int);
+ ZORBA_FLOAT_OP(/=,int);
+ ZORBA_FLOAT_OP(%=,int);
+ ZORBA_FLOAT_OP(+=,long);
+ ZORBA_FLOAT_OP(-=,long);
+ ZORBA_FLOAT_OP(*=,long);
+ ZORBA_FLOAT_OP(/=,long);
+ ZORBA_FLOAT_OP(%=,long);
+ ZORBA_FLOAT_OP(+=,long long);
+ ZORBA_FLOAT_OP(-=,long long);
+ ZORBA_FLOAT_OP(*=,long long);
+ ZORBA_FLOAT_OP(/=,long long);
+ ZORBA_FLOAT_OP(%=,long long);
+ ZORBA_FLOAT_OP(+=,unsigned char);
+ ZORBA_FLOAT_OP(-=,unsigned char);
+ ZORBA_FLOAT_OP(*=,unsigned char);
+ ZORBA_FLOAT_OP(/=,unsigned char);
+ ZORBA_FLOAT_OP(%=,unsigned char);
+ ZORBA_FLOAT_OP(+=,unsigned short);
+ ZORBA_FLOAT_OP(-=,unsigned short);
+ ZORBA_FLOAT_OP(*=,unsigned short);
+ ZORBA_FLOAT_OP(/=,unsigned short);
+ ZORBA_FLOAT_OP(%=,unsigned short);
+ ZORBA_FLOAT_OP(+=,unsigned int);
+ ZORBA_FLOAT_OP(-=,unsigned int);
+ ZORBA_FLOAT_OP(*=,unsigned int);
+ ZORBA_FLOAT_OP(/=,unsigned int);
+ ZORBA_FLOAT_OP(%=,unsigned int);
+ ZORBA_FLOAT_OP(+=,unsigned long);
+ ZORBA_FLOAT_OP(-=,unsigned long);
+ ZORBA_FLOAT_OP(*=,unsigned long);
+ ZORBA_FLOAT_OP(/=,unsigned long);
+ ZORBA_FLOAT_OP(%=,unsigned long);
+ ZORBA_FLOAT_OP(+=,unsigned long long);
+ ZORBA_FLOAT_OP(-=,unsigned long long);
+ ZORBA_FLOAT_OP(*=,unsigned long long);
+ ZORBA_FLOAT_OP(/=,unsigned long long);
+ ZORBA_FLOAT_OP(%=,unsigned long long);
+ ZORBA_FLOAT_OP(+=,float);
+ ZORBA_FLOAT_OP(-=,float);
+ ZORBA_FLOAT_OP(*=,float);
+ ZORBA_FLOAT_OP(/=,float);
+ ZORBA_FLOAT_OP(%=,float);
+ ZORBA_FLOAT_OP(+=,double);
+ ZORBA_FLOAT_OP(-=,double);
+ ZORBA_FLOAT_OP(*=,double);
+ ZORBA_FLOAT_OP(/=,double);
+ ZORBA_FLOAT_OP(%=,double);
#undef ZORBA_FLOAT_OP
#define ZORBA_FLOAT_OP(OP) \
@@ -371,14 +430,28 @@
return *this;
}
-template<typename F> template<typename A> inline
-typename std::enable_if<ZORBA_TR1_NS::is_arithmetic<A>::value,
- FloatImpl<F>&>::type
-FloatImpl<F>::operator=( A n ) {
- value_ = static_cast<F>( n );
- precision_ = max_precision();
- return *this;
-}
+#define ZORBA_FLOAT_OP(T) \
+ template<typename F> \
+ inline FloatImpl<F>& FloatImpl<F>::operator=( T n ) { \
+ value_ = static_cast<F>( n ); \
+ precision_ = max_precision(); \
+ return *this; \
+ }
+
+ZORBA_FLOAT_OP(char)
+ZORBA_FLOAT_OP(signed char)
+ZORBA_FLOAT_OP(short)
+ZORBA_FLOAT_OP(int)
+ZORBA_FLOAT_OP(long)
+ZORBA_FLOAT_OP(long long)
+ZORBA_FLOAT_OP(unsigned char)
+ZORBA_FLOAT_OP(unsigned short)
+ZORBA_FLOAT_OP(unsigned int)
+ZORBA_FLOAT_OP(unsigned long)
+ZORBA_FLOAT_OP(unsigned long long)
+ZORBA_FLOAT_OP(float)
+ZORBA_FLOAT_OP(double)
+#undef ZORBA_FLOAT_OP
template<typename F>
inline FloatImpl<F>& FloatImpl<F>::operator=( char const *s ) {
@@ -388,40 +461,96 @@
////////// arithmetic operators ///////////////////////////////////////////////
-#define ZORBA_FLOAT_OP(OP) \
- template<typename F,typename A> inline \
- typename std::enable_if<ZORBA_TR1_NS::is_arithmetic<A>::value, \
- FloatImpl<F> >::type \
- operator OP( FloatImpl<F> const &f, A n ) { \
+#define ZORBA_FLOAT_OP(OP,T) \
+ template<typename F> \
+ inline FloatImpl<F> operator OP( FloatImpl<F> const &f, T n ) { \
return FloatImpl<F>( f.getNumber() OP static_cast<F>( n ) ); \
} \
\
- template<typename F,typename A> inline \
- typename std::enable_if<ZORBA_TR1_NS::is_arithmetic<A>::value, \
- FloatImpl<F> >::type \
- operator OP( A n, FloatImpl<F> const &f ) { \
+ template<typename F> \
+ inline FloatImpl<F> operator OP( T n, FloatImpl<F> const &f ) { \
return FloatImpl<F>( static_cast<F>( n ) OP f.getNumber() ); \
}
-ZORBA_FLOAT_OP(+)
-ZORBA_FLOAT_OP(-)
-ZORBA_FLOAT_OP(*)
-ZORBA_FLOAT_OP(/)
-#undef ZORBA_FLOAT_OP
-
-template<typename F,typename A> inline
-typename std::enable_if<ZORBA_TR1_NS::is_arithmetic<A>::value,
- FloatImpl<F> >::type
-operator%( FloatImpl<F> const &f, A n ) {
- return FloatImpl<F>( std::fmod( f.getNumber(), static_cast<F>( n ) ) );
-}
-
-template<typename F,typename A> inline
-typename std::enable_if<ZORBA_TR1_NS::is_arithmetic<A>::value,
- FloatImpl<F> >::type
-operator%( A n, FloatImpl<F> const &f ) {
- return FloatImpl<F>( std::fmod( static_cast<F>( n ), f.getNumber() ) );
-}
+ZORBA_FLOAT_OP(+,char)
+ZORBA_FLOAT_OP(-,char)
+ZORBA_FLOAT_OP(*,char)
+ZORBA_FLOAT_OP(/,char)
+ZORBA_FLOAT_OP(+,signed char)
+ZORBA_FLOAT_OP(-,signed char)
+ZORBA_FLOAT_OP(*,signed char)
+ZORBA_FLOAT_OP(/,signed char)
+ZORBA_FLOAT_OP(+,short)
+ZORBA_FLOAT_OP(-,short)
+ZORBA_FLOAT_OP(*,short)
+ZORBA_FLOAT_OP(/,short)
+ZORBA_FLOAT_OP(+,int)
+ZORBA_FLOAT_OP(-,int)
+ZORBA_FLOAT_OP(*,int)
+ZORBA_FLOAT_OP(/,int)
+ZORBA_FLOAT_OP(+,long)
+ZORBA_FLOAT_OP(-,long)
+ZORBA_FLOAT_OP(*,long)
+ZORBA_FLOAT_OP(/,long)
+ZORBA_FLOAT_OP(+,long long)
+ZORBA_FLOAT_OP(-,long long)
+ZORBA_FLOAT_OP(*,long long)
+ZORBA_FLOAT_OP(/,long long)
+ZORBA_FLOAT_OP(+,unsigned char)
+ZORBA_FLOAT_OP(-,unsigned char)
+ZORBA_FLOAT_OP(*,unsigned char)
+ZORBA_FLOAT_OP(/,unsigned char)
+ZORBA_FLOAT_OP(+,unsigned short)
+ZORBA_FLOAT_OP(-,unsigned short)
+ZORBA_FLOAT_OP(*,unsigned short)
+ZORBA_FLOAT_OP(/,unsigned short)
+ZORBA_FLOAT_OP(+,unsigned int)
+ZORBA_FLOAT_OP(-,unsigned int)
+ZORBA_FLOAT_OP(*,unsigned int)
+ZORBA_FLOAT_OP(/,unsigned int)
+ZORBA_FLOAT_OP(+,unsigned long)
+ZORBA_FLOAT_OP(-,unsigned long)
+ZORBA_FLOAT_OP(*,unsigned long)
+ZORBA_FLOAT_OP(/,unsigned long)
+ZORBA_FLOAT_OP(+,unsigned long long)
+ZORBA_FLOAT_OP(-,unsigned long long)
+ZORBA_FLOAT_OP(*,unsigned long long)
+ZORBA_FLOAT_OP(/,unsigned long long)
+ZORBA_FLOAT_OP(+,float)
+ZORBA_FLOAT_OP(-,float)
+ZORBA_FLOAT_OP(*,float)
+ZORBA_FLOAT_OP(/,float)
+ZORBA_FLOAT_OP(+,double)
+ZORBA_FLOAT_OP(-,double)
+ZORBA_FLOAT_OP(*,double)
+ZORBA_FLOAT_OP(/,double)
+#undef ZORBA_FLOAT_OP
+
+#define ZORBA_FLOAT_OP(T) \
+ template<typename F> \
+ inline FloatImpl<F> operator%( FloatImpl<F> const &f, T n ) { \
+ return FloatImpl<F>( std::fmod( f.getNumber(), static_cast<F>( n ) ) ); \
+ } \
+ \
+ template<typename F> \
+ inline FloatImpl<F> operator%( T n, FloatImpl<F> const &f ) { \
+ return FloatImpl<F>( std::fmod( static_cast<F>( n ), f.getNumber() ) ); \
+ }
+
+ZORBA_FLOAT_OP(signed char)
+ZORBA_FLOAT_OP(char)
+ZORBA_FLOAT_OP(short)
+ZORBA_FLOAT_OP(int)
+ZORBA_FLOAT_OP(long)
+ZORBA_FLOAT_OP(long long)
+ZORBA_FLOAT_OP(unsigned char)
+ZORBA_FLOAT_OP(unsigned short)
+ZORBA_FLOAT_OP(unsigned int)
+ZORBA_FLOAT_OP(unsigned long)
+ZORBA_FLOAT_OP(unsigned long long)
+ZORBA_FLOAT_OP(float)
+ZORBA_FLOAT_OP(double)
+#undef ZORBA_FLOAT_OP
#define ZORBA_FLOAT_OP(OP) \
template<typename F> inline \
@@ -440,20 +569,87 @@
return FloatImpl<F>( std::fmod( f.getNumber(), g.getNumber() ) );
}
-#define ZORBA_FLOAT_OP(OP) \
- template<typename F> template<typename A> inline \
- typename std::enable_if<ZORBA_TR1_NS::is_arithmetic<A>::value, \
- FloatImpl<F>&>::type \
- FloatImpl<F>::operator OP( A n ) { \
- value_ OP static_cast<F>( n ); \
- return *this; \
- }
-
-ZORBA_FLOAT_OP(+=)
-ZORBA_FLOAT_OP(-=)
-ZORBA_FLOAT_OP(*=)
-ZORBA_FLOAT_OP(/=)
-ZORBA_FLOAT_OP(%=)
+#define ZORBA_FLOAT_OP(OP,T) \
+ template<typename F> \
+ inline FloatImpl<F>& FloatImpl<F>::operator OP( T n ) { \
+ value_ OP static_cast<F>( n ); \
+ return *this; \
+ }
+
+ZORBA_FLOAT_OP(+=,char)
+ZORBA_FLOAT_OP(-=,char)
+ZORBA_FLOAT_OP(*=,char)
+ZORBA_FLOAT_OP(/=,char)
+ZORBA_FLOAT_OP(+=,signed char)
+ZORBA_FLOAT_OP(-=,signed char)
+ZORBA_FLOAT_OP(*=,signed char)
+ZORBA_FLOAT_OP(/=,signed char)
+ZORBA_FLOAT_OP(+=,short)
+ZORBA_FLOAT_OP(-=,short)
+ZORBA_FLOAT_OP(*=,short)
+ZORBA_FLOAT_OP(/=,short)
+ZORBA_FLOAT_OP(+=,int)
+ZORBA_FLOAT_OP(-=,int)
+ZORBA_FLOAT_OP(*=,int)
+ZORBA_FLOAT_OP(/=,int)
+ZORBA_FLOAT_OP(+=,long)
+ZORBA_FLOAT_OP(-=,long)
+ZORBA_FLOAT_OP(*=,long)
+ZORBA_FLOAT_OP(/=,long)
+ZORBA_FLOAT_OP(+=,long long)
+ZORBA_FLOAT_OP(-=,long long)
+ZORBA_FLOAT_OP(*=,long long)
+ZORBA_FLOAT_OP(/=,long long)
+ZORBA_FLOAT_OP(+=,unsigned char)
+ZORBA_FLOAT_OP(-=,unsigned char)
+ZORBA_FLOAT_OP(*=,unsigned char)
+ZORBA_FLOAT_OP(/=,unsigned char)
+ZORBA_FLOAT_OP(+=,unsigned short)
+ZORBA_FLOAT_OP(-=,unsigned short)
+ZORBA_FLOAT_OP(*=,unsigned short)
+ZORBA_FLOAT_OP(/=,unsigned short)
+ZORBA_FLOAT_OP(+=,unsigned int)
+ZORBA_FLOAT_OP(-=,unsigned int)
+ZORBA_FLOAT_OP(*=,unsigned int)
+ZORBA_FLOAT_OP(/=,unsigned int)
+ZORBA_FLOAT_OP(+=,unsigned long)
+ZORBA_FLOAT_OP(-=,unsigned long)
+ZORBA_FLOAT_OP(*=,unsigned long)
+ZORBA_FLOAT_OP(/=,unsigned long)
+ZORBA_FLOAT_OP(+=,unsigned long long)
+ZORBA_FLOAT_OP(-=,unsigned long long)
+ZORBA_FLOAT_OP(*=,unsigned long long)
+ZORBA_FLOAT_OP(/=,unsigned long long)
+ZORBA_FLOAT_OP(+=,float)
+ZORBA_FLOAT_OP(-=,float)
+ZORBA_FLOAT_OP(*=,float)
+ZORBA_FLOAT_OP(/=,float)
+ZORBA_FLOAT_OP(+=,double)
+ZORBA_FLOAT_OP(-=,double)
+ZORBA_FLOAT_OP(*=,double)
+ZORBA_FLOAT_OP(/=,double)
+#undef ZORBA_FLOAT_OP
+
+#define ZORBA_FLOAT_OP(T) \
+ template<typename F> \
+ inline FloatImpl<F>& FloatImpl<F>::operator%=( T n ) { \
+ value_ = std::fmod( getNumber(), static_cast<F>( n ) ); \
+ return *this; \
+ }
+
+ZORBA_FLOAT_OP(signed char)
+ZORBA_FLOAT_OP(char)
+ZORBA_FLOAT_OP(short)
+ZORBA_FLOAT_OP(int)
+ZORBA_FLOAT_OP(long)
+ZORBA_FLOAT_OP(long long)
+ZORBA_FLOAT_OP(unsigned char)
+ZORBA_FLOAT_OP(unsigned short)
+ZORBA_FLOAT_OP(unsigned int)
+ZORBA_FLOAT_OP(unsigned long)
+ZORBA_FLOAT_OP(unsigned long long)
+ZORBA_FLOAT_OP(float)
+ZORBA_FLOAT_OP(double)
#undef ZORBA_FLOAT_OP
#define ZORBA_FLOAT_OP(OP) \
=== modified file 'src/zorbatypes/integer.cpp'
--- src/zorbatypes/integer.cpp 2012-04-16 20:56:43 +0000
+++ src/zorbatypes/integer.cpp 2012-04-17 18:33:19 +0000
@@ -31,8 +31,8 @@
# define TEMPLATE_DECL(T) /* nothing */
# define INTEGER_IMPL(T) IntegerImpl
#else
-# define TEMPLATE_DECL(T) template<typename T>
-# define INTEGER_IMPL(T) IntegerImpl<T>
+# define TEMPLATE_DECL(T) template<typename T> /* spacer */
+# define INTEGER_IMPL(T) IntegerImpl<T> /* spacer */
#endif /* ZORBA_WITH_BIG_INTEGER */
#define INTEGER_IMPL_LL INTEGER_IMPL(long long)
#define INTEGER_IMPL_ULL INTEGER_IMPL(unsigned long long)
@@ -55,13 +55,12 @@
///////////////////////////////////////////////////////////////////////////////
+TEMPLATE_DECL(I)
+void INTEGER_IMPL(I)::parse( char const *s ) {
#ifdef ZORBA_WITH_BIG_INTEGER
-void IntegerImpl::parse( char const *s ) {
Decimal::parse( s, &value_, Decimal::parse_integer );
#else
-template<typename IntType>
-void IntegerImpl<IntType>::parse( char const *s ) {
- value_type const temp = ztd::aton<value_type>( s );
+ value_type const temp( ztd::aton<value_type>( s ) );
if ( is_too_big( temp ) )
throw std::invalid_argument(
BUILD_STRING( '"', temp, "\": unsigned integer too big" )
@@ -177,6 +176,85 @@
#undef ZORBA_INTEGER_OP
#undef ZORBA_INSTANTIATE
+#ifdef ZORBA_WITH_BIG_INTEGER
+
+#define ZORBA_INTEGER_OP(OP,T) \
+ IntegerImpl operator OP( IntegerImpl const &i, T n ) { \
+ ztd::itoa_buf_type buf; \
+ return i.value_ OP IntegerImpl::value_type( ztd::itoa( n, buf ) ); \
+ } \
+ IntegerImpl operator OP( T n, IntegerImpl const &i ) { \
+ ztd::itoa_buf_type buf; \
+ return IntegerImpl::value_type( ztd::itoa( n, buf ) ) OP i.value_; \
+ }
+
+ZORBA_INTEGER_OP(+,long long)
+ZORBA_INTEGER_OP(-,long long)
+ZORBA_INTEGER_OP(*,long long)
+ZORBA_INTEGER_OP(%,long long)
+ZORBA_INTEGER_OP(+,unsigned long)
+ZORBA_INTEGER_OP(-,unsigned long)
+ZORBA_INTEGER_OP(*,unsigned long)
+ZORBA_INTEGER_OP(%,unsigned long)
+ZORBA_INTEGER_OP(+,unsigned long long)
+ZORBA_INTEGER_OP(-,unsigned long long)
+ZORBA_INTEGER_OP(*,unsigned long long)
+ZORBA_INTEGER_OP(%,unsigned long long)
+#undef ZORBA_INTEGER_OP
+
+#define ZORBA_INTEGER_OP(T) \
+ IntegerImpl operator/( IntegerImpl const &i, T n ) { \
+ ztd::itoa_buf_type buf; \
+ IntegerImpl::value_type const temp( ztd::itoa( n, buf ) ); \
+ return IntegerImpl::ftoi( i.value_ / temp ); \
+ } \
+ IntegerImpl operator/( T n, IntegerImpl const &i ) { \
+ ztd::itoa_buf_type buf; \
+ IntegerImpl::value_type const temp( ztd::itoa( n, buf ) ); \
+ return IntegerImpl::ftoi( temp / i.value_ ); \
+ }
+
+ZORBA_INTEGER_OP(long long)
+ZORBA_INTEGER_OP(unsigned long)
+ZORBA_INTEGER_OP(unsigned long long)
+#undef ZORBA_INTEGER_OP
+
+#define ZORBA_INTEGER_OP(OP,T) \
+ IntegerImpl& IntegerImpl::operator OP( T n ) { \
+ ztd::itoa_buf_type buf; \
+ value_type const temp( ztd::itoa( n, buf ) ); \
+ value_ OP temp; \
+ return *this; \
+ }
+
+ZORBA_INTEGER_OP(+=,long long)
+ZORBA_INTEGER_OP(-=,long long)
+ZORBA_INTEGER_OP(*=,long long)
+ZORBA_INTEGER_OP(%=,long long)
+ZORBA_INTEGER_OP(+=,unsigned long)
+ZORBA_INTEGER_OP(-=,unsigned long)
+ZORBA_INTEGER_OP(*=,unsigned long)
+ZORBA_INTEGER_OP(%=,unsigned long)
+ZORBA_INTEGER_OP(+=,unsigned long long)
+ZORBA_INTEGER_OP(-=,unsigned long long)
+ZORBA_INTEGER_OP(*=,unsigned long long)
+ZORBA_INTEGER_OP(%=,unsigned long long)
+#undef ZORBA_INTEGER_OP
+
+#define ZORBA_INTEGER_OP(T) \
+ IntegerImpl& IntegerImpl::operator/=( T n ) { \
+ ztd::itoa_buf_type buf; \
+ value_type const temp( ztd::itoa( n, buf ) ); \
+ value_ = ftoi( value_ / temp ); \
+ return *this; \
+ }
+
+ZORBA_INTEGER_OP(long long)
+ZORBA_INTEGER_OP(unsigned long)
+ZORBA_INTEGER_OP(unsigned long long)
+#undef ZORBA_INTEGER_OP
+#endif /* ZORBA_WITH_BIG_INTEGER */
+
////////// relational operators ///////////////////////////////////////////////
TEMPLATE_DECL(T)
@@ -197,7 +275,40 @@
ZORBA_INTEGER_OP(>=)
#undef ZORBA_INTEGER_OP
-#ifndef ZORBA_WITH_BIG_INTEGER
+#ifdef ZORBA_WITH_BIG_INTEGER
+
+#define ZORBA_INTEGER_OP(OP,T) \
+ bool operator OP( IntegerImpl const &i, T n ) { \
+ ztd::itoa_buf_type buf; \
+ return i.value_ OP IntegerImpl::value_type( ztd::itoa( n, buf ) ); \
+ } \
+ \
+ bool operator OP( T n, IntegerImpl const &i ) { \
+ ztd::itoa_buf_type buf; \
+ return IntegerImpl::value_type( ztd::itoa( n, buf ) ) OP i.value_; \
+ }
+
+ZORBA_INTEGER_OP(==,long long)
+ZORBA_INTEGER_OP(!=,long long)
+ZORBA_INTEGER_OP(< ,long long)
+ZORBA_INTEGER_OP(<=,long long)
+ZORBA_INTEGER_OP(> ,long long)
+ZORBA_INTEGER_OP(>=,long long)
+ZORBA_INTEGER_OP(==,unsigned long)
+ZORBA_INTEGER_OP(!=,unsigned long)
+ZORBA_INTEGER_OP(< ,unsigned long)
+ZORBA_INTEGER_OP(<=,unsigned long)
+ZORBA_INTEGER_OP(> ,unsigned long)
+ZORBA_INTEGER_OP(>=,unsigned long)
+ZORBA_INTEGER_OP(==,unsigned long long)
+ZORBA_INTEGER_OP(!=,unsigned long long)
+ZORBA_INTEGER_OP(< ,unsigned long long)
+ZORBA_INTEGER_OP(<=,unsigned long long)
+ZORBA_INTEGER_OP(> ,unsigned long long)
+ZORBA_INTEGER_OP(>=,unsigned long long)
+
+#else /* ZORBA_WITH_BIG_INTEGER */
+
#define ZORBA_INSTANTIATE(OP) \
template bool operator OP( INTEGER_IMPL_LL const&, Decimal const& ); \
template bool operator OP( INTEGER_IMPL_ULL const&, Decimal const& )
@@ -209,6 +320,7 @@
ZORBA_INSTANTIATE(> );
ZORBA_INSTANTIATE(>=);
#undef ZORBA_INSTANTIATE
+
#endif /* ZORBA_WITH_BIG_INTEGER */
////////// math functions /////////////////////////////////////////////////////
=== modified file 'src/zorbatypes/integer.h'
--- src/zorbatypes/integer.h 2012-04-16 20:56:43 +0000
+++ src/zorbatypes/integer.h 2012-04-17 18:33:19 +0000
@@ -32,16 +32,14 @@
#include "zstring.h"
#ifdef ZORBA_WITH_BIG_INTEGER
-# define TEMPLATE_DECL(I) /* nothing */
-# define TEMPLATE_DECL2(I,A) template<typename A>
-# define INTEGER_IMPL(I) IntegerImpl
+# define TEMPLATE_DECL(I) /* nothing */
+# define INTEGER_IMPL(I) IntegerImpl
#else
-# define TEMPLATE_DECL(I) template<typename I>
-# define TEMPLATE_DECL2(I,A) template<typename I,typename A>
-# define INTEGER_IMPL(I) IntegerImpl<I>
+# define TEMPLATE_DECL(I) template<typename I> /* spacer */
+# define INTEGER_IMPL(I) IntegerImpl<I> /* spacer */
#endif /* ZORBA_WITH_BIG_INTEGER */
-#define INTEGER_IMPL_LL INTEGER_IMPL(long long)
-#define INTEGER_IMPL_ULL INTEGER_IMPL(unsigned long long)
+#define INTEGER_IMPL_LL INTEGER_IMPL(long long)
+#define INTEGER_IMPL_ULL INTEGER_IMPL(unsigned long long)
namespace zorba {
@@ -127,22 +125,19 @@
TEMPLATE_DECL(IntType2)
IntegerImpl& operator=( INTEGER_IMPL(IntType2) const &i );
- /**
- * For every built-in arithmetic type A, assign to this %IntegerImpl.
- *
- * @tparam A The built-in arithmetic type.
- * @param n The arithmetic value to assign.
- * @return Returns \c *this.
- */
- template<typename A>
- typename std::enable_if<ZORBA_TR1_NS::is_arithmetic<A>::value,
- IntegerImpl&>::type
- operator=( A n );
-
- // These arithmetic types have to be special-cased.
- IntegerImpl& operator=( long long );
- IntegerImpl& operator=( unsigned long );
- IntegerImpl& operator=( unsigned long long );
+ IntegerImpl& operator=( char c );
+ IntegerImpl& operator=( signed char c );
+ IntegerImpl& operator=( short n );
+ IntegerImpl& operator=( int n );
+ IntegerImpl& operator=( long n );
+ IntegerImpl& operator=( long long n );
+ IntegerImpl& operator=( unsigned char c );
+ IntegerImpl& operator=( unsigned short n );
+ IntegerImpl& operator=( unsigned int n );
+ IntegerImpl& operator=( unsigned long n );
+ IntegerImpl& operator=( unsigned long long n );
+ IntegerImpl& operator=( float n );
+ IntegerImpl& operator=( double n );
IntegerImpl& operator=( char const *s );
IntegerImpl& operator=( Decimal const &d );
@@ -169,22 +164,78 @@
ZORBA_INTEGER_OP(%);
#undef ZORBA_INTEGER_OP
-#define ZORBA_INTEGER_OP(OP) \
- TEMPLATE_DECL2(I,A) friend \
- typename std::enable_if<ZORBA_TR1_NS::is_arithmetic<A>::value, \
- INTEGER_IMPL(I)>::type \
- operator OP( INTEGER_IMPL(I) const&, A ); \
- \
- TEMPLATE_DECL2(I,A) friend \
- typename std::enable_if<ZORBA_TR1_NS::is_arithmetic<A>::value, \
- INTEGER_IMPL(I)>::type \
- operator OP( A, INTEGER_IMPL(I) const& )
+#define ZORBA_INTEGER_OP(OP,T) \
+ TEMPLATE_DECL(I) friend \
+ INTEGER_IMPL(I) operator OP( INTEGER_IMPL(I) const&, T ); \
+ \
+ TEMPLATE_DECL(I) friend \
+ INTEGER_IMPL(I) operator OP( T, INTEGER_IMPL(I) const& )
- ZORBA_INTEGER_OP(+);
- ZORBA_INTEGER_OP(-);
- ZORBA_INTEGER_OP(*);
- ZORBA_INTEGER_OP(/);
- ZORBA_INTEGER_OP(%);
+ ZORBA_INTEGER_OP(+,char);
+ ZORBA_INTEGER_OP(-,char);
+ ZORBA_INTEGER_OP(*,char);
+ ZORBA_INTEGER_OP(/,char);
+ ZORBA_INTEGER_OP(%,char);
+ ZORBA_INTEGER_OP(+,signed char);
+ ZORBA_INTEGER_OP(-,signed char);
+ ZORBA_INTEGER_OP(*,signed char);
+ ZORBA_INTEGER_OP(/,signed char);
+ ZORBA_INTEGER_OP(%,signed char);
+ ZORBA_INTEGER_OP(+,short);
+ ZORBA_INTEGER_OP(-,short);
+ ZORBA_INTEGER_OP(*,short);
+ ZORBA_INTEGER_OP(/,short);
+ ZORBA_INTEGER_OP(%,short);
+ ZORBA_INTEGER_OP(+,int);
+ ZORBA_INTEGER_OP(-,int);
+ ZORBA_INTEGER_OP(*,int);
+ ZORBA_INTEGER_OP(/,int);
+ ZORBA_INTEGER_OP(%,int);
+ ZORBA_INTEGER_OP(+,long);
+ ZORBA_INTEGER_OP(-,long);
+ ZORBA_INTEGER_OP(*,long);
+ ZORBA_INTEGER_OP(/,long);
+ ZORBA_INTEGER_OP(%,long);
+ ZORBA_INTEGER_OP(+,long long);
+ ZORBA_INTEGER_OP(-,long long);
+ ZORBA_INTEGER_OP(*,long long);
+ ZORBA_INTEGER_OP(/,long long);
+ ZORBA_INTEGER_OP(%,long long);
+ ZORBA_INTEGER_OP(+,unsigned char);
+ ZORBA_INTEGER_OP(-,unsigned char);
+ ZORBA_INTEGER_OP(*,unsigned char);
+ ZORBA_INTEGER_OP(/,unsigned char);
+ ZORBA_INTEGER_OP(%,unsigned char);
+ ZORBA_INTEGER_OP(+,unsigned short);
+ ZORBA_INTEGER_OP(-,unsigned short);
+ ZORBA_INTEGER_OP(*,unsigned short);
+ ZORBA_INTEGER_OP(/,unsigned short);
+ ZORBA_INTEGER_OP(%,unsigned short);
+ ZORBA_INTEGER_OP(+,unsigned int);
+ ZORBA_INTEGER_OP(-,unsigned int);
+ ZORBA_INTEGER_OP(*,unsigned int);
+ ZORBA_INTEGER_OP(/,unsigned int);
+ ZORBA_INTEGER_OP(%,unsigned int);
+ ZORBA_INTEGER_OP(+,unsigned long);
+ ZORBA_INTEGER_OP(-,unsigned long);
+ ZORBA_INTEGER_OP(*,unsigned long);
+ ZORBA_INTEGER_OP(/,unsigned long);
+ ZORBA_INTEGER_OP(%,unsigned long);
+ ZORBA_INTEGER_OP(+,unsigned long long);
+ ZORBA_INTEGER_OP(-,unsigned long long);
+ ZORBA_INTEGER_OP(*,unsigned long long);
+ ZORBA_INTEGER_OP(/,unsigned long long);
+ ZORBA_INTEGER_OP(%,unsigned long long);
+ ZORBA_INTEGER_OP(+,float);
+ ZORBA_INTEGER_OP(-,float);
+ ZORBA_INTEGER_OP(*,float);
+ ZORBA_INTEGER_OP(/,float);
+ ZORBA_INTEGER_OP(%,float);
+ ZORBA_INTEGER_OP(+,double);
+ ZORBA_INTEGER_OP(-,double);
+ ZORBA_INTEGER_OP(*,double);
+ ZORBA_INTEGER_OP(/,double);
+ ZORBA_INTEGER_OP(%,double);
#undef ZORBA_INTEGER_OP
#define ZORBA_INTEGER_OP(OP,TYPE) \
@@ -197,17 +248,74 @@
ZORBA_INTEGER_OP(%=,IntegerImpl const&);
#undef ZORBA_INTEGER_OP
-#define ZORBA_INTEGER_OP(OP) \
- template<typename A> \
- typename std::enable_if<ZORBA_TR1_NS::is_arithmetic<A>::value, \
- IntegerImpl&>::type \
- operator OP( A )
+#define ZORBA_INTEGER_OP(OP,T) \
+ IntegerImpl& operator OP( T )
- ZORBA_INTEGER_OP(+=);
- ZORBA_INTEGER_OP(-=);
- ZORBA_INTEGER_OP(*=);
- ZORBA_INTEGER_OP(/=);
- ZORBA_INTEGER_OP(%=);
+ ZORBA_INTEGER_OP(+=,char);
+ ZORBA_INTEGER_OP(-=,char);
+ ZORBA_INTEGER_OP(*=,char);
+ ZORBA_INTEGER_OP(/=,char);
+ ZORBA_INTEGER_OP(%=,char);
+ ZORBA_INTEGER_OP(+=,signed char);
+ ZORBA_INTEGER_OP(-=,signed char);
+ ZORBA_INTEGER_OP(*=,signed char);
+ ZORBA_INTEGER_OP(/=,signed char);
+ ZORBA_INTEGER_OP(%=,signed char);
+ ZORBA_INTEGER_OP(+=,short);
+ ZORBA_INTEGER_OP(-=,short);
+ ZORBA_INTEGER_OP(*=,short);
+ ZORBA_INTEGER_OP(/=,short);
+ ZORBA_INTEGER_OP(%=,short);
+ ZORBA_INTEGER_OP(+=,int);
+ ZORBA_INTEGER_OP(-=,int);
+ ZORBA_INTEGER_OP(*=,int);
+ ZORBA_INTEGER_OP(/=,int);
+ ZORBA_INTEGER_OP(%=,int);
+ ZORBA_INTEGER_OP(+=,long);
+ ZORBA_INTEGER_OP(-=,long);
+ ZORBA_INTEGER_OP(*=,long);
+ ZORBA_INTEGER_OP(/=,long);
+ ZORBA_INTEGER_OP(%=,long);
+ ZORBA_INTEGER_OP(+=,long long);
+ ZORBA_INTEGER_OP(-=,long long);
+ ZORBA_INTEGER_OP(*=,long long);
+ ZORBA_INTEGER_OP(/=,long long);
+ ZORBA_INTEGER_OP(%=,long long);
+ ZORBA_INTEGER_OP(+=,unsigned char);
+ ZORBA_INTEGER_OP(-=,unsigned char);
+ ZORBA_INTEGER_OP(*=,unsigned char);
+ ZORBA_INTEGER_OP(/=,unsigned char);
+ ZORBA_INTEGER_OP(%=,unsigned char);
+ ZORBA_INTEGER_OP(+=,unsigned short);
+ ZORBA_INTEGER_OP(-=,unsigned short);
+ ZORBA_INTEGER_OP(*=,unsigned short);
+ ZORBA_INTEGER_OP(/=,unsigned short);
+ ZORBA_INTEGER_OP(%=,unsigned short);
+ ZORBA_INTEGER_OP(+=,unsigned int);
+ ZORBA_INTEGER_OP(-=,unsigned int);
+ ZORBA_INTEGER_OP(*=,unsigned int);
+ ZORBA_INTEGER_OP(/=,unsigned int);
+ ZORBA_INTEGER_OP(%=,unsigned int);
+ ZORBA_INTEGER_OP(+=,unsigned long);
+ ZORBA_INTEGER_OP(-=,unsigned long);
+ ZORBA_INTEGER_OP(*=,unsigned long);
+ ZORBA_INTEGER_OP(/=,unsigned long);
+ ZORBA_INTEGER_OP(%=,unsigned long);
+ ZORBA_INTEGER_OP(+=,unsigned long long);
+ ZORBA_INTEGER_OP(-=,unsigned long long);
+ ZORBA_INTEGER_OP(*=,unsigned long long);
+ ZORBA_INTEGER_OP(/=,unsigned long long);
+ ZORBA_INTEGER_OP(%=,unsigned long long);
+ ZORBA_INTEGER_OP(+=,float);
+ ZORBA_INTEGER_OP(-=,float);
+ ZORBA_INTEGER_OP(*=,float);
+ ZORBA_INTEGER_OP(/=,float);
+ ZORBA_INTEGER_OP(%=,float);
+ ZORBA_INTEGER_OP(+=,double);
+ ZORBA_INTEGER_OP(-=,double);
+ ZORBA_INTEGER_OP(*=,double);
+ ZORBA_INTEGER_OP(/=,double);
+ ZORBA_INTEGER_OP(%=,double);
#undef ZORBA_INTEGER_OP
IntegerImpl operator-() const;
@@ -237,21 +345,88 @@
ZORBA_INTEGER_OP(>=);
#undef ZORBA_INTEGER_OP
-#define ZORBA_INTEGER_OP(OP) \
- TEMPLATE_DECL2(I,A) friend \
- typename std::enable_if<ZORBA_TR1_NS::is_arithmetic<A>::value,bool>::type \
- operator OP( INTEGER_IMPL(I) const&, A ); \
- \
- TEMPLATE_DECL2(I,A) friend \
- typename std::enable_if<ZORBA_TR1_NS::is_arithmetic<A>::value,bool>::type \
- operator OP( A, INTEGER_IMPL(I) const& )
+#define ZORBA_INTEGER_OP(OP,T) \
+ TEMPLATE_DECL(I) friend bool operator OP( INTEGER_IMPL(I) const&, T ); \
+ TEMPLATE_DECL(I) friend bool operator OP( T, INTEGER_IMPL(I) const& )
- ZORBA_INTEGER_OP(==);
- ZORBA_INTEGER_OP(!=);
- ZORBA_INTEGER_OP(< );
- ZORBA_INTEGER_OP(<=);
- ZORBA_INTEGER_OP(> );
- ZORBA_INTEGER_OP(>=);
+ ZORBA_INTEGER_OP(==,char);
+ ZORBA_INTEGER_OP(!=,char);
+ ZORBA_INTEGER_OP(< ,char);
+ ZORBA_INTEGER_OP(<=,char);
+ ZORBA_INTEGER_OP(> ,char);
+ ZORBA_INTEGER_OP(>=,char);
+ ZORBA_INTEGER_OP(==,signed char);
+ ZORBA_INTEGER_OP(!=,signed char);
+ ZORBA_INTEGER_OP(< ,signed char);
+ ZORBA_INTEGER_OP(<=,signed char);
+ ZORBA_INTEGER_OP(> ,signed char);
+ ZORBA_INTEGER_OP(>=,signed char);
+ ZORBA_INTEGER_OP(==,short);
+ ZORBA_INTEGER_OP(!=,short);
+ ZORBA_INTEGER_OP(< ,short);
+ ZORBA_INTEGER_OP(<=,short);
+ ZORBA_INTEGER_OP(> ,short);
+ ZORBA_INTEGER_OP(>=,short);
+ ZORBA_INTEGER_OP(==,int);
+ ZORBA_INTEGER_OP(!=,int);
+ ZORBA_INTEGER_OP(< ,int);
+ ZORBA_INTEGER_OP(<=,int);
+ ZORBA_INTEGER_OP(> ,int);
+ ZORBA_INTEGER_OP(>=,int);
+ ZORBA_INTEGER_OP(==,long);
+ ZORBA_INTEGER_OP(!=,long);
+ ZORBA_INTEGER_OP(< ,long);
+ ZORBA_INTEGER_OP(<=,long);
+ ZORBA_INTEGER_OP(> ,long);
+ ZORBA_INTEGER_OP(>=,long);
+ ZORBA_INTEGER_OP(==,long long);
+ ZORBA_INTEGER_OP(!=,long long);
+ ZORBA_INTEGER_OP(< ,long long);
+ ZORBA_INTEGER_OP(<=,long long);
+ ZORBA_INTEGER_OP(> ,long long);
+ ZORBA_INTEGER_OP(>=,long long);
+ ZORBA_INTEGER_OP(==,unsigned char);
+ ZORBA_INTEGER_OP(!=,unsigned char);
+ ZORBA_INTEGER_OP(< ,unsigned char);
+ ZORBA_INTEGER_OP(<=,unsigned char);
+ ZORBA_INTEGER_OP(> ,unsigned char);
+ ZORBA_INTEGER_OP(>=,unsigned char);
+ ZORBA_INTEGER_OP(==,unsigned short);
+ ZORBA_INTEGER_OP(!=,unsigned short);
+ ZORBA_INTEGER_OP(< ,unsigned short);
+ ZORBA_INTEGER_OP(<=,unsigned short);
+ ZORBA_INTEGER_OP(> ,unsigned short);
+ ZORBA_INTEGER_OP(>=,unsigned short);
+ ZORBA_INTEGER_OP(==,unsigned int);
+ ZORBA_INTEGER_OP(!=,unsigned int);
+ ZORBA_INTEGER_OP(< ,unsigned int);
+ ZORBA_INTEGER_OP(<=,unsigned int);
+ ZORBA_INTEGER_OP(> ,unsigned int);
+ ZORBA_INTEGER_OP(>=,unsigned int);
+ ZORBA_INTEGER_OP(==,unsigned long);
+ ZORBA_INTEGER_OP(!=,unsigned long);
+ ZORBA_INTEGER_OP(< ,unsigned long);
+ ZORBA_INTEGER_OP(<=,unsigned long);
+ ZORBA_INTEGER_OP(> ,unsigned long);
+ ZORBA_INTEGER_OP(>=,unsigned long);
+ ZORBA_INTEGER_OP(==,unsigned long long);
+ ZORBA_INTEGER_OP(!=,unsigned long long);
+ ZORBA_INTEGER_OP(< ,unsigned long long);
+ ZORBA_INTEGER_OP(<=,unsigned long long);
+ ZORBA_INTEGER_OP(> ,unsigned long long);
+ ZORBA_INTEGER_OP(>=,unsigned long long);
+ ZORBA_INTEGER_OP(==,float);
+ ZORBA_INTEGER_OP(!=,float);
+ ZORBA_INTEGER_OP(< ,float);
+ ZORBA_INTEGER_OP(<=,float);
+ ZORBA_INTEGER_OP(> ,float);
+ ZORBA_INTEGER_OP(>=,float);
+ ZORBA_INTEGER_OP(==,double);
+ ZORBA_INTEGER_OP(!=,double);
+ ZORBA_INTEGER_OP(< ,double);
+ ZORBA_INTEGER_OP(<=,double);
+ ZORBA_INTEGER_OP(> ,double);
+ ZORBA_INTEGER_OP(>=,double);
#undef ZORBA_INTEGER_OP
////////// math functions ///////////////////////////////////////////////////
@@ -274,8 +449,10 @@
private:
#ifdef ZORBA_WITH_BIG_INTEGER
typedef MAPM value_type;
+ typedef long int_cast_type;
#else
typedef IntType value_type;
+ typedef IntType int_cast_type;
#endif /* ZORBA_WITH_BIG_INTEGER */
value_type value_;
@@ -289,11 +466,6 @@
}
#ifdef ZORBA_WITH_BIG_INTEGER
- template<typename T>
- static value_type cast( T n ) {
- return value_type( static_cast<long>( n ) );
- }
-
static value_type ftoi( MAPM const &d ) {
return d.sign() >= 0 ? d.floor() : d.ceil();
}
@@ -301,12 +473,12 @@
MAPM const& itod() const {
return value_; // intentional no-op
}
-#else
+
template<typename T>
- static value_type cast( T n ) {
- return static_cast<value_type>( n );
+ static value_type make_value_type( T n ) {
+ return value_type( static_cast<int_cast_type>( n ) );
}
-
+#else /* ZORBA_WITH_BIG_INTEGER */
bool is_long() const;
static value_type ftoi( value_type v ) {
@@ -316,6 +488,11 @@
static value_type ftoi( MAPM const &d );
MAPM itod() const;
+
+ template<typename T>
+ static value_type make_value_type( T n ) {
+ return static_cast<value_type>( n );
+ }
#endif /* ZORBA_WITH_BIG_INTEGER */
void parse( char const *s );
@@ -445,33 +622,29 @@
////////// assignment operators ///////////////////////////////////////////////
-TEMPLATE_DECL(I) template<typename A> inline
-typename std::enable_if<ZORBA_TR1_NS::is_arithmetic<A>::value,
- INTEGER_IMPL(I)&>::type
-INTEGER_IMPL(I)::operator=( A n ) {
- value_ = static_cast<long>( n );
- return *this;
-}
+#define ZORBA_ASSIGN_OP(T) \
+ TEMPLATE_DECL(I) inline \
+ INTEGER_IMPL(I)& INTEGER_IMPL(I)::operator=( T n ) { \
+ value_ = static_cast<int_cast_type>( n ); \
+ return *this; \
+ }
+ZORBA_ASSIGN_OP(char)
+ZORBA_ASSIGN_OP(signed char)
+ZORBA_ASSIGN_OP(short)
+ZORBA_ASSIGN_OP(int)
+ZORBA_ASSIGN_OP(long)
+ZORBA_ASSIGN_OP(unsigned char)
+ZORBA_ASSIGN_OP(unsigned short)
+ZORBA_ASSIGN_OP(unsigned int)
+ZORBA_ASSIGN_OP(float)
+ZORBA_ASSIGN_OP(double)
#ifndef ZORBA_WITH_BIG_INTEGER
-template<typename I>
-inline IntegerImpl<I>& IntegerImpl<I>::operator=( long long n ) {
- value_ = n;
- return *this;
-}
-
-template<typename I>
-inline IntegerImpl<I>& IntegerImpl<I>::operator=( unsigned long n ) {
- value_ = static_cast<long>( n );
- return *this;
-}
-
-template<typename I>
-inline IntegerImpl<I>& IntegerImpl<I>::operator=( unsigned long long n ) {
- value_ = n;
- return *this;
-}
+ZORBA_ASSIGN_OP(long long)
+ZORBA_ASSIGN_OP(unsigned long)
+ZORBA_ASSIGN_OP(unsigned long long)
#endif /* ZORBA_WITH_BIG_INTEGER */
+#undef ZORBA_ASSIGN_OP
TEMPLATE_DECL(I)
inline INTEGER_IMPL(I)& INTEGER_IMPL(I)::operator=( char const *s ) {
@@ -506,44 +679,100 @@
return INTEGER_IMPL(I)( INTEGER_IMPL(I)::ftoi( i.value_ / j.value_ ) );
}
-#define ZORBA_INTEGER_OP(OP) \
- TEMPLATE_DECL2(I,A) inline \
- typename std::enable_if<ZORBA_TR1_NS::is_arithmetic<A>::value, \
- INTEGER_IMPL(I)>::type \
- operator OP( INTEGER_IMPL(I) const& i, A n ) { \
- return INTEGER_IMPL(I)( i.value_ OP INTEGER_IMPL(I)::cast( n ) ); \
- } \
- \
- TEMPLATE_DECL2(I,A) inline \
- typename std::enable_if<ZORBA_TR1_NS::is_arithmetic<A>::value, \
- INTEGER_IMPL(I)>::type \
- operator OP( A n, INTEGER_IMPL(I) const &i ) { \
- return INTEGER_IMPL(I)( INTEGER_IMPL(I)::cast( n ) OP i.value_ ); \
- }
-
-ZORBA_INTEGER_OP(+)
-ZORBA_INTEGER_OP(-)
-ZORBA_INTEGER_OP(*)
-ZORBA_INTEGER_OP(%)
-#undef ZORBA_INTEGER_OP
-
-TEMPLATE_DECL2(I,A) inline
-typename std::enable_if<ZORBA_TR1_NS::is_arithmetic<A>::value,
- INTEGER_IMPL(I)>::type
-operator/( INTEGER_IMPL(I) const &i, A n ) {
- return INTEGER_IMPL(I)(
- INTEGER_IMPL(I)::ftoi( i.value_ / INTEGER_IMPL(I)::cast( n ) )
- );
-}
-
-TEMPLATE_DECL2(I,A) inline
-typename std::enable_if<ZORBA_TR1_NS::is_arithmetic<A>::value,
- INTEGER_IMPL(I)>::type
-operator/( A n, INTEGER_IMPL(I) const &i ) {
- return INTEGER_IMPL(I)(
- INTEGER_IMPL(I)::ftoi( INTEGER_IMPL(I)::cast( n ) / i.value_ )
- );
-}
+#define ZORBA_INTEGER_OP(OP,T) \
+ TEMPLATE_DECL(I) inline \
+ INTEGER_IMPL(I) operator OP( INTEGER_IMPL(I) const &i, T n ) { \
+ return INTEGER_IMPL(I)( i.value_ OP INTEGER_IMPL(I)::make_value_type( n ) ); \
+ } \
+ \
+ TEMPLATE_DECL(I) inline \
+ INTEGER_IMPL(I) operator OP( T n, INTEGER_IMPL(I) const &i ) { \
+ return INTEGER_IMPL(I)( INTEGER_IMPL(I)::make_value_type( n ) OP i.value_ ); \
+ }
+
+ZORBA_INTEGER_OP(+,char)
+ZORBA_INTEGER_OP(-,char)
+ZORBA_INTEGER_OP(*,char)
+ZORBA_INTEGER_OP(%,char)
+ZORBA_INTEGER_OP(+,signed char)
+ZORBA_INTEGER_OP(-,signed char)
+ZORBA_INTEGER_OP(*,signed char)
+ZORBA_INTEGER_OP(%,signed char)
+ZORBA_INTEGER_OP(+,short)
+ZORBA_INTEGER_OP(-,short)
+ZORBA_INTEGER_OP(*,short)
+ZORBA_INTEGER_OP(%,short)
+ZORBA_INTEGER_OP(+,int)
+ZORBA_INTEGER_OP(-,int)
+ZORBA_INTEGER_OP(*,int)
+ZORBA_INTEGER_OP(%,int)
+ZORBA_INTEGER_OP(+,long)
+ZORBA_INTEGER_OP(-,long)
+ZORBA_INTEGER_OP(*,long)
+ZORBA_INTEGER_OP(%,long)
+ZORBA_INTEGER_OP(+,unsigned char)
+ZORBA_INTEGER_OP(-,unsigned char)
+ZORBA_INTEGER_OP(*,unsigned char)
+ZORBA_INTEGER_OP(%,unsigned char)
+ZORBA_INTEGER_OP(+,unsigned short)
+ZORBA_INTEGER_OP(-,unsigned short)
+ZORBA_INTEGER_OP(*,unsigned short)
+ZORBA_INTEGER_OP(%,unsigned short)
+ZORBA_INTEGER_OP(+,unsigned int)
+ZORBA_INTEGER_OP(-,unsigned int)
+ZORBA_INTEGER_OP(*,unsigned int)
+ZORBA_INTEGER_OP(%,unsigned int)
+ZORBA_INTEGER_OP(+,float)
+ZORBA_INTEGER_OP(-,float)
+ZORBA_INTEGER_OP(*,float)
+ZORBA_INTEGER_OP(%,float)
+ZORBA_INTEGER_OP(+,double)
+ZORBA_INTEGER_OP(-,double)
+ZORBA_INTEGER_OP(*,double)
+ZORBA_INTEGER_OP(%,double)
+#ifndef ZORBA_WITH_BIG_INTEGER
+ZORBA_INTEGER_OP(+,long long)
+ZORBA_INTEGER_OP(-,long long)
+ZORBA_INTEGER_OP(*,long long)
+ZORBA_INTEGER_OP(%,long long)
+ZORBA_INTEGER_OP(+,unsigned long)
+ZORBA_INTEGER_OP(-,unsigned long)
+ZORBA_INTEGER_OP(*,unsigned long)
+ZORBA_INTEGER_OP(%,unsigned long)
+ZORBA_INTEGER_OP(+,unsigned long long)
+ZORBA_INTEGER_OP(-,unsigned long long)
+ZORBA_INTEGER_OP(*,unsigned long long)
+ZORBA_INTEGER_OP(%,unsigned long long)
+#endif /* ZORBA_WITH_BIG_INTEGER */
+#undef ZORBA_INTEGER_OP
+
+#define ZORBA_INTEGER_OP(T) \
+ TEMPLATE_DECL(I) inline \
+ INTEGER_IMPL(I) operator/( INTEGER_IMPL(I) const &i, T n ) { \
+ return INTEGER_IMPL(I)( INTEGER_IMPL(I)::ftoi( i.value_ / INTEGER_IMPL(I)::make_value_type( n ) ) ); \
+ } \
+ \
+ TEMPLATE_DECL(I) inline \
+ INTEGER_IMPL(I) operator/( T n, INTEGER_IMPL(I) const &i ) { \
+ return INTEGER_IMPL(I)( INTEGER_IMPL(I)::ftoi( INTEGER_IMPL(I)::make_value_type( n ) / i.value_ ) ); \
+ }
+
+ZORBA_INTEGER_OP(signed char)
+ZORBA_INTEGER_OP(char)
+ZORBA_INTEGER_OP(short)
+ZORBA_INTEGER_OP(int)
+ZORBA_INTEGER_OP(long)
+ZORBA_INTEGER_OP(unsigned char)
+ZORBA_INTEGER_OP(unsigned short)
+ZORBA_INTEGER_OP(unsigned int)
+ZORBA_INTEGER_OP(float)
+ZORBA_INTEGER_OP(double)
+#ifndef ZORBA_WITH_BIG_INTEGER
+ZORBA_INTEGER_OP(long long)
+ZORBA_INTEGER_OP(unsigned long)
+ZORBA_INTEGER_OP(unsigned long long)
+#endif /* ZORBA_WITH_BIG_INTEGER */
+#undef ZORBA_INTEGER_OP
#define ZORBA_INTEGER_OP(OP) \
TEMPLATE_DECL(I) inline \
@@ -564,28 +793,92 @@
return *this;
}
-#define ZORBA_INTEGER_OP(OP) \
- TEMPLATE_DECL(I) template<typename A> inline \
- typename std::enable_if<ZORBA_TR1_NS::is_arithmetic<A>::value, \
- INTEGER_IMPL(I)&>::type \
- INTEGER_IMPL(I)::operator OP( A n ) { \
- value_ OP cast( n ); \
- return *this; \
- }
-
-ZORBA_INTEGER_OP(+=)
-ZORBA_INTEGER_OP(-=)
-ZORBA_INTEGER_OP(*=)
-ZORBA_INTEGER_OP(%=)
-#undef ZORBA_INTEGER_OP
-
-TEMPLATE_DECL(I) template<typename A> inline
-typename std::enable_if<ZORBA_TR1_NS::is_arithmetic<A>::value,
- INTEGER_IMPL(I)&>::type
-INTEGER_IMPL(I)::operator/=( A n ) {
- value_ = ftoi( value_ / cast( n ) );
- return *this;
-}
+#define ZORBA_INTEGER_OP(OP,T) \
+ TEMPLATE_DECL(I) inline \
+ INTEGER_IMPL(I)& INTEGER_IMPL(I)::operator OP( T n ) { \
+ value_ OP make_value_type( n ); \
+ return *this; \
+ }
+
+ZORBA_INTEGER_OP(+=,char)
+ZORBA_INTEGER_OP(-=,char)
+ZORBA_INTEGER_OP(*=,char)
+ZORBA_INTEGER_OP(%=,char)
+ZORBA_INTEGER_OP(+=,signed char)
+ZORBA_INTEGER_OP(-=,signed char)
+ZORBA_INTEGER_OP(*=,signed char)
+ZORBA_INTEGER_OP(%=,signed char)
+ZORBA_INTEGER_OP(+=,short)
+ZORBA_INTEGER_OP(-=,short)
+ZORBA_INTEGER_OP(*=,short)
+ZORBA_INTEGER_OP(%=,short)
+ZORBA_INTEGER_OP(+=,int)
+ZORBA_INTEGER_OP(-=,int)
+ZORBA_INTEGER_OP(*=,int)
+ZORBA_INTEGER_OP(%=,int)
+ZORBA_INTEGER_OP(+=,long)
+ZORBA_INTEGER_OP(-=,long)
+ZORBA_INTEGER_OP(*=,long)
+ZORBA_INTEGER_OP(%=,long)
+ZORBA_INTEGER_OP(+=,unsigned char)
+ZORBA_INTEGER_OP(-=,unsigned char)
+ZORBA_INTEGER_OP(*=,unsigned char)
+ZORBA_INTEGER_OP(%=,unsigned char)
+ZORBA_INTEGER_OP(+=,unsigned short)
+ZORBA_INTEGER_OP(-=,unsigned short)
+ZORBA_INTEGER_OP(*=,unsigned short)
+ZORBA_INTEGER_OP(%=,unsigned short)
+ZORBA_INTEGER_OP(+=,unsigned int)
+ZORBA_INTEGER_OP(-=,unsigned int)
+ZORBA_INTEGER_OP(*=,unsigned int)
+ZORBA_INTEGER_OP(%=,unsigned int)
+ZORBA_INTEGER_OP(+=,float)
+ZORBA_INTEGER_OP(-=,float)
+ZORBA_INTEGER_OP(*=,float)
+ZORBA_INTEGER_OP(%=,float)
+ZORBA_INTEGER_OP(+=,double)
+ZORBA_INTEGER_OP(-=,double)
+ZORBA_INTEGER_OP(*=,double)
+ZORBA_INTEGER_OP(%=,double)
+#ifndef ZORBA_WITH_BIG_INTEGER
+ZORBA_INTEGER_OP(+=,long long)
+ZORBA_INTEGER_OP(-=,long long)
+ZORBA_INTEGER_OP(*=,long long)
+ZORBA_INTEGER_OP(%=,long long)
+ZORBA_INTEGER_OP(+=,unsigned long)
+ZORBA_INTEGER_OP(-=,unsigned long)
+ZORBA_INTEGER_OP(*=,unsigned long)
+ZORBA_INTEGER_OP(%=,unsigned long)
+ZORBA_INTEGER_OP(+=,unsigned long long)
+ZORBA_INTEGER_OP(-=,unsigned long long)
+ZORBA_INTEGER_OP(*=,unsigned long long)
+ZORBA_INTEGER_OP(%=,unsigned long long)
+#endif /* ZORBA_WITH_BIG_INTEGER */
+#undef ZORBA_INTEGER_OP
+
+#define ZORBA_INTEGER_OP(T) \
+ TEMPLATE_DECL(I) inline \
+ INTEGER_IMPL(I)& INTEGER_IMPL(I)::operator/=( T n ) { \
+ value_ = ftoi( value_ / make_value_type( n ) ); \
+ return *this; \
+ }
+
+ZORBA_INTEGER_OP(char)
+ZORBA_INTEGER_OP(signed char)
+ZORBA_INTEGER_OP(short)
+ZORBA_INTEGER_OP(int)
+ZORBA_INTEGER_OP(long)
+ZORBA_INTEGER_OP(unsigned char)
+ZORBA_INTEGER_OP(unsigned short)
+ZORBA_INTEGER_OP(unsigned int)
+ZORBA_INTEGER_OP(float)
+ZORBA_INTEGER_OP(double)
+#ifndef ZORBA_WITH_BIG_INTEGER
+ZORBA_INTEGER_OP(long long)
+ZORBA_INTEGER_OP(unsigned long)
+ZORBA_INTEGER_OP(unsigned long long)
+#endif /* ZORBA_WITH_BIG_INTEGER */
+#undef ZORBA_INTEGER_OP
TEMPLATE_DECL(I)
inline INTEGER_IMPL(I) INTEGER_IMPL(I)::operator-() const {
@@ -634,25 +927,97 @@
ZORBA_INTEGER_OP(>=)
#undef ZORBA_INTEGER_OP
-#define ZORBA_INTEGER_OP(OP) \
- TEMPLATE_DECL2(I,A) inline \
- typename std::enable_if<ZORBA_TR1_NS::is_arithmetic<A>::value,bool>::type \
- operator OP( INTEGER_IMPL(I) const &i, A n ) { \
- return i.value_ OP INTEGER_IMPL(I)::cast( n ); \
- } \
- \
- TEMPLATE_DECL2(I,A) inline \
- typename std::enable_if<ZORBA_TR1_NS::is_arithmetic<A>::value,bool>::type \
- operator OP( A n, INTEGER_IMPL(I) const &i ) { \
- return INTEGER_IMPL(I)::cast( n ) OP i.value_; \
- } \
+#define ZORBA_INTEGER_OP(OP,T) \
+ TEMPLATE_DECL(I) inline \
+ bool operator OP( INTEGER_IMPL(I) const &i, T n ) { \
+ return i.value_ OP INTEGER_IMPL(I)::make_value_type( n ); \
+ } \
+ \
+ TEMPLATE_DECL(I) inline \
+ bool operator OP( T n, INTEGER_IMPL(I) const &i ) { \
+ return INTEGER_IMPL(I)::make_value_type( n ) OP i.value_; \
+ }
- ZORBA_INTEGER_OP(==)
- ZORBA_INTEGER_OP(!=)
- ZORBA_INTEGER_OP(< )
- ZORBA_INTEGER_OP(<=)
- ZORBA_INTEGER_OP(> )
- ZORBA_INTEGER_OP(>=)
+ZORBA_INTEGER_OP(==,char)
+ZORBA_INTEGER_OP(!=,char)
+ZORBA_INTEGER_OP(< ,char)
+ZORBA_INTEGER_OP(<=,char)
+ZORBA_INTEGER_OP(> ,char)
+ZORBA_INTEGER_OP(>=,char)
+ZORBA_INTEGER_OP(==,signed char)
+ZORBA_INTEGER_OP(!=,signed char)
+ZORBA_INTEGER_OP(< ,signed char)
+ZORBA_INTEGER_OP(<=,signed char)
+ZORBA_INTEGER_OP(> ,signed char)
+ZORBA_INTEGER_OP(>=,signed char)
+ZORBA_INTEGER_OP(==,short)
+ZORBA_INTEGER_OP(!=,short)
+ZORBA_INTEGER_OP(< ,short)
+ZORBA_INTEGER_OP(<=,short)
+ZORBA_INTEGER_OP(> ,short)
+ZORBA_INTEGER_OP(>=,short)
+ZORBA_INTEGER_OP(==,int)
+ZORBA_INTEGER_OP(!=,int)
+ZORBA_INTEGER_OP(< ,int)
+ZORBA_INTEGER_OP(<=,int)
+ZORBA_INTEGER_OP(> ,int)
+ZORBA_INTEGER_OP(>=,int)
+ZORBA_INTEGER_OP(==,long)
+ZORBA_INTEGER_OP(!=,long)
+ZORBA_INTEGER_OP(< ,long)
+ZORBA_INTEGER_OP(<=,long)
+ZORBA_INTEGER_OP(> ,long)
+ZORBA_INTEGER_OP(>=,long)
+ZORBA_INTEGER_OP(==,unsigned char)
+ZORBA_INTEGER_OP(!=,unsigned char)
+ZORBA_INTEGER_OP(< ,unsigned char)
+ZORBA_INTEGER_OP(<=,unsigned char)
+ZORBA_INTEGER_OP(> ,unsigned char)
+ZORBA_INTEGER_OP(>=,unsigned char)
+ZORBA_INTEGER_OP(==,unsigned short)
+ZORBA_INTEGER_OP(!=,unsigned short)
+ZORBA_INTEGER_OP(< ,unsigned short)
+ZORBA_INTEGER_OP(<=,unsigned short)
+ZORBA_INTEGER_OP(> ,unsigned short)
+ZORBA_INTEGER_OP(>=,unsigned short)
+ZORBA_INTEGER_OP(==,unsigned int)
+ZORBA_INTEGER_OP(!=,unsigned int)
+ZORBA_INTEGER_OP(< ,unsigned int)
+ZORBA_INTEGER_OP(<=,unsigned int)
+ZORBA_INTEGER_OP(> ,unsigned int)
+ZORBA_INTEGER_OP(>=,unsigned int)
+ZORBA_INTEGER_OP(==,float)
+ZORBA_INTEGER_OP(!=,float)
+ZORBA_INTEGER_OP(< ,float)
+ZORBA_INTEGER_OP(<=,float)
+ZORBA_INTEGER_OP(> ,float)
+ZORBA_INTEGER_OP(>=,float)
+ZORBA_INTEGER_OP(==,double)
+ZORBA_INTEGER_OP(!=,double)
+ZORBA_INTEGER_OP(< ,double)
+ZORBA_INTEGER_OP(<=,double)
+ZORBA_INTEGER_OP(> ,double)
+ZORBA_INTEGER_OP(>=,double)
+#ifndef ZORBA_WITH_BIG_INTEGER
+ZORBA_INTEGER_OP(==,long long)
+ZORBA_INTEGER_OP(!=,long long)
+ZORBA_INTEGER_OP(< ,long long)
+ZORBA_INTEGER_OP(<=,long long)
+ZORBA_INTEGER_OP(> ,long long)
+ZORBA_INTEGER_OP(>=,long long)
+ZORBA_INTEGER_OP(==,unsigned long)
+ZORBA_INTEGER_OP(!=,unsigned long)
+ZORBA_INTEGER_OP(< ,unsigned long)
+ZORBA_INTEGER_OP(<=,unsigned long)
+ZORBA_INTEGER_OP(> ,unsigned long)
+ZORBA_INTEGER_OP(>=,unsigned long)
+ZORBA_INTEGER_OP(==,unsigned long long)
+ZORBA_INTEGER_OP(!=,unsigned long long)
+ZORBA_INTEGER_OP(< ,unsigned long long)
+ZORBA_INTEGER_OP(<=,unsigned long long)
+ZORBA_INTEGER_OP(> ,unsigned long long)
+ZORBA_INTEGER_OP(>=,unsigned long long)
+#endif /* ZORBA_WITH_BIG_INTEGER */
#undef ZORBA_INTEGER_OP
////////// miscellaneous //////////////////////////////////////////////////////
Follow ups
