diff -ru boost_1_39_0/boost/asio/basic_io_object.hpp boost_1_39_0.patched/boost/asio/basic_io_object.hpp
--- boost_1_39_0/boost/asio/basic_io_object.hpp	2008-06-20 00:20:52.000000000 +0200
+++ boost_1_39_0.patched/boost/asio/basic_io_object.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -68,8 +68,8 @@
    * Performs:
    * @code service.construct(implementation); @endcode
    */
-  explicit basic_io_object(boost::asio::io_service& io_service)
-    : service(boost::asio::use_service<IoObjectService>(io_service))
+  explicit basic_io_object(boost::asio::io_service& arg_io_service)
+    : service(boost::asio::use_service<IoObjectService>(arg_io_service))
   {
     service.construct(implementation);
   }
diff -ru boost_1_39_0/boost/asio/basic_socket.hpp boost_1_39_0.patched/boost/asio/basic_socket.hpp
--- boost_1_39_0/boost/asio/basic_socket.hpp	2008-10-09 07:41:50.000000000 +0200
+++ boost_1_39_0.patched/boost/asio/basic_socket.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -63,8 +63,8 @@
    * @param io_service The io_service object that the socket will use to
    * dispatch handlers for any asynchronous operations performed on the socket.
    */
-  explicit basic_socket(boost::asio::io_service& io_service)
-    : basic_io_object<SocketService>(io_service)
+  explicit basic_socket(boost::asio::io_service& arg_io_service)
+    : basic_io_object<SocketService>(arg_io_service)
   {
   }
 
diff -ru boost_1_39_0/boost/asio/basic_stream_socket.hpp boost_1_39_0.patched/boost/asio/basic_stream_socket.hpp
--- boost_1_39_0/boost/asio/basic_stream_socket.hpp	2008-03-12 15:12:08.000000000 +0100
+++ boost_1_39_0.patched/boost/asio/basic_stream_socket.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -66,8 +66,8 @@
    * @param io_service The io_service object that the stream socket will use to
    * dispatch handlers for any asynchronous operations performed on the socket.
    */
-  explicit basic_stream_socket(boost::asio::io_service& io_service)
-    : basic_socket<Protocol, StreamSocketService>(io_service)
+  explicit basic_stream_socket(boost::asio::io_service& arg_io_service)
+    : basic_socket<Protocol, StreamSocketService>(arg_io_service)
   {
   }
 
diff -ru boost_1_39_0/boost/asio/basic_streambuf.hpp boost_1_39_0.patched/boost/asio/basic_streambuf.hpp
--- boost_1_39_0/boost/asio/basic_streambuf.hpp	2008-10-31 13:05:52.000000000 +0100
+++ boost_1_39_0.patched/boost/asio/basic_streambuf.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -124,9 +124,9 @@
    * of the streambuf's input sequence is 0.
    */
   explicit basic_streambuf(
-      std::size_t max_size = (std::numeric_limits<std::size_t>::max)(),
+      std::size_t arg_max_size = (std::numeric_limits<std::size_t>::max)(),
       const Allocator& allocator = Allocator())
-    : max_size_(max_size),
+    : max_size_(arg_max_size),
       buffer_(allocator)
   {
     std::size_t pend = (std::min<std::size_t>)(max_size_, buffer_delta);
diff -ru boost_1_39_0/boost/asio/detail/buffered_stream_storage.hpp boost_1_39_0.patched/boost/asio/detail/buffered_stream_storage.hpp
--- boost_1_39_0/boost/asio/detail/buffered_stream_storage.hpp	2008-03-12 15:12:08.000000000 +0100
+++ boost_1_39_0.patched/boost/asio/detail/buffered_stream_storage.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -39,10 +39,10 @@
   typedef std::size_t size_type;
 
   // Constructor.
-  explicit buffered_stream_storage(std::size_t capacity)
+  explicit buffered_stream_storage(std::size_t arg_capacity)
     : begin_offset_(0),
       end_offset_(0),
-      buffer_(capacity)
+      buffer_(arg_capacity)
   {
   }
 
diff -ru boost_1_39_0/boost/asio/detail/deadline_timer_service.hpp boost_1_39_0.patched/boost/asio/detail/deadline_timer_service.hpp
--- boost_1_39_0/boost/asio/detail/deadline_timer_service.hpp	2008-10-09 22:43:26.000000000 +0200
+++ boost_1_39_0.patched/boost/asio/detail/deadline_timer_service.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -148,8 +148,8 @@
       ::timeval tv;
       tv.tv_sec = timeout.total_seconds();
       tv.tv_usec = timeout.total_microseconds() % 1000000;
-      boost::system::error_code ec;
-      socket_ops::select(0, 0, 0, 0, &tv, ec);
+      boost::system::error_code tmp_ec;
+      socket_ops::select(0, 0, 0, 0, &tv, tmp_ec);
       now = Time_Traits::now();
     }
     ec = boost::system::error_code();
diff -ru boost_1_39_0/boost/asio/detail/hash_map.hpp boost_1_39_0.patched/boost/asio/detail/hash_map.hpp
--- boost_1_39_0/boost/asio/detail/hash_map.hpp	2009-04-11 01:44:53.000000000 +0200
+++ boost_1_39_0.patched/boost/asio/detail/hash_map.hpp	2009-06-23 16:22:36.000000000 +0200
@@ -104,9 +104,9 @@
     iterator it = buckets_[bucket].first;
     if (it == values_.end())
       return values_.end();
-    iterator end = buckets_[bucket].last;
-    ++end;
-    while (it != end)
+    iterator tmp_end = buckets_[bucket].last;
+    ++tmp_end;
+    while (it != tmp_end)
     {
       if (it->first == k)
         return it;
@@ -122,9 +122,9 @@
     const_iterator it = buckets_[bucket].first;
     if (it == values_.end())
       return it;
-    const_iterator end = buckets_[bucket].last;
-    ++end;
-    while (it != end)
+    const_iterator tmp_end = buckets_[bucket].last;
+    ++tmp_end;
+    while (it != tmp_end)
     {
       if (it->first == k)
         return it;
@@ -147,15 +147,15 @@
       ++size_;
       return std::pair<iterator, bool>(buckets_[bucket].last, true);
     }
-    iterator end = buckets_[bucket].last;
-    ++end;
-    while (it != end)
+    iterator tmp_end = buckets_[bucket].last;
+    ++tmp_end;
+    while (it != tmp_end)
     {
       if (it->first == v.first)
         return std::pair<iterator, bool>(it, false);
       ++it;
     }
-    buckets_[bucket].last = values_insert(end, v);
+    buckets_[bucket].last = values_insert(tmp_end, v);
     ++size_;
     return std::pair<iterator, bool>(buckets_[bucket].last, true);
   }
