[PPL-devel] [GIT] ppl/ppl(floating_point): Fixed several mistakes in linearize and started

[Fabio Bossi]

Module: ppl/ppl
Branch: floating_point
Commit: bd7beafc7d3db06788a182b90550ff1129923e63
URL:    http://www.cs.unipr.it/git/gitweb.cgi?p=ppl/ppl.git;a=commit;h=bd7beafc7d3db06788a182b90550ff1129923e63

Author: Fabio Bossi <bossi at cs.unipr.it>
Date:   Tue Jul 27 15:08:52 2010 +0200

Fixed several mistakes in linearize and started
to test it.

---

 src/linearize.hh                            |   36 +++++++++++++-------------
 tests/Concrete_Expression/C_Expr.inlines.hh |    5 +++
 tests/Concrete_Expression/linearize.cc      |    2 +-
 3 files changed, 24 insertions(+), 19 deletions(-)

diff --git a/src/linearize.hh b/src/linearize.hh
index 37143c0..ee8abc1 100644
--- a/src/linearize.hh
+++ b/src/linearize.hh
@@ -629,22 +629,22 @@ linearize(const Concrete_Expression<Target>& expr,
     break;
   case Floating_Point_Constant<Target>::KIND:
   {
-    Floating_Point_Constant<Target> fpc_expr =
-      static_cast<Floating_Point_Constant<Target> >(expr);
-    result = FP_Linear_Form(FP_Interval(fpc_expr.get_value_as_string()));
+    const Floating_Point_Constant<Target>* fpc_expr =
+      static_cast<const Floating_Point_Constant<Target>* >(&expr);
+    result = FP_Linear_Form(FP_Interval_Type(fpc_expr->get_value_as_string()));
     return true;
     break;
   }
   case Unary_Operator<Target>::KIND:
   {
-    Unary_Operator<Target> uop_expr =
-      static_cast<Unary_Operator<Target> >(expr);
-    switch (uop_expr.unary_operator()) {
+    const Unary_Operator<Target>* uop_expr =
+      static_cast<const Unary_Operator<Target>* >(&expr);
+    switch (uop_expr->unary_operator()) {
     case Unary_Operator<Target>::UPLUS:
-      return linearize(uop_expr.argument(), int_store, lf_store, result);
+      return linearize(*(uop_expr->argument()), int_store, lf_store, result);
       break;
     case Unary_Operator<Target>::UMINUS:
-      if (!linearize(uop_expr.argument(), int_store, lf_store, result))
+      if (!linearize(*(uop_expr->argument()), int_store, lf_store, result))
         return false;
 
       result.negate();
@@ -660,20 +660,20 @@ linearize(const Concrete_Expression<Target>& expr,
   }
   case Binary_Operator<Target>::KIND:
   {
-    Binary_Operator<Target> bop_expr =
-      static_cast<Binary_Operator<Target> >(expr);
-    switch (bop_expr.binary_operator()) {
+    const Binary_Operator<Target>* bop_expr =
+      static_cast<const Binary_Operator<Target>* >(&expr);
+    switch (bop_expr->binary_operator()) {
     case Binary_Operator<Target>::ADD:
-      return add_linearize(bop_expr, int_store, lf_store, result);
+      return add_linearize(*bop_expr, int_store, lf_store, result);
       break;
     case Binary_Operator<Target>::SUB:
-      return sub_linearize(bop_expr, int_store, lf_store, result);
+      return sub_linearize(*bop_expr, int_store, lf_store, result);
       break;
     case Binary_Operator<Target>::MUL:
-      return mul_linearize(bop_expr, int_store, lf_store, result);
+      return mul_linearize(*bop_expr, int_store, lf_store, result);
       break;
     case Binary_Operator<Target>::DIV:
-      return div_linearize(bop_expr, int_store, lf_store, result);
+      return div_linearize(*bop_expr, int_store, lf_store, result);
       break;
     case Binary_Operator<Target>::REM:
     case Binary_Operator<Target>::BAND:
@@ -691,11 +691,11 @@ linearize(const Concrete_Expression<Target>& expr,
   }
   case Approximable_Reference<Target>::KIND:
   {
-    Approximable_Reference<Target> ref_expr =
-      static_cast<Approximable_Reference<Target> >(expr);
+    const Approximable_Reference<Target>* ref_expr =
+      static_cast<const Approximable_Reference<Target>* >(&expr);
     /* Variable references are the only that we are currently
        able to analyze */
-    dimension_type variable_index = ref_expr.associated_dimension();
+    dimension_type variable_index = ref_expr->associated_dimension();
     if (variable_index == not_a_dimension())
       return false;
     else {
diff --git a/tests/Concrete_Expression/C_Expr.inlines.hh b/tests/Concrete_Expression/C_Expr.inlines.hh
index 5bc06b5..5c34a55 100644
--- a/tests/Concrete_Expression/C_Expr.inlines.hh
+++ b/tests/Concrete_Expression/C_Expr.inlines.hh
@@ -31,6 +31,11 @@ Concrete_Expression(const C_Expr_Kind KIND)
   : expr_kind(KIND) {
 }
 
+inline Concrete_Expression_Kind
+Concrete_Expression<C_Expr>::kind() const {
+  return expr_kind;
+}
+
 inline Concrete_Expression_Type
 Concrete_Expression<C_Expr>::type() const {
   return Concrete_Expression_Type::floating_point(ANALYZED_FP_FORMAT);
diff --git a/tests/Concrete_Expression/linearize.cc b/tests/Concrete_Expression/linearize.cc
index f8ea4c1..14897c1 100644
--- a/tests/Concrete_Expression/linearize.cc
+++ b/tests/Concrete_Expression/linearize.cc
@@ -32,7 +32,7 @@ bool
 test01() {
   Floating_Point_Constant<C_Expr> num("3", 2);
   Floating_Point_Constant<C_Expr> den("0", 2);
-  Binary_Operator<C_Expr> div(Binary_Operator<C_Expr>::DIV, num, den);
+  Binary_Operator<C_Expr> div(Binary_Operator<C_Expr>::DIV, &num, &den);
   FP_Linear_Form result;
   if (!linearize(div, FP_Interval_Abstract_Store(),
                  FP_Linear_Form_Abstract_Store(), result)) {