1--- misc/boost_1_55_0/boost/unordered/detail/equivalent.hpp 2012-12-05 23:06:57.000000000 +0100 2+++ misc/build/boost_1_55_0/boost/unordered/detail/equivalent.hpp 2014-01-07 10:33:59.550621750 +0100 3@@ -534,11 +534,11 @@ 4 } 5 6 node_pointer first_node = static_cast<node_pointer>(prev->next_); 7- link_pointer end = first_node->group_prev_->next_; 8+ link_pointer end_var = first_node->group_prev_->next_; 9 10- std::size_t count = this->delete_nodes(prev, end); 11+ std::size_t count_var = this->delete_nodes(prev, end_var); 12 this->fix_bucket(bucket_index, prev); 13- return count; 14+ return count_var; 15 } 16 17 iterator erase(c_iterator r) 18@@ -557,21 +557,21 @@ 19 return iterator(r2.node_); 20 } 21 22- link_pointer erase_nodes(node_pointer begin, node_pointer end) 23+ link_pointer erase_nodes(node_pointer begin_arg, node_pointer end_arg) 24 { 25- std::size_t bucket_index = this->hash_to_bucket(begin->hash_); 26+ std::size_t bucket_index = this->hash_to_bucket(begin_arg->hash_); 27 28- // Split the groups containing 'begin' and 'end'. 29+ // Split the groups containing 'begin_arg' and 'end_arg'. 30 // And get the pointer to the node before begin while 31 // we're at it. 32- link_pointer prev = split_groups(begin, end); 33+ link_pointer prev = split_groups(begin_arg, end_arg); 34 35- // If we don't have a 'prev' it means that begin is at the 36+ // If we don't have a 'prev' it means that begin_arg is at the 37 // beginning of a block, so search through the blocks in the 38 // same bucket. 39 if (!prev) { 40 prev = this->get_previous_start(bucket_index); 41- while (prev->next_ != begin) 42+ while (prev->next_ != begin_arg) 43 prev = static_cast<node_pointer>(prev->next_)->group_prev_; 44 } 45 46@@ -581,24 +581,24 @@ 47 static_cast<node_pointer>(prev->next_)->group_prev_->next_; 48 this->delete_nodes(prev, group_end); 49 bucket_index = this->fix_bucket(bucket_index, prev); 50- } while(prev->next_ != end); 51+ } while(prev->next_ != end_arg); 52 53 return prev; 54 } 55 56- static link_pointer split_groups(node_pointer begin, node_pointer end) 57+ static link_pointer split_groups(node_pointer begin_arg, node_pointer end_arg) 58 { 59- node_pointer prev = begin->group_prev_; 60- if (prev->next_ != begin) prev = node_pointer(); 61+ node_pointer prev = begin_arg->group_prev_; 62+ if (prev->next_ != begin_arg) prev = node_pointer(); 63 64- if (end) { 65- node_pointer first = end; 66- while (first != begin && first->group_prev_->next_ == first) { 67+ if (end_arg) { 68+ node_pointer first = end_arg; 69+ while (first != begin_arg && first->group_prev_->next_ == first) { 70 first = first->group_prev_; 71 } 72 73- boost::swap(first->group_prev_, end->group_prev_); 74- if (first == begin) return prev; 75+ boost::swap(first->group_prev_, end_arg->group_prev_); 76+ if (first == begin_arg) return prev; 77 } 78 79 if (prev) { 80@@ -606,7 +606,7 @@ 81 while (first->group_prev_->next_ == first) { 82 first = first->group_prev_; 83 } 84- boost::swap(first->group_prev_, begin->group_prev_); 85+ boost::swap(first->group_prev_, begin_arg->group_prev_); 86 } 87 88 return prev; 89--- misc/boost_1_55_0/boost/unordered/detail/table.hpp 2013-08-18 11:44:14.000000000 +0200 90+++ misc/build/boost_1_55_0/boost/unordered/detail/table.hpp 2014-01-07 10:18:27.862432325 +0100 91@@ -257,9 +257,9 @@ 92 return prev ? iterator(prev->next_) : iterator(); 93 } 94 95- std::size_t hash_to_bucket(std::size_t hash) const 96+ std::size_t hash_to_bucket(std::size_t hash_arg) const 97 { 98- return policy::to_bucket(bucket_count_, hash); 99+ return policy::to_bucket(bucket_count_, hash_arg); 100 } 101 102 float load_factor() const 103@@ -655,8 +655,8 @@ 104 // assign_nodes takes ownership of the container's elements, 105 // assigning to them if possible, and deleting any that are 106 // left over. 107- assign_nodes<table> assign(*this); 108- table_impl::fill_buckets(x.begin(), *this, assign); 109+ assign_nodes<table> assign_var(*this); 110+ table_impl::fill_buckets(x.begin(), *this, assign_var); 111 } 112 113 void assign(table const& x, true_type) 114@@ -730,9 +730,9 @@ 115 // move_assign_nodes takes ownership of the container's 116 // elements, assigning to them if possible, and deleting 117 // any that are left over. 118- move_assign_nodes<table> assign(*this); 119+ move_assign_nodes<table> assign_var(*this); 120 node_holder<node_allocator> nodes(x); 121- table_impl::fill_buckets(nodes.begin(), *this, assign); 122+ table_impl::fill_buckets(nodes.begin(), *this, assign_var); 123 } 124 } 125 126--- misc/boost_1_55_0/boost/unordered/detail/unique.hpp 2013-08-18 11:44:14.000000000 +0200 127+++ misc/build/boost_1_55_0/boost/unordered/detail/unique.hpp 2014-01-07 10:18:27.865432217 +0100 128@@ -529,9 +529,9 @@ 129 130 link_pointer end = static_cast<node_pointer>(prev->next_)->next_; 131 132- std::size_t count = this->delete_nodes(prev, end); 133+ std::size_t count_var = this->delete_nodes(prev, end); 134 this->fix_bucket(bucket_index, prev); 135- return count; 136+ return count_var; 137 } 138 139 iterator erase(c_iterator r) 140@@ -550,19 +550,19 @@ 141 return iterator(r2.node_); 142 } 143 144- void erase_nodes(node_pointer begin, node_pointer end) 145+ void erase_nodes(node_pointer begin_arg, node_pointer end_arg) 146 { 147- std::size_t bucket_index = this->hash_to_bucket(begin->hash_); 148+ std::size_t bucket_index = this->hash_to_bucket(begin_arg->hash_); 149 150- // Find the node before begin. 151+ // Find the node before begin_arg 152 link_pointer prev = this->get_previous_start(bucket_index); 153- while(prev->next_ != begin) prev = prev->next_; 154+ while(prev->next_ != begin_arg) prev = prev->next_; 155 156 // Delete the nodes. 157 do { 158 this->delete_node(prev); 159 bucket_index = this->fix_bucket(bucket_index, prev); 160- } while (prev->next_ != end); 161+ } while (prev->next_ != end_arg); 162 } 163 164 //////////////////////////////////////////////////////////////////////// 165