 +                                      pow((promote_type)v2, c_);
          return result_type(0.5 * diff_ * (contrasted + one_) + min_);
      }
+ 

 
         /** construct image of size 0x0
         */
@@ -569,7 +573,11 @@ class BasicImage
       width_(0),
       height_(0),
       allocator_(alloc),
+#if !defined(SOLARIS) || !defined(SUN) 
       pallocator_(alloc)
+#else
+      pallocator_()

 
         for(x=w-1; x>=0; --x, --is, --id)
         {    
             TempType f = b * old;
             old = as(is) + f;
-            double norm = (1.0 - b) / (1.0 + b - bleft - bright);
+            double norm2 = (1.0 - b) / (1.0 + b - bleft - bright);
             bleft /= b;
             bright *= b;
-            ad.set(norm * (line[x] + f), id);
+            ad.set(norm2 * (line[x] + f), id);
         }
     }
     else if(border == BORDER_TREATMENT_AVOID)
diff -uprN misc/vigra1.4.0/include/vigra/rgbvalue.hxx misc/build/vigra1.4.0/include/vigra/rgbvalue.hxx
--- misc/vigra1.4.0/include/vigra/rgbvalue.hxx	2005-12-21 05:53:43.000000000 +0100
+++ misc/build/vigra1.4.0/include/vigra/rgbvalue.hxx	2006-08-31 12:31:37.392094000 +0200
@@ -39,6 +39,10 @@
 #ifndef VIGRA_RGBVALUE_HXX
 #define VIGRA_RGBVALUE_HXX
 
+#if defined __GNUC__
+#pragma GCC system_header
+#endif
+
 #include <cmath>    // abs(double)
 #include <cstdlib>  // abs(int)
 #include "vigra/config.hxx"
@@ -700,8 +704,6 @@ operator/=(RGBValue<V, RIDX, GIDX, BIDX>
     return l;
 }
 
-using VIGRA_CSTD::abs;
-
     /// component-wise absolute value
 template <class T, unsigned int RIDX, unsigned int GIDX, unsigned int BIDX>
 inline
diff -uprN misc/vigra1.4.0/include/vigra/separableconvolution.hxx misc/build/vigra1.4.0/include/vigra/separableconvolution.hxx
--- misc/vigra1.4.0/include/vigra/separableconvolution.hxx	2005-12-21 05:53:44.000000000 +0100
+++ misc/build/vigra1.4.0/include/vigra/separableconvolution.hxx	2006-08-31 12:08:15.610465000 +0200
@@ -1017,11 +1017,11 @@ class Kernel1D
         */
     InitProxy operator=(value_type const & v)
     {
-        int size = right_ - left_ + 1;
+        int sz = right_ - left_ + 1;
         for(unsigned int i=0; i<kernel_.size(); ++i) kernel_[i] = v;
-        norm_ = (double)size*v;
+        norm_ = (double)sz*v;
 
-        return InitProxy(kernel_.begin(), size, norm_);
+        return InitProxy(kernel_.begin(), sz, norm_);
     }
 
         /** Destructor.
@@ -1235,17 +1235,17 @@ class Kernel1D
                is 1 or equals the size of the kernel.
             \endcode
         */
