couchbase 3.0.0-universal-darwin-19 → 3.0.1-universal-darwin-19

data/ext/third_party/gsl/include/gsl/string_span

@@ -36,11 +36,6 @@
 #pragma warning(disable : 26446) // TODO: bug in parser - attributes and templates
 #pragma warning(disable : 26481) // TODO: suppress does not work inside templates sometimes
 
-#if _MSC_VER < 1910
-#pragma push_macro("constexpr")
-#define constexpr /*constexpr*/
-
-#endif // _MSC_VER < 1910
 #endif // _MSC_VER
 
 namespace gsl
@@ -86,7 +81,7 @@ using u32zstring = basic_zstring<char32_t, Extent>;
 namespace details
 {
     template <class CharT>
-    std::size_t string_length(const CharT* str, std::size_t n)
+    constexpr std::size_t string_length(const CharT* str, std::size_t n)
     {
         if (str == nullptr || n == dynamic_extent) return 0;
 
@@ -108,7 +103,7 @@ namespace details
 // Will fail-fast if sentinel cannot be found before max elements are examined.
 //
 template <typename T, const T Sentinel>
-span<T, dynamic_extent> ensure_sentinel(T* seq,
+constexpr span<T, dynamic_extent> ensure_sentinel(T* seq,
                                         std::size_t max = static_cast<std::size_t>(-1))
 {
     Ensures(seq != nullptr);
@@ -125,25 +120,24 @@ span<T, dynamic_extent> ensure_sentinel(T* seq,
 }
 
 //
-// ensure_z - creates a span for a zero terminated strings.
-// Will fail fast if a null-terminator cannot be found before
-// the limit of size_type.
+// ensure_z - creates a span for a zero terminated strings. The span will not contain the zero termination.
+// Will fail fast if a null-terminator cannot be found before the limit of size_type.
 //
 template <typename CharT>
-span<CharT, dynamic_extent> ensure_z(CharT* const& sz,
+constexpr span<CharT, dynamic_extent> ensure_z(CharT* const& sz,
                                      std::size_t max = static_cast<std::size_t>(-1))
 {
     return ensure_sentinel<CharT, CharT(0)>(sz, max);
 }
 
 template <typename CharT, std::size_t N>
-span<CharT, dynamic_extent> ensure_z(CharT (&sz)[N])
+constexpr span<CharT, dynamic_extent> ensure_z(CharT (&sz)[N])
 {
     return ensure_z(&sz[0], N);
 }
 
 template <class Cont>
-span<typename std::remove_pointer<typename Cont::pointer>::type, dynamic_extent>
+constexpr span<typename std::remove_pointer<typename Cont::pointer>::type, dynamic_extent>
 ensure_z(Cont& cont)
 {
     return ensure_z(cont.data(), cont.size());
@@ -306,13 +300,13 @@ public:
     constexpr reverse_iterator rend() const noexcept { return span_.rend(); }
 
 private:
-    static impl_type remove_z(pointer const& sz, std::size_t max)
+    static constexpr impl_type remove_z(pointer const& sz, std::size_t max)
     {
-        return {sz, details::string_length(sz, max)};
+        return impl_type(sz, details::string_length(sz, max));
     }
 
     template <std::size_t N>
-    static impl_type remove_z(element_type (&sz)[N])
+    static constexpr impl_type remove_z(element_type (&sz)[N])
     {
         return remove_z(&sz[0], N);
     }
@@ -349,7 +343,7 @@ using cu32string_span = basic_string_span<const char32_t, Extent>;
 //
 
 template <typename CharT, std::size_t Extent>
-std::basic_string<typename std::remove_const<CharT>::type>
+constexpr std::basic_string<typename std::remove_const<CharT>::type>
 to_string(basic_string_span<CharT, Extent> view)
 {
     return {view.data(), narrow_cast<std::size_t>(view.length())};
@@ -357,13 +351,14 @@ to_string(basic_string_span<CharT, Extent> view)
 
 template <typename CharT, typename Traits = typename std::char_traits<CharT>,
           typename Allocator = std::allocator<CharT>, typename gCharT, std::size_t Extent>
-std::basic_string<CharT, Traits, Allocator> to_basic_string(basic_string_span<gCharT, Extent> view)
+constexpr std::basic_string<CharT, Traits, Allocator>
+to_basic_string(basic_string_span<gCharT, Extent> view)
 {
     return {view.data(), narrow_cast<std::size_t>(view.length())};
 }
 
 template <class ElementType, std::size_t Extent>
-basic_string_span<const byte, details::calculate_byte_size<ElementType, Extent>::value>
+constexpr basic_string_span<const byte, details::calculate_byte_size<ElementType, Extent>::value>
 as_bytes(basic_string_span<ElementType, Extent> s) noexcept
 {
     GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
@@ -372,7 +367,7 @@ as_bytes(basic_string_span<ElementType, Extent> s) noexcept
 
 template <class ElementType, std::size_t Extent,
           class = std::enable_if_t<!std::is_const<ElementType>::value>>
-basic_string_span<byte, details::calculate_byte_size<ElementType, Extent>::value>
+constexpr basic_string_span<byte, details::calculate_byte_size<ElementType, Extent>::value>
 as_writable_bytes(basic_string_span<ElementType, Extent> s) noexcept
 {
     GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
@@ -400,7 +395,8 @@ public:
     constexpr basic_zstring_span(impl_type s) : span_(s)
     {
         // expects a zero-terminated span
-        Expects(s[s.size() - 1] == '\0');
+        Expects(s.size() > 0);
+        Expects(s[s.size() - 1] == value_type{});
     }
 
     // copy
@@ -415,12 +411,11 @@ public:
     // move assign
     constexpr basic_zstring_span& operator=(basic_zstring_span&& other) = default;
 
-    constexpr bool empty() const noexcept { return span_.size() == 0; }
+    constexpr bool empty() const noexcept { return false; }
 
     constexpr string_span_type as_string_span() const noexcept
     {
-        const auto sz = span_.size();
-        return {span_.data(), sz > 1 ? sz - 1 : 0};
+        return {span_.data(), span_.size() - 1};
     }
     constexpr string_span_type ensure_z() const { return gsl::ensure_z(span_); }
 
@@ -476,7 +471,7 @@ bool operator==(const T& one, const gsl::basic_string_span<CharT, Extent>& other
 }
 
 // operator !=
-template <typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+template <typename CharT, std::size_t Extent = dynamic_extent, typename T,
           typename = std::enable_if_t<std::is_convertible<
               T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
 bool operator!=(gsl::basic_string_span<CharT, Extent> one, const T& other)
@@ -485,7 +480,7 @@ bool operator!=(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }
 
 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
     typename = std::enable_if_t<
         std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
         !gsl::details::is_basic_string_span<T>::value>>
@@ -495,7 +490,7 @@ bool operator!=(const T& one, gsl::basic_string_span<CharT, Extent> other)
 }
 
 // operator<
-template <typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+template <typename CharT, std::size_t Extent = dynamic_extent, typename T,
           typename = std::enable_if_t<std::is_convertible<
               T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
 bool operator<(gsl::basic_string_span<CharT, Extent> one, const T& other)
@@ -505,7 +500,7 @@ bool operator<(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }
 
 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
     typename = std::enable_if_t<
         std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
         !gsl::details::is_basic_string_span<T>::value>>
@@ -521,7 +516,7 @@ bool operator<(const T& one, gsl::basic_string_span<CharT, Extent> other)
 // so the cases below are already covered by the previous operators
 
 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename = std::enable_if_t<
         !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
@@ -535,7 +530,7 @@ bool operator<(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }
 
 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename = std::enable_if_t<
         !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
@@ -550,7 +545,7 @@ bool operator<(const T& one, gsl::basic_string_span<CharT, Extent> other)
 #endif
 
 // operator <=
-template <typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+template <typename CharT, std::size_t Extent = dynamic_extent, typename T,
           typename = std::enable_if_t<std::is_convertible<
               T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
 bool operator<=(gsl::basic_string_span<CharT, Extent> one, const T& other)
@@ -559,7 +554,7 @@ bool operator<=(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }
 
 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
     typename = std::enable_if_t<
         std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
         !gsl::details::is_basic_string_span<T>::value>>
@@ -574,7 +569,7 @@ bool operator<=(const T& one, gsl::basic_string_span<CharT, Extent> other)
 // so the cases below are already covered by the previous operators
 
 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename = std::enable_if_t<
         !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
@@ -587,7 +582,7 @@ bool operator<=(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }
 
 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename = std::enable_if_t<
         !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
@@ -601,7 +596,7 @@ bool operator<=(const T& one, gsl::basic_string_span<CharT, Extent> other)
 #endif
 
 // operator>
-template <typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+template <typename CharT, std::size_t Extent = dynamic_extent, typename T,
           typename = std::enable_if_t<std::is_convertible<
               T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
 bool operator>(gsl::basic_string_span<CharT, Extent> one, const T& other)
@@ -610,7 +605,7 @@ bool operator>(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }
 
 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
     typename = std::enable_if_t<
         std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
         !gsl::details::is_basic_string_span<T>::value>>
@@ -625,7 +620,7 @@ bool operator>(const T& one, gsl::basic_string_span<CharT, Extent> other)
 // so the cases below are already covered by the previous operators
 
 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename = std::enable_if_t<
         !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
@@ -638,7 +633,7 @@ bool operator>(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }
 
 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename = std::enable_if_t<
         !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
@@ -652,7 +647,7 @@ bool operator>(const T& one, gsl::basic_string_span<CharT, Extent> other)
 #endif
 
 // operator >=
-template <typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+template <typename CharT, std::size_t Extent = dynamic_extent, typename T,
           typename = std::enable_if_t<std::is_convertible<
               T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value>>
 bool operator>=(gsl::basic_string_span<CharT, Extent> one, const T& other)
@@ -661,7 +656,7 @@ bool operator>=(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }
 
 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
     typename = std::enable_if_t<
         std::is_convertible<T, gsl::basic_string_span<std::add_const_t<CharT>, Extent>>::value &&
         !gsl::details::is_basic_string_span<T>::value>>
@@ -676,7 +671,7 @@ bool operator>=(const T& one, gsl::basic_string_span<CharT, Extent> other)
 // so the cases below are already covered by the previous operators
 
 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename = std::enable_if_t<
         !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
@@ -689,7 +684,7 @@ bool operator>=(gsl::basic_string_span<CharT, Extent> one, const T& other)
 }
 
 template <
-    typename CharT, std::size_t Extent = gsl::dynamic_extent, typename T,
+    typename CharT, std::size_t Extent = dynamic_extent, typename T,
     typename DataType = typename T::value_type,
     typename = std::enable_if_t<
         !gsl::details::is_span<T>::value && !gsl::details::is_basic_string_span<T>::value &&
@@ -706,11 +701,6 @@ bool operator>=(const T& one, gsl::basic_string_span<CharT, Extent> other)
 #if defined(_MSC_VER) && !defined(__clang__)
 #pragma warning(pop)
 
-#if _MSC_VER < 1910
-#undef constexpr
-#pragma pop_macro("constexpr")
-
-#endif // _MSC_VER < 1910
 #endif // _MSC_VER
 
 #endif // GSL_STRING_SPAN_H

data/ext/third_party/http_parser/http_parser.c

@@ -653,6 +653,8 @@ size_t http_parser_execute (http_parser *parser,
   const char *status_mark = 0;
   enum state p_state = (enum state) parser->state;
   const unsigned int lenient = parser->lenient_http_headers;
+  const unsigned int allow_chunked_length = parser->allow_chunked_length;
+
   uint32_t nread = parser->nread;
 
   /* We're in an error state. Don't bother doing anything. */
@@ -731,7 +733,7 @@ reexecute:
         if (ch == CR || ch == LF)
           break;
         parser->flags = 0;
-        parser->extra_flags = 0;
+        parser->uses_transfer_encoding = 0;
         parser->content_length = ULLONG_MAX;
 
         if (ch == 'H') {
@@ -769,7 +771,7 @@ reexecute:
         if (ch == CR || ch == LF)
           break;
         parser->flags = 0;
-        parser->extra_flags = 0;
+        parser->uses_transfer_encoding = 0;
         parser->content_length = ULLONG_MAX;
 
         if (ch == 'H') {
@@ -927,7 +929,7 @@ reexecute:
         if (ch == CR || ch == LF)
           break;
         parser->flags = 0;
-        parser->extra_flags = 0;
+        parser->uses_transfer_encoding = 0;
         parser->content_length = ULLONG_MAX;
 
         if (UNLIKELY(!IS_ALPHA(ch))) {
@@ -1341,7 +1343,7 @@ reexecute:
                 parser->header_state = h_general;
               } else if (parser->index == sizeof(TRANSFER_ENCODING)-2) {
                 parser->header_state = h_transfer_encoding;
-                parser->extra_flags |= F_TRANSFER_ENCODING >> 8;
+                parser->uses_transfer_encoding = 1;
               }
               break;
 
@@ -1801,14 +1803,19 @@ reexecute:
           REEXECUTE();
         }
 
-        /* Cannot us transfer-encoding and a content-length header together
+        /* Cannot use transfer-encoding and a content-length header together
            per the HTTP specification. (RFC 7230 Section 3.3.3) */
-        if ((parser->extra_flags & (F_TRANSFER_ENCODING >> 8)) &&
+        if ((parser->uses_transfer_encoding == 1) &&
             (parser->flags & F_CONTENTLENGTH)) {
           /* Allow it for lenient parsing as long as `Transfer-Encoding` is
-           * not `chunked`
+           * not `chunked` or allow_length_with_encoding is set
            */
-          if (!lenient || (parser->flags & F_CHUNKED)) {
+          if (parser->flags & F_CHUNKED) {
+            if (!allow_chunked_length) {
+              SET_ERRNO(HPE_UNEXPECTED_CONTENT_LENGTH);
+              goto error;
+            }
+          } else if (!lenient) {
             SET_ERRNO(HPE_UNEXPECTED_CONTENT_LENGTH);
             goto error;
           }
@@ -1889,7 +1896,7 @@ reexecute:
           /* chunked encoding - ignore Content-Length header,
            * prepare for a chunk */
           UPDATE_STATE(s_chunk_size_start);
-        } else if (parser->extra_flags & (F_TRANSFER_ENCODING >> 8)) {
+        } else if (parser->uses_transfer_encoding == 1) {
           if (parser->type == HTTP_REQUEST && !lenient) {
             /* RFC 7230 3.3.3 */
 
@@ -2165,7 +2172,7 @@ http_message_needs_eof (const http_parser *parser)
   }
 
   /* RFC 7230 3.3.3, see `s_headers_almost_done` */
-  if ((parser->extra_flags & (F_TRANSFER_ENCODING >> 8)) &&
+  if ((parser->uses_transfer_encoding == 1) &&
       (parser->flags & F_CHUNKED) == 0) {
     return 1;
   }

data/ext/third_party/http_parser/http_parser.h

@@ -227,7 +227,6 @@ enum flags
   , F_UPGRADE               = 1 << 5
   , F_SKIPBODY              = 1 << 6
   , F_CONTENTLENGTH         = 1 << 7
-  , F_TRANSFER_ENCODING     = 1 << 8  /* Never set in http_parser.flags */
   };
 
 
@@ -302,7 +301,10 @@ struct http_parser {
   unsigned int state : 7;        /* enum state from http_parser.c */
   unsigned int header_state : 7; /* enum header_state from http_parser.c */
   unsigned int index : 5;        /* index into current matcher */
-  unsigned int extra_flags : 2;
+  unsigned int uses_transfer_encoding : 1; /* Transfer-Encoding header is present */
+  unsigned int allow_chunked_length : 1; /* Allow headers with both
+                                          * `Content-Length` and
+                                          * `Transfer-Encoding: chunked` set */
   unsigned int lenient_http_headers : 1;
 
   uint32_t nread;          /* # bytes read in various scenarios */

data/ext/third_party/json/include/tao/json/basic_value.hpp

@@ -7,6 +7,7 @@
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
+#include <map>
 #include <memory>
 #include <optional>
 #include <stdexcept>
@@ -36,7 +37,7 @@
 namespace tao::json
 {
    template< template< typename... > class Traits >
-   class basic_value
+   class basic_value  // NOLINT(cppcoreguidelines-special-member-functions)
       : public Traits< void >::template public_base< basic_value< Traits > >
    {
    public:
@@ -71,7 +72,7 @@ namespace tao::json
       basic_value() = default;
 
       basic_value( const basic_value& r ) = default;
-      basic_value( basic_value&& r ) = default;
+      basic_value( basic_value&& r ) = default;  // NOLINT(performance-noexcept-move-constructor)
 
 #if( __cplusplus > 201703L )
 

data/ext/third_party/json/include/tao/json/binary.hpp

@@ -7,7 +7,7 @@
 #include <cstddef>
 #include <vector>
 
-#include "external/pegtl/internal/always_false.hpp"
+#include "internal/dependent_false.hpp"
 
 namespace tao
 {
@@ -43,7 +43,7 @@ namespace tao::json
       struct unhex_helper< T, vlist< V, Vs... >, C >
          : unhex_helper< T, vlist< V > >
       {
-         static_assert( pegtl::internal::always_false< T >::value, "digits must occur in pairs" );
+         static_assert( internal::dependent_false< T >, "digits must occur in pairs" );
       };
 
       template< typename T, typename V, V... Vs, char C1, char... Cs >
@@ -56,7 +56,7 @@ namespace tao::json
       struct unhex_helper< T, vlist< V, Vs... >, C0, '\'', Cs... >
          : unhex_helper< T, vlist< V > >
       {
-         static_assert( pegtl::internal::always_false< T >::value, "digit separator only allowed between pairs of digits" );
+         static_assert( internal::dependent_false< T >, "digit separator only allowed between pairs of digits" );
       };
 
       template< typename T, typename V, V... Vs, char C0, char C1, char... Cs >
@@ -68,7 +68,7 @@ namespace tao::json
       template< typename T, typename V, char C >
       [[nodiscard]] constexpr T unhex()
       {
-         static_assert( pegtl::internal::always_false< T >::value, "not a hex literal" );
+         static_assert( internal::dependent_false< T >, "not a hex literal" );
          return T{};
       }