Merge remote-tracking branch 'upstream/development' into development

Author: Valtteri Heikkila

Release/include/cpprest/astreambuf.h

@@ -969,7 +969,9 @@ namespace Concurrency { namespace streams
         /// <param name="mode">The I/O mode (in or out) to close for.</param>
         virtual pplx::task<void> close(std::ios_base::openmode mode = (std::ios_base::in | std::ios_base::out))
         {
-            return get_base()->close(mode);
+            // We preserve the check here to workaround a Dev10 compiler crash
+            auto buffer = get_base();
+            return buffer ? buffer->close(mode) : pplx::task_from_result(); 
         }
 
         /// <summary>
@@ -979,7 +981,9 @@ namespace Concurrency { namespace streams
         /// <param name="eptr">Pointer to the exception.</param>
         virtual pplx::task<void> close(std::ios_base::openmode mode, std::exception_ptr eptr)
         {
-            return get_base()->close(mode, eptr);
+            // We preserve the check here to workaround a Dev10 compiler crash
+            auto buffer = get_base();
+            return buffer ? buffer->close(mode, eptr) : pplx::task_from_result(); 
         }
 
         /// <summary>

Release/include/cpprest/asyncrt_utils.h

@@ -148,11 +148,6 @@ namespace conversions
     /// </summary>
     _ASYNCRTIMP std::vector<unsigned char> __cdecl from_base64(const utility::string_t& str);
 
-    /// <summary>
-    /// Converts a type that supports the stream operator << to a string.
-    /// </summary>
-    /// <param name="val">Value to convert to a string.</param>
-    /// <returns>String representation of the value</returns>
     template <typename Source>
     utility::string_t print_string(const Source &val)
     {
@@ -162,12 +157,6 @@ namespace conversions
             throw std::bad_cast();
         return oss.str();
     }
-
-    /// <summary>
-    /// Creates a type from a string using the stream operator >>.
-    /// </summary>
-    /// <param name="str">String to create type from.</param>
-    /// <returns>An instance of type Target.</returns>
     template <typename Target>
     Target scan_string(const utility::string_t &str)
     {

Release/include/cpprest/filestream.h

@@ -222,13 +222,12 @@ namespace details {
             return pplx::create_task(result_tce);
         }
 
-        pplx::task<void> _close_read()
+            // Use a separated function for working around Dev10's ICE
+            pplx::task<void> _close_read_impl()
         {
-            return m_readOps.enqueue_operation([this]()
-            {
                 streambuf_state_manager<_CharType>::_close_read();
 
-                if (this->can_write())
+                if (this->can_write()) 
                 {
                     return pplx::task_from_result();
                 }
@@ -240,7 +239,11 @@ namespace details {
 
                     return _close_file(fileInfo);
                 }
-            });
+        }
+
+        pplx::task<void> _close_read()
+        {
+            return m_readOps.enqueue_operation([this] { return _close_read_impl(); });
         }
 
         pplx::task<void> _close_write()

Release/include/cpprest/streams.h

@@ -951,25 +951,19 @@ namespace Concurrency { namespace streams
             if ( !target.can_write() )
                 return pplx::task_from_exception<size_t>(std::make_exception_ptr(std::runtime_error("source buffer not set up for input of data")));
 
+            // Capture 'buffer' rather than 'helper' here due to VC++ 2010 limitations.
+            auto buffer = helper()->m_buffer;
+
             std::shared_ptr<_read_helper> _locals = std::make_shared<_read_helper>();
-            return pplx::details::do_while([=]() mutable
-            {
-                return helper()->m_buffer.getn(_locals->outbuf, buf_size).then([=](size_t rd) mutable
-                {
-                    if (rd == 0) return pplx::task_from_result(false);
-                    return target.putn(_locals->outbuf, rd).then([=](size_t wr) mutable
-                    {
-                        _locals->total += wr;
-                        return target.sync();
-                    }).then([]()
-                    {
-                        return true;
-                    });
+
+            _dev10_ice_workaround wrkarnd(buffer, target, _locals, buf_size);
+
+            auto loop = pplx::details::do_while(wrkarnd);
+
+            return loop.then([=](bool) mutable -> size_t
+                { 
+                    return _locals->total; 
                 });
-            }).then([=](bool) mutable -> size_t
-            {
-                return _locals->total;
-            });
         }
 
         /// <summary>
@@ -1107,6 +1101,48 @@ namespace Concurrency { namespace streams
             {
             }
         };
+
+        // To workaround a VS 2010 internal compiler error, we have to do our own
+        // "lambda" here...
+        class _dev10_ice_workaround
+        {
+        public:
+            _dev10_ice_workaround(streams::streambuf<CharType> buffer,
+                                  concurrency::streams::streambuf<CharType> target,
+                                  std::shared_ptr<typename basic_istream::_read_helper> locals,
+                                  size_t buf_size)
+            : _buffer(buffer), _target(target), _locals(locals), _buf_size(buf_size)
+            {
+            }
+            pplx::task<bool> operator()()
+            {
+                // We need to capture these, because the object itself may go away
+                // before we're done processing the data.
+                auto locs = _locals;
+                auto trg = _target;
+                
+                auto after_putn =
+                [=](size_t wr) mutable -> bool
+                {
+                    locs->total += wr;
+                    trg.sync().wait();
+                    return true;
+                };
+                
+                return _buffer.getn(locs->outbuf, buf_size).then(
+                                                                 [=] (size_t rd) mutable -> pplx::task<bool>
+                                                                 {
+                                                                     if ( rd == 0 )
+                                                                         return pplx::task_from_result(false);
+                                                                     return trg.putn(locs->outbuf, rd).then(after_putn);
+                                                                 });
+            }
+        private:
+            size_t _buf_size;
+            concurrency::streams::streambuf<CharType> _buffer;
+            concurrency::streams::streambuf<CharType> _target;
+            std::shared_ptr<typename basic_istream::_read_helper> _locals;
+        };
 
         std::shared_ptr<details::basic_istream_helper<CharType>> m_helper;
     };