[PATCH] Canonicalize evaluators wrt constness

[Richard Guenther]

Hi!

The following patch makes all evaluators honour the same constness
assumptions. Namely applying a functor doesnt change it (ok, because
evaluation order undefined) and such all the wrapping stuff not, too.

Regtested on x86, ok?

Richard.


2003Oct13  Richard Guenther <address@hidden>

        * src/Evaluator/ScalarCode.h: mark methods/arguments const
        where possible.
        src/Evaluator/LoopApply.h: likewise.

diff -Nru a/r2/src/Evaluator/LoopApply.h b/r2/src/Evaluator/LoopApply.h
--- a/r2/src/Evaluator/LoopApply.h      Mon Oct 13 16:22:58 2003
+++ b/r2/src/Evaluator/LoopApply.h      Mon Oct 13 16:22:58 2003
@@ -89,13 +89,14 @@
   // of the domain.

   template<class Op, class Dom>
-  inline static void evaluate(Op &op, const Dom &domain)
+  inline static
+  void evaluate(const Op &op, const Dom &domain)
   {
     evaluate(op, domain, WrappedInt<Dom::dimensions>());
   }

   template<class Op, class Domain>
-  inline static void evaluate(Op &op, const Domain &domain, WrappedInt<1>)
+  inline static void evaluate(const Op &op, const Domain &domain, 
WrappedInt<1>)
   {
     CTAssert(Domain::unitStride);
     int f0 = domain[0].first();
@@ -106,7 +107,7 @@
   }

   template<class Op, class Domain>
-  inline static void evaluate(Op &op, const Domain &domain, WrappedInt<2>)
+  inline static void evaluate(const Op &op, const Domain &domain, 
WrappedInt<2>)
   {
     CTAssert(Domain::unitStride);
     int f0 = domain[0].first();
@@ -120,7 +121,7 @@
   }

   template<class Op, class Domain>
-  inline static void evaluate(Op &op, const Domain &domain, WrappedInt<3>)
+  inline static void evaluate(const Op &op, const Domain &domain, 
WrappedInt<3>)
   {
     CTAssert(Domain::unitStride);
     int f0 = domain[0].first();
@@ -137,7 +138,7 @@
   }

   template<class Op, class Domain>
-  inline static void evaluate(Op &op, const Domain &domain, WrappedInt<4>)
+  inline static void evaluate(const Op &op, const Domain &domain, 
WrappedInt<4>)
   {
     CTAssert(Domain::unitStride);
     int f0 = domain[0].first();
@@ -157,7 +158,7 @@
   }

   template<class Op, class Domain>
-  inline static void evaluate(Op &op, const Domain &domain, WrappedInt<5>)
+  inline static void evaluate(const Op &op, const Domain &domain, 
WrappedInt<5>)
   {
     CTAssert(Domain::unitStride);
     int f0 = domain[0].first();
@@ -180,7 +181,7 @@
   }

   template<class Op, class Domain>
-  inline static void evaluate(Op &op, const Domain &domain, WrappedInt<6>)
+  inline static void evaluate(const Op &op, const Domain &domain, 
WrappedInt<6>)
   {
     CTAssert(Domain::unitStride);
     int f0 = domain[0].first();
@@ -206,7 +207,7 @@
   }

   template<class Op, class Domain>