@@ -215,19 +215,19 @@
   // Re-initialise the hash from the values already contained in the list.
   void rehash(std::size_t num_buckets)
   {
-    iterator end = values_.end();
+    iterator tmp_end = values_.end();
 
     // Update number of buckets and initialise all buckets to empty.
     buckets_.resize(num_buckets);
     for (std::size_t i = 0; i < buckets_.size(); ++i)
-      buckets_[i].first = buckets_[i].last = end;
+      buckets_[i].first = buckets_[i].last = tmp_end;
 
     // Put all values back into the hash.
     iterator iter = values_.begin();
-    while (iter != end)
+    while (iter != tmp_end)
     {
       std::size_t bucket = calculate_hash_value(iter->first) % buckets_.size();
-      if (buckets_[bucket].last == end)
+      if (buckets_[bucket].last == tmp_end)
       {
         buckets_[bucket].first = buckets_[bucket].last = iter++;
       }
diff -ru boost_1_39_0/boost/asio/detail/reactive_descriptor_service.hpp boost_1_39_0.patched/boost/asio/detail/reactive_descriptor_service.hpp
--- boost_1_39_0/boost/asio/detail/reactive_descriptor_service.hpp	2008-10-09 22:43:26.000000000 +0200
+++ boost_1_39_0.patched/boost/asio/detail/reactive_descriptor_service.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -77,10 +77,10 @@
   enum { max_buffers = 64 < max_iov_len ? 64 : max_iov_len };
 
   // Constructor.
-  reactive_descriptor_service(boost::asio::io_service& io_service)
+  reactive_descriptor_service(boost::asio::io_service& arg_io_service)
     : boost::asio::detail::service_base<
-        reactive_descriptor_service<Reactor> >(io_service),
-      reactor_(boost::asio::use_service<Reactor>(io_service))
+        reactive_descriptor_service<Reactor> >(arg_io_service),
+      reactor_(boost::asio::use_service<Reactor>(arg_io_service))
   {
     reactor_.init_task();
   }
diff -ru boost_1_39_0/boost/asio/detail/reactive_serial_port_service.hpp boost_1_39_0.patched/boost/asio/detail/reactive_serial_port_service.hpp
--- boost_1_39_0/boost/asio/detail/reactive_serial_port_service.hpp	2009-04-20 01:00:29.000000000 +0200
+++ boost_1_39_0.patched/boost/asio/detail/reactive_serial_port_service.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -52,11 +52,11 @@
   typedef typename reactive_descriptor_service<Reactor>::implementation_type
     implementation_type;
 
-  reactive_serial_port_service(boost::asio::io_service& io_service)
+  reactive_serial_port_service(boost::asio::io_service& arg_io_service)
     : boost::asio::detail::service_base<
-        reactive_serial_port_service>(io_service),
+        reactive_serial_port_service>(arg_io_service),
       descriptor_service_(boost::asio::use_service<
-          reactive_descriptor_service<Reactor> >(io_service))
+          reactive_descriptor_service<Reactor> >(arg_io_service))
   {
   }
 
diff -ru boost_1_39_0/boost/asio/detail/reactive_socket_service.hpp boost_1_39_0.patched/boost/asio/detail/reactive_socket_service.hpp
--- boost_1_39_0/boost/asio/detail/reactive_socket_service.hpp	2009-04-11 01:44:53.000000000 +0200
+++ boost_1_39_0.patched/boost/asio/detail/reactive_socket_service.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -105,10 +105,10 @@
   enum { max_buffers = 64 < max_iov_len ? 64 : max_iov_len };
 
   // Constructor.
-  reactive_socket_service(boost::asio::io_service& io_service)
+  reactive_socket_service(boost::asio::io_service& arg_io_service)
     : boost::asio::detail::service_base<
-        reactive_socket_service<Protocol, Reactor> >(io_service),
-      reactor_(boost::asio::use_service<Reactor>(io_service))
+        reactive_socket_service<Protocol, Reactor> >(arg_io_service),
+      reactor_(boost::asio::use_service<Reactor>(arg_io_service))
   {
     reactor_.init_task();
   }
diff -ru boost_1_39_0/boost/asio/detail/reactor_op_queue.hpp boost_1_39_0.patched/boost/asio/detail/reactor_op_queue.hpp
--- boost_1_39_0/boost/asio/detail/reactor_op_queue.hpp	2008-06-20 00:20:52.000000000 +0200
+++ boost_1_39_0.patched/boost/asio/detail/reactor_op_queue.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -325,11 +325,11 @@
 
     // Construct an operation for the given descriptor.
     op_base(perform_func_type perform_func, complete_func_type complete_func,
-        destroy_func_type destroy_func, Descriptor descriptor)
+        destroy_func_type destroy_func, Descriptor arg_descriptor)
       : perform_func_(perform_func),
         complete_func_(complete_func),
         destroy_func_(destroy_func),
-        descriptor_(descriptor),
+        descriptor_(arg_descriptor),
         result_(),
         bytes_transferred_(0),
         next_(0)
diff -ru boost_1_39_0/boost/asio/detail/resolver_service.hpp boost_1_39_0.patched/boost/asio/detail/resolver_service.hpp
--- boost_1_39_0/boost/asio/detail/resolver_service.hpp	2008-10-31 00:24:23.000000000 +0100
+++ boost_1_39_0.patched/boost/asio/detail/resolver_service.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -85,9 +85,9 @@
   typedef typename Protocol::resolver_iterator iterator_type;
 
   // Constructor.
-  resolver_service(boost::asio::io_service& io_service)
+  resolver_service(boost::asio::io_service& arg_io_service)
     : boost::asio::detail::service_base<
-        resolver_service<Protocol> >(io_service),
+        resolver_service<Protocol> >(arg_io_service),
       mutex_(),
       work_io_service_(new boost::asio::io_service),
       work_(new boost::asio::io_service::work(*work_io_service_)),
diff -ru boost_1_39_0/boost/asio/detail/select_reactor.hpp boost_1_39_0.patched/boost/asio/detail/select_reactor.hpp
--- boost_1_39_0/boost/asio/detail/select_reactor.hpp	2008-10-09 22:43:26.000000000 +0200
+++ boost_1_39_0.patched/boost/asio/detail/select_reactor.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -58,9 +58,9 @@
   };
 
   // Constructor.
-  select_reactor(boost::asio::io_service& io_service)
+  select_reactor(boost::asio::io_service& arg_io_service)
     : boost::asio::detail::service_base<
-        select_reactor<Own_Thread> >(io_service),
+        select_reactor<Own_Thread> >(arg_io_service),
       mutex_(),
       select_in_progress_(false),
       interrupter_(),
@@ -228,11 +228,11 @@
       boost::shared_ptr<bool> completed(new bool(false));
       connect_handler_wrapper<Handler> wrapped_handler(
           descriptor, completed, *this, handler);
-      bool interrupt = write_op_queue_.enqueue_operation(
+      bool has_interrupt = write_op_queue_.enqueue_operation(
           descriptor, wrapped_handler);
-      interrupt = except_op_queue_.enqueue_operation(
-          descriptor, wrapped_handler) || interrupt;
-      if (interrupt)
+      has_interrupt = except_op_queue_.enqueue_operation(
+          descriptor, wrapped_handler) || has_interrupt;
+      if (has_interrupt)
         interrupter_.interrupt();
     }
   }
@@ -476,10 +476,10 @@
   // acquire the select_reactor's mutex.
   void cancel_ops_unlocked(socket_type descriptor)
   {
-    bool interrupt = read_op_queue_.cancel_operations(descriptor);
-    interrupt = write_op_queue_.cancel_operations(descriptor) || interrupt;
-    interrupt = except_op_queue_.cancel_operations(descriptor) || interrupt;
-    if (interrupt)
+    bool has_interrupt = read_op_queue_.cancel_operations(descriptor);
+    has_interrupt = write_op_queue_.cancel_operations(descriptor) || has_interrupt;
+    has_interrupt = except_op_queue_.cancel_operations(descriptor) || has_interrupt;
+    if (has_interrupt)
       interrupter_.interrupt();
   }
 
diff -ru boost_1_39_0/boost/asio/detail/service_base.hpp boost_1_39_0.patched/boost/asio/detail/service_base.hpp
--- boost_1_39_0/boost/asio/detail/service_base.hpp	2008-03-12 15:12:08.000000000 +0100
+++ boost_1_39_0.patched/boost/asio/detail/service_base.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -33,8 +33,8 @@
   static boost::asio::detail::service_id<Type> id;
 
   // Constructor.
-  service_base(boost::asio::io_service& io_service)
-    : boost::asio::io_service::service(io_service)
+  service_base(boost::asio::io_service& arg_io_service)
+    : boost::asio::io_service::service(arg_io_service)
   {
   }
 };
diff -ru boost_1_39_0/boost/asio/detail/strand_service.hpp boost_1_39_0.patched/boost/asio/detail/strand_service.hpp
--- boost_1_39_0/boost/asio/detail/strand_service.hpp	2008-06-20 00:20:52.000000000 +0200
+++ boost_1_39_0.patched/boost/asio/detail/strand_service.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -358,8 +358,8 @@
   };
 
   // Construct a new strand service for the specified io_service.
