Ticket #3924: boost_r59655_gcc_warning_cleanup.patch

boost/gil/locator.hpp

@@ -309 +309 @@
 
 private:
     template <typename X> friend class memory_based_2d_locator;
-    std::ptrdiff_t offset(x_coord_t x, y_coord_t y)        const { return y*row_size() + x*pixel_size(); }
+    std::ptrdiff_t offset(x_coord_t p_x, y_coord_t p_y)        const { return p_y*row_size() + p_x*pixel_size(); }
     StepIterator _p;
 };
 

boost/gil/virtual_locator.hpp

@@ -53 +53 @@
         }
     };
 
-    virtual_2d_locator(const point_t& p=point_t(0,0), const point_t& step=point_t(1,1), const deref_fn_t& d=deref_fn_t()) : _p(p,step,d) {}
+    virtual_2d_locator(const point_t& p=point_t(0,0), const point_t& p_step=point_t(1,1), const deref_fn_t& d=deref_fn_t()) : _p(p,p_step,d) {}
     template <typename D, bool TR> virtual_2d_locator(const virtual_2d_locator<D,TR>& loc, coord_t y_step)
         : _p(loc.pos(), point_t(loc.step().x,loc.step().y*y_step),     loc.deref_fn()) {}
     template <typename D, bool TR> virtual_2d_locator(const virtual_2d_locator<D,TR>& loc, coord_t x_step, coord_t y_step, bool transpose=false)

boost/gil/image_view.hpp

@@ -101 +101 @@
     template <typename View> image_view(const View& iv)                                    : _dimensions(iv.dimensions()), _pixels(iv.pixels()) {}
 
     template <typename L2> image_view(const point_t& sz            , const L2& loc)        : _dimensions(sz),          _pixels(loc) {}
-    template <typename L2> image_view(coord_t width, coord_t height, const L2& loc)        : _dimensions(x_coord_t(width),y_coord_t(height)), _pixels(loc) {}
+    template <typename L2> image_view(coord_t p_width, coord_t p_height, const L2& loc)        : _dimensions(x_coord_t(p_width),y_coord_t(p_height)), _pixels(loc) {}
 
     template <typename View> image_view& operator=(const View& iv)  { _pixels=iv.pixels(); _dimensions=iv.dimensions(); return *this; }
     image_view& operator=(const image_view& iv)                     { _pixels=iv.pixels(); _dimensions=iv.dimensions(); return *this; }

boost/gil/position_iterator.hpp

@@ -52 +52 @@
     typedef typename Deref::argument_type      point_t;
 
     position_iterator() {}
-    position_iterator(const point_t& p, const point_t& step, const Deref& d) : _p(p), _step(step), _d(d) {}
+    position_iterator(const point_t& p, const point_t& p_step, const Deref& d) : _p(p), _step(p_step), _d(d) {}
 
     position_iterator(const position_iterator& p) : _p(p._p), _step(p._step), _d(p._d) {}
     template <typename D> position_iterator(const position_iterator<D,Dim>& p) : _p(p._p), _step(p._step), _d(p._d) {}

boost/gil/iterator_from_2d.hpp

@@ -78 +78 @@
     x_iterator&     x()                   { return _p.x(); }
 
     iterator_from_2d(){}
-    iterator_from_2d(const Loc2& p, std::ptrdiff_t width, std::ptrdiff_t x=0, std::ptrdiff_t y=0) : _coords(x,y), _width(width), _p(p) {}
+    iterator_from_2d(const Loc2& p, std::ptrdiff_t p_width, std::ptrdiff_t p_x=0, std::ptrdiff_t p_y=0) : _coords(p_x,p_y), _width(p_width), _p(p) {}
     iterator_from_2d(const iterator_from_2d& pit) : _coords(pit._coords), _width(pit._width), _p(pit._p) {}
     template <typename Loc> iterator_from_2d(const iterator_from_2d<Loc>& pit) : _coords(pit._coords), _width(pit._width), _p(pit._p) {}
 

boost/gil/pixel_iterator_adaptor.hpp

@@ -62 +62 @@
     dereference_iterator_adaptor() {}
     template <typename Iterator1> 
     dereference_iterator_adaptor(const dereference_iterator_adaptor<Iterator1,DFn>& dit) : parent_t(dit.base()), _deref_fn(dit._deref_fn) {}
-    dereference_iterator_adaptor(Iterator it, DFn deref_fn=DFn()) : parent_t(it), _deref_fn(deref_fn) {}
+    dereference_iterator_adaptor(Iterator it, DFn p_deref_fn=DFn()) : parent_t(it), _deref_fn(p_deref_fn) {}
     template <typename Iterator1, typename DFn1> 
     dereference_iterator_adaptor(const dereference_iterator_adaptor<Iterator1,DFn1>& it) : parent_t(it.base()), _deref_fn(it._deref_fn) {}
     /// For some reason operator[] provided by iterator_facade returns a custom class that is convertible to reference

boost/gil/channel.hpp

@@ -482 +482 @@
     typedef const packed_dynamic_channel_reference<BitField,NumBits,true>  mutable_reference;
     typedef typename parent_t::integer_t                          integer_t;
 
-    packed_dynamic_channel_reference(const void* data_ptr, unsigned first_bit) : parent_t(data_ptr), _first_bit(first_bit) {}
+    packed_dynamic_channel_reference(const void* data_ptr, unsigned p_first_bit) : parent_t(data_ptr), _first_bit(p_first_bit) {}
     packed_dynamic_channel_reference(const const_reference&   ref) : parent_t(ref._data_ptr), _first_bit(ref._first_bit) {}
     packed_dynamic_channel_reference(const mutable_reference& ref) : parent_t(ref._data_ptr), _first_bit(ref._first_bit) {}
 
@@ -510 +510 @@
     typedef const packed_dynamic_channel_reference<BitField,NumBits,true>  mutable_reference;
     typedef typename parent_t::integer_t                          integer_t;
 