-  inline static void evaluate(Op &op, const Domain &domain, WrappedInt<7>)
+  inline static void evaluate(const Op &op, const Domain &domain, 
WrappedInt<7>)
   {
     CTAssert(Domain::unitStride);
     int f0 = domain[0].first();
diff -Nru a/r2/src/Evaluator/ScalarCode.h b/r2/src/Evaluator/ScalarCode.h
--- a/r2/src/Evaluator/ScalarCode.h     Mon Oct 13 16:22:58 2003
+++ b/r2/src/Evaluator/ScalarCode.h     Mon Oct 13 16:22:58 2003
@@ -96,266 +96,266 @@
 template<class A1, class Function>
 struct ApplyMultiArgLoc<MultiArg1<A1>, Function>
 {
-  ApplyMultiArgLoc(MultiArg1<A1> &multiArg, Function &function)
+  ApplyMultiArgLoc(const MultiArg1<A1> &multiArg, const Function &function)
     : multiArg_m(multiArg), function_m(function)
   {
   }

-  void operator()(int i0)
+  void operator()(int i0) const
   {
     function_m(multiArg_m.a1_m, Loc<1>(i0));
   }

-  void operator()(int i0, int i1)
+  void operator()(int i0, int i1) const
   {
     function_m(multiArg_m.a1_m, Loc<2>(i0, i1));
   }

-  void operator()(int i0, int i1, int i2)
+  void operator()(int i0, int i1, int i2) const
   {
     function_m(multiArg_m.a1_m, Loc<3>(i0, i1, i2));
   }

-  void operator()(int i0, int i1, int i2, int i3)
+  void operator()(int i0, int i1, int i2, int i3) const
   {
     function_m(multiArg_m.a1_m, Loc<4>(i0, i1, i2, i3));
   }

-  MultiArg1<A1> &multiArg_m;
-  Function &function_m;
+  const MultiArg1<A1> &multiArg_m;
+  const Function &function_m;
 };

 template<class A1, class A2, class Function>
 struct ApplyMultiArgLoc<MultiArg2<A1, A2>, Function>
 {
-  ApplyMultiArgLoc(MultiArg2<A1, A2> &multiArg,Function &function)
+  ApplyMultiArgLoc(const MultiArg2<A1, A2> &multiArg,const Function &function)
     : multiArg_m(multiArg), function_m(function)
   {
   }

-  void operator()(int i0)
+  void operator()(int i0) const
   {
     function_m(multiArg_m.a1_m, multiArg_m.a2_m, Loc<1>(i0));
   }

-  void operator()(int i0, int i1)
+  void operator()(int i0, int i1) const
   {
     function_m(multiArg_m.a1_m, multiArg_m.a2_m, Loc<2>(i0, i1));
   }

-  void operator()(int i0, int i1, int i2)
+  void operator()(int i0, int i1, int i2) const
   {
     function_m(multiArg_m.a1_m, multiArg_m.a2_m, Loc<3>(i0, i1, i2));
   }

-  void operator()(int i0, int i1, int i2, int i3)
+  void operator()(int i0, int i1, int i2, int i3) const
   {
     function_m(multiArg_m.a1_m, multiArg_m.a2_m, Loc<4>(i0, i1, i2, i3));
   }

-  MultiArg2<A1, A2> &multiArg_m;
-  Function &function_m;
+  const MultiArg2<A1, A2> &multiArg_m;
+  const Function &function_m;
 };

 template<class A1, class A2, class A3, class Function>
 struct ApplyMultiArgLoc<MultiArg3<A1, A2, A3>, Function>
 {
-  ApplyMultiArgLoc(MultiArg3<A1, A2, A3> &multiArg,
-                  Function &function)
+  ApplyMultiArgLoc(const MultiArg3<A1, A2, A3> &multiArg,
+                  const Function &function)
     : multiArg_m(multiArg), function_m(function)
   {
   }

-  void operator()(int i0)
+  void operator()(int i0) const
   {
     function_m(multiArg_m.a1_m, multiArg_m.a2_m, multiArg_m.a3_m,
               Loc<1>(i0));
   }

-  void operator()(int i0, int i1)
+  void operator()(int i0, int i1) const
   {
     function_m(multiArg_m.a1_m, multiArg_m.a2_m, multiArg_m.a3_m,
               Loc<2>(i0, i1));
   }

-  void operator()(int i0, int i1, int i2)
+  void operator()(int i0, int i1, int i2) const
   {
     function_m(multiArg_m.a1_m, multiArg_m.a2_m, multiArg_m.a3_m,
               Loc<3>(i0, i1, i2));
   }

-  void operator()(int i0, int i1, int i2, int i3)
+  void operator()(int i0, int i1, int i2, int i3) const
   {
     function_m(multiArg_m.a1_m, multiArg_m.a2_m, multiArg_m.a3_m,
               Loc<4>(i0, i1, i2, i3));
   }

-  MultiArg3<A1, A2, A3> &multiArg_m;
-  Function &function_m;
+  const MultiArg3<A1, A2, A3> &multiArg_m;
+  const Function &function_m;
 };

 template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, 
class Function>
 struct ApplyMultiArgLoc<MultiArg7<A1, A2, A3, A4, A5, A6, A7>, Function>
 {
-  ApplyMultiArgLoc(MultiArg7<A1, A2, A3, A4, A5, A6, A7> &multiArg,
-                  Function &function)
+  ApplyMultiArgLoc(const MultiArg7<A1, A2, A3, A4, A5, A6, A7> &multiArg,
+                  const Function &function)
     : multiArg_m(multiArg), function_m(function)
   {
   }

-  void operator()(int i0)
+  void operator()(int i0) const
   {
     function_m(multiArg_m.a1_m, multiArg_m.a2_m, multiArg_m.a3_m,
                multiArg_m.a4_m, multiArg_m.a5_m, multiArg_m.a6_m,
                multiArg_m.a7_m, Loc<1>(i0));
   }

-  void operator()(int i0, int i1)
+  void operator()(int i0, int i1) const
   {
     function_m(multiArg_m.a1_m, multiArg_m.a2_m, multiArg_m.a3_m,
                multiArg_m.a4_m, multiArg_m.a5_m, multiArg_m.a6_m,
                multiArg_m.a7_m, Loc<2>(i0, i1));
   }

-  void operator()(int i0, int i1, int i2)
+  void operator()(int i0, int i1, int i2) const
   {
     function_m(multiArg_m.a1_m, multiArg_m.a2_m, multiArg_m.a3_m,
                multiArg_m.a4_m, multiArg_m.a5_m, multiArg_m.a6_m,
                multiArg_m.a7_m, Loc<3>(i0, i1, i2));
   }

-  void operator()(int i0, int i1, int i2, int i3)
+  void operator()(int i0, int i1, int i2, int i3) const
   {
     function_m(multiArg_m.a1_m, multiArg_m.a2_m, multiArg_m.a3_m,
                multiArg_m.a4_m, multiArg_m.a5_m, multiArg_m.a6_m,
                multiArg_m.a7_m, Loc<4>(i0, i1, i2, i3));
   }

-  MultiArg7<A1, A2, A3, A4, A5, A6, A7> &multiArg_m;
-  Function &function_m;
+  const MultiArg7<A1, A2, A3, A4, A5, A6, A7> &multiArg_m;
+  const Function &function_m;
 };

 template<class A1, class A2, class A3, class A4, class A5, class A6, class 
Function>
 struct ApplyMultiArgLoc<MultiArg6<A1, A2, A3, A4, A5, A6>, Function>
 {
-  ApplyMultiArgLoc(MultiArg6<A1, A2, A3, A4, A5, A6> &multiArg,
-                  Function &function)
+  ApplyMultiArgLoc(const MultiArg6<A1, A2, A3, A4, A5, A6> &multiArg,
+                  const Function &function)
     : multiArg_m(multiArg), function_m(function)
   {
   }

-  void operator()(int i0)
+  void operator()(int i0) const
   {
     function_m(multiArg_m.a1_m, multiArg_m.a2_m, multiArg_m.a3_m,
                multiArg_m.a4_m, multiArg_m.a5_m, multiArg_m.a6_m,
                Loc<1>(i0));
   }

-  void operator()(int i0, int i1)
+  void operator()(int i0, int i1) const
   {
     function_m(multiArg_m.a1_m, multiArg_m.a2_m, multiArg_m.a3_m,
                multiArg_m.a4_m, multiArg_m.a5_m, multiArg_m.a6_m,
                 Loc<2>(i0, i1));
   }

-  void operator()(int i0, int i1, int i2)
+  void operator()(int i0, int i1, int i2) const
   {
     function_m(multiArg_m.a1_m, multiArg_m.a2_m, multiArg_m.a3_m,
                multiArg_m.a4_m, multiArg_m.a5_m, multiArg_m.a6_m,
                Loc<3>(i0, i1, i2));
   }

-  void operator()(int i0, int i1, int i2, int i3)
+  void operator()(int i0, int i1, int i2, int i3) const
   {
     function_m(multiArg_m.a1_m, multiArg_m.a2_m, multiArg_m.a3_m,
                multiArg_m.a4_m, multiArg_m.a5_m, multiArg_m.a6_m,
                Loc<4>(i0, i1, i2, i3));
   }

-  MultiArg6<A1, A2, A3, A4, A5, A6> &multiArg_m;
-  Function &function_m;
+  const MultiArg6<A1, A2, A3, A4, A5, A6> &multiArg_m;
+  const Function &function_m;
 };

 template<class A1, class A2, class A3, class A4, class Function>
 struct ApplyMultiArgLoc<MultiArg4<A1, A2, A3, A4>, Function>
 {
-  ApplyMultiArgLoc(MultiArg4<A1, A2, A3, A4> &multiArg,
-                  Function &function)
+  ApplyMultiArgLoc(const MultiArg4<A1, A2, A3, A4> &multiArg,
+                  const Function &function)
     : multiArg_m(multiArg), function_m(function)
   {
   }

-  void operator()(int i0)
+  void operator()(int i0) const
   {
     function_m(multiArg_m.a1_m, multiArg_m.a2_m, multiArg_m.a3_m,
                multiArg_m.a4_m,
                Loc<1>(i0));
   }

-  void operator()(int i0, int i1)
+  void operator()(int i0, int i1) const
   {
     function_m(multiArg_m.a1_m, multiArg_m.a2_m, multiArg_m.a3_m,
                multiArg_m.a4_m,
                 Loc<2>(i0, i1));
   }

-  void operator()(int i0, int i1, int i2)
+  void operator()(int i0, int i1, int i2) const
   {
     function_m(multiArg_m.a1_m, multiArg_m.a2_m, multiArg_m.a3_m,
                multiArg_m.a4_m,
                Loc<3>(i0, i1, i2));
   }

-  void operator()(int i0, int i1, int i2, int i3)
+  void operator()(int i0, int i1, int i2, int i3) const
   {
     function_m(multiArg_m.a1_m, multiArg_m.a2_m, multiArg_m.a3_m,
                multiArg_m.a4_m,
                Loc<4>(i0, i1, i2, i3));
   }

-  MultiArg4<A1, A2, A3, A4> &multiArg_m;
-  Function &function_m;
+  const MultiArg4<A1, A2, A3, A4> &multiArg_m;
+  const Function &function_m;
 };

 template<class A1, class A2, class A3, class A4, class A5, class Function>
 struct ApplyMultiArgLoc<MultiArg5<A1, A2, A3, A4, A5>, Function>
 {
-  ApplyMultiArgLoc(MultiArg5<A1, A2, A3, A4, A5> &multiArg,
-                  Function &function)
+  ApplyMultiArgLoc(const MultiArg5<A1, A2, A3, A4, A5> &multiArg,
+                  const Function &function)
     : multiArg_m(multiArg), function_m(function)
   {
   }

-  void operator()(int i0)
+  void operator()(int i0) const
   {
     function_m(multiArg_m.a1_m, multiArg_m.a2_m, multiArg_m.a3_m,
                multiArg_m.a4_m, multiArg_m.a5_m,
                Loc<1>(i0));
   }

-  void operator()(int i0, int i1)
+  void operator()(int i0, int i1) const
   {
     function_m(multiArg_m.a1_m, multiArg_m.a2_m, multiArg_m.a3_m,
                multiArg_m.a4_m, multiArg_m.a5_m,
                 Loc<2>(i0, i1));
   }

-  void operator()(int i0, int i1, int i2)
+  void operator()(int i0, int i1, int i2) const
   {
     function_m(multiArg_m.a1_m, multiArg_m.a2_m, multiArg_m.a3_m,
                multiArg_m.a4_m, multiArg_m.a5_m,
                Loc<3>(i0, i1, i2));
   }

-  void operator()(int i0, int i1, int i2, int i3)
+  void operator()(int i0, int i1, int i2, int i3) const
   {
     function_m(multiArg_m.a1_m, multiArg_m.a2_m, multiArg_m.a3_m,
                multiArg_m.a4_m, multiArg_m.a5_m,
                Loc<4>(i0, i1, i2, i3));
   }

-  MultiArg5<A1, A2, A3, A4, A5> &multiArg_m;
-  Function &function_m;
+  const MultiArg5<A1, A2, A3, A4, A5> &multiArg_m;
+  const Function &function_m;
 };

 template<class Function, int Dim>
@@ -371,7 +371,7 @@
   }

   template<class MultiArg>
