Partial support for BOOST_NO_EXCEPTIONS:

Some stream operations are modified to use a
helper function which supports BOOST_NO_EXCEPTIONS.

CHANGELOG.md

@@ -3,6 +3,7 @@ Version 187:
 * Add experimental timeout_socket
 * Fix warning in file tests
 * Fix uninitialized comparison in buffers iterator
+* Partial support for BOOST_NO_EXCEPTIONS
 
 --------------------------------------------------------------------------------
 

doc/qbk/09_releases.qbk

@@ -35,6 +35,8 @@
 
 * Workaround for http-server-fast and libstdc++
 
+* Partial support for `BOOST_NO_EXCEPTIONS`
+
 [*Experimental]
 
 * Add [link beast.ref.boost__beast__timeout_socket `timeout_socket`]

include/boost/beast/http/basic_dynamic_body.hpp

@@ -12,6 +12,7 @@
 
 #include <boost/beast/core/detail/config.hpp>
 #include <boost/beast/core/type_traits.hpp>
+#include <boost/beast/core/detail/buffer.hpp>
 #include <boost/beast/http/error.hpp>
 #include <boost/beast/http/message.hpp>
 #include <boost/optional.hpp>
@@ -95,21 +96,15 @@ struct basic_dynamic_body
                 ec = error::buffer_overflow;
                 return 0;
             }
-            boost::optional<typename
+            auto const mb =
-                DynamicBuffer::mutable_buffers_type> b;
+                beast::detail::dynamic_buffer_prepare(
-            try
+                    body_, (std::min)(n,
-            {
+                        body_.max_size() - body_.size()),
-                b.emplace(body_.prepare((std::min)(n,
+                            ec, error::buffer_overflow);
-                    body_.max_size() - body_.size())));
+            if(ec)
-            }
-            catch(std::length_error const&)
-            {
-                ec = error::buffer_overflow;
                 return 0;
-            }
-            ec.assign(0, ec.category());
             auto const bytes_transferred =
-                buffer_copy(*b, buffers);
+                buffer_copy(*mb, buffers);
             body_.commit(bytes_transferred);
             return bytes_transferred;
         }

include/boost/beast/http/impl/read.ipp

@@ -18,6 +18,7 @@
 #include <boost/beast/core/handler_ptr.hpp>
 #include <boost/beast/core/read_size.hpp>
 #include <boost/beast/core/type_traits.hpp>
+#include <boost/beast/core/detail/buffer.hpp>
 #include <boost/asio/associated_allocator.hpp>
 #include <boost/asio/associated_executor.hpp>
 #include <boost/asio/coroutine.hpp>