-    packed_dynamic_channel_reference(void* data_ptr, unsigned first_bit) : parent_t(data_ptr), _first_bit(first_bit) {}
+    packed_dynamic_channel_reference(void* data_ptr, unsigned p_first_bit) : parent_t(data_ptr), _first_bit(p_first_bit) {}
     packed_dynamic_channel_reference(const packed_dynamic_channel_reference& ref) : parent_t(ref._data_ptr), _first_bit(ref._first_bit) {}
 
     const packed_dynamic_channel_reference& operator=(integer_t value) const { assert(value<=parent_t::max_val); set_unsafe(value); return *this; }

boost/gil/bit_aligned_pixel_reference.hpp

@@ -54 +54 @@
 
 public:
     bit_range() : _current_byte(NULL), _bit_offset(0) {}
-    bit_range(byte_t* current_byte, int bit_offset) : _current_byte(current_byte), _bit_offset(bit_offset) { assert(bit_offset>=0 && bit_offset<8); } 
+    bit_range(byte_t* p_current_byte, int p_bit_offset) : _current_byte(p_current_byte), _bit_offset(p_bit_offset) { assert(p_bit_offset>=0 && p_bit_offset<8); } 
 
     bit_range(const bit_range& br) : _current_byte(br._current_byte), _bit_offset(br._bit_offset) {}
     template <bool M> bit_range(const bit_range<RangeSize,M>& br) : _current_byte(br._current_byte), _bit_offset(br._bit_offset) {}
@@ -135 +135 @@
 
     bit_aligned_pixel_reference(){}
     bit_aligned_pixel_reference(data_ptr_t data_ptr, int bit_offset)   : _bit_range(data_ptr, bit_offset) {}
-    explicit bit_aligned_pixel_reference(const bit_range_t& bit_range) : _bit_range(bit_range) {}
+    explicit bit_aligned_pixel_reference(const bit_range_t& p_bit_range) : _bit_range(p_bit_range) {}
     template <bool IsMutable2> bit_aligned_pixel_reference(const bit_aligned_pixel_reference<BitField,ChannelBitSizes,Layout,IsMutable2>& p) : _bit_range(p._bit_range) {}
 
     // Grayscale references can be constructed from the channel reference

boost/gil/image.hpp

@@ -68 +68 @@
         _memory(0), _align_in_bytes(alignment), _alloc(alloc_in) {}
 
     // Create with dimensions and optional initial value and alignment