-  void operator()(MultiArg &multiArg)
+  void operator()(MultiArg &multiArg) const
   {
     ApplyMultiArgLoc<MultiArg, Function> op(multiArg, function_m);
     LoopApplyEvaluator::evaluate(op, domain_m);
@@ -394,7 +394,7 @@
   }

   template<class F1>
-  void operator()(const F1 &f1)
+  void operator()(const F1 &f1) const
   {
     enum { dimensions = F1::dimensions };
     MultiArg1<F1> multiArg(f1);
@@ -408,7 +408,7 @@
   }

   template<class F1, class F2>
-  void operator()(const F1 &f1, const F2 &f2)
+  void operator()(const F1 &f1, const F2 &f2) const
   {
     enum { dimensions = F1::dimensions };
     MultiArg2<F1, F2> multiArg(f1, f2);
@@ -422,7 +422,7 @@
   }

   template<class F1, class F2, class F3>
-  void operator()(const F1 &f1, const F2 &f2, const F3 &f3)
+  void operator()(const F1 &f1, const F2 &f2, const F3 &f3) const
   {
     enum { dimensions = F1::dimensions };
     MultiArg3<F1, F2, F3> multiArg(f1, f2, f3);
@@ -436,7 +436,7 @@
   }

   template<class F1, class F2, class F3, class F4>
