boost/boost.libcdr.warnings.patch.1

   1 --- boost/boost/archive/basic_archive.hpp       2010-08-11 20:15:46.000000000 +0200
   2 +++ boost/boost/archive/basic_archive.hpp       2013-05-17 15:39:58.624333369 +0200
   3 @@ -54,7 +54,7 @@
   4          return *this;
   5      }
   6      // used for text output
   7 -    operator const base_type () const {
   8 +    operator base_type () const {
   9          return t;
  10      }
  11      // used for text input
  12 @@ -90,7 +90,7 @@
  13          return *this;
  14      }
  15      // used for text output
  16 -    operator const base_type () const {
  17 +    operator base_type () const {
  18          return t;
  19      }
  20      // used for text intput
  21 @@ -127,7 +127,7 @@
  22      }
  23
  24      // used for text output
  25 -    operator const int () const {
  26 +    operator int () const {
  27          return t;
  28      }
  29      // used for text input
  30 @@ -161,7 +161,7 @@
  31          return *this;
  32      }
  33      // used for text output
  34 -    operator const uint_least32_t () const {
  35 +    operator uint_least32_t () const {
  36          return t;
  37      }
  38      // used for text input
  39 @@ -254,7 +254,7 @@
  40  #define BOOST_ARCHIVE_STRONG_TYPEDEF(T, D)         \
  41      class D : public T {                           \
  42      public:                                        \
  43 -        explicit D(const T t) : T(t){}             \
  44 +        explicit D(const T t_) : T(t_){}             \
  45      };                                             \
  46  /**/
  47
  48 --- boost/boost/multi_index/detail/index_matcher.hpp    2008-07-03 18:51:53.000000000 +0200
  49 +++ boost/boost/multi_index/detail/index_matcher.hpp    2013-05-17 15:30:12.539099597 +0200
  50 @@ -132,17 +132,17 @@
  51          entries(),entries()+size_,
  52          entry(node),entry::less_by_node()); /* localize entry */
  53      ent->ordered=false;
  54 -    std::size_t n=ent->pos;                 /* get its position */
  55 +    std::size_t n_=ent->pos;                 /* get its position */
  56
  57      entry dummy(0);
  58 -    dummy.pile_top=n;
  59 +    dummy.pile_top=n_;
  60
  61      entry* pile_ent=                        /* find the first available pile */
  62        std::lower_bound(                     /* to stack the entry            */
  63          entries(),entries()+num_piles,
  64          dummy,entry::less_by_pile_top());
  65
  66 -    pile_ent->pile_top=n;                   /* stack the entry */
  67 +    pile_ent->pile_top=n_;                   /* stack the entry */
  68      pile_ent->pile_top_entry=ent;
  69
  70      /* if not the first pile, link entry to top of the preceding pile */
  71 @@ -164,7 +164,7 @@
  72         */
  73
  74        entry* ent=entries()[num_piles-1].pile_top_entry;
  75 -      for(std::size_t n=num_piles;n--;){
  76 +      for(std::size_t n_=num_piles;n_--;){
  77          ent->ordered=true;
  78          ent=ent->previous;
  79        }
  80 --- boost/boost/multi_index/ordered_index.hpp   2010-07-25 12:44:55.000000000 +0200
  81 +++ boost/boost/multi_index/ordered_index.hpp   2013-05-17 15:33:42.785182819 +0200
  82 @@ -436,9 +436,9 @@
  83
  84    template<typename CompatibleKey,typename CompatibleCompare>
  85    iterator find(
  86 -    const CompatibleKey& x,const CompatibleCompare& comp)const
  87 +    const CompatibleKey& x,const CompatibleCompare& comp_)const
  88    {
  89 -    return make_iterator(ordered_index_find(root(),header(),key,x,comp));
  90 +    return make_iterator(ordered_index_find(root(),header(),key,x,comp_));
  91    }
  92
  93    template<typename CompatibleKey>
  94 @@ -448,9 +448,9 @@
  95    }
  96
  97    template<typename CompatibleKey,typename CompatibleCompare>
  98 -  size_type count(const CompatibleKey& x,const CompatibleCompare& comp)const
  99 +  size_type count(const CompatibleKey& x,const CompatibleCompare& comp_)const
 100    {
 101 -    std::pair<iterator,iterator> p=equal_range(x,comp);
 102 +    std::pair<iterator,iterator> p=equal_range(x,comp_);
 103      size_type n=std::distance(p.first,p.second);
 104      return n;
 105    }
 106 @@ -464,10 +464,10 @@
 107
 108    template<typename CompatibleKey,typename CompatibleCompare>
 109    iterator lower_bound(
 110 -    const CompatibleKey& x,const CompatibleCompare& comp)const
 111 +    const CompatibleKey& x,const CompatibleCompare& comp_)const
 112    {
 113      return make_iterator(
 114 -      ordered_index_lower_bound(root(),header(),key,x,comp));
 115 +      ordered_index_lower_bound(root(),header(),key,x,comp_));
 116    }
 117
 118    template<typename CompatibleKey>
 119 @@ -479,10 +479,10 @@
 120
 121    template<typename CompatibleKey,typename CompatibleCompare>
 122    iterator upper_bound(
 123 -    const CompatibleKey& x,const CompatibleCompare& comp)const
 124 +    const CompatibleKey& x,const CompatibleCompare& comp_)const
 125    {
 126      return make_iterator(
 127 -      ordered_index_upper_bound(root(),header(),key,x,comp));
 128 +      ordered_index_upper_bound(root(),header(),key,x,comp_));
 129    }
 130
 131    template<typename CompatibleKey>
 132 @@ -497,10 +497,10 @@
 133
 134    template<typename CompatibleKey,typename CompatibleCompare>
 135    std::pair<iterator,iterator> equal_range(
 136 -    const CompatibleKey& x,const CompatibleCompare& comp)const
 137 +    const CompatibleKey& x,const CompatibleCompare& comp_)const
 138    {
 139      std::pair<node_type*,node_type*> p=
 140 -      ordered_index_equal_range(root(),header(),key,x,comp);
 141 +      ordered_index_equal_range(root(),header(),key,x,comp_);
 142      return std::pair<iterator,iterator>(
 143        make_iterator(p.first),make_iterator(p.second));
 144    }
 145 --- boost/boost/multi_index/sequenced_index.hpp 2008-07-03 18:51:53.000000000 +0200
 146 +++ boost/boost/multi_index/sequenced_index.hpp 2013-05-17 15:44:15.265289335 +0200
 147 @@ -346,7 +346,7 @@
 148    }
 149
 150    template<typename Modifier,typename Rollback>
 151 -  bool modify(iterator position,Modifier mod,Rollback back)
 152 +  bool modify(iterator position,Modifier mod,Rollback back_)
 153    {
 154      BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
 155      BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
 156 @@ -363,7 +363,7 @@
 157  #endif
 158
 159      return this->final_modify_(
 160 -      mod,back,static_cast<final_node_type*>(position.get_node()));
 161 +      mod,back_,static_cast<final_node_type*>(position.get_node()));
 162    }
 163
 164    void swap(sequenced_index<SuperMeta,TagList>& x)
 165 --- boost/boost/multi_index_container.hpp       2010-07-24 11:20:29.000000000 +0200
 166 +++ boost/boost/multi_index_container.hpp       2013-05-17 15:45:56.723899853 +0200
 167 @@ -360,7 +360,7 @@
 168      IteratorType it
 169      BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N))
 170    {
 171 -    typedef typename nth_index<N>::type index;
 172 +    typedef typename nth_index<N>::type index_;
 173
 174  #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
 175      BOOST_STATIC_ASSERT(
 176 @@ -371,7 +371,7 @@
 177      BOOST_MULTI_INDEX_CHECK_IS_OWNER(
 178        it,static_cast<typename IteratorType::container_type&>(*this));
 179
 180 -    return index::make_iterator(static_cast<node_type*>(it.get_node()));
 181 +    return index_::make_iterator(static_cast<node_type*>(it.get_node()));
 182    }
 183
 184    template<int N,typename IteratorType>
 185 @@ -379,7 +379,7 @@
 186      IteratorType it
 187      BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N))const
 188    {
 189 -    typedef typename nth_index<N>::type index;
 190 +    typedef typename nth_index<N>::type index_;
 191
 192  #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
 193      BOOST_STATIC_ASSERT((
 194 @@ -390,7 +390,7 @@
 195      BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
 196      BOOST_MULTI_INDEX_CHECK_IS_OWNER(
 197        it,static_cast<const typename IteratorType::container_type&>(*this));
 198 -    return index::make_iterator(static_cast<node_type*>(it.get_node()));
 199 +    return index_::make_iterator(static_cast<node_type*>(it.get_node()));
 200    }
 201  #endif
 202
 203 @@ -414,7 +414,7 @@
 204      IteratorType it
 205      BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))
 206    {
 207 -    typedef typename index<Tag>::type index;
 208 +    typedef typename index<Tag>::type index_;
 209
 210  #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
 211      BOOST_STATIC_ASSERT(
 212 @@ -424,7 +424,7 @@
 213      BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
 214      BOOST_MULTI_INDEX_CHECK_IS_OWNER(
 215        it,static_cast<typename IteratorType::container_type&>(*this));
 216 -    return index::make_iterator(static_cast<node_type*>(it.get_node()));
 217 +    return index_::make_iterator(static_cast<node_type*>(it.get_node()));
 218    }
 219
 220    template<typename Tag,typename IteratorType>
 221 @@ -432,7 +432,7 @@
 222      IteratorType it
 223      BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))const
 224    {
 225 -    typedef typename index<Tag>::type index;
 226 +    typedef typename index<Tag>::type index_;
 227
 228  #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
 229      BOOST_STATIC_ASSERT((
 230 @@ -443,7 +443,7 @@
 231      BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
 232      BOOST_MULTI_INDEX_CHECK_IS_OWNER(
 233        it,static_cast<const typename IteratorType::container_type&>(*this));
 234 -    return index::make_iterator(static_cast<node_type*>(it.get_node()));
 235 +    return index_::make_iterator(static_cast<node_type*>(it.get_node()));
 236    }
 237  #endif
 238
 239 --- boost/boost/property_tree/detail/exception_implementation.hpp       2009-09-01 23:27:45.000000000 +0200
 240 +++ boost/boost/property_tree/detail/exception_implementation.hpp       2013-05-17 15:28:28.599529530 +0200
 241 @@ -30,8 +30,8 @@
 242      ///////////////////////////////////////////////////////////////////////////
 243      // ptree_error
 244
 245 -    inline ptree_error::ptree_error(const std::string &what):
 246 -        std::runtime_error(what)
 247 +    inline ptree_error::ptree_error(const std::string &what_):
 248 +        std::runtime_error(what_)
 249      {
 250      }
 251
 252 @@ -43,8 +43,8 @@
 253      // ptree_bad_data
 254
 255      template<class D> inline
 256 -    ptree_bad_data::ptree_bad_data(const std::string &what, const D &data):
 257 -        ptree_error(what), m_data(data)
 258 +    ptree_bad_data::ptree_bad_data(const std::string &what_, const D &data_):
 259 +        ptree_error(what_), m_data(data_)
 260      {
 261      }
 262
 263 @@ -62,8 +62,8 @@
 264      // ptree_bad_path
 265
 266      template<class P> inline
 267 -    ptree_bad_path::ptree_bad_path(const std::string &what, const P &path):
 268 -        ptree_error(detail::prepare_bad_path_what(what, path)), m_path(path)
 269 +    ptree_bad_path::ptree_bad_path(const std::string &what_, const P &path_):
 270 +        ptree_error(detail::prepare_bad_path_what(what_, path_)), m_path(path_)
 271      {
 272
 273      }
 274 --- boost/boost/property_tree/detail/file_parser_error.hpp      2009-09-01 23:27:45.000000000 +0200
 275 +++ boost/boost/property_tree/detail/file_parser_error.hpp      2013-05-17 15:36:01.615914822 +0200
 276 @@ -26,11 +26,11 @@
 277          // Construction & destruction
 278
 279          // Construct error
 280 -        file_parser_error(const std::string &message,
 281 -                          const std::string &filename,
 282 -                          unsigned long line) :
 283 -            ptree_error(format_what(message, filename, line)),
 284 -            m_message(message), m_filename(filename), m_line(line)
 285 +        file_parser_error(const std::string &message_,
 286 +                          const std::string &filename_,
 287 +                          unsigned long line_) :
 288 +            ptree_error(format_what(message_, filename_, line_)),
 289 +            m_message(message_), m_filename(filename_), m_line(line_)
 290          {
 291          }
 292
 293 @@ -69,20 +69,20 @@
 294          unsigned long m_line;
 295
 296          // Format error message to be returned by std::runtime_error::what()
 297 -        std::string format_what(const std::string &message,
 298 -                                const std::string &filename,
 299 -                                unsigned long line)
 300 +        std::string format_what(const std::string &message_,
 301 +                                const std::string &filename_,
 302 +                                unsigned long line_)
 303          {
 304              std::stringstream stream;
 305 -            if (line > 0)
 306 -                stream << (filename.empty() ? "<unspecified file>"
 307 -                                            : filename.c_str())
 308 -                       << '(' << line << "): "
 309 -                       << message;
 310 +            if (line_ > 0)
 311 +                stream << (filename_.empty() ? "<unspecified file>"
 312 +                                            : filename_.c_str())
 313 +                       << '(' << line_ << "): "
 314 +                       << message_;
 315              else
 316 -                stream << (filename.empty() ? "<unspecified file>"
 317 -                                            : filename.c_str())
 318 -                       << ": " << message;
 319 +                stream << (filename_.empty() ? "<unspecified file>"
 320 +                                            : filename_.c_str())
 321 +                       << ": " << message_;
 322              return stream.str();
 323          }
 324
 325 --- boost/boost/property_tree/detail/json_parser_error.hpp      2007-05-13 00:02:53.000000000 +0200
 326 +++ boost/boost/property_tree/detail/json_parser_error.hpp      2013-05-17 15:36:44.605902442 +0200
 327 @@ -20,10 +20,10 @@
 328      class json_parser_error: public file_parser_error
 329      {
 330      public:
 331 -        json_parser_error(const std::string &message,
 332 -                          const std::string &filename,
 333 -                          unsigned long line):
 334 -            file_parser_error(message, filename, line)
 335 +        json_parser_error(const std::string &message_,
 336 +                          const std::string &filename_,
 337 +                          unsigned long line_):
 338 +            file_parser_error(message_, filename_, line_)
 339          {
 340          }
 341      };
 342 --- boost/boost/property_tree/detail/json_parser_read.hpp       2013-05-17 15:57:23.740638395 +0200
 343 +++ boost/boost/property_tree/detail/json_parser_read.hpp       2013-05-17 15:31:05.666857356 +0200
 344 @@ -45,7 +45,7 @@
 345          struct a_object_s
 346          {
 347              context &c;
 348 -            a_object_s(context &c): c(c) { }
 349 +            a_object_s(context &c_): c(c_) { }
 350              void operator()(Ch) const
 351              {
 352                  if (c.stack.empty())
 353 @@ -63,7 +63,7 @@
 354          struct a_object_e
 355          {
 356              context &c;
 357 -            a_object_e(context &c): c(c) { }
 358 +            a_object_e(context &c_): c(c_) { }
 359              void operator()(Ch) const
 360              {
 361                  BOOST_ASSERT(c.stack.size() >= 1);
 362 @@ -74,7 +74,7 @@
 363          struct a_name
 364          {
 365              context &c;
 366 -            a_name(context &c): c(c) { }
 367 +            a_name(context &c_): c(c_) { }
 368              void operator()(It, It) const
 369              {
 370                  c.name.swap(c.string);
 371 @@ -85,7 +85,7 @@
 372          struct a_string_val
 373          {
 374              context &c;
 375 -            a_string_val(context &c): c(c) { }
 376 +            a_string_val(context &c_): c(c_) { }
 377              void operator()(It, It) const
 378              {
 379                  BOOST_ASSERT(c.stack.size() >= 1);
 380 @@ -98,7 +98,7 @@
 381          struct a_literal_val
 382          {
 383              context &c;
 384 -            a_literal_val(context &c): c(c) { }
 385 +            a_literal_val(context &c_): c(c_) { }
 386              void operator()(It b, It e) const
 387              {
 388                  BOOST_ASSERT(c.stack.size() >= 1);
 389 @@ -111,8 +111,8 @@
 390          struct a_char
 391          {
 392              context &c;
 393 -            a_char(context &c): c(c) { }
 394 -            void operator()(It b, It e) const
 395 +            a_char(context &c_): c(c_) { }
 396 +            void operator()(It b, It /* e */) const
 397              {
 398                  c.string += *b;
 399              }
 400 @@ -121,7 +121,7 @@
 401          struct a_escape
 402          {
 403              context &c;
 404 -            a_escape(context &c): c(c) { }
 405 +            a_escape(context &c_): c(c_) { }
 406              void operator()(Ch ch) const
 407              {
 408                  switch (ch)
 409 @@ -142,7 +142,7 @@
 410          struct a_unicode
 411          {
 412              context &c;
 413 -            a_unicode(context &c): c(c) { }
 414 +            a_unicode(context &c_): c(c_) { }
 415              void operator()(unsigned long u) const
 416              {
 417                  u = (std::min)(u, static_cast<unsigned long>((std::numeric_limits<Ch>::max)()));
 418 --- boost/boost/property_tree/detail/ptree_implementation.hpp   2010-07-03 22:59:45.000000000 +0200
 419 +++ boost/boost/property_tree/detail/ptree_implementation.hpp   2013-05-17 15:55:56.449713452 +0200
 420 @@ -183,8 +183,8 @@
 421      }
 422
 423      template<class K, class D, class C> inline
 424 -    basic_ptree<K, D, C>::basic_ptree(const data_type &data)
 425 -        : m_data(data), m_children(new typename subs::base_container)
 426 +    basic_ptree<K, D, C>::basic_ptree(const data_type &data_)
 427 +        : m_data(data_), m_children(new typename subs::base_container)
 428      {
 429      }
 430
 431 @@ -539,48 +539,48 @@
 432
 433      template<class K, class D, class C>
 434      basic_ptree<K, D, C> &
 435 -        basic_ptree<K, D, C>::get_child(const path_type &path)
 436 +        basic_ptree<K, D, C>::get_child(const path_type &path_)
 437      {
 438 -        path_type p(path);
 439 +        path_type p(path_);
 440          self_type *n = walk_path(p);
 441          if (!n) {
 442 -            BOOST_PROPERTY_TREE_THROW(ptree_bad_path("No such node", path));
 443 +            BOOST_PROPERTY_TREE_THROW(ptree_bad_path("No such node", path_));
 444          }
 445          return *n;
 446      }
 447
 448      template<class K, class D, class C> inline
 449      const basic_ptree<K, D, C> &
 450 -        basic_ptree<K, D, C>::get_child(const path_type &path) const
 451 +        basic_ptree<K, D, C>::get_child(const path_type &path_) const
 452      {
 453 -        return const_cast<self_type*>(this)->get_child(path);
 454 +        return const_cast<self_type*>(this)->get_child(path_);
 455      }
 456
 457      template<class K, class D, class C> inline
 458      basic_ptree<K, D, C> &
 459 -        basic_ptree<K, D, C>::get_child(const path_type &path,
 460 +        basic_ptree<K, D, C>::get_child(const path_type &path_,
 461                                          self_type &default_value)
 462      {
 463 -        path_type p(path);
 464 +        path_type p(path_);
 465          self_type *n = walk_path(p);
 466          return n ? *n : default_value;
 467      }
 468
 469      template<class K, class D, class C> inline
 470      const basic_ptree<K, D, C> &
 471 -        basic_ptree<K, D, C>::get_child(const path_type &path,
 472 +        basic_ptree<K, D, C>::get_child(const path_type &path_,
 473                                          const self_type &default_value) const
 474      {
 475 -        return const_cast<self_type*>(this)->get_child(path,
 476 +        return const_cast<self_type*>(this)->get_child(path_,
 477              const_cast<self_type&>(default_value));
 478      }
 479
 480
 481      template<class K, class D, class C>
 482      optional<basic_ptree<K, D, C> &>
 483 -        basic_ptree<K, D, C>::get_child_optional(const path_type &path)
 484 +        basic_ptree<K, D, C>::get_child_optional(const path_type &path_)
 485      {
 486 -        path_type p(path);
 487 +        path_type p(path_);
 488          self_type *n = walk_path(p);
 489          if (!n) {
 490              return optional<self_type&>();
 491 @@ -590,9 +590,9 @@
 492
 493      template<class K, class D, class C>
 494      optional<const basic_ptree<K, D, C> &>
 495 -        basic_ptree<K, D, C>::get_child_optional(const path_type &path) const
 496 +        basic_ptree<K, D, C>::get_child_optional(const path_type &path_) const
 497      {
 498 -        path_type p(path);
 499 +        path_type p(path_);
 500          self_type *n = walk_path(p);
 501          if (!n) {
 502              return optional<const self_type&>();
 503 @@ -602,10 +602,10 @@
 504
 505      template<class K, class D, class C>
 506      basic_ptree<K, D, C> &
 507 -        basic_ptree<K, D, C>::put_child(const path_type &path,
 508 +        basic_ptree<K, D, C>::put_child(const path_type &path_,
 509                                          const self_type &value)
 510      {
 511 -        path_type p(path);
 512 +        path_type p(path_);
 513          self_type &parent = force_path(p);
 514          // Got the parent. Now get the correct child.
 515          key_type fragment = p.reduce();
 516 @@ -620,10 +620,10 @@
 517
 518      template<class K, class D, class C>
 519      basic_ptree<K, D, C> &
 520 -        basic_ptree<K, D, C>::add_child(const path_type &path,
 521 +        basic_ptree<K, D, C>::add_child(const path_type &path_,
 522                                          const self_type &value)
 523      {
 524 -        path_type p(path);
 525 +        path_type p(path_);
 526          self_type &parent = force_path(p);
 527          // Got the parent.
 528          key_type fragment = p.reduce();
 529 @@ -709,26 +709,26 @@
 530      template<class K, class D, class C>
 531      template<class Type, class Translator> inline
 532      typename boost::enable_if<detail::is_translator<Translator>, Type>::type
 533 -    basic_ptree<K, D, C>::get(const path_type &path,
 534 +    basic_ptree<K, D, C>::get(const path_type &path_,
 535                                Translator tr) const
 536      {
 537 -        return get_child(path).BOOST_NESTED_TEMPLATE get_value<Type>(tr);
 538 +        return get_child(path_).BOOST_NESTED_TEMPLATE get_value<Type>(tr);
 539      }
 540
 541      template<class K, class D, class C>
 542      template<class Type> inline
 543 -    Type basic_ptree<K, D, C>::get(const path_type &path) const
 544 +    Type basic_ptree<K, D, C>::get(const path_type &path_) const
 545      {
 546 -        return get_child(path).BOOST_NESTED_TEMPLATE get_value<Type>();
 547 +        return get_child(path_).BOOST_NESTED_TEMPLATE get_value<Type>();
 548      }
 549
 550      template<class K, class D, class C>
 551      template<class Type, class Translator> inline
 552 -    Type basic_ptree<K, D, C>::get(const path_type &path,
 553 +    Type basic_ptree<K, D, C>::get(const path_type &path_,
 554                                     const Type &default_value,
 555                                     Translator tr) const
 556      {
 557 -        return get_optional<Type>(path, tr).get_value_or(default_value);
 558 +        return get_optional<Type>(path_, tr).get_value_or(default_value);
 559      }
 560
 561      template<class K, class D, class C>
 562 @@ -738,18 +738,18 @@
 563          std::basic_string<Ch>
 564      >::type
 565      basic_ptree<K, D, C>::get(
 566 -        const path_type &path, const Ch *default_value, Translator tr) const
 567 +        const path_type &path_, const Ch *default_value, Translator tr) const
 568      {
 569 -        return get<std::basic_string<Ch>, Translator>(path, default_value, tr);
 570 +        return get<std::basic_string<Ch>, Translator>(path_, default_value, tr);
 571      }
 572
 573      template<class K, class D, class C>
 574      template<class Type> inline
 575      typename boost::disable_if<detail::is_translator<Type>, Type>::type
 576 -    basic_ptree<K, D, C>::get(const path_type &path,
 577 +    basic_ptree<K, D, C>::get(const path_type &path_,
 578                                const Type &default_value) const
 579      {
 580 -        return get_optional<Type>(path).get_value_or(default_value);
 581 +        return get_optional<Type>(path_).get_value_or(default_value);
 582      }
 583
 584      template<class K, class D, class C>
 585 @@ -759,17 +759,17 @@
 586          std::basic_string<Ch>
 587      >::type
 588      basic_ptree<K, D, C>::get(
 589 -        const path_type &path, const Ch *default_value) const
 590 +        const path_type &path_, const Ch *default_value) const
 591      {
 592 -        return get< std::basic_string<Ch> >(path, default_value);
 593 +        return get< std::basic_string<Ch> >(path_, default_value);
 594      }
 595
 596      template<class K, class D, class C>
 597      template<class Type, class Translator>
 598 -    optional<Type> basic_ptree<K, D, C>::get_optional(const path_type &path,
 599 +    optional<Type> basic_ptree<K, D, C>::get_optional(const path_type &path_,
 600                                                           Translator tr) const
 601      {
 602 -        if (optional<const self_type&> child = get_child_optional(path))
 603 +        if (optional<const self_type&> child = get_child_optional(path_))
 604              return child.get().BOOST_NESTED_TEMPLATE get_value_optional<Type>(tr);
 605          else
 606              return optional<Type>();
 607 @@ -778,9 +778,9 @@
 608      template<class K, class D, class C>
 609      template<class Type>
 610      optional<Type> basic_ptree<K, D, C>::get_optional(
 611 -                                                const path_type &path) const
 612 +                                                const path_type &path_) const
 613      {
 614 -        if (optional<const self_type&> child = get_child_optional(path))
 615 +        if (optional<const self_type&> child = get_child_optional(path_))
 616              return child.get().BOOST_NESTED_TEMPLATE get_value_optional<Type>();
 617          else
 618              return optional<Type>();
 619 @@ -809,13 +809,13 @@
 620      template<class K, class D, class C>
 621      template<class Type, typename Translator>
 622      basic_ptree<K, D, C> & basic_ptree<K, D, C>::put(
 623 -        const path_type &path, const Type &value, Translator tr)
 624 +        const path_type &path_, const Type &value, Translator tr)
 625      {
 626 -        if(optional<self_type &> child = get_child_optional(path)) {
 627 +        if(optional<self_type &> child = get_child_optional(path_)) {
 628              child.get().put_value(value, tr);
 629              return *child;
 630          } else {
 631 -            self_type &child2 = put_child(path, self_type());
 632 +            self_type &child2 = put_child(path_, self_type());
 633              child2.put_value(value, tr);
 634              return child2;
 635          }
 636 @@ -824,18 +824,18 @@
 637      template<class K, class D, class C>
 638      template<class Type> inline
 639      basic_ptree<K, D, C> & basic_ptree<K, D, C>::put(
 640 -        const path_type &path, const Type &value)
 641 +        const path_type &path_, const Type &value)
 642      {
 643 -        return put(path, value,
 644 +        return put(path_, value,
 645                     typename translator_between<data_type, Type>::type());
 646      }
 647
 648      template<class K, class D, class C>
 649      template<class Type, typename Translator> inline
 650      basic_ptree<K, D, C> & basic_ptree<K, D, C>::add(
 651 -        const path_type &path, const Type &value, Translator tr)
 652 +        const path_type &path_, const Type &value, Translator tr)
 653      {
 654 -        self_type &child = add_child(path, self_type());
 655 +        self_type &child = add_child(path_, self_type());
 656          child.put_value(value, tr);
 657          return child;
 658      }
 659 @@ -843,9 +843,9 @@
 660      template<class K, class D, class C>
 661      template<class Type> inline
 662      basic_ptree<K, D, C> & basic_ptree<K, D, C>::add(
 663 -        const path_type &path, const Type &value)
 664 +        const path_type &path_, const Type &value)
 665      {
 666 -        return add(path, value,
 667 +        return add(path_, value,
 668                     typename translator_between<data_type, Type>::type());
 669      }
 670
 671 --- boost/boost/serialization/collection_size_type.hpp  2010-07-09 18:50:03.000000000 +0200
 672 +++ boost/boost/serialization/collection_size_type.hpp  2013-05-17 15:40:32.789528782 +0200
 673 @@ -37,7 +37,7 @@
 674          return *this;
 675      }
 676      // used for text output
 677 -    operator const base_type () const {
 678 +    operator base_type () const {
 679          return t;
 680      }
 681      // used for text input
 682 --- boost/boost/spirit/home/classic/error_handling/exceptions.hpp       2013-05-17 15:57:23.722638823 +0200
 683 +++ boost/boost/spirit/home/classic/error_handling/exceptions.hpp       2013-05-17 15:26:32.319247352 +0200
 684 @@ -126,8 +126,8 @@
 685          typedef unary<ParserT, parser<self_t> >         base_t;
 686          typedef unary_parser_category                   parser_category_t;
 687
 688 -        assertive_parser(ParserT const& parser, ErrorDescrT descriptor_)
 689 -        : base_t(parser), descriptor(descriptor_) {}
 690 +        assertive_parser(ParserT const& parser_, ErrorDescrT descriptor_)
 691 +        : base_t(parser_), descriptor(descriptor_) {}
 692
 693          template <typename ScannerT>
 694          struct result