[PPL-devel] [GIT] ppl/ppl(master): Let bitwise operators be applied to unsigned integer types.

[Enea Zaffanella]

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

Author: Enea Zaffanella <zaffanella at cs.unipr.it>
Date:   Mon Feb 20 17:29:54 2012 +0100

Let bitwise operators be applied to unsigned integer types.
Detected by ECLAIR service utypflag.

---

 src/Linear_Row.cc         |   10 +++++-----
 src/Linear_Row.defs.hh    |    2 +-
 src/Linear_Row.inlines.hh |   39 ++++++++++++++++++++-------------------
 3 files changed, 26 insertions(+), 25 deletions(-)

diff --git a/src/Linear_Row.cc b/src/Linear_Row.cc
index 9b0f52d..5a5de51 100644
--- a/src/Linear_Row.cc
+++ b/src/Linear_Row.cc
@@ -152,14 +152,14 @@ const char* bit_names[] = {rpi_valid, is_rpi, nnc_valid, is_nnc};
 
 void
 PPL::Linear_Row::Flags::ascii_dump(std::ostream& s) const {
-  s << (test_bits(1 << Flags::rpi_validity_bit) ? '+' : '-')
+  s << (test_bits(1U << Flags::rpi_validity_bit) ? '+' : '-')
     << rpi_valid << ' '
-    << (test_bits(1 << Flags::rpi_bit) ? '+' : '-')
+    << (test_bits(1U << Flags::rpi_bit) ? '+' : '-')
     << is_rpi << ' '
     << ' '
-    << (test_bits(1 << Flags::nnc_validity_bit) ? '+' : '-')
+    << (test_bits(1U << Flags::nnc_validity_bit) ? '+' : '-')
     << nnc_valid << ' '
-    << (test_bits(1 << Flags::nnc_bit) ? '+' : '-')
+    << (test_bits(1U << Flags::nnc_bit) ? '+' : '-')
     << is_nnc;
 }
 
@@ -176,7 +176,7 @@ PPL::Linear_Row::Flags::ascii_load(std::istream& s) {
     if (!(s >> str))
       return false;
     if (str[0] == '+')
-      set_bits(1 << (Dense_Row::Flags::first_free_bit + bit));
+      set_bits(1U << (Dense_Row::Flags::first_free_bit + bit));
     else if (str[0] != '-')
       return false;
     if (str.compare(1, strlen(bit_names[bit]), bit_names[bit]) != 0)
diff --git a/src/Linear_Row.defs.hh b/src/Linear_Row.defs.hh
index 65c12db..b42e61f 100644
--- a/src/Linear_Row.defs.hh
+++ b/src/Linear_Row.defs.hh
@@ -187,7 +187,7 @@ public:
   private:
     //! Builds the type from a bit-mask.
     explicit Flags(base_type mask);
-    
+
     //! Constructor from a Dense_Row::Flags object.
     explicit Flags(Dense_Row::Flags flags);
 
diff --git a/src/Linear_Row.inlines.hh b/src/Linear_Row.inlines.hh
index e3037f6..571a7e3 100644
--- a/src/Linear_Row.inlines.hh
+++ b/src/Linear_Row.inlines.hh
@@ -43,75 +43,76 @@ Linear_Row::Flags::Flags(Dense_Row::Flags f)
 
 inline
 Linear_Row::Flags::Flags(const Topology t)
-  : Dense_Row::Flags(t << nnc_bit) {
+  : Dense_Row::Flags(static_cast<unsigned>(t) << nnc_bit) {
 #ifndef NDEBUG
-  set_bits(1 << nnc_validity_bit);
+  set_bits(1U << nnc_validity_bit);
 #endif
 }
 
 inline
 Linear_Row::Flags::Flags(const Topology t, const Kind k)
-  : Dense_Row::Flags((k << rpi_bit) | (t << nnc_bit)) {
+  : Dense_Row::Flags((static_cast<unsigned>(k) << rpi_bit)
+                     | (static_cast<unsigned>(t) << nnc_bit)) {
 #ifndef NDEBUG
-  set_bits((1 << rpi_validity_bit)
-	   | (1 << nnc_validity_bit));
+  set_bits((1U << rpi_validity_bit) | (1U << nnc_validity_bit));
 #endif
 }
 
 inline bool
 Linear_Row::Flags::is_ray_or_point_or_inequality() const {
-  PPL_ASSERT(test_bits(1 << rpi_validity_bit));
-  return test_bits(RAY_OR_POINT_OR_INEQUALITY << rpi_bit);
+  PPL_ASSERT(test_bits(1U << rpi_validity_bit));
+  return
+    test_bits(static_cast<unsigned>(RAY_OR_POINT_OR_INEQUALITY) << rpi_bit);
 }
 
 inline void
 Linear_Row::Flags::set_is_ray_or_point_or_inequality() {
 #ifndef NDEBUG
-  set_bits(1 << rpi_validity_bit);
+  set_bits(1U << rpi_validity_bit);
 #endif
-  set_bits(RAY_OR_POINT_OR_INEQUALITY << rpi_bit);
+  set_bits(static_cast<unsigned>(RAY_OR_POINT_OR_INEQUALITY) << rpi_bit);
 }
 
 inline bool
 Linear_Row::Flags::is_line_or_equality() const {
-  PPL_ASSERT(test_bits(1 << rpi_validity_bit));
+  PPL_ASSERT(test_bits(1U << rpi_validity_bit));
   return !is_ray_or_point_or_inequality();
 }
 
 inline void
 Linear_Row::Flags::set_is_line_or_equality() {
 #ifndef NDEBUG
-  set_bits(1 << rpi_validity_bit);
+  set_bits(1U << rpi_validity_bit);
 #endif
-  reset_bits(RAY_OR_POINT_OR_INEQUALITY << rpi_bit);
+  reset_bits(static_cast<unsigned>(RAY_OR_POINT_OR_INEQUALITY) << rpi_bit);
 }
 
 inline bool
 Linear_Row::Flags::is_not_necessarily_closed() const {
-  PPL_ASSERT(test_bits(1 << nnc_validity_bit));
-  return test_bits(NOT_NECESSARILY_CLOSED << nnc_bit);
+  PPL_ASSERT(test_bits(1U << nnc_validity_bit));
+  return test_bits(static_cast<unsigned>(NOT_NECESSARILY_CLOSED) << nnc_bit);
 }
 
 inline bool
 Linear_Row::Flags::is_necessarily_closed() const {
-  PPL_ASSERT(test_bits(1 << nnc_validity_bit));
+  PPL_ASSERT(test_bits(1U << nnc_validity_bit));
   return !is_not_necessarily_closed();
 }
 
 inline void
 Linear_Row::Flags::set_not_necessarily_closed() {
 #ifndef NDEBUG
-  set_bits(1 << nnc_validity_bit);
+  set_bits(1U << nnc_validity_bit);
 #endif
-  set_bits(NOT_NECESSARILY_CLOSED << nnc_bit);
+  set_bits(static_cast<unsigned>(NOT_NECESSARILY_CLOSED) << nnc_bit);
 }
 
 inline void
 Linear_Row::Flags::set_necessarily_closed() {
 #ifndef NDEBUG
-  set_bits(1 << nnc_validity_bit);
+  set_bits(1U << nnc_validity_bit);
 #endif
-  reset_bits(NOT_NECESSARILY_CLOSED << nnc_bit);
+  reset_bits(static_cast<unsigned>(NOT_NECESSARILY_CLOSED) << nnc_bit);
 }
 
 inline Topology