-    Kernel1D & initExplicitly(int left, int right)
+    Kernel1D & initExplicitly(int l, int r)
     {
-        vigra_precondition(left <= 0,
+        vigra_precondition(l <= 0,
                      "Kernel1D::initExplicitly(): left border must be <= 0.");
-        vigra_precondition(right >= 0,
+        vigra_precondition(r >= 0,
                      "Kernel1D::initExplicitly(): right border must be <= 0.");
 
-        right_ = right;
-        left_ = left;
+        right_ = r;
+        left_ = l;
 
-        kernel_.resize(right - left + 1);
+        kernel_.resize(r - l + 1);
 
         return *this;
     }
@@ -1342,8 +1342,8 @@ class Kernel1D
 };
 
 template <class ARITHTYPE>
-void Kernel1D<ARITHTYPE>::normalize(value_type norm,
-                          unsigned int derivativeOrder,
+void Kernel1D<ARITHTYPE>::normalize(value_type normFactor,
+                          unsigned int derivOrder,
                           double offset)
 {
     typedef typename NumericTraits<value_type>::RealPromote TmpType;
@@ -1352,7 +1352,7 @@ void Kernel1D<ARITHTYPE>::normalize(valu
     Iterator k = kernel_.begin();
     TmpType sum = NumericTraits<TmpType>::zero();
 
-    if(derivativeOrder == 0)
+    if(derivOrder == 0)
     {
         for(; k < kernel_.end(); ++k)
         {
@@ -1362,11 +1362,11 @@ void Kernel1D<ARITHTYPE>::normalize(valu
     else
     {
         unsigned int faculty = 1;
-        for(unsigned int i = 2; i <= derivativeOrder; ++i)
+        for(unsigned int i = 2; i <= derivOrder; ++i)
             faculty *= i;
         for(double x = left() + offset; k < kernel_.end(); ++x, ++k)
         {
-            sum += *k * VIGRA_CSTD::pow(-x, int(derivativeOrder)) / faculty;
+            sum += *k * VIGRA_CSTD::pow(-x, (double)derivOrder) / faculty;
         }
     }
 
@@ -1374,21 +1374,21 @@ void Kernel1D<ARITHTYPE>::normalize(valu
                     "Kernel1D<ARITHTYPE>::normalize(): "
                     "Cannot normalize a kernel with sum = 0");
     // normalize
-    sum = norm / sum;
+    sum = normFactor / sum;
     k = kernel_.begin();
     for(; k != kernel_.end(); ++k)
     {
         *k = *k * sum;
     }
 
-    norm_ = norm;
+    norm_ = normFactor;
 }
 
 /***********************************************************************/
 
 template <class ARITHTYPE>
 void Kernel1D<ARITHTYPE>::initGaussian(double std_dev,
-                                       value_type norm)
+                                       value_type normFactor)
 {
     vigra_precondition(std_dev >= 0.0,
               "Kernel1D::initGaussian(): Standard deviation must be >= 0.");
@@ -1421,8 +1421,8 @@ void Kernel1D<ARITHTYPE>::initGaussian(d
         right_ = 0;
     }
 
-    if(norm != 0.0)
-        normalize(norm);
+    if(normFactor != 0.0)
+        normalize(normFactor);
     else
         norm_ = 1.0;
 
@@ -1434,7 +1434,7 @@ void Kernel1D<ARITHTYPE>::initGaussian(d
 
 template <class ARITHTYPE>
 void Kernel1D<ARITHTYPE>::initDiscreteGaussian(double std_dev,
-                                       value_type norm)
+                                               value_type normFactor)
 {
     vigra_precondition(std_dev >= 0.0,
               "Kernel1D::initDiscreteGaussian(): Standard deviation must be >= 0.");
@@ -1476,7 +1476,7 @@ void Kernel1D<ARITHTYPE>::initDiscreteGa
             er += warray[i];
         }
 
-        double scale = norm / (2*er - warray[0]);
+        double scale = normFactor / (2*er - warray[0]);
 
         initExplicitly(-radius, radius);
         iterator c = center();
@@ -1489,12 +1489,12 @@ void Kernel1D<ARITHTYPE>::initDiscreteGa
     else
     {
         kernel_.erase(kernel_.begin(), kernel_.end());
-        kernel_.push_back(norm);
+        kernel_.push_back(normFactor);
         left_ = 0;
         right_ = 0;
     }
 
-    norm_ = norm;
+    norm_ = normFactor;
 
     // best border treatment for Gaussians is BORDER_TREATMENT_REFLECT
     border_treatment_ = BORDER_TREATMENT_REFLECT;
@@ -1505,15 +1505,15 @@ void Kernel1D<ARITHTYPE>::initDiscreteGa
 template <class ARITHTYPE>
 void
 Kernel1D<ARITHTYPE>::initGaussianDerivative(double std_dev,
-                    int order,
-                    value_type norm)
+                                            int order,
+                                            value_type normFactor)
 {
     vigra_precondition(order >= 0,
               "Kernel1D::initGaussianDerivative(): Order must be >= 0.");
 
     if(order == 0)
     {
-        initGaussian(std_dev, norm);
+        initGaussian(std_dev, normFactor);
         return;
     }
 
@@ -1544,7 +1544,7 @@ Kernel1D<ARITHTYPE>::initGaussianDerivat
 
     // remove DC, but only if kernel correction is permitted by a non-zero
     // value for norm
-    if(norm != 0.0)
+    if(normFactor != 0.0)
     {
         for(unsigned int i=0; i < kernel_.size(); ++i)
         {
@@ -1555,8 +1555,8 @@ Kernel1D<ARITHTYPE>::initGaussianDerivat
     left_ = -radius;
     right_ = radius;
 
-    if(norm != 0.0)
-        normalize(norm, order);
+    if(normFactor != 0.0)
+        normalize(normFactor, order);
     else
         norm_ = 1.0;
 
@@ -1570,7 +1570,7 @@ Kernel1D<ARITHTYPE>::initGaussianDerivat
 template <class ARITHTYPE>
 void
 Kernel1D<ARITHTYPE>::initBinomial(int radius,
-                                  value_type norm)
+                                  value_type normFactor)
 {
     vigra_precondition(radius > 0,
               "Kernel1D::initBinomial(): Radius must be > 0.");
@@ -1600,12 +1600,12 @@ Kernel1D<ARITHTYPE>::initBinomial(int ra
 
     for(i=0; i<=radius*2+1; ++i)
     {
-        kernel_.push_back(kernel[i] * norm);
+        kernel_.push_back(kernel[i] * normFactor);
     }
 
     left_ = -radius;
     right_ = radius;
-    norm_ = norm;
+    norm_ = normFactor;
 
     // best border treatment for Binomial is BORDER_TREATMENT_REFLECT
     border_treatment_ = BORDER_TREATMENT_REFLECT;
@@ -1615,7 +1615,7 @@ Kernel1D<ARITHTYPE>::initBinomial(int ra
 
 template <class ARITHTYPE>
 void Kernel1D<ARITHTYPE>::initAveraging(int radius,
-                                        value_type norm)
+                                        value_type normFactor)
 {
     vigra_precondition(radius > 0,
               "Kernel1D::initAveraging(): Radius must be > 0.");
@@ -1629,12 +1629,12 @@ void Kernel1D<ARITHTYPE>::initAveraging(
 
     for(int i=0; i<=radius*2+1; ++i)
     {
-        kernel_.push_back(scale * norm);
+        kernel_.push_back(scale * normFactor);
     }
 
     left_ = -radius;
     right_ = radius;
-    norm_ = norm;
+    norm_ = normFactor;
 
     // best border treatment for Averaging is BORDER_TREATMENT_CLIP
     border_treatment_ = BORDER_TREATMENT_CLIP;
@@ -1644,18 +1644,18 @@ void Kernel1D<ARITHTYPE>::initAveraging(
 
 template <class ARITHTYPE>
 void
-Kernel1D<ARITHTYPE>::initSymmetricGradient(value_type norm)
+Kernel1D<ARITHTYPE>::initSymmetricGradient(value_type normFactor)
 {
     kernel_.erase(kernel_.begin(), kernel_.end());
     kernel_.reserve(3);
 
-    kernel_.push_back(0.5 * norm);
-    kernel_.push_back(0.0 * norm);
-    kernel_.push_back(-0.5 * norm);
+    kernel_.push_back(0.5 * normFactor);
+    kernel_.push_back(0.0 * normFactor);
+    kernel_.push_back(-0.5 * normFactor);
 
     left_ = -1;
     right_ = 1;
-    norm_ = norm;
+    norm_ = normFactor;
 
     // best border treatment for SymmetricGradient is
     // BORDER_TREATMENT_REPEAT
diff -uprN misc/vigra1.4.0/include/vigra/sized_int.hxx misc/build/vigra1.4.0/include/vigra/sized_int.hxx
--- misc/vigra1.4.0/include/vigra/sized_int.hxx	2005-12-21 05:53:44.000000000 +0100
+++ misc/build/vigra1.4.0/include/vigra/sized_int.hxx	2006-08-31 12:26:31.937797000 +0200
@@ -73,6 +73,10 @@ struct SelectIntegerType<SIZE, Int_type_
     typedef Int_type_not_supported_on_this_platform type;
 };
 
+#if defined __SUNPRO_CC
+#pragma disable_warn
+#endif
+
 template<class LIST>
 struct SelectBiggestIntegerType
 {
@@ -86,6 +90,10 @@ struct SelectBiggestIntegerType
        type;
 };
 
+#if defined __SUNPRO_CC
+#pragma enable_warn
+#endif
+
 template<>
 struct SelectBiggestIntegerType<Int_type_not_supported_on_this_platform>
 {
diff -uprN misc/vigra1.4.0/include/vigra/splines.hxx misc/build/vigra1.4.0/include/vigra/splines.hxx
--- misc/vigra1.4.0/include/vigra/splines.hxx	2005-12-21 05:53:44.000000000 +0100
+++ misc/build/vigra1.4.0/include/vigra/splines.hxx	2006-08-31 12:08:15.655906000 +0200
@@ -108,8 +108,8 @@ class BSplineBase
         /** Create functor for gevine derivative of the spline. The spline's order
             is specified spline by the template argument <TT>ORDER</tt>. 
         */
-    explicit BSplineBase(unsigned int derivativeOrder = 0)
-    : s1_(derivativeOrder)
+    explicit BSplineBase(unsigned int derivOrder = 0)
+    : s1_(derivOrder)
     {}
     
         /** Unary function call.
@@ -280,8 +280,8 @@ class BSplineBase<0, T>
     typedef T            result_type; 
     enum StaticOrder { order = 0 };
 
-    explicit BSplineBase(unsigned int derivativeOrder = 0)
-    : derivativeOrder_(derivativeOrder)
+    explicit BSplineBase(unsigned int derivOrder = 0)
+    : derivativeOrder_(derivOrder)
     {}
     
     result_type operator()(argument_type x) const
@@ -357,8 +357,8 @@ class BSpline<1, T>
     typedef T            result_type; 
     enum  StaticOrder { order = 1 };
 
-    explicit BSpline(unsigned int derivativeOrder = 0)
-    : derivativeOrder_(derivativeOrder)
+    explicit BSpline(unsigned int derivOrder = 0)
+    : derivativeOrder_(derivOrder)
     {}
     
     result_type operator()(argument_type x) const
@@ -454,8 +454,8 @@ class BSpline<2, T>
     typedef T            result_type; 
     enum StaticOrder { order = 2 };
 
-    explicit BSpline(unsigned int derivativeOrder = 0)
-    : derivativeOrder_(derivativeOrder)
+    explicit BSpline(unsigned int derivOrder = 0)
+    : derivativeOrder_(derivOrder)
     {}
     
     result_type operator()(argument_type x) const
@@ -580,8 +580,8 @@ class BSpline<3, T>
     typedef T            result_type; 
     enum StaticOrder { order = 3 };
 
-    explicit BSpline(unsigned int derivativeOrder = 0)
-    : derivativeOrder_(derivativeOrder)
+    explicit BSpline(unsigned int derivOrder = 0)
+    : derivativeOrder_(derivOrder)
     {}
     
     result_type operator()(argument_type x) const
@@ -732,8 +732,8 @@ class BSpline<5, T>
     typedef T            result_type; 
     enum StaticOrder { order = 5 };
 
-    explicit BSpline(unsigned int derivativeOrder = 0)
-    : derivativeOrder_(derivativeOrder)
+    explicit BSpline(unsigned int derivOrder = 0)
+    : derivativeOrder_(derivOrder)
     {}
     
     result_type operator()(argument_type x) const
diff -uprN misc/vigra1.4.0/include/vigra/static_assert.hxx misc/build/vigra1.4.0/include/vigra/static_assert.hxx
--- misc/vigra1.4.0/include/vigra/static_assert.hxx	2005-12-21 05:53:45.000000000 +0100
+++ misc/build/vigra1.4.0/include/vigra/static_assert.hxx	2006-08-31 12:08:15.677548000 +0200
@@ -115,7 +115,7 @@ assertImpl( void (*)(Predicate), typenam
     
 TODO: provide more assertion base classes for other (non boolean) types of tests
 */
-#if !defined(__GNUC__) || __GNUC__ > 2
+#if (!defined(__GNUC__) || __GNUC__ > 2) && (!defined(__SUNPRO_CC) || __SUNPRO_CC > 0x550)
 #define VIGRA_STATIC_ASSERT(Predicate) \
 enum { \
     VIGRA_PREPROCESSOR_CONCATENATE(vigra_assertion_in_line_, __LINE__) = sizeof( \
diff -uprN misc/vigra1.4.0/include/vigra/tinyvector.hxx misc/build/vigra1.4.0/include/vigra/tinyvector.hxx
--- misc/vigra1.4.0/include/vigra/tinyvector.hxx	2005-12-21 05:53:46.000000000 +0100
+++ misc/build/vigra1.4.0/include/vigra/tinyvector.hxx	2006-08-31 12:31:25.140791000 +0200
@@ -39,6 +39,10 @@
 #ifndef VIGRA_TINYVECTOR_HXX
 #define VIGRA_TINYVECTOR_HXX
 
+#if defined __GNUC__
+#pragma GCC system_header
+#endif
+
 #include <cmath>    // abs(double)
 #include <cstdlib>  // abs(int)
 #include <iosfwd>   // ostream
@@ -49,7 +53,6 @@
 
 namespace vigra {
 
-using VIGRA_CSTD::abs;
 using VIGRA_CSTD::ceil;
 using VIGRA_CSTD::floor;
 
@@ -439,9 +442,9 @@ class TinyVectorBase
         /** Initialize from another sequence (must have length SIZE!)
         */
     template <class Iterator>
-    void init(Iterator i, Iterator end)
+    void init(Iterator i, Iterator iend)
     {
-		vigra_precondition(end-i == SIZE,
+		vigra_precondition(iend-i == SIZE,
             "TinyVector::init(): Sequence has wrong size.");
         Loop::assignCast(data_, i);
     }
diff -uprN misc/vigra1.4.0/include/vigra/transformimage.hxx misc/build/vigra1.4.0/include/vigra/transformimage.hxx
--- misc/vigra1.4.0/include/vigra/transformimage.hxx	2005-12-21 05:53:46.000000000 +0100
+++ misc/build/vigra1.4.0/include/vigra/transformimage.hxx	2006-08-31 12:08:15.727415000 +0200
@@ -986,11 +986,11 @@ class BrightnessContrastFunctor
     result_type operator()(argument_type const & v) const
     {
