diff -up ./boost/thread/pthread/condition_variable.hpp~ ./boost/thread/pthread/condition_variable.hpp
--- ./boost/thread/pthread/condition_variable.hpp~	2013-01-14 18:17:50.000000000 +0100
+++ ./boost/thread/pthread/condition_variable.hpp	2013-08-22 11:47:48.330596804 +0200
@@ -200,15 +200,15 @@ namespace boost
 
 #if defined BOOST_THREAD_USES_DATETIME
         template<typename lock_type>
-        bool timed_wait(lock_type& m,boost::system_time const& wait_until)
+        bool timed_wait(lock_type& m,boost::system_time const& a_wait_until)
         {
-            struct timespec const timeout=detail::to_timespec(wait_until);
+            struct timespec const timeout=detail::to_timespec(a_wait_until);
             return do_wait_until(m, timeout);
         }
         template<typename lock_type>
-        bool timed_wait(lock_type& m,xtime const& wait_until)
+        bool timed_wait(lock_type& m,xtime const& a_wait_until)
         {
-            return timed_wait(m,system_time(wait_until));
+            return timed_wait(m,system_time(a_wait_until));
         }
 
         template<typename lock_type,typename duration_type>
@@ -218,20 +218,20 @@ namespace boost
         }
 
         template<typename lock_type,typename predicate_type>
-        bool timed_wait(lock_type& m,boost::system_time const& wait_until,predicate_type pred)
+        bool timed_wait(lock_type& m,boost::system_time const& a_wait_until,predicate_type pred)
         {
             while (!pred())
             {
-                if(!timed_wait(m, wait_until))
+                if(!timed_wait(m, a_wait_until))
                     return pred();
             }
             return true;
         }
 
         template<typename lock_type,typename predicate_type>
-        bool timed_wait(lock_type& m,xtime const& wait_until,predicate_type pred)
+        bool timed_wait(lock_type& m,xtime const& a_wait_until,predicate_type pred)
         {
-            return timed_wait(m,system_time(wait_until),pred);
+            return timed_wait(m,system_time(a_wait_until),pred);
         }
 
         template<typename lock_type,typename duration_type,typename predicate_type>
diff -up ./boost/thread/pthread/condition_variable_fwd.hpp~ ./boost/thread/pthread/condition_variable_fwd.hpp
--- ./boost/thread/pthread/condition_variable_fwd.hpp~	2013-01-14 18:17:50.000000000 +0100
+++ ./boost/thread/pthread/condition_variable_fwd.hpp	2013-08-22 11:46:26.579385366 +0200
@@ -98,21 +98,21 @@ namespace boost
 #if defined BOOST_THREAD_USES_DATETIME
         inline bool timed_wait(
             unique_lock<mutex>& m,
-            boost::system_time const& wait_until)
+            boost::system_time const& a_wait_until)
         {
 #if defined BOOST_THREAD_WAIT_BUG
-            struct timespec const timeout=detail::to_timespec(wait_until + BOOST_THREAD_WAIT_BUG);
+            struct timespec const timeout=detail::to_timespec(a_wait_until + BOOST_THREAD_WAIT_BUG);
             return do_wait_until(m, timeout);
 #else
-            struct timespec const timeout=detail::to_timespec(wait_until);
+            struct timespec const timeout=detail::to_timespec(a_wait_until);
             return do_wait_until(m, timeout);
 #endif
         }
         bool timed_wait(
             unique_lock<mutex>& m,
-            xtime const& wait_until)
+            xtime const& a_wait_until)
         {
-            return timed_wait(m,system_time(wait_until));
+            return timed_wait(m,system_time(a_wait_until));
         }
 
         template<typename duration_type>
@@ -126,11 +126,11 @@ namespace boost
         template<typename predicate_type>
         bool timed_wait(
             unique_lock<mutex>& m,
-            boost::system_time const& wait_until,predicate_type pred)
+            boost::system_time const& a_wait_until,predicate_type pred)
         {
             while (!pred())
             {
-                if(!timed_wait(m, wait_until))
+                if(!timed_wait(m, a_wait_until))
                     return pred();
             }
             return true;
@@ -139,9 +139,9 @@ namespace boost
         template<typename predicate_type>
         bool timed_wait(
             unique_lock<mutex>& m,
-            xtime const& wait_until,predicate_type pred)
+            xtime const& a_wait_until,predicate_type pred)
         {
-            return timed_wait(m,system_time(wait_until),pred);
+            return timed_wait(m,system_time(a_wait_until),pred);
         }
 
         template<typename duration_type,typename predicate_type>