-  void operator()(const F1 &f1, const F2 &f2, const F3 &f3, const F4 &f4)
+  void operator()(const F1 &f1, const F2 &f2, const F3 &f3, const F4 &f4) const
   {
     enum { dimensions = F1::dimensions };
     MultiArg4<F1, F2, F3, F4> multiArg(f1, f2, f3, f4);
@@ -451,7 +451,7 @@

   template<class F1, class F2, class F3, class F4, class F5>
   void operator()(const F1 &f1, const F2 &f2, const F3 &f3, const F4 &f4,
-                 const F5 &f5)
+                 const F5 &f5) const
   {
     enum { dimensions = F1::dimensions };
     MultiArg5<F1, F2, F3, F4, F5> multiArg(f1, f2, f3, f4, f5);
@@ -466,7 +466,7 @@

   template<class F1, class F2, class F3, class F4, class F5, class F6>
   void operator()(const F1 &f1, const F2 &f2, const F3 &f3, const F4 &f4,
-                 const F5 &f5, const F6 &f6)
+                 const F5 &f5, const F6 &f6) const
   {
     enum { dimensions = F1::dimensions };
     MultiArg6<F1, F2, F3, F4, F5, F6> multiArg(f1, f2, f3, f4, f5, f6);
@@ -481,7 +481,7 @@

   template<class F1, class F2, class F3, class F4, class F5, class F6, class 
F7>
   void operator()(const F1 &f1, const F2 &f2, const F3 &f3, const F4 &f4,
-                 const F5 &f5, const F6 &f6, const F7 &f7)
+                 const F5 &f5, const F6 &f6, const F7 &f7) const
   {
     enum { dimensions = F1::dimensions };
     MultiArg7<F1, F2, F3, F4, F5, F6, F7> multiArg(f1, f2, f3, f4, f5, f6, f7);