| blob | d1224f65cbba5336c2afba922059ec6d821043b2 |
1 --- misc/boost_1_44_0/boost/date_time/date_names_put.hpp 2008-02-27 21:00:24.000000000 +0100
2 +++ misc/build/boost_1_44_0/boost/date_time/date_names_put.hpp 2011-10-05 16:58:58.413575307 +0200
3 @@ -218,14 +218,14 @@
4 const charT* const weekday_long_names[],
5 charT separator_char = '-',
6 ymd_order_spec order_spec = ymd_order_iso,
7 - month_format_spec month_format = month_as_short_string) :
8 + month_format_spec month_format_ = month_as_short_string) :
9 month_short_names_(month_short_names),
10 month_long_names_(month_long_names),
11 special_value_names_(special_value_names),
12 weekday_short_names_(weekday_short_names),
13 weekday_long_names_(weekday_long_names),
14 order_spec_(order_spec),
15 - month_format_spec_(month_format)
16 + month_format_spec_(month_format_)
17 {
18 separator_char_[0] = separator_char;
19 separator_char_[1] = '\0';
20 --- misc/boost_1_44_0/boost/ptr_container/detail/map_iterator.hpp 2008-06-24 22:37:35.000000000 +0200
21 +++ misc/build/boost_1_44_0/boost/ptr_container/detail/map_iterator.hpp 2011-02-04 16:39:19.000000000 +0100
22 @@ -49,7 +49,7 @@
23 : first(rp->first), second(rp->second)
24 { }
26 - const ref_pair* const operator->() const
27 + const ref_pair* operator->() const
28 {
29 return this;
30 }
31 --- misc/boost_1_44_0/boost/ptr_container/ptr_map_adapter.hpp 2008-06-24 22:37:35.000000000 +0200
32 +++ misc/build/boost_1_44_0/boost/ptr_container/ptr_map_adapter.hpp 2011-02-04 16:39:19.000000000 +0100
33 @@ -477,6 +477,7 @@
34 }
36 ptr_map_adapter( const ptr_map_adapter& r )
37 + : base_type()
38 {
39 map_basic_clone_and_insert( r.begin(), r.end() );
40 }
41 --- misc/boost_1_44_0/boost/ptr_container/ptr_sequence_adapter.hpp 2009-11-01 12:07:12.000000000 +0100
42 +++ misc/build/boost_1_44_0/boost/ptr_container/ptr_sequence_adapter.hpp 2011-02-04 16:39:19.000000000 +0100
43 @@ -476,19 +476,19 @@
44 public: // C-array support
46 void transfer( iterator before, value_type* from,
47 - size_type size, bool delete_from = true ) // strong
48 + size_type size_, bool delete_from = true ) // strong
49 {
50 BOOST_ASSERT( from != 0 );
51 if( delete_from )
52 {
53 BOOST_DEDUCED_TYPENAME base_type::scoped_deleter
54 - deleter( from, size ); // nothrow
55 - this->base().insert( before.base(), from, from + size ); // strong
56 + deleter( from, size_ ); // nothrow
57 + this->base().insert( before.base(), from, from + size_ ); // strong
58 deleter.release(); // nothrow
59 }
60 else
61 {
62 - this->base().insert( before.base(), from, from + size ); // strong
63 + this->base().insert( before.base(), from, from + size_ ); // strong
64 }
65 }
67 @@ -671,6 +671,7 @@
68 void range_check_impl( iterator first, iterator last,
69 std::random_access_iterator_tag )
70 {
71 + (void)first; (void)last;
72 BOOST_ASSERT( first <= last && "out of range unique()/erase_if()" );
73 BOOST_ASSERT( this->begin() <= first && "out of range unique()/erase_if()" );
74 BOOST_ASSERT( last <= this->end() && "out of range unique()/erase_if)(" );
75 --- misc/boost_1_44_0/boost/spirit/home/classic/error_handling/exceptions.hpp 2010-04-07 02:41:42.000000000 +0200
76 +++ misc/build/boost_1_44_0/boost/spirit/home/classic/error_handling/exceptions.hpp 2011-02-04 16:39:19.000000000 +0100
77 @@ -222,9 +222,9 @@
79 error_status(
80 result_t result_ = fail,
81 - std::ptrdiff_t length = -1,
82 + std::ptrdiff_t length_ = -1,
83 T const& value_ = T())
84 - : result(result_), length(length), value(value_) {}
85 + : result(result_), length(length_), value(value_) {}
87 result_t result;
88 std::ptrdiff_t length;
89 --- misc/boost_1_44_0/boost/spirit/home/classic/symbols/symbols.hpp 2008-06-22 17:05:38.000000000 +0200
90 +++ misc/build/boost_1_44_0/boost/spirit/home/classic/symbols/symbols.hpp 2011-02-04 16:39:19.000000000 +0100
91 @@ -102,13 +102,13 @@
92 {
93 typedef typename ScannerT::iterator_t iterator_t;
94 iterator_t first = scan.first;
95 - typename SetT::search_info result = SetT::find(scan);
96 + typename SetT::search_info result_ = SetT::find(scan);
98 - if (result.data)
99 + if (result_.data)
100 return scan.
101 create_match(
102 - result.length,
103 - symbol_ref_t(*result.data),
104 + result_.length,
105 + symbol_ref_t(*result_.data),
106 first,
107 scan.first);
108 else
109 --- misc/boost_1_44_0/boost/spirit/home/classic/utility/functor_parser.hpp 2008-06-22 17:05:38.000000000 +0200
110 +++ misc/build/boost_1_44_0/boost/spirit/home/classic/utility/functor_parser.hpp 2011-02-04 16:39:19.000000000 +0100
111 @@ -54,13 +54,13 @@
112 typedef typename ScannerT::iterator_t iterator_t;
114 iterator_t const s(scan.first);
115 - functor_result_t result;
116 - std::ptrdiff_t len = functor(scan, result);
117 + functor_result_t functor_result;
118 + std::ptrdiff_t len = functor(scan, functor_result);
120 if (len < 0)
121 return scan.no_match();
122 else
123 - return scan.create_match(std::size_t(len), result, s, scan.first);
124 + return scan.create_match(std::size_t(len), functor_result, s, scan.first);
125 }
126 };
128 --- misc/boost_1_44_0/boost/spirit/home/classic/utility/loops.hpp 2008-06-22 17:05:38.000000000 +0200
129 +++ misc/build/boost_1_44_0/boost/spirit/home/classic/utility/loops.hpp 2011-02-04 16:39:19.000000000 +0100
130 @@ -47,8 +47,8 @@
131 typedef fixed_loop<ParserT, ExactT> self_t;
132 typedef unary<ParserT, parser<self_t> > base_t;
134 - fixed_loop (ParserT const & subject, ExactT const & exact)
135 - : base_t(subject), m_exact(exact) {}
136 + fixed_loop (ParserT const & subject_, ExactT const & exact)
137 + : base_t(subject_), m_exact(exact) {}
139 template <typename ScannerT>
140 typename parser_result <self_t, ScannerT>::type
141 @@ -112,8 +112,8 @@
142 typedef finite_loop <ParserT, MinT, MaxT> self_t;
143 typedef unary<ParserT, parser<self_t> > base_t;
145 - finite_loop (ParserT const & subject, MinT const & min, MaxT const & max)
146 - : base_t(subject), m_min(min), m_max(max) {}
147 + finite_loop (ParserT const & subject_, MinT const & min, MaxT const & max)
148 + : base_t(subject_), m_min(min), m_max(max) {}
150 template <typename ScannerT>
151 typename parser_result <self_t, ScannerT>::type
152 @@ -196,11 +196,11 @@
153 typedef unary<ParserT, parser<self_t> > base_t;
155 infinite_loop (
156 - ParserT const& subject,
157 + ParserT const& subject_,
158 MinT const& min,
159 more_t const&
160 )
161 - : base_t(subject), m_min(min) {}
162 + : base_t(subject_), m_min(min) {}
164 template <typename ScannerT>
165 typename parser_result <self_t, ScannerT>::type
166 @@ -253,9 +253,9 @@
168 template <typename ParserT>
169 fixed_loop <ParserT, ExactT>
170 - operator[](parser <ParserT> const & subject) const
171 + operator[](parser <ParserT> const & subject_) const
172 {
173 - return fixed_loop <ParserT, ExactT> (subject.derived (), m_exact);
174 + return fixed_loop <ParserT, ExactT> (subject_.derived (), m_exact);
175 }
177 ExactT m_exact;
178 @@ -283,11 +283,11 @@
180 template <typename ParserT>
181 typename impl::loop_traits<ParserT, MinT, MaxT>::type
182 - operator[](parser <ParserT> const & subject) const
183 + operator[](parser <ParserT> const & subject_) const
184 {
185 typedef typename impl::loop_traits<ParserT, MinT, MaxT>::type ret_t;
186 return ret_t(
187 - subject.derived(),
188 + subject_.derived(),
189 m_min,
190 m_max);
191 }
192 --- misc/boost_1_44_0/boost/unordered/detail/table.hpp 2011-02-04 16:55:26.000000000 +0100
193 +++ misc/build/boost_1_44_0/boost/unordered/detail/table.hpp 2011-02-05 03:34:26.000000000 +0100
194 @@ -33,10 +33,10 @@
195 template <class T>
196 template <class Key, class Pred>
197 inline BOOST_DEDUCED_TYPENAME T::node_ptr
198 - hash_table<T>::find_iterator(bucket_ptr bucket, Key const& k,
199 + hash_table<T>::find_iterator(bucket_ptr bucket_, Key const& k,
200 Pred const& eq) const
201 {
202 - node_ptr it = bucket->next_;
203 + node_ptr it = bucket_->next_;
204 while (BOOST_UNORDERED_BORLAND_BOOL(it) &&
205 !eq(k, get_key(node::get_value(it))))
206 {
207 @@ -50,9 +50,9 @@
208 template <class T>
209 inline BOOST_DEDUCED_TYPENAME T::node_ptr
210 hash_table<T>::find_iterator(
211 - bucket_ptr bucket, key_type const& k) const
212 + bucket_ptr bucket_, key_type const& k) const
213 {
214 - node_ptr it = bucket->next_;
215 + node_ptr it = bucket_->next_;
216 while (BOOST_UNORDERED_BORLAND_BOOL(it) &&
217 !equal(k, node::get_value(it)))
218 {
219 @@ -75,9 +75,9 @@
220 template <class T>
221 inline BOOST_DEDUCED_TYPENAME T::node_ptr*
222 hash_table<T>::find_for_erase(
223 - bucket_ptr bucket, key_type const& k) const
224 + bucket_ptr bucket_, key_type const& k) const
225 {
226 - node_ptr* it = &bucket->next_;
227 + node_ptr* it = &bucket_->next_;
228 while(BOOST_UNORDERED_BORLAND_BOOL(*it) &&
229 !equal(k, node::get_value(*it)))
230 {
231 @@ -475,7 +475,7 @@
232 {
233 hasher const& hf = this->hash_function();
234 std::size_t size = this->size_;
235 - bucket_ptr end = this->get_bucket(this->bucket_count_);
236 + bucket_ptr end_ = this->get_bucket(this->bucket_count_);
238 buckets dst(this->node_alloc(), num_buckets);
239 dst.create_buckets();
240 @@ -484,10 +484,10 @@
241 src.swap(*this);
242 this->size_ = 0;
244 - for(bucket_ptr bucket = this->cached_begin_bucket_;
245 - bucket != end; ++bucket)
246 + for(bucket_ptr bucket_ = this->cached_begin_bucket_;
247 + bucket_ != end_; ++bucket_)
248 {
249 - node_ptr group = bucket->next_;
250 + node_ptr group = bucket_->next_;
251 while(group) {
252 // Move the first group of equivalent nodes in bucket to dst.
254 @@ -496,10 +496,10 @@
255 hf(get_key_from_ptr(group)));
257 node_ptr& next_group = node::next_group(group);
258 - bucket->next_ = next_group;
259 + bucket_->next_ = next_group;
260 next_group = dst_bucket->next_;
261 dst_bucket->next_ = group;
262 - group = bucket->next_;
263 + group = bucket_->next_;
264 }
265 }
267 @@ -525,13 +525,13 @@
268 BOOST_ASSERT(this->buckets_ && !dst.buckets_);
270 hasher const& hf = this->hash_function();
271 - bucket_ptr end = this->get_bucket(this->bucket_count_);
272 + bucket_ptr end_ = this->get_bucket(this->bucket_count_);
274 node_constructor a(dst);
275 dst.create_buckets();
277 // no throw:
278 - for(bucket_ptr i = this->cached_begin_bucket_; i != end; ++i) {
279 + for(bucket_ptr i = this->cached_begin_bucket_; i != end_; ++i) {
280 // no throw:
281 for(node_ptr it = i->next_; it;) {
282 // hash function can throw.
283 @@ -579,11 +579,11 @@
284 {
285 if(!this->size_) return this->end();
287 - bucket_ptr bucket = this->get_bucket(this->bucket_index(k));
288 - node_ptr it = find_iterator(bucket, k);
289 + bucket_ptr bucket_ = this->get_bucket(this->bucket_index(k));
290 + node_ptr it = find_iterator(bucket_, k);
292 if (BOOST_UNORDERED_BORLAND_BOOL(it))
293 - return iterator_base(bucket, it);
294 + return iterator_base(bucket_, it);
295 else
296 return this->end();
297 }
298 @@ -595,11 +595,11 @@
299 {
300 if(!this->size_) return this->end();
302 - bucket_ptr bucket = this->get_bucket(h(k) % this->bucket_count_);
303 - node_ptr it = find_iterator(bucket, k, eq);
304 + bucket_ptr bucket_ = this->get_bucket(h(k) % this->bucket_count_);
305 + node_ptr it = find_iterator(bucket_, k, eq);
307 if (BOOST_UNORDERED_BORLAND_BOOL(it))
308 - return iterator_base(bucket, it);
309 + return iterator_base(bucket_, it);
310 else
311 return this->end();
312 }
313 @@ -611,8 +611,8 @@
314 if(!this->size_)
315 boost::throw_exception(std::out_of_range("Unable to find key in unordered_map."));
317 - bucket_ptr bucket = this->get_bucket(this->bucket_index(k));
318 - node_ptr it = find_iterator(bucket, k);
319 + bucket_ptr bucket_ = this->get_bucket(this->bucket_index(k));
320 + node_ptr it = find_iterator(bucket_, k);
322 if (!it)
323 boost::throw_exception(std::out_of_range("Unable to find key in unordered_map."));
324 @@ -630,10 +630,10 @@
325 if(!this->size_)
326 return iterator_pair(this->end(), this->end());
328 - bucket_ptr bucket = this->get_bucket(this->bucket_index(k));
329 - node_ptr it = find_iterator(bucket, k);
330 + bucket_ptr bucket_ = this->get_bucket(this->bucket_index(k));
331 + node_ptr it = find_iterator(bucket_, k);
332 if (BOOST_UNORDERED_BORLAND_BOOL(it)) {
333 - iterator_base first(iterator_base(bucket, it));
334 + iterator_base first(iterator_base(bucket_, it));
335 iterator_base second(first);
336 second.increment_bucket(node::next_group(second.node_));
337 return iterator_pair(first, second);
338 @@ -651,26 +651,26 @@
339 {
340 if(!this->size_) return;
342 - bucket_ptr end = this->get_bucket(this->bucket_count_);
343 - for(bucket_ptr begin = this->buckets_; begin != end; ++begin) {
344 - this->clear_bucket(begin);
345 + bucket_ptr end_ = this->get_bucket(this->bucket_count_);
346 + for(bucket_ptr begin_ = this->buckets_; begin_ != end_; ++begin_) {
347 + this->clear_bucket(begin_);
348 }
350 this->size_ = 0;
351 - this->cached_begin_bucket_ = end;
352 + this->cached_begin_bucket_ = end_;
353 }
355 template <class T>
356 inline std::size_t hash_table<T>::erase_group(
357 - node_ptr* it, bucket_ptr bucket)
358 + node_ptr* it, bucket_ptr bucket_)
359 {
360 node_ptr pos = *it;
361 - node_ptr end = node::next_group(pos);
362 - *it = end;
363 - std::size_t count = this->delete_nodes(pos, end);
364 - this->size_ -= count;
365 - this->recompute_begin_bucket(bucket);
366 - return count;
367 + node_ptr end_ = node::next_group(pos);
368 + *it = end_;
369 + std::size_t count_ = this->delete_nodes(pos, end_);
370 + this->size_ -= count_;
371 + this->recompute_begin_bucket(bucket_);
372 + return count_;
373 }
375 template <class T>
376 @@ -679,11 +679,11 @@
377 if(!this->size_) return 0;
379 // No side effects in initial section
380 - bucket_ptr bucket = this->get_bucket(this->bucket_index(k));
381 - node_ptr* it = this->find_for_erase(bucket, k);
382 + bucket_ptr bucket_ = this->get_bucket(this->bucket_index(k));
383 + node_ptr* it = this->find_for_erase(bucket_, k);
385 // No throw.
386 - return *it ? this->erase_group(it, bucket) : 0;
387 + return *it ? this->erase_group(it, bucket_) : 0;
388 }
390 template <class T>
391 @@ -766,12 +766,12 @@
392 std::size_t hash_value = this->hash_function()(k);
393 if(this->buckets_) this->reserve_for_insert(size);
394 else this->create_for_insert(size);
395 - bucket_ptr bucket = this->bucket_ptr_from_hash(hash_value);
396 + bucket_ptr bucket_ = this->bucket_ptr_from_hash(hash_value);
397 node_ptr n = a.release();
398 - node::add_to_bucket(n, *bucket);
399 + node::add_to_bucket(n, *bucket_);
400 ++this->size_;
401 - this->cached_begin_bucket_ = bucket;
402 - return iterator_base(bucket, n);
403 + this->cached_begin_bucket_ = bucket_;
404 + return iterator_base(bucket_, n);
405 }
406 }}
408 --- misc/boost_1_44_0/boost/unordered/detail/unique.hpp 2011-02-05 03:28:39.000000000 +0100
409 +++ misc/build/boost_1_44_0/boost/unordered/detail/unique.hpp 2011-02-05 03:36:54.000000000 +0100
410 @@ -57,7 +57,7 @@
412 bool equals(hash_unique_table const&) const;
414 - node_ptr add_node(node_constructor& a, bucket_ptr bucket);
415 + node_ptr add_node(node_constructor& a, bucket_ptr bucket_);
417 #if defined(BOOST_UNORDERED_STD_FORWARD)
419 @@ -135,8 +135,8 @@
420 if(this->size_ != other.size_) return false;
421 if(!this->size_) return true;
423 - bucket_ptr end = this->get_bucket(this->bucket_count_);
424 - for(bucket_ptr i = this->cached_begin_bucket_; i != end; ++i)
425 + bucket_ptr end_ = this->get_bucket(this->bucket_count_);
426 + for(bucket_ptr i = this->cached_begin_bucket_; i != end_; ++i)
427 {
428 node_ptr it1 = i->next_;
429 while(BOOST_UNORDERED_BORLAND_BOOL(it1))
430 @@ -159,13 +159,13 @@
431 template <class T>
432 inline BOOST_DEDUCED_TYPENAME hash_unique_table<T>::node_ptr
433 hash_unique_table<T>::add_node(node_constructor& a,
434 - bucket_ptr bucket)
435 + bucket_ptr bucket_)
436 {
437 node_ptr n = a.release();
438 - node::add_to_bucket(n, *bucket);
439 + node::add_to_bucket(n, *bucket_);
440 ++this->size_;
441 - if(bucket < this->cached_begin_bucket_)
442 - this->cached_begin_bucket_ = bucket;
443 + if(bucket_ < this->cached_begin_bucket_)
444 + this->cached_begin_bucket_ = bucket_;
445 return n;
446 }
448 @@ -181,7 +181,7 @@
449 typedef BOOST_DEDUCED_TYPENAME value_type::second_type mapped_type;
451 std::size_t hash_value = this->hash_function()(k);
452 - bucket_ptr bucket = this->bucket_ptr_from_hash(hash_value);
453 + bucket_ptr bucket_ = this->bucket_ptr_from_hash(hash_value);
455 if(!this->buckets_) {
456 node_constructor a(*this);
457 @@ -189,7 +189,7 @@
458 return *this->emplace_empty_impl_with_node(a, 1);
459 }
461 - node_ptr pos = this->find_iterator(bucket, k);
462 + node_ptr pos = this->find_iterator(bucket_, k);
464 if (BOOST_UNORDERED_BORLAND_BOOL(pos)) {
465 return node::get_value(pos);
466 @@ -205,11 +205,11 @@
467 // reserve has basic exception safety if the hash function
468 // throws, strong otherwise.
469 if(this->reserve_for_insert(this->size_ + 1))
470 - bucket = this->bucket_ptr_from_hash(hash_value);
471 + bucket_ = this->bucket_ptr_from_hash(hash_value);
473 // Nothing after this point can throw.
475 - return node::get_value(add_node(a, bucket));
476 + return node::get_value(add_node(a, bucket_));
477 }
478 }
480 @@ -220,22 +220,22 @@
481 // No side effects in this initial code
482 key_type const& k = this->get_key(a.value());
483 std::size_t hash_value = this->hash_function()(k);
484 - bucket_ptr bucket = this->bucket_ptr_from_hash(hash_value);
485 - node_ptr pos = this->find_iterator(bucket, k);
486 + bucket_ptr bucket_ = this->bucket_ptr_from_hash(hash_value);
487 + node_ptr pos = this->find_iterator(bucket_, k);
489 if (BOOST_UNORDERED_BORLAND_BOOL(pos)) {
490 // Found an existing key, return it (no throw).
491 - return emplace_return(iterator_base(bucket, pos), false);
492 + return emplace_return(iterator_base(bucket_, pos), false);
493 } else {
494 // reserve has basic exception safety if the hash function
495 // throws, strong otherwise.
496 if(this->reserve_for_insert(this->size_ + 1))
497 - bucket = this->bucket_ptr_from_hash(hash_value);
498 + bucket_ = this->bucket_ptr_from_hash(hash_value);
500 // Nothing after this point can throw.
502 return emplace_return(
503 - iterator_base(bucket, add_node(a, bucket)),
504 + iterator_base(bucket_, add_node(a, bucket_)),
505 true);
506 }
507 }
508 @@ -250,12 +250,12 @@
509 {
510 // No side effects in this initial code
511 std::size_t hash_value = this->hash_function()(k);
512 - bucket_ptr bucket = this->bucket_ptr_from_hash(hash_value);
513 - node_ptr pos = this->find_iterator(bucket, k);
514 + bucket_ptr bucket_ = this->bucket_ptr_from_hash(hash_value);
515 + node_ptr pos = this->find_iterator(bucket_, k);
517 if (BOOST_UNORDERED_BORLAND_BOOL(pos)) {
518 // Found an existing key, return it (no throw).
519 - return emplace_return(iterator_base(bucket, pos), false);
520 + return emplace_return(iterator_base(bucket_, pos), false);
522 } else {
523 // Doesn't already exist, add to bucket.
524 @@ -269,12 +269,12 @@
525 // reserve has basic exception safety if the hash function
526 // throws, strong otherwise.
527 if(this->reserve_for_insert(this->size_ + 1))
528 - bucket = this->bucket_ptr_from_hash(hash_value);
529 + bucket_ = this->bucket_ptr_from_hash(hash_value);
531 // Nothing after this point can throw.
533 return emplace_return(
534 - iterator_base(bucket, add_node(a, bucket)),
535 + iterator_base(bucket_, add_node(a, bucket_)),
536 true);
537 }
538 }
539 @@ -313,21 +313,21 @@
540 BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params)) \
541 { \
542 std::size_t hash_value = this->hash_function()(k); \
543 - bucket_ptr bucket \
544 + bucket_ptr bucket_ \
545 = this->bucket_ptr_from_hash(hash_value); \
546 - node_ptr pos = this->find_iterator(bucket, k); \
547 + node_ptr pos = this->find_iterator(bucket_, k); \
548 \
549 if (BOOST_UNORDERED_BORLAND_BOOL(pos)) { \
550 - return emplace_return(iterator_base(bucket, pos), false); \
551 + return emplace_return(iterator_base(bucket_, pos), false); \
552 } else { \
553 node_constructor a(*this); \
554 a.construct(BOOST_UNORDERED_CALL_PARAMS(z, num_params)); \
555 \
556 if(this->reserve_for_insert(this->size_ + 1)) \
557 - bucket = this->bucket_ptr_from_hash(hash_value); \
558 + bucket_ = this->bucket_ptr_from_hash(hash_value); \
559 \
560 - return emplace_return(iterator_base(bucket, \
561 - add_node(a, bucket)), true); \
562 + return emplace_return(iterator_base(bucket_, \
563 + add_node(a, bucket_)), true); \
564 } \
565 } \
566 \
567 @@ -441,8 +441,8 @@
568 // different second_type.
569 key_type const& k = extractor::extract(*i);
570 std::size_t hash_value = this->hash_function()(k);
571 - bucket_ptr bucket = this->bucket_ptr_from_hash(hash_value);
572 - node_ptr pos = this->find_iterator(bucket, k);
573 + bucket_ptr bucket_ = this->bucket_ptr_from_hash(hash_value);
574 + node_ptr pos = this->find_iterator(bucket_, k);
576 if (!BOOST_UNORDERED_BORLAND_BOOL(pos)) {
577 // Doesn't already exist, add to bucket.
578 @@ -456,11 +456,11 @@
579 // throws, strong otherwise.
580 if(this->size_ + 1 >= this->max_load_) {
581 this->reserve_for_insert(this->size_ + insert_size(i, j));
582 - bucket = this->bucket_ptr_from_hash(hash_value);
583 + bucket_ = this->bucket_ptr_from_hash(hash_value);
584 }
586 // Nothing after this point can throw.
587 - add_node(a, bucket);
588 + add_node(a, bucket_);
589 }
590 } while(++i != j);
591 }
592 --- misc/boost_1_44_0/boost/unordered/detail/equivalent.hpp 2010-06-09 01:23:43.000000000 +0200
593 +++ misc/build/boost_1_44_0/boost/unordered/detail/equivalent.hpp 2011-02-05 04:15:47.000000000 +0100
594 @@ -57,7 +57,7 @@
595 bool equals(hash_equivalent_table const&) const;
597 inline node_ptr add_node(node_constructor& a,
598 - bucket_ptr bucket, node_ptr pos);
599 + bucket_ptr bucket_, node_ptr pos);
601 #if defined(BOOST_UNORDERED_STD_FORWARD)
603 @@ -117,8 +117,8 @@
604 if(this->size_ != other.size_) return false;
605 if(!this->size_) return true;
607 - bucket_ptr end = this->get_bucket(this->bucket_count_);
608 - for(bucket_ptr i = this->cached_begin_bucket_; i != end; ++i)
609 + bucket_ptr end_ = this->get_bucket(this->bucket_count_);
610 + for(bucket_ptr i = this->cached_begin_bucket_; i != end_; ++i)
611 {
612 node_ptr it1 = i->next_;
613 while(BOOST_UNORDERED_BORLAND_BOOL(it1))
614 @@ -149,16 +149,16 @@
615 template <class T>
616 inline BOOST_DEDUCED_TYPENAME hash_equivalent_table<T>::node_ptr
617 hash_equivalent_table<T>
618 - ::add_node(node_constructor& a, bucket_ptr bucket, node_ptr pos)
619 + ::add_node(node_constructor& a, bucket_ptr bucket_, node_ptr pos)
620 {
621 node_ptr n = a.release();
622 if(BOOST_UNORDERED_BORLAND_BOOL(pos)) {
623 node::add_after_node(n, pos);
624 }
625 else {
626 - node::add_to_bucket(n, *bucket);
627 - if(bucket < this->cached_begin_bucket_)
628 - this->cached_begin_bucket_ = bucket;
629 + node::add_to_bucket(n, *bucket_);
630 + if(bucket_ < this->cached_begin_bucket_)
631 + this->cached_begin_bucket_ = bucket_;
632 }
633 ++this->size_;
634 return n;
635 @@ -179,15 +179,15 @@
636 return this->emplace_empty_impl_with_node(a, 1);
637 }
638 else {
639 - bucket_ptr bucket = this->bucket_ptr_from_hash(hash_value);
640 - node_ptr position = this->find_iterator(bucket, k);
641 + bucket_ptr bucket_ = this->bucket_ptr_from_hash(hash_value);
642 + node_ptr position = this->find_iterator(bucket_, k);
644 // reserve has basic exception safety if the hash function
645 // throws, strong otherwise.
646 if(this->reserve_for_insert(this->size_ + 1))
647 - bucket = this->bucket_ptr_from_hash(hash_value);
648 + bucket_ = this->bucket_ptr_from_hash(hash_value);
650 - return iterator_base(bucket, add_node(a, bucket, position));
651 + return iterator_base(bucket_, add_node(a, bucket_, position));
652 }
653 }
655 @@ -196,8 +196,8 @@
656 ::emplace_impl_no_rehash(node_constructor& a)
657 {
658 key_type const& k = this->get_key(a.value());
659 - bucket_ptr bucket = this->get_bucket(this->bucket_index(k));
660 - add_node(a, bucket, this->find_iterator(bucket, k));
661 + bucket_ptr bucket_ = this->get_bucket(this->bucket_index(k));
662 + add_node(a, bucket_, this->find_iterator(bucket_, k));
663 }
665 #if defined(BOOST_UNORDERED_STD_FORWARD)
666 --- misc/boost_1_44_0/boost/ptr_container/exception.hpp 2011-02-05 09:42:56.074932485 +0000
667 +++ misc/build/boost_1_44_0/boost/ptr_container/exception.hpp 2011-02-05 09:43:00.350931536 +0000
668 @@ -24,7 +24,7 @@
669 {
670 const char* what_;
671 public:
672 - bad_ptr_container_operation( const char* what ) : what_( what )
673 + bad_ptr_container_operation( const char* _what ) : what_( _what )
674 { }
676 virtual const char* what() const throw()
677 @@ -38,7 +38,7 @@
678 class bad_index : public bad_ptr_container_operation
679 {
680 public:
681 - bad_index( const char* what ) : bad_ptr_container_operation( what )
682 + bad_index( const char* _what ) : bad_ptr_container_operation( _what )
683 { }
684 };
686 --- misc/boost_1_44_0/boost/ptr_container/detail/reversible_ptr_container.hpp 2011-02-05 09:49:30.373931807 +0000
687 +++ misc/build/boost_1_44_0/boost/ptr_container/detail/reversible_ptr_container.hpp 2011-02-05 09:49:34.804931932 +0000
688 @@ -278,9 +278,9 @@
690 private:
691 template< class ForwardIterator >
692 - ForwardIterator advance( ForwardIterator begin, size_type n )
693 + ForwardIterator advance( ForwardIterator begin_, size_type n )
694 {
695 - ForwardIterator iter = begin;
696 + ForwardIterator iter = begin_;
697 std::advance( iter, n );
698 return iter;
699 }
700 --- misc/boost_1_44_0/boost/ptr_container/detail/static_move_ptr.hpp 2011-02-05 09:55:44.846931338 +0000
701 +++ misc/build/boost_1_44_0/boost/ptr_container/detail/static_move_ptr.hpp 2011-02-05 09:56:42.760931701 +0000
702 @@ -151,7 +151,7 @@
703 deleter_const_reference get_deleter() const { return impl_.second(); }
704 private:
705 template<typename TT, typename DD>
706 - void check(const static_move_ptr<TT, DD>& ptr)
707 + void check(const static_move_ptr<TT, DD>&)
708 {
709 typedef move_ptrs::is_smart_ptr_convertible<TT, T> convertible;
710 BOOST_STATIC_ASSERT(convertible::value);
711 --- misc/boost_1_44_0/boost/ptr_container/detail/move.hpp 2011-02-05 10:01:21.156931884 +0000
712 +++ misc/build/boost_1_44_0/boost/ptr_container/detail/move.hpp 2011-02-05 10:01:14.160931007 +0000
713 @@ -20,7 +20,7 @@
714 template<typename Ptr>
715 class move_source {
716 public:
717 - move_source(Ptr& ptr) : ptr_(ptr) {}
718 + move_source(Ptr& _ptr) : ptr_(_ptr) {}
719 Ptr& ptr() const { return ptr_; }
720 private:
721 Ptr& ptr_;
722 --- misc/boost_1_44_0/boost/spirit/home/classic/core/non_terminal/subrule.hpp 2011-02-08 09:24:50.817320629 +0000
723 +++ misc/build/boost_1_44_0/boost/spirit/home/classic/core/non_terminal/subrule.hpp 2011-02-08 09:25:20.496639901 +0000
724 @@ -210,7 +210,7 @@
725 subrule_list<
726 subrule_parser<ID2, DefT2, ContextT2>,
727 nil_t> >
728 - operator,(subrule_parser<ID2, DefT2, ContextT2> const& rhs) const
729 + operator,(subrule_parser<ID2, DefT2, ContextT2> const& rhs_) const
730 {
731 return subrule_list<
732 self_t,
733 @@ -220,7 +220,7 @@
734 *this,
735 subrule_list<
736 subrule_parser<ID2, DefT2, ContextT2>, nil_t>(
737 - rhs, nil_t()));
738 + rhs_, nil_t()));
739 }
741 typename DefT::embed_t rhs;
742 --- misc/boost_1_44_0/boost/ptr_container/ptr_sequence_adapter.hpp 2011-02-09 08:49:00.416529470 +0000
743 +++ misc/build/boost_1_44_0/boost/ptr_container/ptr_sequence_adapter.hpp 2011-02-09 08:50:44.607653864 +0000
744 @@ -510,72 +510,72 @@
746 public: // resize
748 - void resize( size_type size ) // basic
749 + void resize( size_type size_ ) // basic
750 {
751 size_type old_size = this->size();
752 - if( old_size > size )
753 + if( old_size > size_ )
754 {
755 - this->erase( boost::next( this->begin(), size ), this->end() );
756 + this->erase( boost::next( this->begin(), size_ ), this->end() );
757 }
758 - else if( size > old_size )
759 + else if( size_ > old_size )
760 {
761 - for( ; old_size != size; ++old_size )
762 + for( ; old_size != size_; ++old_size )
763 this->push_back( new BOOST_DEDUCED_TYPENAME
764 boost::remove_pointer<value_type>::type() );
765 }
767 - BOOST_ASSERT( this->size() == size );
768 + BOOST_ASSERT( this->size() == size_ );
769 }
771 - void resize( size_type size, value_type to_clone ) // basic
772 + void resize( size_type size_, value_type to_clone ) // basic
773 {
774 size_type old_size = this->size();
775 - if( old_size > size )
776 + if( old_size > size_ )
777 {
778 - this->erase( boost::next( this->begin(), size ), this->end() );
779 + this->erase( boost::next( this->begin(), size_ ), this->end() );
780 }
781 - else if( size > old_size )
782 + else if( size_ > old_size )
783 {
784 - for( ; old_size != size; ++old_size )
785 + for( ; old_size != size_; ++old_size )
786 this->push_back( this->null_policy_allocate_clone( to_clone ) );
787 }
789 - BOOST_ASSERT( this->size() == size );
790 + BOOST_ASSERT( this->size() == size_ );
791 }
793 - void rresize( size_type size ) // basic
794 + void rresize( size_type size_ ) // basic
795 {
796 size_type old_size = this->size();
797 - if( old_size > size )
798 + if( old_size > size_ )
799 {
800 this->erase( this->begin(),
801 - boost::next( this->begin(), old_size - size ) );
802 + boost::next( this->begin(), old_size - size_ ) );
803 }
804 - else if( size > old_size )
805 + else if( size_ > old_size )
806 {
807 - for( ; old_size != size; ++old_size )
808 + for( ; old_size != size_; ++old_size )
809 this->push_front( new BOOST_DEDUCED_TYPENAME
810 boost::remove_pointer<value_type>::type() );
811 }
813 - BOOST_ASSERT( this->size() == size );
814 + BOOST_ASSERT( this->size() == size_ );
815 }
817 - void rresize( size_type size, value_type to_clone ) // basic
818 + void rresize( size_type size_, value_type to_clone ) // basic
819 {
820 size_type old_size = this->size();
821 - if( old_size > size )
822 + if( old_size > size_ )
823 {
824 this->erase( this->begin(),
825 - boost::next( this->begin(), old_size - size ) );
826 + boost::next( this->begin(), old_size - size_ ) );
827 }
828 - else if( size > old_size )
829 + else if( size_ > old_size )
830 {
831 - for( ; old_size != size; ++old_size )
832 + for( ; old_size != size_; ++old_size )
833 this->push_front( this->null_policy_allocate_clone( to_clone ) );
834 }
836 - BOOST_ASSERT( this->size() == size );
837 + BOOST_ASSERT( this->size() == size_ );
838 }
840 public: // algorithms
841 --- misc/boost_1_44_0/boost/unordered/detail/table.hpp 2011-02-10 15:04:57.999046223 +0000
842 +++ misc/build/boost_1_44_0/boost/unordered/detail/table.hpp 2011-02-10 15:05:44.260588237 +0000
843 @@ -119,7 +119,7 @@
845 // From 6.3.1/13:
846 // Only resize when size >= mlf_ * count
847 - return double_to_size_t(ceil((double) mlf_ * this->bucket_count_));
848 + return double_to_size_t(ceil((double)mlf_ * (double)this->bucket_count_));
849 }
851 template <class T>
852 @@ -145,7 +145,7 @@
853 //
854 // Or from rehash post-condition:
855 // count > size / mlf_
856 - return next_prime(double_to_size_t(floor(size / (double) mlf_)) + 1);
857 + return next_prime(double_to_size_t(floor((double)size / (double)mlf_)) + 1);
858 }
860 ////////////////////////////////////////////////////////////////////////////
861 --- misc/boost_1_44_0/boost/functional/hash/detail/hash_float_generic.hpp 2011-02-10 14:50:52.173229648 +0000
862 +++ misc/build/boost_1_44_0/boost/functional/hash/detail/hash_float_generic.hpp 2011-02-10 14:52:36.824433976 +0000
863 @@ -53,7 +53,7 @@
865 v = ldexp(v, limits<std::size_t>::digits);
866 std::size_t seed = static_cast<std::size_t>(v);
867 - v -= seed;
868 + v -= static_cast<T>(seed);
870 // ceiling(digits(T) * log2(radix(T))/ digits(size_t)) - 1;
871 std::size_t const length
872 @@ -66,7 +66,7 @@
873 {
874 v = ldexp(v, limits<std::size_t>::digits);
875 std::size_t part = static_cast<std::size_t>(v);
876 - v -= part;
877 + v -= static_cast<T>(part);
878 hash_float_combine(seed, part);
879 }
881 --- misc/boost_1_44_0/boost/dynamic_bitset.hpp 2011-02-28 17:10:13.892131527 +0000
882 +++ misc/build/boost_1_44_0/boost/dynamic_bitset/dynamic_bitset.hpp 2011-02-28 17:11:05.868726195 +0000
883 @@ -1108,10 +1108,10 @@
884 // beyond the "allowed" positions
885 typedef unsigned long result_type;
887 - const size_type max_size =
888 + const size_type max_size_ =
889 (std::min)(m_num_bits, static_cast<size_type>(ulong_width));
891 - const size_type last_block = block_index( max_size - 1 );
892 + const size_type last_block = block_index( max_size_ - 1 );
894 assert((last_block * bits_per_block) < static_cast<size_type>(ulong_width));
896 --- misc/boost_1_44_0/boost/ptr_container/detail/reversible_ptr_container.hpp 2011-03-04 11:33:36.269274940 +0000
897 +++ misc/build/boost_1_44_0/boost/ptr_container/detail/reversible_ptr_container.hpp 2011-03-04 11:33:36.269274940 +0000
898 @@ -259,6 +259,10 @@
900 static void enforce_null_policy( const Ty_* x, const char* msg )
901 {
902 +#ifdef BOOST_PTR_CONTAINER_NO_EXCEPTIONS
903 + (void)x;
904 + (void)msg;
905 +#endif
906 if( !allow_null )
907 {
908 BOOST_PTR_CONTAINER_THROW_EXCEPTION( 0 == x && "null not allowed",
909 --- misc/boost_1_44_0/boost/pool/object_pool.hpp 2011-07-14 16:08:31.672964851 +0100
910 +++ misc/build/boost_1_44_0/boost/pool/object_pool.hpp 2011-07-14 16:09:20.851594534 +0100
911 @@ -53,8 +53,8 @@
913 public:
914 // This constructor parameter is an extension!
915 - explicit object_pool(const size_type next_size = 32)
916 - :pool<UserAllocator>(sizeof(T), next_size) { }
917 + explicit object_pool(const size_type next_size_ = 32)
918 + :pool<UserAllocator>(sizeof(T), next_size_) { }
920 ~object_pool();
922 --- misc/boost_1_44_0/libs/date_time/src/gregorian/greg_month.cpp 2008-11-23 12:13:35.000000000 +0100
923 +++ misc/build/boost_1_44_0/libs/date_time/src/gregorian/greg_month.cpp 2011-10-05 16:56:34.627320523 +0200
924 @@ -108,7 +108,7 @@
925 */
926 BOOST_DATE_TIME_DECL
927 boost::date_time::all_date_names_put<greg_facet_config, char>*
928 - create_facet_def(char type)
929 + create_facet_def(char /* type */)
930 {
931 typedef
932 boost::date_time::all_date_names_put<greg_facet_config, char> facet_def;
933 @@ -121,7 +121,7 @@
934 }
936 //! generates a locale with the set of gregorian name-strings of type char*
937 - BOOST_DATE_TIME_DECL std::locale generate_locale(std::locale& loc, char type){
938 + BOOST_DATE_TIME_DECL std::locale generate_locale(std::locale& loc, char /* type */){
939 typedef boost::date_time::all_date_names_put<greg_facet_config, char> facet_def;
940 return std::locale(loc, new facet_def(short_month_names,
941 long_month_names,
942 @@ -139,7 +139,7 @@
943 */
944 BOOST_DATE_TIME_DECL
945 boost::date_time::all_date_names_put<greg_facet_config, wchar_t>*
946 - create_facet_def(wchar_t type)
947 + create_facet_def(wchar_t /* type */)
948 {
949 typedef
950 boost::date_time::all_date_names_put<greg_facet_config,wchar_t> facet_def;
951 @@ -152,7 +152,7 @@
952 }
954 //! generates a locale with the set of gregorian name-strings of type wchar_t*
955 - BOOST_DATE_TIME_DECL std::locale generate_locale(std::locale& loc, wchar_t type){
956 + BOOST_DATE_TIME_DECL std::locale generate_locale(std::locale& loc, wchar_t /* type */){
957 typedef boost::date_time::all_date_names_put<greg_facet_config, wchar_t> facet_def;
958 return std::locale(loc, new facet_def(w_short_month_names,
959 w_long_month_names,
960 --- misc/boost_1_44_0/boost/date_time/time_facet.hpp 2012-08-20 09:12:51.552094137 +0100
961 +++ misc/build/boost_1_44_0/boost/date_time/time_facet.hpp 2012-08-20 09:10:07.884255317 +0100
962 @@ -439,31 +439,31 @@
963 a_time_dur.get_rep().as_special());
964 }
966 - string_type format(m_time_duration_format);
967 + string_type lcl_format(m_time_duration_format);
968 if (a_time_dur.is_negative()) {
969 // replace %- with minus sign. Should we use the numpunct facet?
970 - boost::algorithm::replace_all(format,
971 + boost::algorithm::replace_all(lcl_format,
972 duration_sign_negative_only,
973 negative_sign);
974 // remove all the %+ in the string with '-'
975 - boost::algorithm::replace_all(format,
976 + boost::algorithm::replace_all(lcl_format,
977 duration_sign_always,
978 negative_sign);
979 }
980 else { //duration is positive
981 // remove all the %- combos from the string
982 - boost::algorithm::erase_all(format, duration_sign_negative_only);
983 + boost::algorithm::erase_all(lcl_format, duration_sign_negative_only);
984 // remove all the %+ in the string with '+'
985 - boost::algorithm::replace_all(format,
986 + boost::algorithm::replace_all(lcl_format,
987 duration_sign_always,
988 positive_sign);
989 }
991 // %T and %R have to be replaced here since they are not standard
992 - boost::algorithm::replace_all(format,
993 + boost::algorithm::replace_all(lcl_format,
994 boost::as_literal(formats_type::full_24_hour_time_format),
995 boost::as_literal(formats_type::full_24_hour_time_expanded_format));
996 - boost::algorithm::replace_all(format,
997 + boost::algorithm::replace_all(lcl_format,
998 boost::as_literal(formats_type::short_24_hour_time_format),
999 boost::as_literal(formats_type::short_24_hour_time_expanded_format));
1001 @@ -476,22 +476,22 @@
1002 * here ourself.
1003 */
1004 string_type hours_str;
1005 - if (format.find(unrestricted_hours_format) != string_type::npos) {
1006 + if (lcl_format.find(unrestricted_hours_format) != string_type::npos) {
1007 hours_str = hours_as_string(a_time_dur);
1008 - boost::algorithm::replace_all(format, unrestricted_hours_format, hours_str);
1009 + boost::algorithm::replace_all(lcl_format, unrestricted_hours_format, hours_str);
1010 }
1011 // We still have to process restricted hours format specifier. In order to
1012 // support parseability of durations in ISO format (%H%M%S), we'll have to
1013 // restrict the stringified hours length to 2 characters.
1014 - if (format.find(hours_format) != string_type::npos) {
1015 + if (lcl_format.find(hours_format) != string_type::npos) {
1016 if (hours_str.empty())
1017 hours_str = hours_as_string(a_time_dur);
1018 BOOST_ASSERT(hours_str.length() <= 2);
1019 - boost::algorithm::replace_all(format, hours_format, hours_str);
1020 + boost::algorithm::replace_all(lcl_format, hours_format, hours_str);
1021 }
1023 string_type frac_str;
1024 - if (format.find(seconds_with_fractional_seconds_format) != string_type::npos) {
1025 + if (lcl_format.find(seconds_with_fractional_seconds_format) != string_type::npos) {
1026 // replace %s with %S.nnn
1027 frac_str =
1028 fractional_seconds_as_string(a_time_dur, false);
1029 @@ -500,21 +500,21 @@
1030 string_type replace_string(seconds_format);
1031 replace_string += sep;
1032 replace_string += frac_str;
1033 - boost::algorithm::replace_all(format,
1034 + boost::algorithm::replace_all(lcl_format,
1035 seconds_with_fractional_seconds_format,
1036 replace_string);
1037 }
1038 - if (format.find(fractional_seconds_format) != string_type::npos) {
1039 + if (lcl_format.find(fractional_seconds_format) != string_type::npos) {
1040 // replace %f with nnnnnnn
1041 if (!frac_str.size()) {
1042 frac_str = fractional_seconds_as_string(a_time_dur, false);
1043 }
1044 - boost::algorithm::replace_all(format,
1045 + boost::algorithm::replace_all(lcl_format,
1046 fractional_seconds_format,
1047 frac_str);
1048 }
1050 - if (format.find(fractional_seconds_or_none_format) != string_type::npos) {
1051 + if (lcl_format.find(fractional_seconds_or_none_format) != string_type::npos) {
1052 // replace %F with nnnnnnn or nothing if fs == 0
1053 frac_str =
1054 fractional_seconds_as_string(a_time_dur, true);
1055 @@ -523,18 +523,18 @@
1056 string_type replace_string;
1057 replace_string += sep;
1058 replace_string += frac_str;
1059 - boost::algorithm::replace_all(format,
1060 + boost::algorithm::replace_all(lcl_format,
1061 fractional_seconds_or_none_format,
1062 replace_string);
1063 }
1064 else {
1065 - boost::algorithm::erase_all(format,
1066 + boost::algorithm::erase_all(lcl_format,
1067 fractional_seconds_or_none_format);
1068 }
1069 }
1071 return this->do_put_tm(a_next, a_ios, a_fill,
1072 - to_tm(a_time_dur), format);
1073 + to_tm(a_time_dur), lcl_format);
1074 }
1076 OutItrT put(OutItrT next, std::ios_base& a_ios,