27 Nov
2003
27 Nov
'03
11:49 a.m.
int_u6 = int_u8 + int_u8
est safe au niveau de l'opération arithmétique, seul l'affectation à
besoin d'être checkée.
int_u6 = int_u32 + int_u8
n'est pas safe au niveau arithmétique, ie. il ne suffit pas de faire
l'opération puis de vérifier l'affectation. (int + int => int en C/C++).
Ce patch permet de déterminer avec plus de précision les cas où un
check dynamique est requis.
Index: integre/ChangeLog
from Nicolas Burrus <burrus_n(a)lrde.epita.fr>
* tests/types/tests/int_u8: New test.
* tests/types/runtests: Rename KEEP_RUN as KEEP_RUNS.
+2003-11-27 Nicolas Burrus <burrus_n(a)lrde.epita.fr>
+
+ * ntg/real/behavior.hh: Check arithmetic operators, not arithmetic
+ assignment operators.
+ (force): New behavior.
+ (ret_behavior_if): New helper struct.
+
+ * ntg/core/value.hh: Define unsafe_type.
+ * ntg/core/macros.hh (ntg_unsafe_type): New macro.
+ * ntg/utils/cast.hh: Use ntg_unsafe_type.
+
+ * ntg/real/typetraits_builtin_int.hh: Define abstract_behavior_type.
+ * ntg/real/builtin_float.hh: Likewise.
+ * ntg/real/range.hh: Likewise.
+ * ntg/real/cycle.hh: Likewise.
+
+ * ntg/real/int_s.hh: Remove useless arithmetic operations
+ checks. Define need_check for operation traits.
+ * ntg/real/int_u.hh: Likewise.
+
+ * ntg/real/optraits_real_defs.hh: Derive arithmetic assignment
+ operators from arithmetic operators. Use the behavior given by the
+ operator traits instead of the behavior of the return type.
+ * ntg/real/optraits_real.hh: Adjust consequently.
+
+2003-11-27 Nicolas Burrus <burrus_n(a)lrde.epita.fr>
+
Make typetraits and optraits reproduce more accurately the value
hierarchy.
Index: integre/ntg/real/behavior.hh
--- integre/ntg/real/behavior.hh Wed, 26 Nov 2003 16:45:27 +0100 burrus_n
(oln/g/31_behaviour. 1.13.1.16 640)
+++ integre/ntg/real/behavior.hh Thu, 27 Nov 2003 11:26:27 +0100 burrus_n
(oln/g/31_behaviour. 1.13.1.15.1.1 640)
@@ -29,7 +29,7 @@
# define NTG_REAL_BEHAVIOUR_HH
/*
- Behaviors for data_types int_u, int_s, etc ...
+ Behaviors for real datatypes int_u, int_s, etc ...
<WARNING> Don't forget that behaviors are checked on assignements
and contruction of types, and use comparison, so create only vars
@@ -53,10 +53,10 @@
# include <string>
# include <sstream>
-
// FIXME: there is maybe simpler a way to write that, but we want it
// to be compatible with icc, so the behaviors must stay classes, not
// meta classes.
+// FIXME: are these considerations still accurate?
namespace ntg
{
@@ -86,28 +86,28 @@
template <class T1, class T2>
static T
- check_plus_equal (T1 lhs, T2 rhs)
+ check_plus (T1 lhs, T2 rhs)
{ return lhs + rhs; }
template <class T1, class T2>
static T
- check_minus_equal (T1 lhs, T2 rhs)
+ check_minus (T1 lhs, T2 rhs)
{ return lhs - rhs; }
template <class T1, class T2>
static T
- check_times_equal (T1 lhs, T2 rhs)
+ check_times (T1 lhs, T2 rhs)
{ return lhs * rhs; }
template <class T1, class T2>
static T
- check_div_equal (T1 lhs, T2 rhs)
+ check_div (T1 lhs, T2 rhs)
{ return lhs / rhs; }
template <class P>
static storage_type
check (const P& p)
- { return static_cast<storage_type>(p); }
+ { return p; }
};
static std::string
@@ -115,6 +115,63 @@
{ return "unsafe"; }
};
+ /*------.
+ | force |
+ `------*/
+ //! Force the value to be assigned without checks.
+ /*!
+ Quite similar to unsafe, but even if the destination type has a
+ strict behavior, by using cast::force we ensure that no check will
+ be performed.
+
+ Example:
+
+ int_u<8, strict> a;
+ a = force::get<int_u<8, strict> >::check_plus(5, 6);
+
+ => no check
+
+ This construction is useful when we want to use code from a
+ particular behavior to a type defined with another behavior.
+ */
+ struct force
+ {
+ template <class T>
+ struct get
+ {
+ typedef ntgi_storage_type(T) storage_type;
+
+ template <class T1, class T2>
+ static T
+ check_plus (T1 lhs, T2 rhs)
+ { return cast::force<T>(lhs + rhs); }
+
+ template <class T1, class T2>
+ static T
+ check_minus (T1 lhs, T2 rhs)
+ { return cast::force<T>(lhs - rhs); }
+
+ template <class T1, class T2>
+ static T
+ check_times (T1 lhs, T2 rhs)
+ { return cast::force<T>(lhs * rhs); }
+
+ template <class T1, class T2>
+ static T
+ check_div (T1 lhs, T2 rhs)
+ { return cast::force<T>(lhs / rhs); }
+
+ template <class P>
+ static storage_type
+ check (const P& p)
+ { return cast::force<T>(p); }
+ };
+
+ static std::string
+ name()
+ { return "force"; }
+ };
+
/*-------.
| strict |
`-------*/
@@ -136,7 +193,7 @@
template <class T1, class T2>
static T
- check_plus_equal (T1 lhs, T2 rhs)
+ check_plus (T1 lhs, T2 rhs)
{
T ret = lhs + rhs;
if (rhs > 0)
@@ -148,7 +205,7 @@
template <class T1, class T2>
static T
- check_minus_equal (T1 lhs, T2 rhs)
+ check_minus (T1 lhs, T2 rhs)
{
T ret = lhs - rhs;
if (rhs > 0)
@@ -161,7 +218,7 @@
// FIXME: this check is very slow! Find another solution.
template <class T1, class T2>
static T
- check_times_equal (T1 lhs, T2 rhs)
+ check_times (T1 lhs, T2 rhs)
{
T ret = lhs * rhs;
if (rhs != 0)
@@ -171,7 +228,7 @@
template <class T1, class T2>
static T
- check_div_equal (T1 lhs, T2 rhs)
+ check_div (T1 lhs, T2 rhs)
{ return lhs / rhs; }
template <class P>
@@ -203,7 +260,7 @@
template <class T1, class T2>
static T
- check_plus_equal (T1 lhs, T2 rhs)
+ check_plus (T1 lhs, T2 rhs)
{
T ret = lhs + rhs;
if (rhs > 0)
@@ -218,7 +275,7 @@
template <class T1, class T2>
static T
- check_minus_equal (T1 lhs, T2 rhs)
+ check_minus (T1 lhs, T2 rhs)
{
T ret = lhs - rhs;
if (rhs > 0)
@@ -234,7 +291,7 @@
// FIXME: this check is very slow ! find another solution ...
template <class T1, class T2>
static T
- check_times_equal (T1 lhs, T2 rhs)
+ check_times (T1 lhs, T2 rhs)
{
T ret = lhs * rhs;
if ((ret / rhs) != lhs)
@@ -250,7 +307,7 @@
template <class T1, class T2>
static T
- check_div_equal (T1 lhs, T2 rhs)
+ check_div (T1 lhs, T2 rhs)
{ return lhs / rhs; }
template <class P>
@@ -292,19 +349,19 @@
// FIXME: calculate real values!
template <class T1, class T2>
- static T check_plus_equal (T1 lhs, T2 rhs)
+ static T check_plus (T1 lhs, T2 rhs)
{ return lhs + rhs; }
template <class T1, class T2>
- static T check_minus_equal (T1 lhs, T2 rhs)
+ static T check_minus (T1 lhs, T2 rhs)
{ return lhs - rhs; }
template <class T1, class T2>
- static T check_times_equal (T1 lhs, T2 rhs)
+ static T check_times (T1 lhs, T2 rhs)
{ return lhs * rhs; }
template <class T1, class T2>
- static T check_div_equal (T1 lhs, T2 rhs)
+ static T check_div (T1 lhs, T2 rhs)
{ return lhs / rhs; }
// float modulus
@@ -372,6 +429,32 @@
struct deduce_op_behavior<B, B>
{ typedef B ret; };
+ /*----------------.
+ | ret_behavior_if |
+ `----------------*/
+
+ //! Determine the behavior to use depending on check requirements.
+ /*!
+ If need_check is true, the returned behavior will be the same as
+ the previously determined return type (generally safe).
+
+ In some cases, no check is required, thus type used to perform
+ the calculus does not need to be safe. The force behavior is
+ returned in such cases.
+ */
+
+ template <bool need_check, class Ret>
+ struct ret_behavior_if
+ {
+ typedef typename typetraits<Ret>::abstract_behavior_type ret;
+ };
+
+ template <class Ret>
+ struct ret_behavior_if<false, Ret>
+ {
+ typedef ntg::force ret;
+ };
+
} // end of internal.
} // end of ntg.
Index: integre/ntg/utils/cast.hh
--- integre/ntg/utils/cast.hh Fri, 07 Nov 2003 17:26:19 +0100 burrus_n (oln/i/26_cast.hh
1.3.1.10 640)
+++ integre/ntg/utils/cast.hh Thu, 27 Nov 2003 11:26:27 +0100 burrus_n (oln/i/26_cast.hh
1.3.1.11 640)
@@ -74,7 +74,7 @@
const Tdest
force(const Tsrc& val)
{
- Tdest tmp(static_cast<ntg_storage_type(Tdest)>(val));
+ ntg_unsafe_type(Tdest) tmp (val);
return tmp;
}
Index: integre/ntg/real/int_s.hh
--- integre/ntg/real/int_s.hh Thu, 27 Nov 2003 11:17:00 +0100 burrus_n (oln/g/24_int_s.hh
1.16.1.18 640)
+++ integre/ntg/real/int_s.hh Thu, 27 Nov 2003 11:26:27 +0100 burrus_n (oln/g/24_int_s.hh
1.16.1.16.1.1 640)
@@ -46,17 +46,41 @@
// FIXME: add bits number comparison to avoid useless checks.
-# define INT_S_CTOR_FROM_BUILTIN(Builtin) \
+# define INT_S_CTOR_FROM_UNSIGNED_BUILTIN(Builtin) \
int_s (const Builtin rhs) \
{ \
+ if ((unsigned) internal::typetraits<ntg_type(Builtin)>::size < nbits) \
+ this->val_ = rhs; \
+ else \
this->val_ = optraits_type::check(rhs); \
} \
self& operator=(const Builtin rhs) \
{ \
+ if ((unsigned) internal::typetraits<ntg_type(Builtin)>::size < nbits) \
+ this->val_ = rhs; \
+ else \
this->val_ = optraits_type::check(rhs); \
return *this; \
}
+# define INT_S_CTOR_FROM_SIGNED_BUILTIN(Builtin) \
+int_s (const Builtin rhs) \
+{ \
+ if ((unsigned)internal::typetraits<ntg_type(Builtin)>::size <= nbits) \
+ this->val_ = rhs; \
+ else \
+ this->val_ = optraits_type::check(rhs); \
+} \
+self& operator=(const Builtin rhs) \
+{ \
+ if ((unsigned)internal::typetraits<ntg_type(Builtin)>::size <= nbits) \
+ this->val_ = rhs; \
+ else \
+ this->val_ = optraits_type::check(rhs); \
+ return *this; \
+}
+
+
namespace ntg {
namespace internal {
@@ -76,6 +100,7 @@
ntg_build_value_type(sint_value<E>);
typedef optraits<self> optraits_type;
+ typedef behavior abstract_behavior_type;
typedef typename behavior::template get<self> behavior_type;
typedef self base_type;
@@ -90,6 +115,9 @@
typedef int_u<32, behavior> unsigned_largest_type;
typedef int_u<32, behavior> unsigned_cumul_type;
typedef signed int integer_type;
+
+ // Particular properties
+ enum { size = nbits };
};
} // end of internal.
@@ -112,18 +140,18 @@
// We define ctor for each builtin to avoid implicit builtin
// promotion.
- INT_S_CTOR_FROM_BUILTIN(unsigned long);
- INT_S_CTOR_FROM_BUILTIN(signed long);
+ INT_S_CTOR_FROM_UNSIGNED_BUILTIN(unsigned long);
+ INT_S_CTOR_FROM_SIGNED_BUILTIN(signed long);
- INT_S_CTOR_FROM_BUILTIN(unsigned int);
- INT_S_CTOR_FROM_BUILTIN(signed int);
+ INT_S_CTOR_FROM_UNSIGNED_BUILTIN(unsigned int);
+ INT_S_CTOR_FROM_SIGNED_BUILTIN(signed int);
- INT_S_CTOR_FROM_BUILTIN(unsigned short);
- INT_S_CTOR_FROM_BUILTIN(signed short);
+ INT_S_CTOR_FROM_UNSIGNED_BUILTIN(unsigned short);
+ INT_S_CTOR_FROM_SIGNED_BUILTIN(signed short);
- INT_S_CTOR_FROM_BUILTIN(unsigned char);
- INT_S_CTOR_FROM_BUILTIN(signed char);
- INT_S_CTOR_FROM_BUILTIN(char);
+ INT_S_CTOR_FROM_UNSIGNED_BUILTIN(unsigned char);
+ INT_S_CTOR_FROM_SIGNED_BUILTIN(signed char);
+ INT_S_CTOR_FROM_SIGNED_BUILTIN(char);
template <unsigned mbits, class B2>
int_s (const int_s<mbits, B2>& rhs)
@@ -306,7 +334,8 @@
// debug
static std::string name() {
std::ostringstream out;
- out << "int_s<" << int(nbits) << ", " <<
behavior::name() << ">"<< std::ends;
+ out << "int_s<" << int(nbits) << ", " <<
behavior::name() << ">"
+ << std::ends;
return out.str();
}
};
@@ -325,10 +354,12 @@
template<unsigned nbits, class B1, unsigned mbits, class B2>
struct operator_traits<operator_plus, int_s<nbits, B1>, int_s<mbits,
B2> >
{
- enum { commutative = true };
+ enum { commutative = true,
+ need_check = ((unsigned) mlc::max<nbits, mbits>::ret >= 32) };
typedef int_s<(unsigned)mlc::maxN<nbits + 1,mbits + 1, 32>::ret,
typename deduce_op_behavior<B1, B2>::ret> ret;
- typedef int_s<nbits, B1> impl;
+ typedef int_s<nbits,
+ typename ret_behavior_if<need_check, ret>::ret> impl;
};
@@ -337,10 +368,12 @@
template <unsigned nbits, class B1, unsigned mbits, class B2>
struct operator_traits<operator_plus, int_s<nbits, B1>, int_u<mbits,
B2> >
{
- enum { commutative = true };
+ enum { commutative = true,
+ need_check = ((mbits >= 31) || (nbits >= 32)) };
typedef int_s<(unsigned)mlc::maxN<nbits + 1,mbits + 2, 32>::ret,
typename deduce_op_behavior<B1, B2>::ret> ret;
- typedef int_s<nbits, B1> impl;
+ typedef int_s<nbits,
+ typename ret_behavior_if<need_check, ret>::ret> impl;
};
@@ -353,10 +386,12 @@
template<unsigned nbits, class B1, unsigned mbits, class B2>
struct operator_traits<operator_minus, int_s<nbits, B1>, int_s<mbits,
B2> >
{
- enum { commutative = true };
+ enum { commutative = true,
+ need_check = ((mbits >= 31) || (nbits >= 31)) };
typedef int_s<(unsigned)mlc::maxN<nbits + 1, mbits + 1, 32>::ret,
typename deduce_op_behavior<B1, B2>::ret> ret;
- typedef int_s<nbits, B1> impl;
+ typedef int_s<nbits,
+ typename ret_behavior_if<need_check, ret>::ret> impl;
};
// int_s - int_u ; int_u - int_s
@@ -364,10 +399,12 @@
template <unsigned nbits, class B1, unsigned mbits, class B2>
struct operator_traits<operator_minus, int_s<nbits, B1>, int_u<mbits,
B2> >
{
- enum { commutative = true };
+ enum { commutative = true,
+ need_check = ((mbits >= 31) || (nbits >= 32)) };
typedef int_s<(unsigned)mlc::maxN<nbits + 1, mbits + 2, 32>::ret,
typename deduce_op_behavior<B1, B2>::ret> ret;
- typedef int_s<nbits, B1> impl;
+ typedef int_s<nbits,
+ typename ret_behavior_if<need_check, ret>::ret> impl;
};
@@ -380,10 +417,12 @@
template<unsigned nbits, class B1, unsigned mbits, class B2>
struct operator_traits<operator_times, int_s<nbits, B1>, int_s<mbits,
B2> >
{
- enum { commutative = true };
+ enum { commutative = true,
+ need_check = (mbits + nbits > 32) };
typedef int_s<(unsigned)mlc::saturateN<nbits + mbits, 32>::ret,
typename deduce_op_behavior<B1, B2>::ret> ret;
- typedef int_s<nbits, B1> impl;
+ typedef int_s<nbits,
+ typename ret_behavior_if<need_check, ret>::ret> impl;
};
@@ -392,10 +431,12 @@
template <unsigned nbits, class B1, unsigned mbits, class B2>
struct operator_traits<operator_times, int_s<nbits, B1>, int_u<mbits,
B2> >
{
- enum { commutative = true };
+ enum { commutative = true,
+ need_check = (nbits + mbits + 1 > 32)};
typedef int_s<(unsigned)mlc::saturateN<nbits + mbits+1, 32>::ret,
typename deduce_op_behavior<B1, B2>::ret> ret;
- typedef int_s<nbits, B1> impl;
+ typedef int_s<nbits,
+ typename ret_behavior_if<need_check, ret>::ret> impl;
};
//
@@ -409,7 +450,7 @@
{
enum { commutative = true };
typedef int_s<nbits, typename deduce_op_behavior<B1, B2>::ret> ret;
- typedef int_s<nbits, B1> impl;
+ typedef int_s<nbits, force> impl;
};
// int_s / int_u ; int_u / int_s
@@ -417,18 +458,22 @@
template <unsigned nbits, class B1, unsigned mbits, class B2>
struct operator_traits<operator_div, int_s<nbits, B1>, int_u<mbits,
B2> >
{
- enum { commutative = false };
+ enum { commutative = false,
+ need_check = (mbits >= 32) };
typedef int_s<nbits, typename deduce_op_behavior<B1, B2>::ret> ret;
- typedef int_s<nbits, B1> impl;
+ typedef int_s<nbits,
+ typename ret_behavior_if<need_check, ret>::ret> impl;
};
template <unsigned nbits, class B1, unsigned mbits, class B2>
struct operator_traits<operator_div, int_u<mbits, B2>, int_s<nbits,
B1> >
{
- enum { commutative = false };
+ enum { commutative = false,
+ need_check = (mbits >= 32) };
typedef int_s<mlc::saturateN<mbits + 1, 32>::ret,
typename deduce_op_behavior<B1, B2>::ret> ret;
- typedef int_s<nbits, B1> impl;
+ typedef int_s<nbits,
+ typename ret_behavior_if<need_check, ret>::ret> impl;
};
//
@@ -442,7 +487,7 @@
{
enum { commutative = false };
typedef int_s<mbits, typename deduce_op_behavior<B1, B2>::ret> ret;
- typedef int_s<nbits, B1> impl;
+ typedef int_s<nbits, force> impl;
};
// int_s % int_u ; int_u % int_s
@@ -450,12 +495,19 @@
template <unsigned nbits, class B1, unsigned mbits, class B2>
struct operator_traits<operator_mod, int_s<nbits, B1>, int_u<mbits,
B2> >
{
- enum { commutative = false };
+ enum { commutative = false,
+ need_check = (mbits >= 32) };
typedef int_s<(unsigned)mlc::saturateN<mbits + 1, 32>::ret,
typename deduce_op_behavior<B1, B2>::ret> ret;
- typedef int_s<nbits, B1> impl;
+ typedef int_s<nbits,
+ typename ret_behavior_if<need_check, ret>::ret> impl;
};
+ // FIXME: don't know what to do with this operator, so the
+ // implementation is disabled. In classical C++, (a % b) with b < 0
+ // returns a whatever b is.
+
+#if 0
template <unsigned nbits, class B1, unsigned mbits, class B2>
struct operator_traits<operator_mod, int_u<nbits, B1>, int_s<mbits,
B2> >
{
@@ -463,7 +515,7 @@
typedef int_u<mbits, typename deduce_op_behavior<B1, B2>::ret> ret;
typedef int_s<nbits, B1> impl;
};
-
+#endif
//
// Min
@@ -477,7 +529,7 @@
enum { commutative = true };
typedef int_s<(unsigned) mlc::min<nbits, mbits>::ret,
typename deduce_op_behavior<B1, B2>::ret> ret;
- typedef int_s<nbits, B1> impl;
+ typedef int_s<nbits, force> impl;
};
//
@@ -492,7 +544,7 @@
enum { commutative = true };
typedef int_s<(unsigned) mlc::max<nbits, mbits>::ret,
typename deduce_op_behavior<B1, B2>::ret> ret;
- typedef int_s<nbits, B1> impl;
+ typedef int_s<nbits, force> impl;
};
//
@@ -506,7 +558,7 @@
{
enum { commutative = true };
typedef int_s<(unsigned)mlc::maxN<nbits,mbits,32>::ret, unsafe> ret;
- typedef int_s<nbits, B1> impl;
+ typedef int_s<nbits, force> impl;
};
@@ -517,7 +569,7 @@
{
enum { commutative = true };
typedef int_s<(unsigned)mlc::maxN<nbits,mbits+1, 32>::ret, unsafe>
ret;
- typedef int_s<nbits, B1> impl;
+ typedef int_s<nbits, force> impl;
};
} // end of internal.
Index: integre/ntg/real/int_u.hh
--- integre/ntg/real/int_u.hh Thu, 27 Nov 2003 11:17:00 +0100 burrus_n (oln/g/23_int_u.hh
1.19.1.18 640)
+++ integre/ntg/real/int_u.hh Thu, 27 Nov 2003 11:26:27 +0100 burrus_n (oln/g/23_int_u.hh
1.19.1.16.1.1 640)
@@ -42,6 +42,23 @@
| macros |
`-------*/
+# define INT_U_CTOR_FROM_UNSIGNED_BUILTIN_INT(Builtin) \
+int_u (const Builtin rhs) \
+{ \
+ if ((unsigned) internal::typetraits<ntg_type(Builtin)>::size <= nbits) \
+ this->val_ = rhs; \
+ else \
+ this->val_ = optraits_type::check(rhs); \
+} \
+self& operator=(const Builtin rhs) \
+{ \
+ if ((unsigned) internal::typetraits<ntg_type(Builtin)>::size <= nbits) \
+ this->val_ = rhs; \
+ else \
+ this->val_ = optraits_type::check(rhs); \
+ return *this; \
+}
+
# define INT_U_CTOR_FROM_BUILTIN_INT(Builtin) \
int_u (const Builtin rhs) \
{ \
@@ -53,6 +70,7 @@
return *this; \
}
+
namespace ntg {
namespace internal {
@@ -72,9 +90,9 @@
ntg_build_value_type(uint_value<E>);
typedef optraits<self> optraits_type;
+ typedef behavior abstract_behavior_type;
typedef typename behavior::template get<self> behavior_type;
-
typedef self base_type;
typedef typename C_for_int_u<nbits>::type storage_type;
typedef int_s<mlc::saturateN<nbits+1, 32>::ret,
@@ -88,6 +106,10 @@
typedef int_u<32, behavior> unsigned_largest_type;
typedef int_u<32, behavior> unsigned_cumul_type;
typedef unsigned int integer_type;
+ typedef int_u<nbits, unsafe> unsafe_type;
+
+ // Particular properties
+ enum { size = nbits };
};
} // end of internal.
@@ -111,16 +133,18 @@
// We define ctor for each builtin to avoid implicit builtin
// promotion.
- INT_U_CTOR_FROM_BUILTIN_INT(unsigned long);
+ // FIXME: dynamic checks are not necessary for all builtin types!
+
+ INT_U_CTOR_FROM_UNSIGNED_BUILTIN_INT(unsigned long);
INT_U_CTOR_FROM_BUILTIN_INT(signed long);
- INT_U_CTOR_FROM_BUILTIN_INT(unsigned int);
+ INT_U_CTOR_FROM_UNSIGNED_BUILTIN_INT(unsigned int);
INT_U_CTOR_FROM_BUILTIN_INT(signed int);
- INT_U_CTOR_FROM_BUILTIN_INT(unsigned short);
+ INT_U_CTOR_FROM_UNSIGNED_BUILTIN_INT(unsigned short);
INT_U_CTOR_FROM_BUILTIN_INT(signed short);
- INT_U_CTOR_FROM_BUILTIN_INT(unsigned char);
+ INT_U_CTOR_FROM_UNSIGNED_BUILTIN_INT(unsigned char);
INT_U_CTOR_FROM_BUILTIN_INT(signed char);
INT_U_CTOR_FROM_BUILTIN_INT(char);
@@ -252,10 +276,12 @@
template<unsigned nbits, class B1, unsigned mbits, class B2>
struct operator_traits<operator_plus, int_u<nbits, B1>, int_u<mbits,
B2> >
{
- enum { commutative = true };
+ enum { commutative = true,
+ need_check = ((unsigned) mlc::max<nbits, mbits>::ret >= 32) };
typedef int_u<(unsigned) mlc::maxN<nbits + 1, mbits + 1, 32>::ret,
typename deduce_op_behavior<B1, B2>::ret> ret;
- typedef int_u<nbits, B1> impl;
+ typedef int_u<nbits,
+ typename ret_behavior_if<need_check, ret>::ret> impl;
};
//
@@ -267,10 +293,12 @@
template<unsigned nbits, class B1, unsigned mbits, class B2>
struct operator_traits<operator_minus, int_u<nbits, B1>, int_u<mbits,
B2> >
{
- enum { commutative = true };
+ enum { commutative = true,
+ need_check = ((unsigned) mlc::max<nbits, mbits>::ret >= 32) };
typedef int_s<(unsigned) mlc::maxN<nbits+1, mbits+1, 32>::ret,
typename deduce_op_behavior<B1, B2>::ret> ret;
- typedef int_u<nbits, B1> impl;
+ typedef int_u<nbits,
+ typename ret_behavior_if<need_check, ret>::ret> impl;
};
// int_u32 - int_u : we do not convert result to int_s because we
@@ -281,7 +309,7 @@
{
enum { commutative = true };
typedef int_u<32, typename deduce_op_behavior<B1, B2>::ret> ret;
- typedef int_u<32, B1> impl;
+ typedef int_u<32, force> impl;
};
//
@@ -293,10 +321,11 @@
template<unsigned nbits, class B1, unsigned mbits, class B2>
struct operator_traits<operator_times, int_u<nbits, B1>, int_u<mbits,
B2> >
{
- enum { commutative = true };
+ enum { commutative = true, need_check = (nbits + mbits > 32) };
typedef int_u<(unsigned) mlc::saturateN<nbits + mbits, 32>::ret,
typename deduce_op_behavior<B1, B2>::ret> ret;
- typedef int_u<nbits, B1> impl;
+ typedef int_u<nbits,
+ typename ret_behavior_if<need_check, ret>::ret> impl;
};
//
@@ -310,7 +339,7 @@
{
enum { commutative = true };
typedef int_u<nbits, typename deduce_op_behavior<B1, B2>::ret> ret;
- typedef int_u<nbits, B1> impl;
+ typedef int_u<nbits, force> impl;
};
//
@@ -324,7 +353,7 @@
{
enum { commutative = false };
typedef int_u<mbits, typename deduce_op_behavior<B1, B2>::ret> ret;
- typedef int_u<nbits, B1> impl;
+ typedef int_u<nbits, force> impl;
};
//
@@ -339,7 +368,7 @@
enum { commutative = true };
typedef int_u<(unsigned) mlc::min<nbits, mbits>::ret,
typename deduce_op_behavior<B1, B2>::ret> ret;
- typedef int_u<nbits, B1> impl;
+ typedef int_u<nbits, force> impl;
};
@@ -355,7 +384,7 @@
enum { commutative = true };
typedef int_u<(unsigned) mlc::max<nbits, mbits>::ret,
typename deduce_op_behavior<B1, B2>::ret> ret;
- typedef int_u<nbits, B1> impl;
+ typedef int_u<nbits, force> impl;
};
@@ -369,8 +398,9 @@
struct operator_traits<operator_cmp, int_u<nbits, B1>, int_u<mbits,
B2> >
{
enum { commutative = true };
+ // FIXME: why unsafe? I think there is a reason.
typedef int_u<(unsigned) mlc::maxN<nbits, mbits, 32>::ret, unsafe>
ret;
- typedef int_u<nbits, B1> impl;
+ typedef int_u<nbits, force> impl;
};
} // end of internal.
Index: integre/ntg/real/optraits_real_defs.hh
--- integre/ntg/real/optraits_real_defs.hh Wed, 26 Nov 2003 16:45:27 +0100 burrus_n
(oln/g/11_optraits_s 1.15 640)
+++ integre/ntg/real/optraits_real_defs.hh Thu, 27 Nov 2003 11:26:27 +0100 burrus_n
(oln/g/11_optraits_s 1.14.1.1 640)
@@ -29,23 +29,23 @@
# define NTG_OPTRAITS_REAL_DEFS_HH
//
-// macros used in optraits_scalar definition
+// macros used in optraits_real definition
//
/////////////////////////////////////////////
-# define ASSIGN_SCALAR_OPERATOR(Name, Op) \
+# define ASSIGN_SCALAR_OPERATOR(Name) \
template <class T1, class T2> inline \
- static T1& Name(T1& lhs, const T2& rhs) \
+ static T1& Name##_equal(T1& lhs, const T2& rhs) \
{ \
ntg_is_a(T1, ntg::real)::ensure(); \
ntg_is_a(T2, ntg::real)::ensure(); \
\
- return Name##_impl<T1,T2>(lhs, rhs); \
+ return Name##_equal_impl<T1,T2>(lhs, rhs); \
} \
\
template <class T1, class T2> inline \
static T1& \
- Name##_impl(ntg::real_value<T1>& lhs, \
+ Name##_equal_impl(ntg::real_value<T1>& lhs, \
const ntg::real_value<T2>& rhs) \
{ \
typedef typename typetraits<T1>::behavior_type behavior_type; \
@@ -56,7 +56,7 @@
\
template <class T1, class T2> inline \
static T1& \
- Name##_impl(ntg::real_value<T1>& lhs, \
+ Name##_equal_impl(ntg::real_value<T1>& lhs, \
const ntg::any_const_class<T2> rhs) \
{ \
typedef typename typetraits<T1>::behavior_type behavior_type; \
@@ -67,7 +67,7 @@
\
template <class T1, class T2> inline \
static T1& \
- Name##_impl(ntg::any_class<T1> lhs, \
+ Name##_equal_impl(ntg::any_class<T1> lhs, \
const ntg::real_value<T2>& rhs) \
{ \
typedef typename typetraits<T1>::behavior_type behavior_type; \
@@ -76,7 +76,7 @@
return lhs.exact(); \
}
-# define ARITH_SCALAR_OPERATOR(Name, Op) \
+# define ARITH_SCALAR_OPERATOR(Name) \
template <class T1, class T2> inline \
static ntg_return_type(Name, T1, T2) \
Name(const T1& lhs, const T2& rhs) \
@@ -84,13 +84,54 @@
ntg_is_a(T1, ntg::real)::ensure(); \
ntg_is_a(T2, ntg::real)::ensure(); \
\
+ return Name##_impl<T1,T2>(lhs, rhs); \
+ } \
+ \
+ template <class T1, class T2> inline \
+ static ntg_return_type(Name, T1, T2) \
+ Name##_impl(const ntg::real_value<T1>& lhs, \
+ const ntg::real_value<T2>& rhs) \
+ { \
typedef ntg_return_type(Name, T1, T2) return_type; \
- return_type result(lhs); \
- result Op rhs; \
- return result; \
+ typedef typename \
+ typetraits<E>::abstract_behavior_type::get<return_type> \
+ behavior_type; \
+ return_type tmp; \
+ tmp = behavior_type::check_##Name(lhs.exact().val(), \
+ rhs.exact().val()); \
+ return tmp; \
+ } \
+ \
+ template <class T1, class T2> inline \
+ static ntg_return_type(Name, T1, T2) \
+ Name##_impl(const ntg::real_value<T1>& lhs, \
+ const ntg::any_const_class<T2>& rhs) \
+ { \
+ typedef ntg_return_type(Name, T1, T2) return_type; \
+ typedef typename \
+ typetraits<E>::abstract_behavior_type::get<return_type> \
+ behavior_type; \
+ return_type tmp; \
+ tmp = behavior_type::check_##Name(lhs.exact().val(), \
+ rhs.exact()); \
+ return tmp; \
+ } \
+ \
+ template <class T1, class T2> inline \
+ static ntg_return_type(Name, T1, T2) \
+ Name##_impl(const ntg::any_const_class<T1>& lhs, \
+ const ntg::real_value<T2>& rhs) \
+ { \
+ typedef ntg_return_type(Name, T1, T2) return_type; \
+ typedef typename \
+ typetraits<E>::abstract_behavior_type::get<return_type> \
+ behavior_type; \
+ return_type tmp; \
+ tmp = behavior_type::check_##Name(lhs.exact(), \
+ rhs.exact().val()); \
+ return tmp; \
}
-
# define CMP_SCALAR_OPERATOR(Name, Op) \
template <class T1, class T2> inline \
static bool Name (const T1& lhs, const T2& rhs) \
@@ -105,7 +146,8 @@
} \
\
template <class T> inline \
- static bool Name##_impl(const ntg::real_value<T>& lhs, \
+ static bool \
+ Name##_impl(const ntg::real_value<T>& lhs, \
const ntg::real_value<T>& rhs) \
{ return lhs.exact().val() Op rhs.exact().val(); } \
\
@@ -121,7 +163,6 @@
//
////////////////////////////
-
# define ASSIGN_INT_OPERATOR(Name, Op) \
template <class T1, class T2> inline \
static T1& Name(T1& lhs, const T2& rhs) \
Index: integre/ntg/real/optraits_real.hh
--- integre/ntg/real/optraits_real.hh Thu, 27 Nov 2003 11:17:00 +0100 burrus_n
(oln/g/12_optraits_s 1.11.1.10 640)
+++ integre/ntg/real/optraits_real.hh Thu, 27 Nov 2003 11:26:27 +0100 burrus_n
(oln/g/12_optraits_s 1.11.1.8.1.1 640)
@@ -65,27 +65,26 @@
static storage_type_ default_val() { return zero(); }
//
- // dev note : the goal in those default operators is to check the kind
+ // dev note : the aim of these default operators is to check the kind
// of operands (value or not), and then call the good function.
//
// ASSIGN_SCALAR_OPERATOR includes default check_xxx_equal functions
//
- ASSIGN_SCALAR_OPERATOR(plus_equal, +)
- ASSIGN_SCALAR_OPERATOR(minus_equal, -)
- ASSIGN_SCALAR_OPERATOR(times_equal, *)
- ASSIGN_SCALAR_OPERATOR(div_equal, /)
-
- ARITH_SCALAR_OPERATOR(plus, +=)
- ARITH_SCALAR_OPERATOR(minus, -=)
- ARITH_SCALAR_OPERATOR(times, *=)
- ARITH_SCALAR_OPERATOR(div, /=)
+ ASSIGN_SCALAR_OPERATOR(plus)
+ ASSIGN_SCALAR_OPERATOR(minus)
+ ASSIGN_SCALAR_OPERATOR(times)
+ ASSIGN_SCALAR_OPERATOR(div)
+
+ ARITH_SCALAR_OPERATOR(plus)
+ ARITH_SCALAR_OPERATOR(minus)
+ ARITH_SCALAR_OPERATOR(times)
+ ARITH_SCALAR_OPERATOR(div)
CMP_SCALAR_OPERATOR(cmp_eq, ==)
CMP_SCALAR_OPERATOR(cmp_lt, <)
};
-
/*----------------------.
| optraits<float_value> |
`----------------------*/
Index: integre/ntg/core/value.hh
--- integre/ntg/core/value.hh Thu, 27 Nov 2003 11:17:00 +0100 burrus_n (oln/g/8_rec_value.
1.8.1.9 640)
+++ integre/ntg/core/value.hh Thu, 27 Nov 2003 11:26:27 +0100 burrus_n (oln/g/8_rec_value.
1.8.1.8.1.1 640)
@@ -107,7 +107,9 @@
template <class E>
struct typetraits<value<E> >
- {};
+ {
+ typedef E unsafe_type;
+ };
template <class E>
struct optraits<value<E> >
Index: integre/ntg/real/typetraits_builtin_int.hh
--- integre/ntg/real/typetraits_builtin_int.hh Thu, 27 Nov 2003 11:17:00 +0100 burrus_n
(oln/g/3_typetraits 1.7.1.13 640)
+++ integre/ntg/real/typetraits_builtin_int.hh Thu, 27 Nov 2003 11:26:27 +0100 burrus_n
(oln/g/3_typetraits 1.7.1.11.1.1 640)
@@ -51,6 +51,7 @@
\
typedef optraits<self> optraits; \
typedef unsafe::get<self> behavior_type; \
+ typedef unsafe abstract_behavior_type; \
\
typedef self base_type; \
typedef self storage_type; \
Index: integre/tests/types/runtests
--- integre/tests/types/runtests Fri, 01 Aug 2003 11:42:33 +0200 burrus_n
(oln/h/3_runtests 1.14.1.6 750)
+++ integre/tests/types/runtests Thu, 27 Nov 2003 11:26:27 +0100 burrus_n
(oln/h/3_runtests 1.14.1.7 750)
@@ -93,7 +93,7 @@
msg="";
case $expected:$estatus in
ok:0 | compfail:50 | abort:134)
- if test ! x"$KEEP_RUN" = x"1"; then
+ if test ! x"$KEEP_RUNS" = x"1"; then
rm -rf "$dir";
fi
msg="(ok)" ;;
Index: integre/ntg/core/macros.hh
--- integre/ntg/core/macros.hh Sun, 27 Jul 2003 19:14:42 +0200 burrus_n
(oln/s/19_macros.hh 1.7 640)
+++ integre/ntg/core/macros.hh Thu, 27 Nov 2003 11:26:27 +0100 burrus_n
(oln/s/19_macros.hh 1.8 640)
@@ -92,6 +92,9 @@
# define ntg_comp_type_(T) \
ntg::type_traits<T>::comp_type
+# define ntg_unsafe_type(T) typename ntg::type_traits<T>::unsafe_type
+# define ntg_unsafe_type_(T) ntg::type_traits<T>::unsafe_type
+
/*-----------------.
| values accessors |
`-----------------*/
Index: integre/ntg/real/builtin_float.hh
--- integre/ntg/real/builtin_float.hh Thu, 27 Nov 2003 11:17:00 +0100 burrus_n
(oln/s/47_builtin_fl 1.4 640)
+++ integre/ntg/real/builtin_float.hh Thu, 27 Nov 2003 11:26:27 +0100 burrus_n
(oln/s/47_builtin_fl 1.2.1.1 640)
@@ -57,6 +57,7 @@
typedef optraits<self> optraits_type;
typedef unsafe::get<self> behavior_type;
+ typedef unsafe abstract_behavior_type;
typedef self base_type;
typedef self storage_type;
@@ -86,6 +87,7 @@
typedef optraits<self> optraits_type;
typedef unsafe::get<self> behavior_type;
+ typedef unsafe abstract_behavior_type;
typedef self base_type;
typedef self storage_type;
Index: integre/ntg/real/range.hh
--- integre/ntg/real/range.hh Thu, 27 Nov 2003 11:17:00 +0100 burrus_n (oln/t/16_range.hh
1.5 640)
+++ integre/ntg/real/range.hh Thu, 27 Nov 2003 11:26:27 +0100 burrus_n (oln/t/16_range.hh
1.3.1.1 640)
@@ -53,6 +53,7 @@
typedef self ntg_type;
typedef optraits<self> optraits_type;
typedef typename behavior::template get<self> behavior_type;
+ typedef behavior abstract_behavior_type;
typedef ntgi_base_type(T) base_type;
typedef T storage_type;
Index: integre/ntg/real/cycle.hh
--- integre/ntg/real/cycle.hh Thu, 27 Nov 2003 11:17:00 +0100 burrus_n (oln/t/17_cycle.hh
1.3 640)
+++ integre/ntg/real/cycle.hh Thu, 27 Nov 2003 11:26:27 +0100 burrus_n (oln/t/17_cycle.hh
1.2.1.1 640)
@@ -53,6 +53,7 @@
typedef self ntg_type;
typedef optraits<self> optraits_type;
typedef cycle_behavior::get<self> behavior_type;
+ typedef cycle_behavior abstract_behavior_type;
typedef typename typetraits<T>::base_type base_type;
typedef T storage_type;
Index: integre/tests/types/tests/int_u8
--- integre/tests/types/tests/int_u8 Thu, 27 Nov 2003 11:45:11 +0100 burrus_n ()
+++ integre/tests/types/tests/int_u8 Thu, 27 Nov 2003 11:26:27 +0100 burrus_n
(oln/w/6_int_u8 1.1 640)
@@ -0,0 +1,9 @@
+int_u8 u1 = (unsigned char) 56;
+int_u8 u2 = (unsigned char) 153;
+int_u32 u = 0U;
+
+for (unsigned i = 0; i < 5000000; ++i)
+ for (unsigned j = 0; j < 10; ++j)
+ u = u1 * u2 + int_u8u(i % 50);
+
+return u != 8617;