Ticket #11508: boost_1_59_0.iostreams.wshadow.patch

boost/iostreams/detail/buffer.hpp

@@ -179 +179 @@
     : basic_buffer<Ch, Alloc>(buffer_size) { }
 
 template<typename Ch, typename Alloc>
-inline void buffer<Ch, Alloc>::set(std::streamsize ptr, std::streamsize end)
+inline void buffer<Ch, Alloc>::set(std::streamsize ptr_arg, std::streamsize end)
 { 
-    ptr_ = data() + ptr; 
+    ptr_ = data() + ptr_arg; 
     eptr_ = data() + end; 
 }
 

boost/iostreams/filter/gzip.hpp

@@ -135 +135 @@
 struct gzip_params : zlib_params {
 
     // Non-explicit constructor.
-    gzip_params( int level              = gzip::default_compression,
-                 int method             = gzip::deflated,
-                 int window_bits        = gzip::default_window_bits,
-                 int mem_level          = gzip::default_mem_level,
-                 int strategy           = gzip::default_strategy,
-                 std::string file_name  = "",
-                 std::string comment    = "",
-                 std::time_t mtime      = 0 )
-        : zlib_params(level, method, window_bits, mem_level, strategy),
-          file_name(file_name), comment(comment), mtime(mtime)
+    gzip_params( int level_              = gzip::default_compression,
+                 int method_             = gzip::deflated,
+                 int window_bits_        = gzip::default_window_bits,
+                 int mem_level_          = gzip::default_mem_level,
+                 int strategy_           = gzip::default_strategy,
+                 std::string file_name_  = "",
+                 std::string comment_    = "",
+                 std::time_t mtime_      = 0 )
+        : zlib_params(level_, method_, window_bits_, mem_level_, strategy_),
+          file_name(file_name_), comment(comment_), mtime(mtime_)
         { }
     std::string  file_name;
     std::string  comment;
@@ -160 +160 @@
 //
 class gzip_error : public BOOST_IOSTREAMS_FAILURE {
 public:
-    explicit gzip_error(int error)
+    explicit gzip_error(int error_arg)
         : BOOST_IOSTREAMS_FAILURE("gzip error"),
-          error_(error), zlib_error_code_(zlib::okay) { }
+          error_(error_arg), zlib_error_code_(zlib::okay) { }
     explicit gzip_error(const zlib_error& e)
         : BOOST_IOSTREAMS_FAILURE("gzip error"),
           error_(gzip::zlib_error), zlib_error_code_(e.error())
@@ -505 +505 @@
                 if (footer_.done()) {
                     if (footer_.crc() != this->crc())
                         boost::throw_exception(gzip_error(gzip::bad_crc));
-                    int c = boost::iostreams::get(peek);
-                    if (traits_type::is_eof(c)) {
+                    int c2 = boost::iostreams::get(peek);
+                    if (traits_type::is_eof(c2)) {
                         state_ = s_done;
                     } else {
                         peek.putback(c);
@@ -567 +567 @@
     struct peekable_source {
         typedef char char_type;
         struct category : source_tag, peekable_tag { };
-        explicit peekable_source(Source& src, const string_type& putback = "") 
-            : src_(src), putback_(putback), offset_(0)
+        explicit peekable_source(Source& src, const string_type& putback_arg = "") 
+            : src_(src), putback_(putback_arg), offset_(0)
             { }
         std::streamsize read(char* s, std::streamsize n)
         {

boost/iostreams/filter/symmetric.hpp

@@ -102 +102 @@
         if (!(state() & f_read))
             begin_read();
 
-        buffer_type&  buf = pimpl_->buf_;
+        buffer_type&  buf_l = pimpl_->buf_;
         int           status = (state() & f_eof) != 0 ? f_eof : f_good;
         char_type    *next_s = s,
                      *end_s = s + n;
@@ -110 +110 @@
         {
             // Invoke filter if there are unconsumed characters in buffer or if
             // filter must be flushed.
-            bool flush = status == f_eof;
-            if (buf.ptr() != buf.eptr() || flush) {
-                const char_type* next = buf.ptr();
+            bool flush_l = status == f_eof;
+            if (buf_l.ptr() != buf_l.eptr() || flush_l) {
+                const char_type* next = buf_l.ptr();
                 bool done =
-                    !filter().filter(next, buf.eptr(), next_s, end_s, flush);
-                buf.ptr() = buf.data() + (next - buf.data());
+                    !filter().filter(next, buf_l.eptr(), next_s, end_s, flush_l);
+                buf_l.ptr() = buf_l.data() + (next - buf_l.data());
                 if (done)
                     return detail::check_eof(
                                static_cast<std::streamsize>(next_s - s)
@@ -124 +124 @@
 
             // If no more characters are available without blocking, or
             // if read request has been satisfied, return.
-            if ( (status == f_would_block && buf.ptr() == buf.eptr()) ||
+            if ( (status == f_would_block && buf_l.ptr() == buf_l.eptr()) ||
                  next_s == end_s )
             {
                 return static_cast<std::streamsize>(next_s - s);
@@ -142 +142 @@
         if (!(state() & f_write))
             begin_write();
 
-        buffer_type&     buf = pimpl_->buf_;
+        buffer_type&     buf_l = pimpl_->buf_;
         const char_type *next_s, *end_s;
         for (next_s = s, end_s = s + n; next_s != end_s; ) {
-            if (buf.ptr() == buf.eptr() && !flush(snk))
+            if (buf_l.ptr() == buf_l.eptr() && !flush(snk))
                 break;
-            if(!filter().filter(next_s, end_s, buf.ptr(), buf.eptr(), false)) {
+            if(!filter().filter(next_s, end_s, buf_l.ptr(), buf_l.eptr(), false)) {
                 flush(snk);
                 break;
             }
@@ -165 +165 @@
 
             // Repeatedly invoke filter() with no input.
             try {
-                buffer_type&     buf = pimpl_->buf_;
+                buffer_type&     buf_l = pimpl_->buf_;
                 char_type        dummy;
                 const char_type* end = &dummy;
                 bool             again = true;
                 while (again) {
-                    if (buf.ptr() != buf.eptr())
-                        again = filter().filter( end, end, buf.ptr(),
-                                                 buf.eptr(), true );
+                    if (buf_l.ptr() != buf_l.eptr())
+                        again = filter().filter( end, end, buf_l.ptr(),
+                                                 buf_l.eptr(), true );
                     flush(snk);
                 }
             } catch (...) {

boost/iostreams/filter/zlib.hpp

@@ -110 +110 @@
 struct zlib_params {
 
     // Non-explicit constructor.
-    zlib_params( int level           = zlib::default_compression,
-                 int method          = zlib::deflated,
-                 int window_bits     = zlib::default_window_bits, 
-                 int mem_level       = zlib::default_mem_level, 
-                 int strategy        = zlib::default_strategy,
-                 bool noheader       = zlib::default_noheader,
-                 bool calculate_crc  = zlib::default_crc )
-        : level(level), method(method), window_bits(window_bits),
-          mem_level(mem_level), strategy(strategy),  
-          noheader(noheader), calculate_crc(calculate_crc)
+    zlib_params( int level_           = zlib::default_compression,
+                 int method_          = zlib::deflated,
+                 int window_bits_     = zlib::default_window_bits, 
+                 int mem_level_       = zlib::default_mem_level, 
+                 int strategy_        = zlib::default_strategy,
+                 bool noheader_       = zlib::default_noheader,
+                 bool calculate_crc_  = zlib::default_crc )
+        : level(level_), method(method_), window_bits(window_bits_),
+          mem_level(mem_level_), strategy(strategy_),  
+          noheader(noheader_), calculate_crc(calculate_crc_)
         { }
     int level;
     int method;

libs/iostreams/src/zlib.cpp

@@ -67 +67 @@
 
 //------------------Implementation of zlib_error------------------------------//
                     
-zlib_error::zlib_error(int error) 
-    : BOOST_IOSTREAMS_FAILURE("zlib error"), error_(error) 
+zlib_error::zlib_error(int error_arg) 
+    : BOOST_IOSTREAMS_FAILURE("zlib error"), error_(error_arg) 
     { }
 
 void zlib_error::check BOOST_PREVENT_MACRO_SUBSTITUTION(int error)