-  explicit strand_service(boost::asio::io_service& io_service)
-    : boost::asio::detail::service_base<strand_service>(io_service),
+  explicit strand_service(boost::asio::io_service& arg_io_service)
+    : boost::asio::detail::service_base<strand_service>(arg_io_service),
       mutex_(),
       impl_list_(0)
   {
diff -ru boost_1_39_0/boost/asio/detail/task_io_service.hpp boost_1_39_0.patched/boost/asio/detail/task_io_service.hpp
--- boost_1_39_0/boost/asio/detail/task_io_service.hpp	2008-10-09 22:43:26.000000000 +0200
+++ boost_1_39_0.patched/boost/asio/detail/task_io_service.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -41,8 +41,8 @@
 {
 public:
   // Constructor.
-  task_io_service(boost::asio::io_service& io_service)
-    : boost::asio::detail::service_base<task_io_service<Task> >(io_service),
+  task_io_service(boost::asio::io_service& arg_io_service)
+    : boost::asio::detail::service_base<task_io_service<Task> >(arg_io_service),
       mutex_(),
       task_(0),
       task_interrupted_(true),
diff -ru boost_1_39_0/boost/asio/impl/io_service.ipp boost_1_39_0.patched/boost/asio/impl/io_service.ipp
--- boost_1_39_0/boost/asio/impl/io_service.ipp	2008-03-12 15:12:08.000000000 +0100
+++ boost_1_39_0.patched/boost/asio/impl/io_service.ipp	2009-06-23 15:18:03.000000000 +0200
@@ -137,8 +137,8 @@
   return detail::wrapped_handler<io_service&, Handler>(*this, handler);
 }
 
-inline io_service::work::work(boost::asio::io_service& io_service)
-  : io_service_(io_service)
+inline io_service::work::work(boost::asio::io_service& arg_io_service)
+  : io_service_(arg_io_service)
 {
   io_service_.impl_.work_started();
 }
diff -ru boost_1_39_0/boost/asio/impl/read_until.ipp boost_1_39_0.patched/boost/asio/impl/read_until.ipp
--- boost_1_39_0/boost/asio/impl/read_until.ipp	2008-10-31 00:24:23.000000000 +0100
+++ boost_1_39_0.patched/boost/asio/impl/read_until.ipp	2009-06-23 15:18:03.000000000 +0200
@@ -376,8 +376,8 @@
       if (streambuf_.size() == streambuf_.max_size())
       {
         std::size_t bytes = 0;
-        boost::system::error_code ec(error::not_found);
-        handler_(ec, bytes);
+        boost::system::error_code tmp_ec(error::not_found);
+        handler_(tmp_ec, bytes);
         return;
       }
 
@@ -708,8 +708,8 @@
       if (streambuf_.size() == streambuf_.max_size())
       {
         std::size_t bytes = 0;
-        boost::system::error_code ec(error::not_found);
-        handler_(ec, bytes);
+        boost::system::error_code tmp_ec(error::not_found);
+        handler_(tmp_ec, bytes);
         return;
       }
 
@@ -877,8 +877,8 @@
       if (streambuf_.size() == streambuf_.max_size())
       {
         std::size_t bytes = 0;
-        boost::system::error_code ec(error::not_found);
-        handler_(ec, bytes);
+        boost::system::error_code tmp_ec(error::not_found);
+        handler_(tmp_ec, bytes);
         return;
       }
 
diff -ru boost_1_39_0/boost/asio/ip/address_v6.hpp boost_1_39_0.patched/boost/asio/ip/address_v6.hpp
--- boost_1_39_0/boost/asio/ip/address_v6.hpp	2008-10-09 22:43:26.000000000 +0200
+++ boost_1_39_0.patched/boost/asio/ip/address_v6.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -60,8 +60,8 @@
   }
 
   /// Construct an address from raw bytes and scope ID.