-    image(const point_t& dimensions,
+    image(const point_t& p_dimensions,
           std::size_t alignment=0,
           const Alloc alloc_in = Alloc()) : _memory(0), _align_in_bytes(alignment), _alloc(alloc_in) {
-        allocate_and_default_construct(dimensions);
+        allocate_and_default_construct(p_dimensions);
     }
-    image(x_coord_t width, y_coord_t height,
+    image(x_coord_t p_width, y_coord_t p_height,
           std::size_t alignment=0,
           const Alloc alloc_in = Alloc()) : _memory(0), _align_in_bytes(alignment), _alloc(alloc_in) {
-        allocate_and_default_construct(point_t(width,height));
+        allocate_and_default_construct(point_t(p_width,p_height));
     }
-    image(const point_t& dimensions, 
+    image(const point_t& p_dimensions, 
           const Pixel& p_in,
           std::size_t alignment,
           const Alloc alloc_in = Alloc())  :
         _memory(0), _align_in_bytes(alignment), _alloc(alloc_in) {
-        allocate_and_fill(dimensions, p_in);
+        allocate_and_fill(p_dimensions, p_in);
     }
-    image(x_coord_t width, y_coord_t height,
+    image(x_coord_t p_width, y_coord_t p_height,
           const Pixel& p_in,
           std::size_t alignment,
           const Alloc alloc_in = Alloc())  :
         _memory(0), _align_in_bytes(alignment), _alloc(alloc_in) {
-        allocate_and_fill(point_t(width,height),p_in);
+        allocate_and_fill(point_t(p_width,p_height),p_in);
     }
 
     image(const image& img) :
@@ -146 +146 @@
             swap(tmp);
         }
     }
-    void recreate(x_coord_t width, y_coord_t height, std::size_t alignment=0, const Alloc alloc_in = Alloc()) {
-        recreate(point_t(width,height),alignment,alloc_in);
+    void recreate(x_coord_t p_width, y_coord_t p_height, std::size_t alignment=0, const Alloc alloc_in = Alloc()) {
+        recreate(point_t(p_width,p_height),alignment,alloc_in);
     }
     void recreate(const point_t& dims, 
                   const Pixel& p_in, std::size_t alignment, const Alloc alloc_in = Alloc()) {
@@ -156 +156 @@
             swap(tmp);
         }
     }
-    void recreate(x_coord_t width, y_coord_t height, 
+    void recreate(x_coord_t p_width, y_coord_t p_height, 
                   const Pixel& p_in, std::size_t alignment, const Alloc alloc_in = Alloc()) {
-        recreate(point_t(width,height),p_in,alignment,alloc_in);
+        recreate(point_t(p_width,p_height),p_in,alignment,alloc_in);
     }
 
     view_t       _view;      // contains pointer to the pixels, the image size and ways to navigate pixels
@@ -167 +167 @@
     std::size_t    _align_in_bytes;
     allocator_type _alloc;
 
-    void allocate_and_default_construct(const point_t& dimensions) { 
+    void allocate_and_default_construct(const point_t& p_dimensions) { 
         try {
-            allocate_(dimensions,mpl::bool_<IsPlanar>());
+            allocate_(p_dimensions,mpl::bool_<IsPlanar>());
             default_construct_pixels(_view);
-        } catch(...) { deallocate(dimensions); throw; }
+        } catch(...) { deallocate(p_dimensions); throw; }
     }
 
-    void allocate_and_fill(const point_t& dimensions, const Pixel& p_in) { 
+    void allocate_and_fill(const point_t& p_dimensions, const Pixel& p_in) { 
         try {
-            allocate_(dimensions,mpl::bool_<IsPlanar>());
+            allocate_(p_dimensions,mpl::bool_<IsPlanar>());
             uninitialized_fill_pixels(_view, p_in);
-        } catch(...) { deallocate(dimensions); throw; }
+        } catch(...) { deallocate(p_dimensions); throw; }
     }
 
     template <typename View>
-    void allocate_and_copy(const point_t& dimensions, const View& v) { 
+    void allocate_and_copy(const point_t& p_dimensions, const View& v) { 
         try {
-            allocate_(dimensions,mpl::bool_<IsPlanar>());
+            allocate_(p_dimensions,mpl::bool_<IsPlanar>());
             uninitialized_copy_pixels(v,_view);
-        } catch(...) { deallocate(dimensions); throw; }
+        } catch(...) { deallocate(p_dimensions); throw; }
     }
 
-    void deallocate(const point_t& dimensions) { 
-        if (_memory) _alloc.deallocate(_memory, total_allocated_size_in_bytes(dimensions));
+    void deallocate(const point_t& p_dimensions) { 
+        if (_memory) _alloc.deallocate(_memory, total_allocated_size_in_bytes(p_dimensions));
     }
 
-    std::size_t total_allocated_size_in_bytes(const point_t& dimensions) const {
-        std::size_t size_in_units = get_row_size_in_memunits(dimensions.x)*dimensions.y;
+    std::size_t total_allocated_size_in_bytes(const point_t& p_dimensions) const {
+        std::size_t size_in_units = get_row_size_in_memunits(p_dimensions.x)*p_dimensions.y;
         if (IsPlanar)
             size_in_units = size_in_units*num_channels<view_t>::value;
 
@@ -203 +203 @@
             + (_align_in_bytes>0 ? _align_in_bytes-1:0);    // add extra padding in case we need to align the first image pixel
     }
 
-    std::size_t get_row_size_in_memunits(x_coord_t width) const {   // number of units per row
-        std::size_t size_in_memunits = width*memunit_step(typename view_t::x_iterator());
+    std::size_t get_row_size_in_memunits(x_coord_t p_width) const {   // number of units per row
+        std::size_t size_in_memunits = p_width*memunit_step(typename view_t::x_iterator());
         if (_align_in_bytes>0) {
             std::size_t alignment_in_memunits=_align_in_bytes*byte_to_memunit<typename view_t::x_iterator>::value;
             return align(size_in_memunits, alignment_in_memunits);
@@ -212 +212 @@
         return size_in_memunits;
     }
     
-    void allocate_(const point_t& dimensions, mpl::false_) {  // if it throws and _memory!=0 the client must deallocate _memory
-        _memory=_alloc.allocate(total_allocated_size_in_bytes(dimensions));
+    void allocate_(const point_t& p_dimensions, mpl::false_) {  // if it throws and _memory!=0 the client must deallocate _memory
+        _memory=_alloc.allocate(total_allocated_size_in_bytes(p_dimensions));
         unsigned char* tmp=(_align_in_bytes>0) ? (unsigned char*)align((std::size_t)_memory,_align_in_bytes) : _memory;
-        _view=view_t(dimensions,typename view_t::locator(typename view_t::x_iterator(tmp),get_row_size_in_memunits(dimensions.x)));
+        _view=view_t(p_dimensions,typename view_t::locator(typename view_t::x_iterator(tmp),get_row_size_in_memunits(p_dimensions.x)));
     }
 
-    void allocate_(const point_t& dimensions, mpl::true_) {   // if it throws and _memory!=0 the client must deallocate _memory
-        std::size_t row_size=get_row_size_in_memunits(dimensions.x);
-        std::size_t plane_size=row_size*dimensions.y;
-        _memory=_alloc.allocate(total_allocated_size_in_bytes(dimensions));
+    void allocate_(const point_t& p_dimensions, mpl::true_) {   // if it throws and _memory!=0 the client must deallocate _memory
+        std::size_t row_size=get_row_size_in_memunits(p_dimensions.x);
+        std::size_t plane_size=row_size*p_dimensions.y;
+        _memory=_alloc.allocate(total_allocated_size_in_bytes(p_dimensions));
         unsigned char* tmp=(_align_in_bytes>0) ? (unsigned char*)align((std::size_t)_memory,_align_in_bytes) : _memory;
         typename view_t::x_iterator first; 
         for (int i=0; i<num_channels<view_t>::value; ++i) {
             dynamic_at_c(first,i) = (typename channel_type<view_t>::type*)tmp;
             memunit_advance(dynamic_at_c(first,i), plane_size*i);
         }
-        _view=view_t(dimensions, typename view_t::locator(first, row_size));
+        _view=view_t(p_dimensions, typename view_t::locator(first, row_size));
     }
 };
 

boost/gil/step_iterator.hpp

@@ -133 +133 @@
 struct memunit_step_fn {
     typedef std::ptrdiff_t difference_type;
 
-    memunit_step_fn(difference_type step=memunit_step(Iterator())) : _step(step) {}
+    memunit_step_fn(difference_type p_step=memunit_step(Iterator())) : _step(p_step) {}
 
     difference_type difference(const Iterator& it1, const Iterator& it2) const { return memunit_distance(it1,it2)/_step; }
     void            advance(Iterator& it, difference_type d)             const { memunit_advance(it,d*_step); } 
     difference_type step()                                               const { return _step; }
 
-    void            set_step(std::ptrdiff_t step) { _step=step; }
+    void            set_step(std::ptrdiff_t p_step) { _step=p_step; }
 private:
     GIL_CLASS_REQUIRE(Iterator, boost::gil, MemoryBasedIteratorConcept)
     difference_type _step;

boost/gil/extension/io/io_error.hpp

@@ -24 +24 @@
 
 namespace boost { namespace gil {
 
+inline void io_error(const char* descr)
+#if BOOST_WORKAROUND(__GNUC__, >= 3)
+                                                __attribute__((noreturn))
+#endif
+;
 inline void io_error(const char* descr) { throw std::ios_base::failure(descr); }
 inline void io_error_if(bool expr, const char* descr="") { if (expr) io_error(descr); }
 

boost/gil/algorithm.hpp

@@ -192 +192 @@
 /// Source range is delimited by image iterators
 template <typename IL, typename O>  // IL Models ConstPixelLocatorConcept, O Models PixelIteratorConcept
 struct copier_n<iterator_from_2d<IL>,O> {
-    typedef typename std::iterator_traits<iterator_from_2d<IL> >::difference_type diff_t;
-    GIL_FORCEINLINE void operator()(iterator_from_2d<IL> src, diff_t n, O dst) const {
+    typedef typename std::iterator_traits<iterator_from_2d<IL> >::difference_type it_diff_t;
+    GIL_FORCEINLINE void operator()(iterator_from_2d<IL> src, it_diff_t n, O dst) const {
         gil_function_requires<PixelLocatorConcept<IL> >();
         gil_function_requires<MutablePixelIteratorConcept<O> >();
         while (n>0) {

boost/detail/workaround.hpp

@@ -65 +65 @@
 #else
 #define BOOST_MSVC_WORKAROUND_GUARD 0
 #endif
+#ifndef BOOST_MSVC_FULL_VER
+#define BOOST_MSVC_FULL_VER_WORKAROUND_GUARD 1
+#else
+#define BOOST_MSVC_FULL_VER_WORKAROUND_GUARD 0
+#endif
 #ifndef __GNUC__
 #define __GNUC___WORKAROUND_GUARD 1
 #else

boost/multi_index/sequenced_index.hpp

@@ -346 +346 @@
   }
 
   template<typename Modifier,typename Rollback>
-  bool modify(iterator position,Modifier mod,Rollback back)
+  bool modify(iterator position,Modifier mod,Rollback p_back)
   {
     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(position);
     BOOST_MULTI_INDEX_CHECK_DEREFERENCEABLE_ITERATOR(position);
@@ -363 +363 @@
 #endif
 
     return this->final_modify_(
-      mod,back,static_cast<final_node_type*>(position.get_node()));
+      mod,p_back,static_cast<final_node_type*>(position.get_node()));
   }
 
   void swap(sequenced_index<SuperMeta,TagList>& x)

boost/multi_index/ordered_index.hpp

@@ -436 +436 @@
 
   template<typename CompatibleKey,typename CompatibleCompare>
   iterator find(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
+    const CompatibleKey& x,const CompatibleCompare& p_comp)const
   {
-    return make_iterator(ordered_index_find(root(),header(),key,x,comp));
+    return make_iterator(ordered_index_find(root(),header(),key,x,p_comp));
   }
 
   template<typename CompatibleKey>
@@ -448 +448 @@
   }
 
   template<typename CompatibleKey,typename CompatibleCompare>
-  size_type count(const CompatibleKey& x,const CompatibleCompare& comp)const
+  size_type count(const CompatibleKey& x,const CompatibleCompare& p_comp)const
   {
-    std::pair<iterator,iterator> p=equal_range(x,comp);
+    std::pair<iterator,iterator> p=equal_range(x,p_comp);
     size_type n=std::distance(p.first,p.second);
     return n;
   }
@@ -464 +464 @@
 
   template<typename CompatibleKey,typename CompatibleCompare>
   iterator lower_bound(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
+    const CompatibleKey& x,const CompatibleCompare& p_comp)const
   {
     return make_iterator(
-      ordered_index_lower_bound(root(),header(),key,x,comp));
+      ordered_index_lower_bound(root(),header(),key,x,p_comp));
   }
 
   template<typename CompatibleKey>
@@ -479 +479 @@
 
   template<typename CompatibleKey,typename CompatibleCompare>
   iterator upper_bound(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
+    const CompatibleKey& x,const CompatibleCompare& p_comp)const
   {
     return make_iterator(
-      ordered_index_upper_bound(root(),header(),key,x,comp));
+      ordered_index_upper_bound(root(),header(),key,x,p_comp));
   }
 
   template<typename CompatibleKey>
@@ -497 +497 @@
 
   template<typename CompatibleKey,typename CompatibleCompare>
   std::pair<iterator,iterator> equal_range(
-    const CompatibleKey& x,const CompatibleCompare& comp)const
+    const CompatibleKey& x,const CompatibleCompare& p_comp)const
   {
     std::pair<node_type*,node_type*> p=
-      ordered_index_equal_range(root(),header(),key,x,comp);
+      ordered_index_equal_range(root(),header(),key,x,p_comp);
     return std::pair<iterator,iterator>(
       make_iterator(p.first),make_iterator(p.second));
   }

boost/multi_index/detail/index_matcher.hpp

@@ -132 +132 @@
         entries(),entries()+size_,
         entry(node),entry::less_by_node()); /* localize entry */
     ent->ordered=false;
-    std::size_t n=ent->pos;                 /* get its position */
+    std::size_t epos=ent->pos;                 /* get its position */
 
     entry dummy(0);
-    dummy.pile_top=n;
+    dummy.pile_top=epos;
 
     entry* pile_ent=                        /* find the first available pile */
       std::lower_bound(                     /* to stack the entry            */
         entries(),entries()+num_piles,
         dummy,entry::less_by_pile_top());
 
-    pile_ent->pile_top=n;                   /* stack the entry */
+    pile_ent->pile_top=epos;                   /* stack the entry */
     pile_ent->pile_top_entry=ent;        
 
     /* if not the first pile, link entry to top of the preceding pile */
@@ -164 +164 @@
        */
 
       entry* ent=entries()[num_piles-1].pile_top_entry;
-      for(std::size_t n=num_piles;n--;){
+      for(std::size_t pnum=num_piles;pnum--;){
         ent->ordered=true;
         ent=ent->previous;
       }

boost/property_tree/detail/exception_implementation.hpp

@@ -30 +30 @@
     ///////////////////////////////////////////////////////////////////////////
     // ptree_error
 
-    inline ptree_error::ptree_error(const std::string &what): 
-        std::runtime_error(what) 
+    inline ptree_error::ptree_error(const std::string &p_what): 
+        std::runtime_error(p_what) 
     {
     }
 
@@ -43 +43 @@
     // ptree_bad_data
 
     template<class D> inline
-    ptree_bad_data::ptree_bad_data(const std::string &what, const D &data):
-        ptree_error(what), m_data(data)
+    ptree_bad_data::ptree_bad_data(const std::string &p_what, const D &p_data):
+        ptree_error(p_what), m_data(p_data)
     {
     }
 
@@ -62 +62 @@
     // ptree_bad_path
 
     template<class P> inline
-    ptree_bad_path::ptree_bad_path(const std::string &what, const P &path):
-        ptree_error(detail::prepare_bad_path_what(what, path)), m_path(path)
+    ptree_bad_path::ptree_bad_path(const std::string &p_what, const P &p_path):
+        ptree_error(detail::prepare_bad_path_what(p_what, p_path)), m_path(p_path)
     {
 
     }

boost/property_tree/detail/file_parser_error.hpp

@@ -26 +26 @@
         // Construction & destruction
 
         // Construct error
-        file_parser_error(const std::string &message,
-                          const std::string &filename,
-                          unsigned long line) :
-            ptree_error(format_what(message, filename, line)),
-            m_message(message), m_filename(filename), m_line(line)
+        file_parser_error(const std::string &p_message,
+                          const std::string &p_filename,
+                          unsigned long p_line) :
+            ptree_error(format_what(p_message, p_filename, p_line)),
+            m_message(p_message), m_filename(p_filename), m_line(p_line)
         {
         }
 
@@ -69 +69 @@
         unsigned long m_line;
 
         // Format error message to be returned by std::runtime_error::what()
-        std::string format_what(const std::string &message,
-                                const std::string &filename,
-                                unsigned long line)
+        std::string format_what(const std::string &p_message,
+                                const std::string &p_filename,
+                                unsigned long p_line)
         {
             std::stringstream stream;
-            if (line > 0)
-                stream << (filename.empty() ? "<unspecified file>"
-                                            : filename.c_str())
-                       << '(' << line << "): "
-                       << message;
+            if (p_line > 0)
+                stream << (p_filename.empty() ? "<unspecified file>"
+                                            : p_filename.c_str())
+                       << '(' << p_line << "): "
+                       << p_message;
             else
-                stream << (filename.empty() ? "<unspecified file>"
-                                            : filename.c_str())
-                       << ": " << message;
+                stream << (p_filename.empty() ? "<unspecified file>"
+                                            : p_filename.c_str())
+                       << ": " << p_message;
             return stream.str();
         }
 

boost/property_tree/detail/rapidxml.hpp

@@ -80 +80 @@
     public:
     
         //! Constructs parse error
-        parse_error(const char *what, void *where)
-            : m_what(what)
-            , m_where(where)
+        parse_error(const char *p_what, void *p_where)
+            : m_what(p_what)
+            , m_where(p_where)
         {
         }
 
@@ -724 +724 @@
         //! Use name(const Ch *) function to have the length automatically calculated (string must be zero terminated).
         //! \param name Name of node to set. Does not have to be zero terminated.
         //! \param size Size of name, in characters. This does not include zero terminator, if one is present.
-        void name(const Ch *name, std::size_t size)
+        void name(const Ch *p_name, std::size_t size)
         {
-            m_name = const_cast<Ch *>(name);
+            m_name = const_cast<Ch *>(p_name);
             m_name_size = size;
         }
 
         //! Sets name of node to a zero-terminated string.
         //! See also \ref ownership_of_strings and xml_node::name(const Ch *, std::size_t).
         //! \param name Name of node to set. Must be zero terminated.
-        void name(const Ch *name)
+        void name(const Ch *p_name)
         {
-            this->name(name, internal::measure(name));
+            this->name(p_name, internal::measure(p_name));
         }
 
         //! Sets value of node to a non zero-terminated string.
@@ -754 +754 @@
         //! If you want to manipulate data of elements using values, use parser flag rapidxml::parse_no_data_nodes to prevent creation of data nodes by the parser.
         //! \param value value of node to set. Does not have to be zero terminated.
         //! \param size Size of value, in characters. This does not include zero terminator, if one is present.
-        void value(const Ch *value, std::size_t size)
+        void value(const Ch *p_value, std::size_t size)
         {
-            m_value = const_cast<Ch *>(value);
+            m_value = const_cast<Ch *>(p_value);
             m_value_size = size;
         }
 
         //! Sets value of node to a zero-terminated string.
         //! See also \ref ownership_of_strings and xml_node::value(const Ch *, std::size_t).
         //! \param value Vame of node to set. Must be zero terminated.
-        void value(const Ch *value)
+        void value(const Ch *p_value)
         {
-            this->value(value, internal::measure(value));
+            this->value(p_value, internal::measure(p_value));
         }
 
         ///////////////////////////////////////////////////////////////////////////
@@ -839 +839 @@
         //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
         //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
         //! \return Pointer to found attribute, or 0 if not found.
-        xml_attribute<Ch> *previous_attribute(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
+        xml_attribute<Ch> *previous_attribute(const Ch *p_name = 0, std::size_t p_name_size = 0, bool case_sensitive = true) const
         {
-            if (name)
+            if (p_name)
             {
-                if (name_size == 0)
-                    name_size = internal::measure(name);
+                if (p_name_size == 0)
+                    p_name_size = internal::measure(p_name);
                 for (xml_attribute<Ch> *attribute = m_prev_attribute; attribute; attribute = attribute->m_prev_attribute)
-                    if (internal::compare(attribute->name(), attribute->name_size(), name, name_size, case_sensitive))
+                    if (internal::compare(attribute->name(), attribute->name_size(), p_name, p_name_size, case_sensitive))
                         return attribute;
                 return 0;
             }
@@ -859 +859 @@
         //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
         //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
         //! \return Pointer to found attribute, or 0 if not found.
-        xml_attribute<Ch> *next_attribute(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
+        xml_attribute<Ch> *next_attribute(const Ch *p_name = 0, std::size_t p_name_size = 0, bool case_sensitive = true) const
         {
-            if (name)
+            if (p_name)
             {
-                if (name_size == 0)
-                    name_size = internal::measure(name);
+                if (p_name_size == 0)
+                    p_name_size = internal::measure(p_name);
                 for (xml_attribute<Ch> *attribute = m_next_attribute; attribute; attribute = attribute->m_next_attribute)
-                    if (internal::compare(attribute->name(), attribute->name_size(), name, name_size, case_sensitive))
+                    if (internal::compare(attribute->name(), attribute->name_size(), p_name, p_name_size, case_sensitive))
                         return attribute;
                 return 0;
             }
@@ -904 +904 @@
         //! Constructs an empty node with the specified type. 
         //! Consider using memory_pool of appropriate document to allocate nodes manually.
         //! \param type Type of node to construct.
-        xml_node(node_type type)
-            : m_type(type)
+        xml_node(node_type p_type)
+            : m_type(p_type)
             , m_first_node(0)
             , m_first_attribute(0)
         {
@@ -939 +939 @@
         //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
         //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
         //! \return Pointer to found child, or 0 if not found.
-        xml_node<Ch> *first_node(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
+        xml_node<Ch> *first_node(const Ch *p_name = 0, std::size_t p_name_size = 0, bool case_sensitive = true) const
         {
-            if (name)
+            if (p_name)
             {
-                if (name_size == 0)
-                    name_size = internal::measure(name);
+                if (p_name_size == 0)
+                    p_name_size = internal::measure(p_name);
                 for (xml_node<Ch> *child = m_first_node; child; child = child->next_sibling())
-                    if (internal::compare(child->name(), child->name_size(), name, name_size, case_sensitive))
+                    if (internal::compare(child->name(), child->name_size(), p_name, p_name_size, case_sensitive))
                         return child;
                 return 0;
             }
@@ -961 +961 @@
         //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
         //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
         //! \return Pointer to found child, or 0 if not found.
-        xml_node<Ch> *last_node(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
+        xml_node<Ch> *last_node(const Ch *p_name = 0, std::size_t p_name_size = 0, bool case_sensitive = true) const
         {
             assert(m_first_node);  // Cannot query for last child if node has no children
-            if (name)
+            if (p_name)
             {
-                if (name_size == 0)
-                    name_size = internal::measure(name);
+                if (p_name_size == 0)
+                    p_name_size = internal::measure(p_name);
                 for (xml_node<Ch> *child = m_last_node; child; child = child->previous_sibling())
-                    if (internal::compare(child->name(), child->name_size(), name, name_size, case_sensitive))
+                    if (internal::compare(child->name(), child->name_size(), p_name, p_name_size, case_sensitive))
                         return child;
                 return 0;
             }
@@ -984 +984 @@
         //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
         //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
         //! \return Pointer to found sibling, or 0 if not found.
-        xml_node<Ch> *previous_sibling(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
+        xml_node<Ch> *previous_sibling(const Ch *p_name = 0, std::size_t p_name_size = 0, bool case_sensitive = true) const
         {
             assert(this->m_parent);     // Cannot query for siblings if node has no parent
-            if (name)
+            if (p_name)
             {
-                if (name_size == 0)
-                    name_size = internal::measure(name);
+                if (p_name_size == 0)
+                    p_name_size = internal::measure(p_name);
                 for (xml_node<Ch> *sibling = m_prev_sibling; sibling; sibling = sibling->m_prev_sibling)
-                    if (internal::compare(sibling->name(), sibling->name_size(), name, name_size, case_sensitive))
+                    if (internal::compare(sibling->name(), sibling->name_size(), p_name, p_name_size, case_sensitive))
                         return sibling;
                 return 0;
             }
@@ -1007 +1007 @@
         //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
         //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
         //! \return Pointer to found sibling, or 0 if not found.
-        xml_node<Ch> *next_sibling(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
+        xml_node<Ch> *next_sibling(const Ch *p_name = 0, std::size_t p_name_size = 0, bool case_sensitive = true) const
         {
             assert(this->m_parent);     // Cannot query for siblings if node has no parent
-            if (name)
+            if (p_name)
             {
-                if (name_size == 0)
-                    name_size = internal::measure(name);
+                if (p_name_size == 0)
+                    p_name_size = internal::measure(p_name);
                 for (xml_node<Ch> *sibling = m_next_sibling; sibling; sibling = sibling->m_next_sibling)
-                    if (internal::compare(sibling->name(), sibling->name_size(), name, name_size, case_sensitive))
+                    if (internal::compare(sibling->name(), sibling->name_size(), p_name, p_name_size, case_sensitive))
                         return sibling;
                 return 0;
             }
@@ -1028 +1028 @@
         //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
         //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
         //! \return Pointer to found attribute, or 0 if not found.
-        xml_attribute<Ch> *first_attribute(const Ch *name = 0, std::size_t name_size = 0, bool case_sensitive = true) const
+        xml_attribute<Ch> *first_attribute(const Ch *p_name = 0, std::size_t p_name_size = 0, bool case_sensitive = true) const
         {
-            if (name)
+            if (p_name)
             {
-                if (name_size == 0)
-                    name_size = internal::measure(name);
+                if (p_name_size == 0)
+                    p_name_size = internal::measure(p_name);
                 for (xml_attribute<Ch> *attribute = m_first_attribute; attribute; attribute = attribute->m_next_attribute)
-                    if (internal::compare(attribute->name(), attribute->name_size(), name, name_size, case_sensitive))
+                    if (internal::compare(attribute->name(), attribute->name_size(), p_name, p_name_size, case_sensitive))
                         return attribute;
                 return 0;
             }
@@ -1068 +1068 @@
     
         //! Sets type of node.
         //! \param type Type of node to set.
-        void type(node_type type)
+        void type(node_type p_type)
         {
-            m_type = type;
+            m_type = p_type;
         }
 
         ///////////////////////////////////////////////////////////////////////////
@@ -1793 +1793 @@
             }
 
             // Remember value start
-            Ch *value = text;
+            Ch *text_value = text;
 
             // Skip until end of comment
             while (text[0] != Ch('-') || text[1] != Ch('-') || text[2] != Ch('>'))
@@ -1805 +1805 @@
 
             // Create comment node
             xml_node<Ch> *comment = this->allocate_node(node_comment);
-            comment->value(value, text - value);
+            comment->value(text_value, text - text_value);
             
             // Place zero terminator after comment value
             if (!(Flags & parse_no_string_terminators))
@@ -1820 +1820 @@
         xml_node<Ch> *parse_doctype(Ch *&text)
         {
             // Remember value start
-            Ch *value = text;
+            Ch *text_value = text;
 
             // Skip to >
             while (*text != Ch('>'))
@@ -1842 +1842 @@
                             case Ch('['): ++depth; break;
                             case Ch(']'): --depth; break;
                             case 0: RAPIDXML_PARSE_ERROR("unexpected end of data", text);
+                                                                                                                default: break;
                         }
                         ++text;
                     }
@@ -1864 +1865 @@
             {
                 // Create a new doctype node
                 xml_node<Ch> *doctype = this->allocate_node(node_doctype);
-                doctype->value(value, text - value);
+                doctype->value(text_value, text - text_value);
                 
                 // Place zero terminator after value
                 if (!(Flags & parse_no_string_terminators))
@@ -1892 +1893 @@
                 xml_node<Ch> *pi = this->allocate_node(node_pi);
 
                 // Extract PI target name
-                Ch *name = text;
+                Ch *text_name = text;
                 skip<node_name_pred, Flags>(text);
-                if (text == name)
+                if (text == text_name)
                     RAPIDXML_PARSE_ERROR("expected PI target", text);
-                pi->name(name, text - name);
+                pi->name(text_name, text - text_name);
                 
                 // Skip whitespace between pi target and pi
                 skip<whitespace_pred, Flags>(text);
 
                 // Remember start of pi
-                Ch *value = text;
+                Ch *text_value = text;
                 
                 // Skip to '?>'
                 while (text[0] != Ch('?') || text[1] != Ch('>'))
@@ -1913 +1914 @@
                 }
 
                 // Set pi value (verbatim, no entity expansion or whitespace normalization)
-                pi->value(value, text - value);     
+                pi->value(text_value, text - text_value);     
                 
                 // Place zero terminator after name and value
                 if (!(Flags & parse_no_string_terminators))
@@ -1950 +1951 @@
                 text = contents_start;     
             
             // Skip until end of data
-            Ch *value = text, *end;
+            Ch *text_value = text, *end;
             if (Flags & parse_normalize_whitespace)
                 end = skip_and_expand_character_refs<text_pred, text_pure_with_ws_pred, Flags>(text);   
             else
@@ -1978 +1979 @@
             if (!(Flags & parse_no_data_nodes))
             {
                 xml_node<Ch> *data = this->allocate_node(node_data);
-                data->value(value, end - value);
+                data->value(text_value, end - text_value);
                 node->append_node(data);
             }
 
             // Add data to parent node if no data exists yet
             if (!(Flags & parse_no_element_values)) 
                 if (*node->value() == Ch('\0'))
-                    node->value(value, end - value);
+                    node->value(text_value, end - text_value);
 
             // Place zero terminator after value
             if (!(Flags & parse_no_string_terminators))
@@ -2018 +2019 @@
             }
 
             // Skip until end of cdata
-            Ch *value = text;
+            Ch *text_value = text;
             while (text[0] != Ch(']') || text[1] != Ch(']') || text[2] != Ch('>'))
             {
                 if (!text[0])
@@ -2028 +2029 @@
 
             // Create new cdata node
             xml_node<Ch> *cdata = this->allocate_node(node_cdata);
-            cdata->value(value, text - value);
+            cdata->value(text_value, text - text_value);
 
             // Place zero terminator after value
             if (!(Flags & parse_no_string_terminators))
@@ -2046 +2047 @@
             xml_node<Ch> *element = this->allocate_node(node_element);
 
             // Extract element name
-            Ch *name = text;
+            Ch *text_name = text;
             skip<node_name_pred, Flags>(text);
-            if (text == name)
+            if (text == text_name)
                 RAPIDXML_PARSE_ERROR("expected element name", text);
-            element->name(name, text - name);
+            element->name(text_name, text - text_name);
             
             // Skip whitespace between element name and attributes or >
             skip<whitespace_pred, Flags>(text);
@@ -2151 +2152 @@
                         text += 9;      // skip '!DOCTYPE '
                         return parse_doctype<Flags>(text);
                     }
+                                                                default: break;
 
                 }   // switch
 
@@ -2247 +2249 @@
             while (attribute_name_pred::test(*text))
             {
                 // Extract attribute name
-                Ch *name = text;
+                Ch *text_name = text;
                 ++text;     // Skip first character of attribute name
                 skip<attribute_name_pred, Flags>(text);
-                if (text == name)
-                    RAPIDXML_PARSE_ERROR("expected attribute name", name);
+                if (text == text_name)
+                    RAPIDXML_PARSE_ERROR("expected attribute name", text_name);
 
                 // Create new attribute
                 xml_attribute<Ch> *attribute = this->allocate_attribute();
-                attribute->name(name, text - name);
+                attribute->name(text_name, text - text_name);
                 node->append_attribute(attribute);
 
                 // Skip whitespace after attribute name
@@ -2280 +2282 @@
                 ++text;
 
                 // Extract attribute value and expand char refs in it
-                Ch *value = text, *end;
+                Ch *text_value = text, *end;
                 const int AttFlags = Flags & ~parse_normalize_whitespace;   // No whitespace normalization in attributes
                 if (quote == Ch('\''))
                     end = skip_and_expand_character_refs<attribute_value_pred<Ch('\'')>, attribute_value_pure_pred<Ch('\'')>, AttFlags>(text);
@@ -2288 +2290 @@
                     end = skip_and_expand_character_refs<attribute_value_pred<Ch('"')>, attribute_value_pure_pred<Ch('"')>, AttFlags>(text);
                 
                 // Set attribute value
-                attribute->value(value, end - value);
+                attribute->value(text_value, end - text_value);
                 
                 // Make sure that end quote is present
                 if (*text != quote)

boost/property_tree/detail/ptree_implementation.hpp

@@ -161 +161 @@
     }
 
     template<class K, class D, class C> inline
-    basic_ptree<K, D, C>::basic_ptree(const data_type &data)
-        : m_data(data), m_children(new typename subs::base_container)
+    basic_ptree<K, D, C>::basic_ptree(const data_type &p_data)
+        : m_data(p_data), m_children(new typename subs::base_container)
     {
     }
 

boost/property_tree/detail/xml_parser_error.hpp

@@ -20 +20 @@
     class xml_parser_error: public file_parser_error
     {
     public:
-        xml_parser_error(const std::string &message, 
-                         const std::string &filename, 
-                         unsigned long line): 
-            file_parser_error(message, filename, line)
+        xml_parser_error(const std::string &p_message, 
+                         const std::string &p_filename, 
+                         unsigned long p_line): 
+            file_parser_error(p_message, p_filename, p_line)
         {
         }
     };

boost/property_tree/detail/xml_parser_writer_settings.hpp

@@ -35 +35 @@
     class xml_writer_settings
     {
     public:
-        xml_writer_settings(Ch indent_char = Ch(' '),
-                typename std::basic_string<Ch>::size_type indent_count = 0,
-                const std::basic_string<Ch> &encoding = widen<Ch>("utf-8"))
-            : indent_char(indent_char)
-            , indent_count(indent_count)
-            , encoding(encoding)
+        xml_writer_settings(Ch p_indent_char = Ch(' '),
+                typename std::basic_string<Ch>::size_type p_indent_count = 0,
+                const std::basic_string<Ch> &p_encoding = widen<Ch>("utf-8"))
+            : indent_char(p_indent_char)
+            , indent_count(p_indent_count)
+            , encoding(p_encoding)
         {
         }
 

boost/exception/exception.hpp

@@ -411 +411 @@
 
             void
             rethrow() const
+#if BOOST_WORKAROUND(__GNUC__, >= 3)
+                                                __attribute__((noreturn))
+#endif
                 {
                 throw*this;
                 }

boost/multi_index_container.hpp

@@ -360 +360 @@
     IteratorType it
     BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N))
   {
-    typedef typename nth_index<N>::type index;
+    typedef typename nth_index<N>::type n_index;
 
 #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
     BOOST_STATIC_ASSERT(
@@ -371 +371 @@
     BOOST_MULTI_INDEX_CHECK_IS_OWNER(
       it,static_cast<typename IteratorType::container_type&>(*this));
 
-    return index::make_iterator(static_cast<node_type*>(it.get_node()));
+    return n_index::make_iterator(static_cast<node_type*>(it.get_node()));
   }
 
   template<int N,typename IteratorType>
@@ -379 +379 @@
     IteratorType it
     BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N))const
   {
-    typedef typename nth_index<N>::type index;
+    typedef typename nth_index<N>::type n_index;
 
 #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
     BOOST_STATIC_ASSERT((
@@ -390 +390 @@
     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
     BOOST_MULTI_INDEX_CHECK_IS_OWNER(
       it,static_cast<const typename IteratorType::container_type&>(*this));
-    return index::make_iterator(static_cast<node_type*>(it.get_node()));
+    return n_index::make_iterator(static_cast<node_type*>(it.get_node()));
   }
 #endif
 
@@ -414 +414 @@
     IteratorType it
     BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))
   {
-    typedef typename index<Tag>::type index;
+    typedef typename index<Tag>::type tag_index;
 
 #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
     BOOST_STATIC_ASSERT(
@@ -424 +424 @@
     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
     BOOST_MULTI_INDEX_CHECK_IS_OWNER(
       it,static_cast<typename IteratorType::container_type&>(*this));
-    return index::make_iterator(static_cast<node_type*>(it.get_node()));
+    return tag_index::make_iterator(static_cast<node_type*>(it.get_node()));
   }
 
   template<typename Tag,typename IteratorType>
@@ -432 +432 @@
     IteratorType it
     BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))const
   {
-    typedef typename index<Tag>::type index;
+    typedef typename index<Tag>::type tag_index;
 
 #if !defined(__SUNPRO_CC)||!(__SUNPRO_CC<0x580) /* fails in Sun C++ 5.7 */
     BOOST_STATIC_ASSERT((
@@ -443 +443 @@
     BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it);
     BOOST_MULTI_INDEX_CHECK_IS_OWNER(
       it,static_cast<const typename IteratorType::container_type&>(*this));
-    return index::make_iterator(static_cast<node_type*>(it.get_node()));
+    return tag_index::make_iterator(static_cast<node_type*>(it.get_node()));
   }
 #endif
 

boost/test/utils/lazy_ostream.hpp

@@ -45 +45 @@
     // actual printing interface; to be accessed only by this class and children
     virtual std::ostream&   operator()( std::ostream& ostr ) const                  { return ostr; }
 protected:
-    explicit                lazy_ostream( bool empty = true ) : m_empty( empty )    {}
+    explicit                lazy_ostream( bool p_empty = true ) : m_empty( p_empty )    {}
 
     // protected destructor to make sure right one is called
 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))