Index: boost/thread/v2/shared_mutex.hpp
===================================================================
--- boost/thread/v2/shared_mutex.hpp	(revision 83553)
+++ boost/thread/v2/shared_mutex.hpp	(working copy)
@@ -165,16 +165,16 @@
     {
       typedef ::boost::mutex              mutex_t;
       typedef ::boost::condition_variable cond_t;
-      typedef unsigned                count_t;
+      typedef unsigned                    count_t;
 
       mutex_t mut_;
       cond_t  gate1_;
       cond_t  gate2_;
-      count_t state_;
+      count_t write_entered_ : 1,
+              n_readers_     : 31;
+      
+      static const count_t N_READERS_MAX = 0x7FFFFFFF;
 
-      static const count_t write_entered_ = 1U << (sizeof(count_t)*CHAR_BIT - 1);
-      static const count_t n_readers_ = ~write_entered_;
-
     public:
       BOOST_THREAD_INLINE shared_mutex();
       BOOST_THREAD_INLINE ~shared_mutex();
@@ -244,28 +244,28 @@
         const boost::chrono::time_point<Clock, Duration>& abs_time)
     {
       boost::unique_lock<mutex_t> lk(mut_);
-      if (state_ & write_entered_)
+      if (write_entered_)
       {
         while (true)
         {
           boost::cv_status status = gate1_.wait_until(lk, abs_time);
-          if ((state_ & write_entered_) == 0)
+          if ((write_entered_) == 0)
             break;
           if (status == boost::cv_status::timeout)
             return false;
         }
       }
-      state_ |= write_entered_;
-      if (state_ & n_readers_)
+      write_entered_ = true;
+      if (n_readers_)
       {
         while (true)
         {
           boost::cv_status status = gate2_.wait_until(lk, abs_time);
-          if ((state_ & n_readers_) == 0)
+          if (n_readers_ == 0)
             break;
           if (status == boost::cv_status::timeout)
           {
-            state_ &= ~write_entered_;
+            write_entered_ = false;
             return false;
           }
         }
@@ -279,21 +279,18 @@
         const boost::chrono::time_point<Clock, Duration>& abs_time)
     {
       boost::unique_lock<mutex_t> lk(mut_);
-      if ((state_ & write_entered_) || (state_ & n_readers_) == n_readers_)
+      if (write_entered_ || n_readers_ == N_READERS_MAX)
       {
         while (true)
         {
           boost::cv_status status = gate1_.wait_until(lk, abs_time);
-          if ((state_ & write_entered_) == 0 &&
-              (state_ & n_readers_) < n_readers_)
+          if ((write_entered_ == 0) && (n_readers_ < N_READERS_MAX))
             break;
           if (status == boost::cv_status::timeout)
             return false;
         }
       }
-      count_t num_readers = (state_ & n_readers_) + 1;
-      state_ &= ~n_readers_;
-      state_ |= num_readers;
+      ++n_readers_;
       return true;
     }
 
@@ -301,28 +298,28 @@
     bool shared_mutex::timed_lock(system_time const& abs_time)
     {
       boost::unique_lock<mutex_t> lk(mut_);
-      if (state_ & write_entered_)
+      if (write_entered_)
       {
         while (true)
         {
           bool status = gate1_.timed_wait(lk, abs_time);
-          if ((state_ & write_entered_) == 0)
+          if (write_entered_ == 0)
             break;
           if (!status)
             return false;
         }
       }
-      state_ |= write_entered_;
-      if (state_ & n_readers_)
+      write_entered_ = true;
+      if (n_readers_)
       {
         while (true)
         {
           bool status = gate2_.timed_wait(lk, abs_time);
-          if ((state_ & n_readers_) == 0)
+          if (n_readers_ == 0)
             break;
           if (!status)
           {
-            state_ &= ~write_entered_;
+            write_entered_ = false;
             return false;
           }
         }
@@ -332,28 +329,28 @@
       bool shared_mutex::timed_lock_shared(system_time const& abs_time)
       {
         boost::unique_lock<mutex_t> lk(mut_);
-        if (state_ & write_entered_)
+        if (write_entered_)
         {
           while (true)
           {
             bool status = gate1_.timed_wait(lk, abs_time);
-            if ((state_ & write_entered_) == 0)
+            if (write_entered_ == 0)
               break;
             if (!status )
               return false;
           }
         }
-        state_ |= write_entered_;
-        if (state_ & n_readers_)
+        write_entered_ = true;
+        if (n_readers_)
         {
           while (true)
           {
             bool status = gate2_.timed_wait(lk, abs_time);
-            if ((state_ & n_readers_) == 0)
+            if (n_readers_ == 0)
               break;
             if (!status)
             {
-              state_ &= ~write_entered_;
+              write_entered_ = false;
               return false;
             }
           }
@@ -742,7 +739,7 @@
     // shared_mutex
 
     shared_mutex::shared_mutex()
-    : state_(0)
+    : write_entered_(0), n_readers_(0)
     {
     }
 
@@ -757,10 +754,10 @@
     shared_mutex::lock()
     {
       boost::unique_lock<mutex_t> lk(mut_);
-      while (state_ & write_entered_)
+      while (write_entered_)
         gate1_.wait(lk);
-      state_ |= write_entered_;
-      while (state_ & n_readers_)
+      write_entered_ = true;
+      while (n_readers_)
         gate2_.wait(lk);
     }
 
@@ -768,9 +765,9 @@
     shared_mutex::try_lock()
     {
       boost::unique_lock<mutex_t> lk(mut_);
-      if (state_ == 0)
+      if (!write_entered_ && (n_readers_ == 0))
       {
-        state_ = write_entered_;
+        write_entered_ = true;
         return true;
       }
       return false;
@@ -780,7 +777,7 @@
     shared_mutex::unlock()
     {
       boost::lock_guard<mutex_t> _(mut_);
-      state_ = 0;
+      write_entered_ = false;
       gate1_.notify_all();
     }
 
@@ -790,23 +787,19 @@
     shared_mutex::lock_shared()
     {
       boost::unique_lock<mutex_t> lk(mut_);
-      while ((state_ & write_entered_) || (state_ & n_readers_) == n_readers_)
+      while (write_entered_ || (n_readers_ == N_READERS_MAX))
         gate1_.wait(lk);
-      count_t num_readers = (state_ & n_readers_) + 1;
-      state_ &= ~n_readers_;
-      state_ |= num_readers;
+      
+      ++n_readers_;
     }
 
     bool
     shared_mutex::try_lock_shared()
     {
       boost::unique_lock<mutex_t> lk(mut_);
-      count_t num_readers = state_ & n_readers_;
-      if (!(state_ & write_entered_) && num_readers != n_readers_)
+      if (!write_entered_ && (n_readers_ != N_READERS_MAX))
       {
-        ++num_readers;
-        state_ &= ~n_readers_;
-        state_ |= num_readers;
+        ++n_readers_;
         return true;
       }
       return false;
@@ -816,17 +809,15 @@
     shared_mutex::unlock_shared()
     {
       boost::lock_guard<mutex_t> _(mut_);
-      count_t num_readers = (state_ & n_readers_) - 1;
-      state_ &= ~n_readers_;
-      state_ |= num_readers;
-      if (state_ & write_entered_)
+      --n_readers_;
+      if (write_entered_)
       {
-        if (num_readers == 0)
+        if (n_readers_ == 0)
           gate2_.notify_one();
       }
       else
       {
-        if (num_readers == n_readers_ - 1)
+        if (n_readers_ == N_READERS_MAX - 1)
           gate1_.notify_one();
       }
     }