external/boost/boost.libcdr.warnings.patch.1

   1 --- boost/boost/multi_index/detail/index_matcher.hpp    2008-07-03 18:51:53.000000000 +0200
   2 +++ boost/boost/multi_index/detail/index_matcher.hpp    2013-05-17 15:30:12.539099597 +0200
   3 @@ -132,17 +132,17 @@
   4          entries(),entries()+size_,
   5          entry(node),entry::less_by_node()); /* localize entry */
   6      ent->ordered=false;
   7 -    std::size_t n=ent->pos;                 /* get its position */
   8 +    std::size_t n_=ent->pos;                 /* get its position */
   9
  10      entry dummy(0);
  11 -    dummy.pile_top=n;
  12 +    dummy.pile_top=n_;
  13
  14      entry* pile_ent=                        /* find the first available pile */
  15        std::lower_bound(                     /* to stack the entry            */
  16          entries(),entries()+num_piles,
  17          dummy,entry::less_by_pile_top());
  18
  19 -    pile_ent->pile_top=n;                   /* stack the entry */
  20 +    pile_ent->pile_top=n_;                   /* stack the entry */
  21      pile_ent->pile_top_entry=ent;
  22
  23      /* if not the first pile, link entry to top of the preceding pile */
  24 @@ -164,7 +164,7 @@
  25         */
  26
  27        entry* ent=entries()[num_piles-1].pile_top_entry;
  28 -      for(std::size_t n=num_piles;n--;){
  29 +      for(std::size_t n_=num_piles;n_--;){
  30          ent->ordered=true;
  31          ent=ent->previous;
  32        }
  33 --- boost/boost/multi_index/ordered_index.hpp   2010-07-25 12:44:55.000000000 +0200
  34 +++ boost/boost/multi_index/ordered_index.hpp   2013-05-17 15:33:42.785182819 +0200
  35 @@ -436,9 +436,9 @@
  36
  37    template<typename CompatibleKey,typename CompatibleCompare>
  38    iterator find(
  39 -    const CompatibleKey& x,const CompatibleCompare& comp)const
  40 +    const CompatibleKey& x,const CompatibleCompare& comp_)const
  41    {
  42 -    return make_iterator(ordered_index_find(root(),header(),key,x,comp));
  43 +    return make_iterator(ordered_index_find(root(),header(),key,x,comp_));
  44    }
  45
  46    template<typename CompatibleKey>
  47 @@ -448,9 +448,9 @@
  48    }
  49
  50    template<typename CompatibleKey,typename CompatibleCompare>
  51 -  size_type count(const CompatibleKey& x,const CompatibleCompare& comp)const
  52 +  size_type count(const CompatibleKey& x,const CompatibleCompare& comp_)const
  53    {
  54 -    std::pair<iterator,iterator> p=equal_range(x,comp);
  55 +    std::pair<iterator,iterator> p=equal_range(x,comp_);
  56      size_type n=std::distance(p.first,p.second);
  57      return n;
  58    }
  59 @@ -464,10 +464,10 @@
  60
  61    template<typename CompatibleKey,typename CompatibleCompare>
  62    iterator lower_bound(
  63 -    const CompatibleKey& x,const CompatibleCompare& comp)const
  64 +    const CompatibleKey& x,const CompatibleCompare& comp_)const
  65    {
  66      return make_iterator(
  67 -      ordered_index_lower_bound(root(),header(),key,x,comp));
  68 +      ordered_index_lower_bound(root(),header(),key,x,comp_));
  69    }
  70
  71    template<typename CompatibleKey>
  72 @@ -479,10 +479,10 @@
  73
  74    template<typename CompatibleKey,typename CompatibleCompare>
  75    iterator upper_bound(
  76 -    const CompatibleKey& x,const CompatibleCompare& comp)const
  77 +    const CompatibleKey& x,const CompatibleCompare& comp_)const
  78    {
  79      return make_iterator(
  80 -      ordered_index_upper_bound(root(),header(),key,x,comp));
  81 +      ordered_index_upper_bound(root(),header(),key,x,comp_));
  82    }
  83
  84    template<typename CompatibleKey>
  85 @@ -497,10 +497,10 @@
  86
  87    template<typename CompatibleKey,typename CompatibleCompare>
  88    std::pair<iterator,iterator> equal_range(
  89 -    const CompatibleKey& x,const CompatibleCompare& comp)const
  90 +    const CompatibleKey& x,const CompatibleCompare& comp_)const
  91    {
  92      std::pair<node_type*,node_type*> p=
  93 -      ordered_index_equal_range(root(),header(),key,x,comp);
  94 +      ordered_index_equal_range(root(),header(),key,x,comp_);
  95      return std::pair<iterator,iterator>(
  96        make_iterator(p.first),make_iterator(p.second));
  97    }
  98 --- boost/boost/multi_index/sequenced_index.hpp 2008-07-03 18:51:53.000000000 +0200
  99 +++ boost/boost/multi_index/sequenced_index.hpp 2013-05-17 15:44:15.265289335 +0200
 100 @@ -346,7 +346,7 @@
 101    }
 102
 103    template<typename Modifier,typename Rollback>
 104 -  bool modify(iterator position,Modifier mod,Rollback back)
 105 +  bool modify(iterator position,Modifier mod,Rollback back_)
 106    {
 107      BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
 108      BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
 109 @@ -363,7 +363,7 @@
 110  #endif
 111
 112      return this->final_modify_(
 113 -      mod,back,static_cast<final_node_type*>(position.get_node()));
 114 +      mod,back_,static_cast<final_node_type*>(position.get_node()));
 115    }
 116
 117    void swap(sequenced_index<SuperMeta,TagList>& x)
 118 --- boost/boost/multi_index_container.hpp       2010-07-24 11:20:29.000000000 +0200
 119 +++ boost/boost/multi_index_container.hpp       2013-05-17 15:45:56.723899853 +0200
 120 @@ -360,7 +360,7 @@
 121      IteratorType it
 122      BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N))
 123    {
 124 -    typedef typename nth_index<N>::type index;
 125 +    typedef typename nth_index<N>::type index_;
 126
 127  #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
 128      BOOST_STATIC_ASSERT(
 129 @@ -371,7 +371,7 @@
 130      BOOST_MULTI_INDEX_CHECK_IS_OWNER(
 131        it,static_cast<typename IteratorType::container_type&>(*this));
 132
 133 -    return index::make_iterator(static_cast<node_type*>(it.get_node()));
 134 +    return index_::make_iterator(static_cast<node_type*>(it.get_node()));
 135    }
 136
 137    template<int N,typename IteratorType>
 138 @@ -379,7 +379,7 @@
 139      IteratorType it
 140      BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N))const
 141    {
 142 -    typedef typename nth_index<N>::type index;
 143 +    typedef typename nth_index<N>::type index_;
 144
 145  #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
 146      BOOST_STATIC_ASSERT((
 147 @@ -390,7 +390,7 @@
 148      BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
 149      BOOST_MULTI_INDEX_CHECK_IS_OWNER(
 150        it,static_cast<const typename IteratorType::container_type&>(*this));
 151 -    return index::make_iterator(static_cast<node_type*>(it.get_node()));
 152 +    return index_::make_iterator(static_cast<node_type*>(it.get_node()));
 153    }
 154  #endif
 155
 156 @@ -414,7 +414,7 @@
 157      IteratorType it
 158      BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))
 159    {
 160 -    typedef typename index<Tag>::type index;
 161 +    typedef typename index<Tag>::type index_;
 162
 163  #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
 164      BOOST_STATIC_ASSERT(
 165 @@ -424,7 +424,7 @@
 166      BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
 167      BOOST_MULTI_INDEX_CHECK_IS_OWNER(
 168        it,static_cast<typename IteratorType::container_type&>(*this));
 169 -    return index::make_iterator(static_cast<node_type*>(it.get_node()));
 170 +    return index_::make_iterator(static_cast<node_type*>(it.get_node()));
 171    }
 172
 173    template<typename Tag,typename IteratorType>
 174 @@ -432,7 +432,7 @@
 175      IteratorType it
 176      BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))const
 177    {
 178 -    typedef typename index<Tag>::type index;
 179 +    typedef typename index<Tag>::type index_;
 180
 181  #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
 182      BOOST_STATIC_ASSERT((
 183 @@ -443,7 +443,7 @@
 184      BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
 185      BOOST_MULTI_INDEX_CHECK_IS_OWNER(
 186        it,static_cast<const typename IteratorType::container_type&>(*this));
 187 -    return index::make_iterator(static_cast<node_type*>(it.get_node()));
 188 +    return index_::make_iterator(static_cast<node_type*>(it.get_node()));
 189    }
 190  #endif
 191
 192 --- boost/boost/property_tree/detail/json_parser_error.hpp      2007-05-13 00:02:53.000000000 +0200
 193 +++ boost/boost/property_tree/detail/json_parser_error.hpp      2013-05-17 15:36:44.605902442 +0200
 194 @@ -20,10 +20,10 @@
 195      class json_parser_error: public file_parser_error
 196      {
 197      public:
 198 -        json_parser_error(const std::string &message,
 199 -                          const std::string &filename,
 200 -                          unsigned long line):
 201 -            file_parser_error(message, filename, line)
 202 +        json_parser_error(const std::string &message_,
 203 +                          const std::string &filename_,
 204 +                          unsigned long line_):
 205 +            file_parser_error(message_, filename_, line_)
 206          {
 207          }
 208      };
 209 --- boost/boost/property_tree/detail/json_parser_read.hpp       2013-05-17 15:57:23.740638395 +0200
 210 +++ boost/boost/property_tree/detail/json_parser_read.hpp       2013-05-17 15:31:05.666857356 +0200
 211 @@ -45,7 +45,7 @@
 212          struct a_object_s
 213          {
 214              context &c;
 215 -            a_object_s(context &c): c(c) { }
 216 +            a_object_s(context &c_): c(c_) { }
 217              void operator()(Ch) const
 218              {
 219                  if (c.stack.empty())
 220 @@ -63,7 +63,7 @@
 221          struct a_object_e
 222          {
 223              context &c;
 224 -            a_object_e(context &c): c(c) { }
 225 +            a_object_e(context &c_): c(c_) { }
 226              void operator()(Ch) const
 227              {
 228                  BOOST_ASSERT(c.stack.size() >= 1);
 229 @@ -74,7 +74,7 @@
 230          struct a_name
 231          {
 232              context &c;
 233 -            a_name(context &c): c(c) { }
 234 +            a_name(context &c_): c(c_) { }
 235              void operator()(It, It) const
 236              {
 237                  c.name.swap(c.string);
 238 @@ -85,7 +85,7 @@
 239          struct a_string_val
 240          {
 241              context &c;
 242 -            a_string_val(context &c): c(c) { }
 243 +            a_string_val(context &c_): c(c_) { }
 244              void operator()(It, It) const
 245              {
 246                  BOOST_ASSERT(c.stack.size() >= 1);
 247 @@ -98,7 +98,7 @@
 248          struct a_literal_val
 249          {
 250              context &c;
 251 -            a_literal_val(context &c): c(c) { }
 252 +            a_literal_val(context &c_): c(c_) { }
 253              void operator()(It b, It e) const
 254              {
 255                  BOOST_ASSERT(c.stack.size() >= 1);
 256 @@ -111,8 +111,8 @@
 257          struct a_char
 258          {
 259              context &c;
 260 -            a_char(context &c): c(c) { }
 261 -            void operator()(It b, It e) const
 262 +            a_char(context &c_): c(c_) { }
 263 +            void operator()(It b, It /* e */) const
 264              {
 265                  c.string += *b;
 266              }
 267 @@ -121,7 +121,7 @@
 268          struct a_escape
 269          {
 270              context &c;
 271 -            a_escape(context &c): c(c) { }
 272 +            a_escape(context &c_): c(c_) { }
 273              void operator()(Ch ch) const
 274              {
 275                  switch (ch)
 276 @@ -142,7 +142,7 @@
 277          struct a_unicode
 278          {
 279              context &c;
 280 -            a_unicode(context &c): c(c) { }
 281 +            a_unicode(context &c_): c(c_) { }
 282              void operator()(unsigned long u) const
 283              {
 284                  u = (std::min)(u, static_cast<unsigned long>((std::numeric_limits<Ch>::max)()));
 285 --- boost/boost/property_tree/detail/ptree_implementation.hpp   2010-07-03 22:59:45.000000000 +0200
 286 +++ boost/boost/property_tree/detail/ptree_implementation.hpp   2013-05-17 15:55:56.449713452 +0200
 287 @@ -539,48 +539,48 @@
 288
 289      template<class K, class D, class C>
 290      basic_ptree<K, D, C> &
 291 -        basic_ptree<K, D, C>::get_child(const path_type &path)
 292 +        basic_ptree<K, D, C>::get_child(const path_type &path_)
 293      {
 294 -        path_type p(path);
 295 +        path_type p(path_);
 296          self_type *n = walk_path(p);
 297          if (!n) {
 298 -            BOOST_PROPERTY_TREE_THROW(ptree_bad_path("No such node", path));
 299 +            BOOST_PROPERTY_TREE_THROW(ptree_bad_path("No such node", path_));
 300          }
 301          return *n;
 302      }
 303
 304      template<class K, class D, class C> inline
 305      const basic_ptree<K, D, C> &
 306 -        basic_ptree<K, D, C>::get_child(const path_type &path) const
 307 +        basic_ptree<K, D, C>::get_child(const path_type &path_) const
 308      {
 309 -        return const_cast<self_type*>(this)->get_child(path);
 310 +        return const_cast<self_type*>(this)->get_child(path_);
 311      }
 312
 313      template<class K, class D, class C> inline
 314      basic_ptree<K, D, C> &
 315 -        basic_ptree<K, D, C>::get_child(const path_type &path,
 316 +        basic_ptree<K, D, C>::get_child(const path_type &path_,
 317                                          self_type &default_value)
 318      {
 319 -        path_type p(path);
 320 +        path_type p(path_);
 321          self_type *n = walk_path(p);
 322          return n ? *n : default_value;
 323      }
 324
 325      template<class K, class D, class C> inline
 326      const basic_ptree<K, D, C> &
 327 -        basic_ptree<K, D, C>::get_child(const path_type &path,
 328 +        basic_ptree<K, D, C>::get_child(const path_type &path_,
 329                                          const self_type &default_value) const
 330      {
 331 -        return const_cast<self_type*>(this)->get_child(path,
 332 +        return const_cast<self_type*>(this)->get_child(path_,
 333              const_cast<self_type&>(default_value));
 334      }
 335
 336
 337      template<class K, class D, class C>
 338      optional<basic_ptree<K, D, C> &>
 339 -        basic_ptree<K, D, C>::get_child_optional(const path_type &path)
 340 +        basic_ptree<K, D, C>::get_child_optional(const path_type &path_)
 341      {
 342 -        path_type p(path);
 343 +        path_type p(path_);
 344          self_type *n = walk_path(p);
 345          if (!n) {
 346              return optional<self_type&>();
 347 @@ -590,9 +590,9 @@
 348
 349      template<class K, class D, class C>
 350      optional<const basic_ptree<K, D, C> &>
 351 -        basic_ptree<K, D, C>::get_child_optional(const path_type &path) const
 352 +        basic_ptree<K, D, C>::get_child_optional(const path_type &path_) const
 353      {
 354 -        path_type p(path);
 355 +        path_type p(path_);
 356          self_type *n = walk_path(p);
 357          if (!n) {
 358              return optional<const self_type&>();
 359 @@ -602,10 +602,10 @@
 360
 361      template<class K, class D, class C>
 362      basic_ptree<K, D, C> &
 363 -        basic_ptree<K, D, C>::put_child(const path_type &path,
 364 +        basic_ptree<K, D, C>::put_child(const path_type &path_,
 365                                          const self_type &value)
 366      {
 367 -        path_type p(path);
 368 +        path_type p(path_);
 369          self_type &parent = force_path(p);
 370          // Got the parent. Now get the correct child.
 371          key_type fragment = p.reduce();
 372 @@ -620,10 +620,10 @@
 373
 374      template<class K, class D, class C>
 375      basic_ptree<K, D, C> &
 376 -        basic_ptree<K, D, C>::add_child(const path_type &path,
 377 +        basic_ptree<K, D, C>::add_child(const path_type &path_,
 378                                          const self_type &value)
 379      {
 380 -        path_type p(path);
 381 +        path_type p(path_);
 382          self_type &parent = force_path(p);
 383          // Got the parent.
 384          key_type fragment = p.reduce();
 385 @@ -709,26 +709,26 @@
 386      template<class K, class D, class C>
 387      template<class Type, class Translator> inline
 388      typename boost::enable_if<detail::is_translator<Translator>, Type>::type
 389 -    basic_ptree<K, D, C>::get(const path_type &path,
 390 +    basic_ptree<K, D, C>::get(const path_type &path_,
 391                                Translator tr) const
 392      {
 393 -        return get_child(path).BOOST_NESTED_TEMPLATE get_value<Type>(tr);
 394 +        return get_child(path_).BOOST_NESTED_TEMPLATE get_value<Type>(tr);
 395      }
 396
 397      template<class K, class D, class C>
 398      template<class Type> inline
 399 -    Type basic_ptree<K, D, C>::get(const path_type &path) const
 400 +    Type basic_ptree<K, D, C>::get(const path_type &path_) const
 401      {
 402 -        return get_child(path).BOOST_NESTED_TEMPLATE get_value<Type>();
 403 +        return get_child(path_).BOOST_NESTED_TEMPLATE get_value<Type>();
 404      }
 405
 406      template<class K, class D, class C>
 407      template<class Type, class Translator> inline
 408 -    Type basic_ptree<K, D, C>::get(const path_type &path,
 409 +    Type basic_ptree<K, D, C>::get(const path_type &path_,
 410                                     const Type &default_value,
 411                                     Translator tr) const
 412      {
 413 -        return get_optional<Type>(path, tr).get_value_or(default_value);
 414 +        return get_optional<Type>(path_, tr).get_value_or(default_value);
 415      }
 416
 417      template<class K, class D, class C>
 418 @@ -738,18 +738,18 @@
 419          std::basic_string<Ch>
 420      >::type
 421      basic_ptree<K, D, C>::get(
 422 -        const path_type &path, const Ch *default_value, Translator tr) const
 423 +        const path_type &path_, const Ch *default_value, Translator tr) const
 424      {
 425 -        return get<std::basic_string<Ch>, Translator>(path, default_value, tr);
 426 +        return get<std::basic_string<Ch>, Translator>(path_, default_value, tr);
 427      }
 428
 429      template<class K, class D, class C>
 430      template<class Type> inline
 431      typename boost::disable_if<detail::is_translator<Type>, Type>::type
 432 -    basic_ptree<K, D, C>::get(const path_type &path,
 433 +    basic_ptree<K, D, C>::get(const path_type &path_,
 434                                const Type &default_value) const
 435      {
 436 -        return get_optional<Type>(path).get_value_or(default_value);
 437 +        return get_optional<Type>(path_).get_value_or(default_value);
 438      }
 439
 440      template<class K, class D, class C>
 441 @@ -759,17 +759,17 @@
 442          std::basic_string<Ch>
 443      >::type
 444      basic_ptree<K, D, C>::get(
 445 -        const path_type &path, const Ch *default_value) const
 446 +        const path_type &path_, const Ch *default_value) const
 447      {
 448 -        return get< std::basic_string<Ch> >(path, default_value);
 449 +        return get< std::basic_string<Ch> >(path_, default_value);
 450      }
 451
 452      template<class K, class D, class C>
 453      template<class Type, class Translator>
 454 -    optional<Type> basic_ptree<K, D, C>::get_optional(const path_type &path,
 455 +    optional<Type> basic_ptree<K, D, C>::get_optional(const path_type &path_,
 456                                                           Translator tr) const
 457      {
 458 -        if (optional<const self_type&> child = get_child_optional(path))
 459 +        if (optional<const self_type&> child = get_child_optional(path_))
 460              return child.get().
 461                  BOOST_NESTED_TEMPLATE get_value_optional<Type>(tr);
 462          else
 463 @@ -778,9 +778,9 @@
 464      template<class K, class D, class C>
 465      template<class Type>
 466      optional<Type> basic_ptree<K, D, C>::get_optional(
 467 -                                                const path_type &path) const
 468 +                                                const path_type &path_) const
 469      {
 470 -        if (optional<const self_type&> child = get_child_optional(path))
 471 +        if (optional<const self_type&> child = get_child_optional(path_))
 472              return child.get().BOOST_NESTED_TEMPLATE get_value_optional<Type>();
 473          else
 474              return optional<Type>();
 475 @@ -809,13 +809,13 @@
 476      template<class K, class D, class C>
 477      template<class Type, typename Translator>
 478      basic_ptree<K, D, C> & basic_ptree<K, D, C>::put(
 479 -        const path_type &path, const Type &value, Translator tr)
 480 +        const path_type &path_, const Type &value, Translator tr)
 481      {
 482 -        if(optional<self_type &> child = get_child_optional(path)) {
 483 +        if(optional<self_type &> child = get_child_optional(path_)) {
 484              child.get().put_value(value, tr);
 485              return *child;
 486          } else {
 487 -            self_type &child2 = put_child(path, self_type());
 488 +            self_type &child2 = put_child(path_, self_type());
 489              child2.put_value(value, tr);
 490              return child2;
 491          }
 492 @@ -824,18 +824,18 @@
 493      template<class K, class D, class C>
 494      template<class Type> inline
 495      basic_ptree<K, D, C> & basic_ptree<K, D, C>::put(
 496 -        const path_type &path, const Type &value)
 497 +        const path_type &path_, const Type &value)
 498      {
 499 -        return put(path, value,
 500 +        return put(path_, value,
 501                     typename translator_between<data_type, Type>::type());
 502      }
 503
 504      template<class K, class D, class C>
 505      template<class Type, typename Translator> inline
 506      basic_ptree<K, D, C> & basic_ptree<K, D, C>::add(
 507 -        const path_type &path, const Type &value, Translator tr)
 508 +        const path_type &path_, const Type &value, Translator tr)
 509      {
 510 -        self_type &child = add_child(path, self_type());
 511 +        self_type &child = add_child(path_, self_type());
 512          child.put_value(value, tr);
 513          return child;
 514      }
 515 @@ -843,9 +843,9 @@
 516      template<class K, class D, class C>
 517      template<class Type> inline
 518      basic_ptree<K, D, C> & basic_ptree<K, D, C>::add(
 519 -        const path_type &path, const Type &value)
 520 +        const path_type &path_, const Type &value)
 521      {
 522 -        return add(path, value,
 523 +        return add(path_, value,
 524                     typename translator_between<data_type, Type>::type());
 525      }
 526
 527 --- boost/boost/spirit/home/classic/error_handling/exceptions.hpp       2013-05-17 15:57:23.722638823 +0200
 528 +++ boost/boost/spirit/home/classic/error_handling/exceptions.hpp       2013-05-17 15:26:32.319247352 +0200
 529 @@ -126,8 +126,8 @@
 530          typedef unary<ParserT, parser<self_t> >         base_t;
 531          typedef unary_parser_category                   parser_category_t;
 532
 533 -        assertive_parser(ParserT const& parser, ErrorDescrT descriptor_)
 534 -        : base_t(parser), descriptor(descriptor_) {}
 535 +        assertive_parser(ParserT const& parser_, ErrorDescrT descriptor_)
 536 +        : base_t(parser_), descriptor(descriptor_) {}
 537
 538          template <typename ScannerT>
 539          struct result