@@ -121,8 +122,6 @@ operator()(
     bool cont)
 {
     cont_ = cont;
-    boost::optional<typename
-        DynamicBuffer::mutable_buffers_type> mb;
     BOOST_ASIO_CORO_REENTER(*this)
     {
         if(b_.size() == 0)
@@ -139,18 +138,22 @@ operator()(
                 break;
 
         do_read:
-            try
-            {
-                mb.emplace(b_.prepare(
-                    read_size_or_throw(b_, 65536)));
-            }
-            catch(std::length_error const&)
-            {
-                ec = error::buffer_overflow;
-                break;
-            }
             BOOST_ASIO_CORO_YIELD
-            s_.async_read_some(*mb, std::move(*this));
+            {
+                // VFALCO This was read_size_or_throw
+                auto const size = read_size(b_, 65536);
+                if(size == 0)
+                {
+                    ec = error::buffer_overflow;
+                    goto upcall;
+                }
+                auto const mb =
+                    beast::detail::dynamic_buffer_prepare(
+                        b_, size, ec, error::buffer_overflow);
+                if(ec)
+                    goto upcall;
+                s_.async_read_some(*mb, std::move(*this));
+            }
             if(ec == boost::asio::error::eof)
             {
                 BOOST_ASSERT(bytes_transferred == 0);
@@ -513,19 +516,18 @@ read_some(
                 break;
         }
     do_read:
-        boost::optional<typename
+        auto const size = read_size(buffer, 65536);
-            DynamicBuffer::mutable_buffers_type> b;
+        if(size == 0)
-        try
-        {
-            b.emplace(buffer.prepare(
-                read_size_or_throw(buffer, 65536)));
-        }
-        catch(std::length_error const&)
         {
             ec = error::buffer_overflow;
-            return bytes_transferred;
+            break;
         }
-        auto const n = stream.read_some(*b, ec);
+        auto const mb =
+            beast::detail::dynamic_buffer_prepare(
+                buffer, size, ec, error::buffer_overflow);
+        if(ec)
+            break;
+        auto const n = stream.read_some(*mb, ec);
         if(ec == boost::asio::error::eof)
         {
             BOOST_ASSERT(n == 0);

include/boost/beast/websocket/impl/accept.ipp

@@ -18,6 +18,7 @@
 #include <boost/beast/http/write.hpp>
 #include <boost/beast/core/buffers_prefix.hpp>
 #include <boost/beast/core/handler_ptr.hpp>
+#include <boost/beast/core/detail/buffer.hpp>
 #include <boost/beast/core/detail/type_traits.hpp>
 #include <boost/asio/coroutine.hpp>
 #include <boost/asio/associated_allocator.hpp>
@@ -244,20 +245,12 @@ run(Buffers const& buffers)
     using boost::asio::buffer_size;
     auto& d = *d_;
     error_code ec;
-    boost::optional<typename
+    auto const mb = beast::detail::dynamic_buffer_prepare(
-        static_buffer_base::mutable_buffers_type> mb;
+        d.ws.rd_buf_, buffer_size(buffers), ec,
-    auto const len = buffer_size(buffers);
+            error::buffer_overflow);
-    try
+    if(ec)
-    {
-        mb.emplace(d.ws.rd_buf_.prepare(len));
-    }
-    catch(std::length_error const&)
-    {
-        ec = error::buffer_overflow;
         return (*this)(ec);
-    }
+    d.ws.rd_buf_.commit(buffer_copy(*mb, buffers));
-    d.ws.rd_buf_.commit(
-        buffer_copy(*mb, buffers));
     (*this)(ec);
 }
 
@@ -432,20 +425,12 @@ accept(
     using boost::asio::buffer_copy;
     using boost::asio::buffer_size;
     reset();
-    boost::optional<typename
+    auto const mb = beast::detail::dynamic_buffer_prepare(
-        static_buffer_base::mutable_buffers_type> mb;
+        rd_buf_, buffer_size(buffers), ec,
-    try
+            error::buffer_overflow);
-    {
+    if(ec)
-        mb.emplace(rd_buf_.prepare(
-            buffer_size(buffers)));
-    }
-    catch(std::length_error const&)
-    {
-        ec = error::buffer_overflow;
         return;
-    }
+    rd_buf_.commit(buffer_copy(*mb, buffers));
-    rd_buf_.commit(
-        buffer_copy(*mb, buffers));
     do_accept(&default_decorate_res, ec);
 }
 
@@ -472,18 +457,11 @@ accept_ex(
     using boost::asio::buffer_copy;
     using boost::asio::buffer_size;
     reset();
-    boost::optional<typename
+    auto const mb = beast::detail::dynamic_buffer_prepare(
-        static_buffer_base::mutable_buffers_type> mb;
+        rd_buf_, buffer_size(buffers), ec,
-    try
+            error::buffer_overflow);
-    {
+    if(ec)
-        mb.emplace(rd_buf_.prepare(
-            buffer_size(buffers)));
-    }
-    catch(std::length_error const&)
-    {
-        ec = error::buffer_overflow;
         return;
-    }
     rd_buf_.commit(buffer_copy(*mb, buffers));
     do_accept(decorator, ec);
 }

include/boost/beast/websocket/impl/read.ipp

@@ -16,6 +16,7 @@
 #include <boost/beast/core/buffers_suffix.hpp>
 #include <boost/beast/core/flat_static_buffer.hpp>
 #include <boost/beast/core/type_traits.hpp>
+#include <boost/beast/core/detail/buffer.hpp>
 #include <boost/beast/core/detail/clamp.hpp>
 #include <boost/beast/core/detail/config.hpp>
 #include <boost/asio/associated_allocator.hpp>
@@ -800,35 +801,27 @@ operator()(
     std::size_t bytes_transferred)
 {
     using beast::detail::clamp;
-    using buffers_type = typename
-        DynamicBuffer::mutable_buffers_type;
-    boost::optional<buffers_type> mb;
     BOOST_ASIO_CORO_REENTER(*this)
     {
         do
         {
-            try
-            {
-                mb.emplace(b_.prepare(clamp(
-                    ws_.read_size_hint(b_), limit_)));
-            }
-            catch(std::length_error const&)
-            {
-                ec = error::buffer_overflow;
-            }
-            if(ec)
-            {
-                BOOST_ASIO_CORO_YIELD
-                boost::asio::post(
-                    ws_.get_executor(),
-                    bind_handler(std::move(*this),
-                        error::buffer_overflow, 0));
-                break;
-            }
             BOOST_ASIO_CORO_YIELD
-            read_some_op<buffers_type, read_op>{
+            {
-                std::move(*this), ws_, *mb}(
+                auto mb = beast::detail::dynamic_buffer_prepare(b_,
-                    {}, 0, false);
+                    clamp(ws_.read_size_hint(b_), limit_),
+                        ec, error::buffer_overflow);
+                if(ec)
+                    boost::asio::post(
+                        ws_.get_executor(),
+                        bind_handler(
+                            std::move(*this), ec, 0));
+                else
+                    read_some_op<typename
+                        DynamicBuffer::mutable_buffers_type,
+                            read_op>(std::move(*this), ws_, *mb)(
+                                {}, 0, false);
+                return;
+            }
             if(ec)
                 break;
             b_.commit(bytes_transferred);
@@ -950,17 +943,10 @@ read_some(
     auto const size =
         clamp(read_size_hint(buffer), limit);
     BOOST_ASSERT(size > 0);
-    boost::optional<typename
+    auto mb = beast::detail::dynamic_buffer_prepare(
-        DynamicBuffer::mutable_buffers_type> mb;
+        buffer, size, ec, error::buffer_overflow);
-    try
+    if(ec)
-    {
-        mb.emplace(buffer.prepare(size));
-    }
-    catch(std::length_error const&)
-    {
-        ec = error::buffer_overflow;
         return 0;
-    }
     auto const bytes_written = read_some(*mb, ec);
     buffer.commit(bytes_written);
     return bytes_written;