-  explicit address_v6(const bytes_type& bytes, unsigned long scope_id = 0)
-    : scope_id_(scope_id)
+  explicit address_v6(const bytes_type& bytes, unsigned long arg_scope_id = 0)
+    : scope_id_(arg_scope_id)
   {
 #if UCHAR_MAX > 0xFF
     for (std::size_t i = 0; i < bytes.size(); ++i)
diff -ru boost_1_39_0/boost/asio/ip/basic_endpoint.hpp boost_1_39_0.patched/boost/asio/ip/basic_endpoint.hpp
--- boost_1_39_0/boost/asio/ip/basic_endpoint.hpp	2009-04-11 01:44:53.000000000 +0200
+++ boost_1_39_0.patched/boost/asio/ip/basic_endpoint.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -88,11 +88,11 @@
    * boost::asio::ip::udp::endpoint ep(boost::asio::ip::udp::v6(), 9876);
    * @endcode
    */
-  basic_endpoint(const InternetProtocol& protocol, unsigned short port_num)
+  basic_endpoint(const InternetProtocol& arg_protocol, unsigned short port_num)
     : data_()
   {
     using namespace std; // For memcpy.
-    if (protocol.family() == PF_INET)
+    if (arg_protocol.family() == PF_INET)
     {
       data_.v4.sin_family = AF_INET;
       data_.v4.sin_port =
@@ -183,9 +183,9 @@
   }
 
   /// Set the underlying size of the endpoint in the native type.
-  void resize(std::size_t size)
+  void resize(std::size_t arg_size)
   {
-    if (size > sizeof(boost::asio::detail::sockaddr_storage_type))
+    if (arg_size > sizeof(boost::asio::detail::sockaddr_storage_type))
     {
       boost::system::system_error e(boost::asio::error::invalid_argument);
       boost::throw_exception(e);
diff -ru boost_1_39_0/boost/asio/ip/basic_resolver.hpp boost_1_39_0.patched/boost/asio/ip/basic_resolver.hpp
--- boost_1_39_0/boost/asio/ip/basic_resolver.hpp	2008-10-09 07:41:50.000000000 +0200
+++ boost_1_39_0.patched/boost/asio/ip/basic_resolver.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -60,8 +60,8 @@
    * @param io_service The io_service object that the resolver will use to
    * dispatch handlers for any asynchronous operations performed on the timer.
    */
-  explicit basic_resolver(boost::asio::io_service& io_service)
-    : basic_io_object<ResolverService>(io_service)
+  explicit basic_resolver(boost::asio::io_service& arg_io_service)
+    : basic_io_object<ResolverService>(arg_io_service)
   {
   }
 
diff -ru boost_1_39_0/boost/asio/ip/basic_resolver_entry.hpp boost_1_39_0.patched/boost/asio/ip/basic_resolver_entry.hpp
--- boost_1_39_0/boost/asio/ip/basic_resolver_entry.hpp	2008-03-12 15:12:08.000000000 +0100
+++ boost_1_39_0.patched/boost/asio/ip/basic_resolver_entry.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -50,11 +50,11 @@
   }
 
   /// Construct with specified endpoint, host name and service name.
-  basic_resolver_entry(const endpoint_type& endpoint,
-      const std::string& host_name, const std::string& service_name)
-    : endpoint_(endpoint),
-      host_name_(host_name),
-      service_name_(service_name)
+  basic_resolver_entry(const endpoint_type& arg_endpoint,
+      const std::string& arg_host_name, const std::string& arg_service_name)
+    : endpoint_(arg_endpoint),
+      host_name_(arg_host_name),
+      service_name_(arg_service_name)
   {
   }
 
diff -ru boost_1_39_0/boost/asio/ip/basic_resolver_query.hpp boost_1_39_0.patched/boost/asio/ip/basic_resolver_query.hpp
--- boost_1_39_0/boost/asio/ip/basic_resolver_query.hpp	2008-03-12 15:12:08.000000000 +0100
+++ boost_1_39_0.patched/boost/asio/ip/basic_resolver_query.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -47,11 +47,11 @@
   typedef InternetProtocol protocol_type;
 
   /// Construct with specified service name for any protocol.
-  basic_resolver_query(const std::string& service_name,
+  basic_resolver_query(const std::string& arg_service_name,
       int flags = passive | address_configured)
     : hints_(),
       host_name_(),
-      service_name_(service_name)
+      service_name_(arg_service_name)
   {
     typename InternetProtocol::endpoint endpoint;
     hints_.ai_flags = flags;
@@ -66,11 +66,11 @@
 
   /// Construct with specified service name for a given protocol.
   basic_resolver_query(const protocol_type& protocol,
-      const std::string& service_name,
+      const std::string& arg_service_name,
       int flags = passive | address_configured)
     : hints_(),
       host_name_(),
-      service_name_(service_name)
+      service_name_(arg_service_name)
   {
     hints_.ai_flags = flags;
     hints_.ai_family = protocol.family();
@@ -83,11 +83,11 @@
   }
 
   /// Construct with specified host name and service name for any protocol.
-  basic_resolver_query(const std::string& host_name,
-      const std::string& service_name, int flags = address_configured)
+  basic_resolver_query(const std::string& arg_host_name,
+      const std::string& arg_service_name, int flags = address_configured)
     : hints_(),
-      host_name_(host_name),
-      service_name_(service_name)
+      host_name_(arg_host_name),
+      service_name_(arg_service_name)
   {
     typename InternetProtocol::endpoint endpoint;
     hints_.ai_flags = flags;
@@ -102,11 +102,11 @@
 
   /// Construct with specified host name and service name for a given protocol.
   basic_resolver_query(const protocol_type& protocol,
-      const std::string& host_name, const std::string& service_name,
+      const std::string& arg_host_name, const std::string& arg_service_name,
       int flags = address_configured)
     : hints_(),
-      host_name_(host_name),
-      service_name_(service_name)
+      host_name_(arg_host_name),
+      service_name_(arg_service_name)
   {
     hints_.ai_flags = flags;
     hints_.ai_family = protocol.family();
diff -ru boost_1_39_0/boost/asio/ip/icmp.hpp boost_1_39_0.patched/boost/asio/ip/icmp.hpp
--- boost_1_39_0/boost/asio/ip/icmp.hpp	2008-06-20 00:20:52.000000000 +0200
+++ boost_1_39_0.patched/boost/asio/ip/icmp.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -101,9 +101,9 @@
 
 private:
   // Construct with a specific family.
-  explicit icmp(int protocol, int family)
-    : protocol_(protocol),
-      family_(family)
+  explicit icmp(int arg_protocol, int arg_family)
+    : protocol_(arg_protocol),
+      family_(arg_family)
   {
   }
 
diff -ru boost_1_39_0/boost/asio/ip/resolver_service.hpp boost_1_39_0.patched/boost/asio/ip/resolver_service.hpp
--- boost_1_39_0/boost/asio/ip/resolver_service.hpp	2008-03-12 15:12:08.000000000 +0100
+++ boost_1_39_0.patched/boost/asio/ip/resolver_service.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -68,10 +68,10 @@
 #endif
 
   /// Construct a new resolver service for the specified io_service.
-  explicit resolver_service(boost::asio::io_service& io_service)
+  explicit resolver_service(boost::asio::io_service& arg_io_service)
     : boost::asio::detail::service_base<
-        resolver_service<InternetProtocol> >(io_service),
-      service_impl_(boost::asio::use_service<service_impl_type>(io_service))
+        resolver_service<InternetProtocol> >(arg_io_service),
+      service_impl_(boost::asio::use_service<service_impl_type>(arg_io_service))
   {
   }
 
diff -ru boost_1_39_0/boost/asio/ip/tcp.hpp boost_1_39_0.patched/boost/asio/ip/tcp.hpp
--- boost_1_39_0/boost/asio/ip/tcp.hpp	2008-03-12 15:12:08.000000000 +0100
+++ boost_1_39_0.patched/boost/asio/ip/tcp.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -143,8 +143,8 @@
 
 private:
   // Construct with a specific family.
-  explicit tcp(int family)
-    : family_(family)
+  explicit tcp(int arg_family)
+    : family_(arg_family)
   {
   }
 
diff -ru boost_1_39_0/boost/asio/ip/udp.hpp boost_1_39_0.patched/boost/asio/ip/udp.hpp
--- boost_1_39_0/boost/asio/ip/udp.hpp	2008-03-12 15:12:08.000000000 +0100
+++ boost_1_39_0.patched/boost/asio/ip/udp.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -101,8 +101,8 @@
 
 private:
   // Construct with a specific family.
-  explicit udp(int family)
-    : family_(family)
+  explicit udp(int arg_family)
+    : family_(arg_family)
   {
   }
 
diff -ru boost_1_39_0/boost/asio/local/basic_endpoint.hpp boost_1_39_0.patched/boost/asio/local/basic_endpoint.hpp
--- boost_1_39_0/boost/asio/local/basic_endpoint.hpp	2008-07-22 10:30:38.000000000 +0200
+++ boost_1_39_0.patched/boost/asio/local/basic_endpoint.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -79,16 +79,16 @@
   }
 
   /// Construct an endpoint using the specified path name.
-  basic_endpoint(const char* path)
+  basic_endpoint(const char* arg_path)
   {
     using namespace std; // For strlen.
-    init(path, strlen(path));
+    init(arg_path, strlen(arg_path));
   }
 
   /// Construct an endpoint using the specified path name.
-  basic_endpoint(const std::string& path)
+  basic_endpoint(const std::string& arg_path)
   {
-    init(path.data(), path.length());
+    init(arg_path.data(), arg_path.length());
   }
 
   /// Copy constructor.
@@ -132,20 +132,20 @@
   }
 
   /// Set the underlying size of the endpoint in the native type.
-  void resize(std::size_t size)
+  void resize(std::size_t arg_size)
   {
-    if (size > sizeof(boost::asio::detail::sockaddr_un_type))
+    if (arg_size > sizeof(boost::asio::detail::sockaddr_un_type))
     {
       boost::system::system_error e(boost::asio::error::invalid_argument);
       boost::throw_exception(e);
     }
-    else if (size == 0)
+    else if (arg_size == 0)
     {
       path_length_ = 0;
     }
     else
     {
-      path_length_ = size
+      path_length_ = arg_size
         - offsetof(boost::asio::detail::sockaddr_un_type, sun_path);
 
       // The path returned by the operating system may be NUL-terminated.
@@ -212,7 +212,7 @@
   std::size_t path_length_;
 
   // Initialise with a specified path.
-  void init(const char* path, std::size_t path_length)
+  void init(const char* arg_path, std::size_t path_length)
   {
     if (path_length > sizeof(data_.local.sun_path) - 1)
     {
@@ -224,7 +224,7 @@
     using namespace std; // For memcpy.
     data_.local = boost::asio::detail::sockaddr_un_type();
     data_.local.sun_family = AF_UNIX;
-    memcpy(data_.local.sun_path, path, path_length);
+    memcpy(data_.local.sun_path, arg_path, path_length);
     path_length_ = path_length;
 
     // NUL-terminate normal path names. Names that start with a NUL are in the
diff -ru boost_1_39_0/boost/asio/posix/stream_descriptor_service.hpp boost_1_39_0.patched/boost/asio/posix/stream_descriptor_service.hpp
--- boost_1_39_0/boost/asio/posix/stream_descriptor_service.hpp	2008-06-20 00:20:52.000000000 +0200
+++ boost_1_39_0.patched/boost/asio/posix/stream_descriptor_service.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -89,9 +89,9 @@
 #endif
 
   /// Construct a new stream descriptor service for the specified io_service.
-  explicit stream_descriptor_service(boost::asio::io_service& io_service)
-    : boost::asio::detail::service_base<stream_descriptor_service>(io_service),
-      service_impl_(boost::asio::use_service<service_impl_type>(io_service))
+  explicit stream_descriptor_service(boost::asio::io_service& arg_io_service)
+    : boost::asio::detail::service_base<stream_descriptor_service>(arg_io_service),
+      service_impl_(boost::asio::use_service<service_impl_type>(arg_io_service))
   {
   }
 
diff -ru boost_1_39_0/boost/asio/serial_port_service.hpp boost_1_39_0.patched/boost/asio/serial_port_service.hpp
--- boost_1_39_0/boost/asio/serial_port_service.hpp	2009-04-20 01:00:29.000000000 +0200
+++ boost_1_39_0.patched/boost/asio/serial_port_service.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -84,9 +84,9 @@
 #endif
 
   /// Construct a new serial port service for the specified io_service.
-  explicit serial_port_service(boost::asio::io_service& io_service)
-    : boost::asio::detail::service_base<serial_port_service>(io_service),
-      service_impl_(boost::asio::use_service<service_impl_type>(io_service))
+  explicit serial_port_service(boost::asio::io_service& arg_io_service)
+    : boost::asio::detail::service_base<serial_port_service>(arg_io_service),
+      service_impl_(boost::asio::use_service<service_impl_type>(arg_io_service))
   {
   }
 
diff -ru boost_1_39_0/boost/asio/strand.hpp boost_1_39_0.patched/boost/asio/strand.hpp
--- boost_1_39_0/boost/asio/strand.hpp	2008-03-12 15:12:08.000000000 +0100
+++ boost_1_39_0.patched/boost/asio/strand.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -47,9 +47,9 @@
    * @param io_service The io_service object that the strand will use to
    * dispatch handlers that are ready to be run.
    */
-  explicit strand(boost::asio::io_service& io_service)
+  explicit strand(boost::asio::io_service& arg_io_service)
     : service_(boost::asio::use_service<
-        boost::asio::detail::strand_service>(io_service))
+        boost::asio::detail::strand_service>(arg_io_service))
   {
     service_.construct(impl_);
   }
diff -ru boost_1_39_0/boost/asio/stream_socket_service.hpp boost_1_39_0.patched/boost/asio/stream_socket_service.hpp
--- boost_1_39_0/boost/asio/stream_socket_service.hpp	2008-03-12 15:12:08.000000000 +0100
+++ boost_1_39_0.patched/boost/asio/stream_socket_service.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -89,10 +89,10 @@
 #endif
 
   /// Construct a new stream socket service for the specified io_service.
-  explicit stream_socket_service(boost::asio::io_service& io_service)
+  explicit stream_socket_service(boost::asio::io_service& arg_io_service)
     : boost::asio::detail::service_base<
-        stream_socket_service<Protocol> >(io_service),
-      service_impl_(boost::asio::use_service<service_impl_type>(io_service))
+        stream_socket_service<Protocol> >(arg_io_service),
+      service_impl_(boost::asio::use_service<service_impl_type>(arg_io_service))
   {
   }
 
diff -ru boost_1_39_0/boost/crc.hpp boost_1_39_0.patched/boost/crc.hpp
--- boost_1_39_0/boost/crc.hpp	2005-12-08 04:23:02.000000000 +0100
+++ boost_1_39_0.patched/boost/crc.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -751,15 +751,15 @@
 crc_basic<Bits>::process_bits
 (
     unsigned char  bits,
-    std::size_t    bit_count
+    std::size_t    arg_bit_count
 )
 {
     // ignore the bits above the ones we want
-    bits <<= CHAR_BIT - bit_count;
+    bits <<= CHAR_BIT - arg_bit_count;
 
     // compute the CRC for each bit, starting with the upper ones
     unsigned char const  high_bit_mask = 1u << ( CHAR_BIT - 1u );
-    for ( std::size_t i = bit_count ; i > 0u ; --i, bits <<= 1u )
+    for ( std::size_t i = arg_bit_count ; i > 0u ; --i, bits <<= 1u )
     {
         process_bit( static_cast<bool>(bits & high_bit_mask) );
     }
diff -ru boost_1_39_0/boost/date_time/posix_time/posix_time_config.hpp boost_1_39_0.patched/boost/date_time/posix_time/posix_time_config.hpp
--- boost_1_39_0/boost/date_time/posix_time/posix_time_config.hpp	2008-10-13 11:00:03.000000000 +0200
+++ boost_1_39_0.patched/boost/date_time/posix_time/posix_time_config.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -82,8 +82,8 @@
     //Give duration access to ticks constructor -- hide from users
     friend class date_time::time_duration<time_duration, time_res_traits>;
   private:
-    explicit time_duration(impl_type ticks) :
-      date_time::time_duration<time_duration, time_res_traits>(ticks)
+    explicit time_duration(impl_type arg_ticks) :
+      date_time::time_duration<time_duration, time_res_traits>(arg_ticks)
     {}
   };
 
diff -ru boost_1_39_0/boost/exception/diagnostic_information.hpp boost_1_39_0.patched/boost/exception/diagnostic_information.hpp
--- boost_1_39_0/boost/exception/diagnostic_information.hpp	2009-04-13 07:41:31.000000000 +0200
+++ boost_1_39_0.patched/boost/exception/diagnostic_information.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -139,10 +139,10 @@
     std::string
     current_exception_diagnostic_information()
         {
-        if( boost::exception const * e=current_exception_cast<boost::exception const>() )
-            return diagnostic_information(*e);
-        else if( std::exception const * e=current_exception_cast<std::exception const>() )
-            return diagnostic_information(*e);
+        if( boost::exception const * be=current_exception_cast<boost::exception const>() )
+            return diagnostic_information(*be);
+        else if( std::exception const * se=current_exception_cast<std::exception const>() )
+            return diagnostic_information(*se);
         else
             return "No diagnostic information available.";
         }
diff -ru boost_1_39_0/boost/exception/info.hpp boost_1_39_0.patched/boost/exception/info.hpp
--- boost_1_39_0/boost/exception/info.hpp	2009-04-07 20:33:44.000000000 +0200
+++ boost_1_39_0.patched/boost/exception/info.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -26,8 +26,8 @@
     template <class Tag,class T>
     inline
     error_info<Tag,T>::
-    error_info( value_type const & value ):
-        value_(value)
+    error_info( value_type const & arg_value ):
+        value_(arg_value)
         {
         }
 
diff -ru boost_1_39_0/boost/multi_index/detail/index_matcher.hpp boost_1_39_0.patched/boost/multi_index/detail/index_matcher.hpp
--- boost_1_39_0/boost/multi_index/detail/index_matcher.hpp	2008-07-03 18:51:53.000000000 +0200
+++ boost_1_39_0.patched/boost/multi_index/detail/index_matcher.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -132,17 +132,17 @@
         entries(),entries()+size_,
         entry(node),entry::less_by_node()); /* localize entry */
     ent->ordered=false;
-    std::size_t n=ent->pos;                 /* get its position */
+    std::size_t tmp_n=ent->pos;                 /* get its position */
 
     entry dummy(0);
-    dummy.pile_top=n;
+    dummy.pile_top=tmp_n;
 
     entry* pile_ent=                        /* find the first available pile */
       std::lower_bound(                     /* to stack the entry            */
         entries(),entries()+num_piles,
         dummy,entry::less_by_pile_top());
 
-    pile_ent->pile_top=n;                   /* stack the entry */
+    pile_ent->pile_top=tmp_n;                   /* stack the entry */
     pile_ent->pile_top_entry=ent;        
 
     /* if not the first pile, link entry to top of the preceding pile */
@@ -164,7 +164,7 @@
        */
 
       entry* ent=entries()[num_piles-1].pile_top_entry;
-      for(std::size_t n=num_piles;n--;){
+      for(std::size_t tmp_n=num_piles;tmp_n--;){
         ent->ordered=true;
         ent=ent->previous;
       }
diff -ru boost_1_39_0/boost/multi_index/ordered_index.hpp boost_1_39_0.patched/boost/multi_index/ordered_index.hpp
--- boost_1_39_0/boost/multi_index/ordered_index.hpp	2008-07-03 18:51:53.000000000 +0200
+++ boost_1_39_0.patched/boost/multi_index/ordered_index.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -436,9 +436,9 @@
 
   template<typename CompatibleKey,typename CompatibleCompare>
   iterator find(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
+    const CompatibleKey& x,const CompatibleCompare& arg_comp) const
   {
-    return make_iterator(ordered_index_find(root(),header(),key,x,comp));
+    return make_iterator(ordered_index_find(root(),header(),key,x,arg_comp));
   }
 
   template<typename CompatibleKey>
@@ -448,9 +448,9 @@
   }
 
   template<typename CompatibleKey,typename CompatibleCompare>
-  size_type count(const CompatibleKey& x,const CompatibleCompare& comp)const
+  size_type count(const CompatibleKey& x,const CompatibleCompare& arg_comp) const
   {
-    std::pair<iterator,iterator> p=equal_range(x,comp);
+    std::pair<iterator,iterator> p=equal_range(x,arg_comp);
     size_type n=std::distance(p.first,p.second);
     return n;
   }
@@ -464,10 +464,10 @@
 
   template<typename CompatibleKey,typename CompatibleCompare>
   iterator lower_bound(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
+    const CompatibleKey& x,const CompatibleCompare& arg_comp) const
   {
     return make_iterator(
-      ordered_index_lower_bound(root(),header(),key,x,comp));
+      ordered_index_lower_bound(root(),header(),key,x,arg_comp));
   }
 
   template<typename CompatibleKey>
@@ -479,10 +479,10 @@
 
   template<typename CompatibleKey,typename CompatibleCompare>
   iterator upper_bound(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
+    const CompatibleKey& x,const CompatibleCompare& arg_comp) const
   {
     return make_iterator(
-      ordered_index_upper_bound(root(),header(),key,x,comp));
+      ordered_index_upper_bound(root(),header(),key,x,arg_comp));
   }
 
   template<typename CompatibleKey>
@@ -497,10 +497,10 @@
 
   template<typename CompatibleKey,typename CompatibleCompare>
   std::pair<iterator,iterator> equal_range(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
+    const CompatibleKey& x,const CompatibleCompare& arg_comp) const
   {
     std::pair<node_type*,node_type*> p=
-      ordered_index_equal_range(root(),header(),key,x,comp);
+      ordered_index_equal_range(root(),header(),key,x,arg_comp);
     return std::pair<iterator,iterator>(
       make_iterator(p.first),make_iterator(p.second));
   }
diff -ru boost_1_39_0/boost/multi_index/sequenced_index.hpp boost_1_39_0.patched/boost/multi_index/sequenced_index.hpp
--- boost_1_39_0/boost/multi_index/sequenced_index.hpp	2008-07-03 18:51:53.000000000 +0200
+++ boost_1_39_0.patched/boost/multi_index/sequenced_index.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -346,7 +346,7 @@
   }
 
   template<typename Modifier,typename Rollback>
-  bool modify(iterator position,Modifier mod,Rollback back)
+  bool modify(iterator position,Modifier mod,Rollback arg_back)
   {
     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
     BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
@@ -363,7 +363,7 @@
 #endif
 
     return this->final_modify_(
-      mod,back,static_cast<final_node_type*>(position.get_node()));
+      mod,arg_back,static_cast<final_node_type*>(position.get_node()));
   }
 
   void swap(sequenced_index<SuperMeta,TagList>& x)
diff -ru boost_1_39_0/boost/multi_index_container.hpp boost_1_39_0.patched/boost/multi_index_container.hpp
--- boost_1_39_0/boost/multi_index_container.hpp	2008-09-14 18:36:06.000000000 +0200
+++ boost_1_39_0.patched/boost/multi_index_container.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -357,7 +357,7 @@
     IteratorType it
     BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N))
   {
-    typedef typename nth_index<N>::type index;
+    typedef typename nth_index<N>::type N_Index;
 
 #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
     BOOST_STATIC_ASSERT(
@@ -368,7 +368,7 @@
     BOOST_MULTI_INDEX_CHECK_IS_OWNER(
       it,static_cast<typename IteratorType::container_type&>(*this));
 
-    return index::make_iterator(static_cast<node_type*>(it.get_node()));
+    return N_Index::make_iterator(static_cast<node_type*>(it.get_node()));
   }
 
   template<int N,typename IteratorType>
@@ -376,7 +376,7 @@
     IteratorType it
     BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N))const
   {
-    typedef typename nth_index<N>::type index;
+    typedef typename nth_index<N>::type N_Index;
 
 #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
     BOOST_STATIC_ASSERT((
@@ -387,7 +387,7 @@
     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
     BOOST_MULTI_INDEX_CHECK_IS_OWNER(
       it,static_cast<const typename IteratorType::container_type&>(*this));
-    return index::make_iterator(static_cast<node_type*>(it.get_node()));
+    return N_Index::make_iterator(static_cast<node_type*>(it.get_node()));
   }
 #endif
 
@@ -411,7 +411,7 @@
     IteratorType it
     BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))
   {
-    typedef typename index<Tag>::type index;
+    typedef typename index<Tag>::type Tag_Index;
 
 #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
     BOOST_STATIC_ASSERT(
@@ -421,7 +421,7 @@
     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
     BOOST_MULTI_INDEX_CHECK_IS_OWNER(
       it,static_cast<typename IteratorType::container_type&>(*this));
-    return index::make_iterator(static_cast<node_type*>(it.get_node()));
+    return Tag_Index::make_iterator(static_cast<node_type*>(it.get_node()));
   }
 
   template<typename Tag,typename IteratorType>
@@ -429,7 +429,7 @@
     IteratorType it
     BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))const
   {
-    typedef typename index<Tag>::type index;
+    typedef typename index<Tag>::type Tag_Index;
 
 #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
     BOOST_STATIC_ASSERT((
@@ -440,7 +440,7 @@
     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
     BOOST_MULTI_INDEX_CHECK_IS_OWNER(
       it,static_cast<const typename IteratorType::container_type&>(*this));
-    return index::make_iterator(static_cast<node_type*>(it.get_node()));
+    return Tag_Index::make_iterator(static_cast<node_type*>(it.get_node()));
   }
 #endif
 
diff -ru boost_1_39_0/boost/program_options/detail/parsers.hpp boost_1_39_0.patched/boost/program_options/detail/parsers.hpp
--- boost_1_39_0/boost/program_options/detail/parsers.hpp	2008-02-20 15:55:25.000000000 +0100
+++ boost_1_39_0.patched/boost/program_options/detail/parsers.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -27,8 +27,8 @@
     template<class charT>
     basic_command_line_parser<charT>::
     basic_command_line_parser(const std::vector<
-                              std::basic_string<charT> >& args)
-       : detail::cmdline(to_internal(args))
+                              std::basic_string<charT> >& arg_args)
+       : detail::cmdline(to_internal(arg_args))
     {}
 
 
@@ -62,9 +62,9 @@
 
     template<class charT>
     basic_command_line_parser<charT>& 
-    basic_command_line_parser<charT>::style(int style)
+    basic_command_line_parser<charT>::style(int arg_style)
     {
-        detail::cmdline::style(style);
+        detail::cmdline::style(arg_style);
         return *this;
     }
 
diff -ru boost_1_39_0/boost/program_options/detail/value_semantic.hpp boost_1_39_0.patched/boost/program_options/detail/value_semantic.hpp
--- boost_1_39_0/boost/program_options/detail/value_semantic.hpp	2007-11-25 19:07:19.000000000 +0100
+++ boost_1_39_0.patched/boost/program_options/detail/value_semantic.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -144,9 +144,9 @@
                    a validator for class T, we use it even
                    when parsing vector<T>.  */
                 boost::any a;
-                std::vector<std::basic_string<charT> > v;
-                v.push_back(s[i]);
-                validate(a, v, (T*)0, 0);                
+                std::vector<std::basic_string<charT> > tmp_v;
+                tmp_v.push_back(s[i]);
+                validate(a, tmp_v, (T*)0, 0);                
                 tv->push_back(boost::any_cast<T>(a));
             }
             catch(const bad_lexical_cast& /*e*/) {
diff -ru boost_1_39_0/boost/program_options/errors.hpp boost_1_39_0.patched/boost/program_options/errors.hpp
--- boost_1_39_0/boost/program_options/errors.hpp	2006-05-15 16:06:24.000000000 +0200
+++ boost_1_39_0.patched/boost/program_options/errors.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -20,14 +20,14 @@
     /** Base class for all errors in the library. */
     class BOOST_PROGRAM_OPTIONS_DECL error : public std::logic_error {
     public:
-        error(const std::string& what) : std::logic_error(what) {}
+        error(const std::string& arg_what) : std::logic_error(arg_what) {}
     };
 
     class BOOST_PROGRAM_OPTIONS_DECL invalid_syntax : public error {
     public:
-        invalid_syntax(const std::string& tokens, const std::string& msg)
-        : error(std::string(msg).append(" in '").append(tokens).append("'")),
-          tokens(tokens), msg(msg)                       
+        invalid_syntax(const std::string& arg_tokens, const std::string& arg_msg)
+        : error(std::string(arg_msg).append(" in '").append(arg_tokens).append("'")),
+          tokens(arg_tokens), msg(arg_msg)                       
         {}
 
         // gcc says that throw specification on dtor is loosened
@@ -50,9 +50,9 @@
     class BOOST_PROGRAM_OPTIONS_DECL ambiguous_option : public error {
     public:
         ambiguous_option(const std::string& name, 
-                         const std::vector<std::string>& alternatives)
+                         const std::vector<std::string>& arg_alternatives)
         : error(std::string("ambiguous option ").append(name)),
-          alternatives(alternatives)
+          alternatives(arg_alternatives)
         {}
 
         ~ambiguous_option() throw() {}
@@ -65,7 +65,7 @@
         user called a method which cannot return them all. */
     class BOOST_PROGRAM_OPTIONS_DECL multiple_values : public error {
     public:
-        multiple_values(const std::string& what) : error(what) {}
+        multiple_values(const std::string& arg_what) : error(arg_what) {}
     };
 
     /** Class thrown when there are several occurrences of an
@@ -73,13 +73,13 @@
         them all. */
     class BOOST_PROGRAM_OPTIONS_DECL multiple_occurrences : public error {
     public:
-        multiple_occurrences(const std::string& what) : error(what) {}
+        multiple_occurrences(const std::string& arg_what) : error(arg_what) {}
     };
 
     /** Class thrown when value of option is incorrect. */
     class BOOST_PROGRAM_OPTIONS_DECL validation_error : public error {
     public:
-        validation_error(const std::string& what) : error(what) {}
+        validation_error(const std::string& arg_what) : error(arg_what) {}
         ~validation_error() throw() {}
         void set_option_name(const std::string& option);
 
@@ -103,15 +103,15 @@
     /** Class thrown when there are too many positional options. */
     class BOOST_PROGRAM_OPTIONS_DECL too_many_positional_options_error : public error {
     public:
-        too_many_positional_options_error(const std::string& what) 
-        : error(what) {}
+        too_many_positional_options_error(const std::string& arg_what) 
+        : error(arg_what) {}
     };
 
     /** Class thrown when there are too few positional options. */
     class BOOST_PROGRAM_OPTIONS_DECL too_few_positional_options_error : public error {
     public:
-        too_few_positional_options_error(const std::string& what) 
-        : error(what) {}
+        too_few_positional_options_error(const std::string& arg_what) 
+        : error(arg_what) {}
     };
 
     class BOOST_PROGRAM_OPTIONS_DECL invalid_command_line_syntax : public invalid_syntax {
diff -ru boost_1_39_0/boost/program_options/option.hpp boost_1_39_0.patched/boost/program_options/option.hpp
--- boost_1_39_0/boost/program_options/option.hpp	2005-10-27 11:20:16.000000000 +0200
+++ boost_1_39_0.patched/boost/program_options/option.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -24,9 +24,9 @@
     class basic_option {
     public:
         basic_option() : position_key(-1), unregistered(false) {}
-        basic_option(const std::string& string_key, 
-               const std::vector< std::string> &value) 
-        : string_key(string_key), value(value), unregistered(false)
+        basic_option(const std::string& arg_string_key, 
+               const std::vector< std::string> &arg_value) 
+        : string_key(arg_string_key), value(arg_value), unregistered(false)
         {}
 
         /** String key of this option. Intentionally independent of the template
diff -ru boost_1_39_0/boost/program_options/options_description.hpp boost_1_39_0.patched/boost/program_options/options_description.hpp
--- boost_1_39_0/boost/program_options/options_description.hpp	2007-11-25 19:07:19.000000000 +0100
+++ boost_1_39_0.patched/boost/program_options/options_description.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -234,7 +234,7 @@
     /** Class thrown when duplicate option description is found. */
     class BOOST_PROGRAM_OPTIONS_DECL duplicate_option_error : public error {
     public:
-        duplicate_option_error(const std::string& what) : error(what) {}
+        duplicate_option_error(const std::string& arg_what) : error(arg_what) {}
     };
 }}
 
diff -ru boost_1_39_0/boost/program_options/parsers.hpp boost_1_39_0.patched/boost/program_options/parsers.hpp
--- boost_1_39_0/boost/program_options/parsers.hpp	2007-11-25 19:07:19.000000000 +0100
+++ boost_1_39_0.patched/boost/program_options/parsers.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -31,8 +31,8 @@
     template<class charT>
     class basic_parsed_options {
     public:
-        explicit basic_parsed_options(const options_description* description) 
-        : description(description) {}
+        explicit basic_parsed_options(const options_description* arg_description) 
+        : description(arg_description) {}
         /** Options found in the source. */
         std::vector< basic_option<charT> > options;
         /** Options description that was used for parsing. 
diff -ru boost_1_39_0/boost/program_options/variables_map.hpp boost_1_39_0.patched/boost/program_options/variables_map.hpp
--- boost_1_39_0/boost/program_options/variables_map.hpp	2007-11-25 19:07:19.000000000 +0100
+++ boost_1_39_0.patched/boost/program_options/variables_map.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -53,8 +53,8 @@
     class BOOST_PROGRAM_OPTIONS_DECL variable_value {
     public:
         variable_value() : m_defaulted(false) {}
-        variable_value(const boost::any& v, bool defaulted) 
-        : v(v), m_defaulted(defaulted) 
+        variable_value(const boost::any& arg_v, bool arg_defaulted) 
+        : v(arg_v), m_defaulted(arg_defaulted) 
         {}
 
         /** If stored value if of type T, returns that value. Otherwise,
diff -ru boost_1_39_0/boost/serialization/nvp.hpp boost_1_39_0.patched/boost/serialization/nvp.hpp
--- boost_1_39_0/boost/serialization/nvp.hpp	2007-11-25 19:07:19.000000000 +0100
+++ boost_1_39_0.patched/boost/serialization/nvp.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -43,7 +43,7 @@
     public std::pair<const char *, T *>,
     public wrapper_traits<nvp<T> >
 {
-    explicit nvp(const char * name, T & t) :
+    explicit nvp(const char * name_, T & t) :
         // note: redundant cast works around borland issue
         std::pair<const char *, T *>(name, (T*)(& t))
     {}
diff -ru boost_1_39_0/boost/signal.hpp boost_1_39_0.patched/boost/signal.hpp
--- boost_1_39_0/boost/signal.hpp	2006-04-10 21:31:55.000000000 +0200
+++ boost_1_39_0.patched/boost/signal.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -341,9 +341,9 @@
                        SlotFunction>::type base_type;
 
   public:
-    explicit signal(const Combiner& combiner = Combiner(),
+    explicit signal(const Combiner& arg_combiner = Combiner(),
                     const GroupCompare& group_compare = GroupCompare()) :
-      base_type(combiner, group_compare)
+      base_type(arg_combiner, group_compare)
     {
     }
   };
diff -ru boost_1_39_0/boost/signals/detail/named_slot_map.hpp boost_1_39_0.patched/boost/signals/detail/named_slot_map.hpp
--- boost_1_39_0/boost/signals/detail/named_slot_map.hpp	2007-12-14 15:48:14.000000000 +0100
+++ boost_1_39_0.patched/boost/signals/detail/named_slot_map.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -32,10 +32,10 @@
  public:
   enum storage_kind { sk_empty, sk_front, sk_back, sk_group };
 
-  stored_group(storage_kind kind = sk_empty) : kind(kind), group() { }
+  stored_group(storage_kind arg_kind = sk_empty) : kind(arg_kind), group() { }
 
   template<typename T>
-  stored_group(const T& group) : kind(sk_group), group(new T(group)) { }
+  stored_group(const T& arg_group) : kind(sk_group), group(new T(arg_group)) { }
 
   bool is_front() const { return kind == sk_front; }
   bool is_back() const { return kind == sk_back; }
@@ -133,12 +133,12 @@
 #endif
 
 private:
-  named_slot_map_iterator(group_iterator group, group_iterator last) :
-    group(group), last_group(last), slot_assigned(false)
+  named_slot_map_iterator(group_iterator arg_group, group_iterator arg_last) :
+    group(arg_group), last_group(arg_last), slot_assigned(false)
   { init_next_group(); }
-  named_slot_map_iterator(group_iterator group, group_iterator last,
-                          slot_pair_iterator slot) :
-    group(group), last_group(last), slot_(slot), slot_assigned(true)
+  named_slot_map_iterator(group_iterator arg_group, group_iterator arg_last,
+                          slot_pair_iterator arg_slot) :
+    group(arg_group), last_group(arg_last), slot_(arg_slot), slot_assigned(true)
   { }
 
   void init_next_group()
diff -ru boost_1_39_0/boost/signals/detail/slot_call_iterator.hpp boost_1_39_0.patched/boost/signals/detail/slot_call_iterator.hpp
--- boost_1_39_0/boost/signals/detail/slot_call_iterator.hpp	2005-02-20 00:44:26.000000000 +0100
+++ boost_1_39_0.patched/boost/signals/detail/slot_call_iterator.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -47,9 +47,9 @@
         friend class iterator_core_access;
 
       public:
-        slot_call_iterator(Iterator iter_in, Iterator end_in, Function f,
+        slot_call_iterator(Iterator iter_in, Iterator end_in, Function arg_f,
                            optional<result_type> &c)
-          : iter(iter_in), end(end_in), f(f), cache(&c)
+          : iter(iter_in), end(end_in), f(arg_f), cache(&c)
         {
           iter = std::find_if(iter, end, is_callable());
         }
diff -ru boost_1_39_0/boost/signals/signal_template.hpp boost_1_39_0.patched/boost/signals/signal_template.hpp
--- boost_1_39_0/boost/signals/signal_template.hpp	2006-09-21 20:16:36.000000000 +0200
+++ boost_1_39_0.patched/boost/signals/signal_template.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -345,8 +345,8 @@
 #endif // BOOST_SIGNALS_NUM_ARGS > 0
     call_bound_slot f(&args);
 
-    typedef typename call_bound_slot::result_type result_type;
-    optional<result_type> cache;
+    typedef typename call_bound_slot::result_type x_result_type;
+    optional<x_result_type> cache;
     // Let the combiner call the slots via a pair of input iterators
     return combiner()(slot_call_iterator(notification.impl->slots_.begin(),
                                          impl->slots_.end(), f, cache),
@@ -386,8 +386,8 @@
 
     call_bound_slot f(&args);
 
-    typedef typename call_bound_slot::result_type result_type;
-    optional<result_type> cache;
+    typedef typename call_bound_slot::result_type y_result_type;
+    optional<y_result_type> cache;
 
     // Let the combiner call the slots via a pair of input iterators
     return combiner()(slot_call_iterator(notification.impl->slots_.begin(),
diff -ru boost_1_39_0/boost/spirit/home/classic/core/impl/match.ipp boost_1_39_0.patched/boost/spirit/home/classic/core/impl/match.ipp
--- boost_1_39_0/boost/spirit/home/classic/core/impl/match.ipp	2008-06-22 17:05:38.000000000 +0200
+++ boost_1_39_0.patched/boost/spirit/home/classic/core/impl/match.ipp	2009-06-23 15:18:04.000000000 +0200
@@ -19,12 +19,12 @@
     : len(-1), val() {}
 
     template <typename T>
-    inline match<T>::match(std::size_t length)
-    : len(length), val() {}
+    inline match<T>::match(std::size_t arg_length)
+    : len(arg_length), val() {}
 
     template <typename T>
-    inline match<T>::match(std::size_t length, ctor_param_t val_)
-    : len(length), val(val_) {}
+    inline match<T>::match(std::size_t arg_length, ctor_param_t val_)
+    : len(arg_length), val(val_) {}
 
     template <typename T>
     inline bool
@@ -66,11 +66,11 @@
     inline match<nil_t>::match()
     : len(-1) {}
 
-    inline match<nil_t>::match(std::size_t length)
-    : len(length) {}
+    inline match<nil_t>::match(std::size_t arg_length)
+    : len(arg_length) {}
 
-    inline match<nil_t>::match(std::size_t length, nil_t)
-    : len(length) {}
+    inline match<nil_t>::match(std::size_t arg_length, nil_t)
+    : len(arg_length) {}
 
     inline bool
     match<nil_t>::operator!() const
diff -ru boost_1_39_0/boost/spirit/home/classic/core/non_terminal/impl/rule.ipp boost_1_39_0.patched/boost/spirit/home/classic/core/non_terminal/impl/rule.ipp
--- boost_1_39_0/boost/spirit/home/classic/core/non_terminal/impl/rule.ipp	2008-06-22 17:05:38.000000000 +0200
+++ boost_1_39_0.patched/boost/spirit/home/classic/core/non_terminal/impl/rule.ipp	2009-06-23 15:18:04.000000000 +0200
@@ -226,7 +226,7 @@
         template <typename ParserT, typename ScannerT, typename AttrT>
         struct concrete_parser : abstract_parser<ScannerT, AttrT>
         {
-            concrete_parser(ParserT const& p) : p(p) {}
+            concrete_parser(ParserT const& arg_p) : p(arg_p) {}
             virtual ~concrete_parser() {}
 
             virtual typename match_result<ScannerT, AttrT>::type
diff -ru boost_1_39_0/boost/spirit/home/classic/core/non_terminal/parser_id.hpp boost_1_39_0.patched/boost/spirit/home/classic/core/non_terminal/parser_id.hpp
--- boost_1_39_0/boost/spirit/home/classic/core/non_terminal/parser_id.hpp	2008-06-22 17:05:38.000000000 +0200
+++ boost_1_39_0.patched/boost/spirit/home/classic/core/non_terminal/parser_id.hpp	2009-06-23 15:18:04.000000000 +0200
@@ -106,7 +106,7 @@
                 : parser_id(reinterpret_cast<std::size_t>(this)); 
         }
 
-        void set_id(parser_id id) { tag = id; } 
+        void set_id(parser_id arg_id) { tag = arg_id; } 
         
     private:
     
diff -ru boost_1_39_0/boost/spirit/home/classic/core/non_terminal/rule.hpp boost_1_39_0.patched/boost/spirit/home/classic/core/non_terminal/rule.hpp
--- boost_1_39_0/boost/spirit/home/classic/core/non_terminal/rule.hpp	2008-06-22 17:05:38.000000000 +0200
+++ boost_1_39_0.patched/boost/spirit/home/classic/core/non_terminal/rule.hpp	2009-06-23 15:18:04.000000000 +0200
@@ -159,11 +159,11 @@
             return ptr.get();
         }
 
-        rule(abstract_parser_t* ptr)
-        : ptr(ptr) {}
+        rule(abstract_parser_t* arg_ptr)
+        : ptr(arg_ptr) {}
 
-        rule(abstract_parser_t const* ptr)
-        : ptr(ptr) {}
+        rule(abstract_parser_t const* arg_ptr)
+        : ptr(arg_ptr) {}
 
         scoped_ptr<abstract_parser_t> ptr;
     };
diff -ru boost_1_39_0/boost/spirit/home/classic/core/non_terminal/subrule.hpp boost_1_39_0.patched/boost/spirit/home/classic/core/non_terminal/subrule.hpp
--- boost_1_39_0/boost/spirit/home/classic/core/non_terminal/subrule.hpp	2008-06-22 17:05:38.000000000 +0200
+++ boost_1_39_0.patched/boost/spirit/home/classic/core/non_terminal/subrule.hpp	2009-06-23 15:18:04.000000000 +0200
@@ -210,7 +210,7 @@
             subrule_list<
                 subrule_parser<ID2, DefT2, ContextT2>,
                 nil_t> >
-        operator,(subrule_parser<ID2, DefT2, ContextT2> const& rhs) const
+        operator,(subrule_parser<ID2, DefT2, ContextT2> const& arg_rhs) const
         {
             return subrule_list<
                 self_t,
@@ -220,7 +220,7 @@
                         *this,
                         subrule_list<
                             subrule_parser<ID2, DefT2, ContextT2>, nil_t>(
-                                rhs, nil_t()));
+                                arg_rhs, nil_t()));
         }
 
         typename DefT::embed_t rhs;
@@ -258,10 +258,10 @@
         parse_main(ScannerT const& scan) const
         {
             typedef typename parser_result<self_t, ScannerT>::type result_t;
-            result_t result;
+            result_t tmp_result;
             impl::parse_subrule<result_t, ScannerT, ID>::
-                do_(result, scan);
-            return result;
+                do_(tmp_result, scan);
+            return tmp_result;
         }
 
         template <typename ScannerT>
diff -ru boost_1_39_0/boost/spirit/home/classic/tree/common.hpp boost_1_39_0.patched/boost/spirit/home/classic/tree/common.hpp
--- boost_1_39_0/boost/spirit/home/classic/tree/common.hpp	2008-06-22 17:05:38.000000000 +0200
+++ boost_1_39_0.patched/boost/spirit/home/classic/tree/common.hpp	2009-06-23 15:18:04.000000000 +0200
@@ -555,18 +555,18 @@
     {}
 
     explicit
-    tree_match(std::size_t length)
-    : match<T>(length), trees()
+    tree_match(std::size_t arg_length)
+    : match<T>(arg_length), trees()
     {}
 
-    tree_match(std::size_t length, parse_node_t const& n)
-    : match<T>(length), trees()
+    tree_match(std::size_t arg_length, parse_node_t const& n)
+    : match<T>(arg_length), trees()
     { 
         trees.push_back(node_t(n)); 
     }
 
-    tree_match(std::size_t length, param_type val, parse_node_t const& n)
-    : match<T>(length, val), trees()
+    tree_match(std::size_t arg_length, param_type arg_val, parse_node_t const& n)
+    : match<T>(arg_length, arg_val), trees()
     {
 #if !defined(BOOST_SPIRIT_USE_LIST_FOR_TREES)
         trees.reserve(10); // this is more or less an arbitrary number...
@@ -575,14 +575,14 @@
     }
 
     // attention, these constructors will change the second parameter!
-    tree_match(std::size_t length, container_t& c)
-    : match<T>(length), trees()
+    tree_match(std::size_t arg_length, container_t& c)
+    : match<T>(arg_length), trees()
     { 
         impl::cp_swap(trees, c);
     }
 
-    tree_match(std::size_t length, param_type val, container_t& c)
-    : match<T>(length, val), trees()
+    tree_match(std::size_t arg_length, param_type val, container_t& c)
+    : match<T>(arg_length, val), trees()
     {
         impl::cp_swap(trees, c);
     }
diff -ru boost_1_39_0/boost/test/utils/lazy_ostream.hpp boost_1_39_0.patched/boost/test/utils/lazy_ostream.hpp
--- boost_1_39_0/boost/test/utils/lazy_ostream.hpp	2008-10-13 10:20:26.000000000 +0200
+++ boost_1_39_0.patched/boost/test/utils/lazy_ostream.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -45,7 +45,7 @@
     // actual printing interface; to be accessed only by this class and children
     virtual std::ostream&   operator()( std::ostream& ostr ) const                  { return ostr; }
 protected:
-    explicit                lazy_ostream( bool empty = true ) : m_empty( empty )    {}
+    explicit                lazy_ostream( bool arg_empty = true ) : m_empty( arg_empty )    {}
 
     // protected destructor to make sure right one is called
 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
diff -ru boost_1_39_0/boost/variant/variant.hpp boost_1_39_0.patched/boost/variant/variant.hpp
--- boost_1_39_0/boost/variant/variant.hpp	2007-11-25 19:07:19.000000000 +0100
+++ boost_1_39_0.patched/boost/variant/variant.hpp	2009-06-23 15:18:03.000000000 +0200
@@ -1112,14 +1112,14 @@
     which_t which_;
     storage_t storage_;
 
-    void indicate_which(int which)
+    void indicate_which(int arg_which)
     {
-        which_ = static_cast<which_t>( which );
+        which_ = static_cast<which_t>( arg_which );
     }
 
-    void indicate_backup_which(int which)
+    void indicate_backup_which(int arg_which)
     {
-        which_ = static_cast<which_t>( -(which + 1) );
+        which_ = static_cast<which_t>( -(arg_which + 1) );
     }
 
 private: // helpers, for queries (below)