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

data/ext/third_party/json/include/tao/json/external/pegtl/internal/success.hpp

@@ -0,0 +1,32 @@
+// Copyright (c) 2014-2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_JSON_PEGTL_INTERNAL_SUCCESS_HPP
+#define TAO_JSON_PEGTL_INTERNAL_SUCCESS_HPP
+
+#include "../config.hpp"
+
+#include "enable_control.hpp"
+
+#include "../type_list.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE::internal
+{
+   struct success
+   {
+      using rule_t = success;
+      using subs_t = empty_list;
+
+      template< typename ParseInput >
+      [[nodiscard]] static bool match( ParseInput& /*unused*/ ) noexcept
+      {
+         return true;
+      }
+   };
+
+   template<>
+   inline constexpr bool enable_control< success > = false;
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
+
+#endif

data/ext/third_party/json/include/tao/json/external/pegtl/internal/try_catch_type.hpp

@@ -8,31 +8,31 @@
 
 #include "../config.hpp"
 
-#include "duseltronik.hpp"
+#include "enable_control.hpp"
 #include "seq.hpp"
-#include "skip_control.hpp"
-#include "trivial.hpp"
+#include "success.hpp"
 
 #include "../apply_mode.hpp"
 #include "../rewind_mode.hpp"
-
-#include "../analysis/generic.hpp"
+#include "../type_list.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE::internal
 {
    template< typename Exception, typename... Rules >
-   struct try_catch_type;
+   struct try_catch_type
+      : try_catch_type< Exception, seq< Rules... > >
+   {};
 
    template< typename Exception >
    struct try_catch_type< Exception >
-      : trivial< true >
-   {
-   };
+      : success
+   {};
 
-   template< typename Exception, typename... Rules >
-   struct try_catch_type
+   template< typename Exception, typename Rule >
+   struct try_catch_type< Exception, Rule >
    {
-      using analyze_t = analysis::generic< analysis::rule_type::seq, Rules... >;
+      using rule_t = try_catch_type;
+      using subs_t = type_list< Rule >;
 
       template< apply_mode A,
                 rewind_mode M,
@@ -40,15 +40,15 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
                 class Action,
                 template< typename... >
                 class Control,
-                typename Input,
+                typename ParseInput,
                 typename... States >
-      [[nodiscard]] static bool match( Input& in, States&&... st )
+      [[nodiscard]] static bool match( ParseInput& in, States&&... st )
       {
          auto m = in.template mark< M >();
          using m_t = decltype( m );
 
          try {
-            return m( duseltronik< seq< Rules... >, A, m_t::next_rewind_mode, Action, Control >::match( in, st... ) );
+            return m( Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) );
          }
          catch( const Exception& ) {
             return false;
@@ -57,7 +57,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
    };
 
    template< typename Exception, typename... Rules >
-   inline constexpr bool skip_control< try_catch_type< Exception, Rules... > > = true;
+   inline constexpr bool enable_control< try_catch_type< Exception, Rules... > > = false;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
 

data/ext/third_party/json/include/tao/json/external/pegtl/internal/until.hpp

@@ -7,25 +7,28 @@
 #include "../config.hpp"
 
 #include "bytes.hpp"
+#include "enable_control.hpp"
 #include "eof.hpp"
 #include "not_at.hpp"
-#include "skip_control.hpp"
+#include "seq.hpp"
 #include "star.hpp"
 
 #include "../apply_mode.hpp"
 #include "../rewind_mode.hpp"
-
-#include "../analysis/generic.hpp"
+#include "../type_list.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE::internal
 {
    template< typename Cond, typename... Rules >
-   struct until;
+   struct until
+      : until< Cond, seq< Rules... > >
+   {};
 
    template< typename Cond >
    struct until< Cond >
    {
-      using analyze_t = analysis::generic< analysis::rule_type::seq, star< not_at< Cond >, not_at< eof >, bytes< 1 > >, Cond >;
+      using rule_t = until;
+      using subs_t = type_list< Cond >;
 
       template< apply_mode A,
                 rewind_mode M,
@@ -33,9 +36,9 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
                 class Action,
                 template< typename... >
                 class Control,
-                typename Input,
+                typename ParseInput,
                 typename... States >
-      [[nodiscard]] static bool match( Input& in, States&&... st )
+      [[nodiscard]] static bool match( ParseInput& in, States&&... st )
       {
          auto m = in.template mark< M >();
 
@@ -49,10 +52,11 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
       }
    };
 
-   template< typename Cond, typename... Rules >
-   struct until
+   template< typename Cond, typename Rule >
+   struct until< Cond, Rule >
    {
-      using analyze_t = analysis::generic< analysis::rule_type::seq, star< not_at< Cond >, not_at< eof >, Rules... >, Cond >;
+      using rule_t = until;
+      using subs_t = type_list< Cond, Rule >;
 
       template< apply_mode A,
                 rewind_mode M,
@@ -60,15 +64,15 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
                 class Action,
                 template< typename... >
                 class Control,
-                typename Input,
+                typename ParseInput,
                 typename... States >
-      [[nodiscard]] static bool match( Input& in, States&&... st )
+      [[nodiscard]] static bool match( ParseInput& in, States&&... st )
       {
          auto m = in.template mark< M >();
          using m_t = decltype( m );
 
          while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
-            if( !( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) ) {
+            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
                return false;
             }
          }
@@ -77,7 +81,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
    };
 
    template< typename Cond, typename... Rules >
-   inline constexpr bool skip_control< until< Cond, Rules... > > = true;
+   inline constexpr bool enable_control< until< Cond, Rules... > > = false;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
 

data/ext/third_party/json/include/tao/json/external/pegtl/istream_input.hpp

@@ -21,12 +21,11 @@ namespace TAO_JSON_PEGTL_NAMESPACE
       template< typename T >
       istream_input( std::istream& in_stream, const std::size_t in_maximum, T&& in_source )
          : buffer_input< internal::istream_reader, Eol, std::string, Chunk >( std::forward< T >( in_source ), in_maximum, in_stream )
-      {
-      }
+      {}
    };
 
    template< typename... Ts >
-   istream_input( Ts&&... )->istream_input<>;
+   istream_input( Ts&&... ) -> istream_input<>;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE
 

data/ext/third_party/json/include/tao/json/external/pegtl/match.hpp

@@ -13,16 +13,79 @@
 #include "require_apply0.hpp"
 #include "rewind_mode.hpp"
 
-#include "internal/dusel_mode.hpp"
-#include "internal/duseltronik.hpp"
 #include "internal/has_apply.hpp"
 #include "internal/has_apply0.hpp"
+#include "internal/has_unwind.hpp"
+#include "internal/marker.hpp"
 #include "internal/missing_apply.hpp"
 #include "internal/missing_apply0.hpp"
-#include "internal/skip_control.hpp"
+
+#if defined( _MSC_VER )
+#pragma warning( push )
+#pragma warning( disable : 4702 )
+#endif
 
 namespace TAO_JSON_PEGTL_NAMESPACE
 {
+   namespace internal
+   {
+      template< typename Rule,
+                apply_mode A,
+                rewind_mode M,
+                template< typename... >
+                class Action,
+                template< typename... >
+                class Control,
+                typename ParseInput,
+                typename... States >
+      [[nodiscard]] static auto match_no_control( ParseInput& in, States&&... st )
+         -> decltype( Rule::template match< A, M, Action, Control >( in, st... ) )
+      {
+         return Rule::template match< A, M, Action, Control >( in, st... );
+      }
+
+      template< typename Rule,
+                apply_mode A,
+                rewind_mode M,
+                template< typename... >
+                class Action,
+                template< typename... >
+                class Control,
+                typename ParseInput,
+                typename... States >
+      [[nodiscard]] static auto match_no_control( ParseInput& in, States&&... /*unused*/ )
+         -> decltype( Rule::match( in ) )
+      {
+         return Rule::match( in );
+      }
+
+      template< typename Rule,
+                apply_mode A,
+                rewind_mode M,
+                template< typename... >
+                class Action,
+                template< typename... >
+                class Control,
+                typename ParseInput,
+                typename... States >
+      [[nodiscard]] auto match_control_unwind( ParseInput& in, States&&... st )
+      {
+         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
+            try {
+               return match_no_control< Rule, A, M, Action, Control >( in, st... );
+            }
+            catch( ... ) {
+               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
+               throw;
+            }
+         }
+         else {
+            return match_no_control< Rule, A, M, Action, Control >( in, st... );
+         }
+      }
+
+   }  // namespace internal
+
    template< typename Rule,
              apply_mode A,
              rewind_mode M,
@@ -30,44 +93,77 @@ namespace TAO_JSON_PEGTL_NAMESPACE
              class Action,
              template< typename... >
              class Control,
-             typename Input,
+             typename ParseInput,
              typename... States >
-   [[nodiscard]] bool match( Input& in, States&&... st )
+   [[nodiscard]] auto match( ParseInput& in, States&&... st )
    {
-      constexpr bool enable_control = !internal::skip_control< Rule >;
-      constexpr bool enable_action = enable_control && ( A == apply_mode::action );
+      if constexpr( !Control< Rule >::enable ) {
+         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
+      }
+      else {
+         constexpr bool enable_action = ( A == apply_mode::action );
 
-      using iterator_t = typename Input::iterator_t;
-      constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const Input&, States... >::value;
-      constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const Input&, States... >::value;
-      constexpr bool has_apply = has_apply_void || has_apply_bool;
+         using iterator_t = typename ParseInput::iterator_t;
+         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
+         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
+         constexpr bool has_apply = has_apply_void || has_apply_bool;
 
-      constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const Input&, States... >::value;
-      constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const Input&, States... >::value;
-      constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
+         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
+         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
+         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
 
-      static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
+         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
 
-      constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
-      static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
-      static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
+         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
+         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
+         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
 
-      if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
-         internal::missing_apply< Control< Rule >, Action >( in, st... );
-      }
+         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
+            internal::missing_apply< Control< Rule >, Action >( in, st... );
+         }
 
-      if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
-         internal::missing_apply0< Control< Rule >, Action >( in, st... );
-      }
+         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
+            internal::missing_apply0< Control< Rule >, Action >( in, st... );
+         }
 
-      constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
-      constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
-      static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
+         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
+         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
+         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
 
-      constexpr auto mode = static_cast< internal::dusel_mode >( enable_control + has_apply_void + 2 * has_apply_bool + 3 * has_apply0_void + 4 * has_apply0_bool );
-      return internal::duseltronik< Rule, A, M, Action, Control, mode >::match( in, st... );
+         constexpr bool use_marker = has_apply || has_apply0_bool;
+
+         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
+         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
+         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
+         if( result ) {
+            if constexpr( has_apply_void ) {
+               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
+            }
+            else if constexpr( has_apply_bool ) {
+               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
+            }
+            else if constexpr( has_apply0_void ) {
+               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
+            }
+            else if constexpr( has_apply0_bool ) {
+               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
+            }
+         }
+         if( result ) {
+            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
+         }
+         else {
+            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
+         }
+         (void)m( result );
+         return result;
+      }
    }
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE
 
+#if defined( _MSC_VER )
+#pragma warning( pop )
+#endif
+
 #endif

data/ext/third_party/json/include/tao/json/external/pegtl/memory_input.hpp

@@ -4,6 +4,7 @@
 #ifndef TAO_JSON_PEGTL_MEMORY_INPUT_HPP
 #define TAO_JSON_PEGTL_MEMORY_INPUT_HPP
 
+#include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
@@ -46,8 +47,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE
               m_current( in_begin ),
               m_end( in_end ),
               m_source( std::forward< T >( in_source ) )
-         {
-         }
+         {}
 
          template< typename T >
          memory_input_base( const char* in_begin, const char* in_end, T&& in_source ) noexcept( std::is_nothrow_constructible_v< Source, T&& > )
@@ -55,8 +55,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE
               m_current( in_begin ),
               m_end( in_end ),
               m_source( std::forward< T >( in_source ) )
-         {
-         }
+         {}
 
          memory_input_base( const memory_input_base& ) = delete;
          memory_input_base( memory_input_base&& ) = delete;
@@ -91,9 +90,9 @@ namespace TAO_JSON_PEGTL_NAMESPACE
             return m_current.line;
          }
 
-         [[nodiscard]] std::size_t byte_in_line() const noexcept
+         [[nodiscard]] std::size_t column() const noexcept
          {
-            return m_current.byte_in_line;
+            return m_current.column;
          }
 
          void bump( const std::size_t in_count = 1 ) noexcept
@@ -116,21 +115,15 @@ namespace TAO_JSON_PEGTL_NAMESPACE
             return TAO_JSON_PEGTL_NAMESPACE::position( it, m_source );
          }
 
-         void restart( const std::size_t in_byte = 0, const std::size_t in_line = 1, const std::size_t in_byte_in_line = 0 )
+         void restart( const std::size_t in_byte = 0, const std::size_t in_line = 1, const std::size_t in_column = 1 )
          {
+            assert( in_line != 0 );
+            assert( in_column != 0 );
+
             m_current.data = m_begin;
             m_current.byte = in_byte;
             m_current.line = in_line;
-            m_current.byte_in_line = in_byte_in_line;
-         }
-
-         template< rewind_mode M >
-         void restart( const internal::marker< iterator_t, M >& m )
-         {
-            m_current.data = m.iterator().data;
-            m_current.byte = m.iterator().byte;
-            m_current.line = m.iterator().line;
-            m_current.byte_in_line = m.iterator().byte_in_line;
+            m_current.column = in_column;
          }
 
       protected:
@@ -152,8 +145,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE
               m_current( in_begin.data ),
               m_end( in_end ),
               m_source( std::forward< T >( in_source ) )
-         {
-         }
+         {}
 
          template< typename T >
          memory_input_base( const char* in_begin, const char* in_end, T&& in_source ) noexcept( std::is_nothrow_constructible_v< Source, T&& > )
@@ -161,8 +153,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE
               m_current( in_begin ),
               m_end( in_end ),
               m_source( std::forward< T >( in_source ) )
-         {
-         }
+         {}
 
          memory_input_base( const memory_input_base& ) = delete;
          memory_input_base( memory_input_base&& ) = delete;
@@ -219,12 +210,6 @@ namespace TAO_JSON_PEGTL_NAMESPACE
             m_current = m_begin.data;
          }
 
-         template< rewind_mode M >
-         void restart( const internal::marker< iterator_t, M >& m )
-         {
-            m_current = m.iterator();
-         }
-
       protected:
          const internal::iterator m_begin;
          iterator_t m_current;
@@ -253,20 +238,17 @@ namespace TAO_JSON_PEGTL_NAMESPACE
       template< typename T >
       memory_input( const char* in_begin, const std::size_t in_size, T&& in_source ) noexcept( std::is_nothrow_constructible_v< Source, T&& > )
          : memory_input( in_begin, in_begin + in_size, std::forward< T >( in_source ) )
-      {
-      }
+      {}
 
       template< typename T >
       memory_input( const std::string& in_string, T&& in_source ) noexcept( std::is_nothrow_constructible_v< Source, T&& > )
          : memory_input( in_string.data(), in_string.size(), std::forward< T >( in_source ) )
-      {
-      }
+      {}
 
       template< typename T >
       memory_input( const std::string_view in_string, T&& in_source ) noexcept( std::is_nothrow_constructible_v< Source, T&& > )
          : memory_input( in_string.data(), in_string.size(), std::forward< T >( in_source ) )
-      {
-      }
+      {}
 
       template< typename T >
       memory_input( std::string&&, T&& ) = delete;
@@ -274,14 +256,12 @@ namespace TAO_JSON_PEGTL_NAMESPACE
       template< typename T >
       memory_input( const char* in_begin, T&& in_source ) noexcept( std::is_nothrow_constructible_v< Source, T&& > )
          : memory_input( in_begin, std::strlen( in_begin ), std::forward< T >( in_source ) )
-      {
-      }
+      {}
 
       template< typename T >
-      memory_input( const char* in_begin, const char* in_end, T&& in_source, const std::size_t in_byte, const std::size_t in_line, const std::size_t in_byte_in_line ) noexcept( std::is_nothrow_constructible_v< Source, T&& > )
-         : memory_input( { in_begin, in_byte, in_line, in_byte_in_line }, in_end, std::forward< T >( in_source ) )
-      {
-      }
+      memory_input( const char* in_begin, const char* in_end, T&& in_source, const std::size_t in_byte, const std::size_t in_line, const std::size_t in_column ) noexcept( std::is_nothrow_constructible_v< Source, T&& > )
+         : memory_input( { in_begin, in_byte, in_line, in_column }, in_end, std::forward< T >( in_source ) )
+      {}
 
       memory_input( const memory_input& ) = delete;
       memory_input( memory_input&& ) = delete;
@@ -326,6 +306,14 @@ namespace TAO_JSON_PEGTL_NAMESPACE
          return this->m_current;
       }
 
+      using internal::memory_input_base< P, Eol, Source >::restart;
+
+      template< rewind_mode M >
+      void restart( const internal::marker< iterator_t, M >& m ) noexcept
+      {
+         iterator() = m.iterator();
+      }
+
       using internal::memory_input_base< P, Eol, Source >::position;
 
       [[nodiscard]] TAO_JSON_PEGTL_NAMESPACE::position position() const
@@ -333,13 +321,9 @@ namespace TAO_JSON_PEGTL_NAMESPACE
          return position( iterator() );
       }
 
-      void discard() const noexcept
-      {
-      }
+      void discard() const noexcept {}
 
-      void require( const std::size_t /*unused*/ ) const noexcept
-      {
-      }
+      void require( const std::size_t /*unused*/ ) const noexcept {}
 
       template< rewind_mode M >
       [[nodiscard]] internal::marker< iterator_t, M > mark() noexcept
@@ -354,7 +338,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE
 
       [[nodiscard]] const char* begin_of_line( const TAO_JSON_PEGTL_NAMESPACE::position& p ) const noexcept
       {
-         return at( p ) - p.byte_in_line;
+         return at( p ) - ( p.column - 1 );
       }
 
       [[nodiscard]] const char* end_of_line( const TAO_JSON_PEGTL_NAMESPACE::position& p ) const noexcept
@@ -369,12 +353,12 @@ namespace TAO_JSON_PEGTL_NAMESPACE
       [[nodiscard]] std::string_view line_at( const TAO_JSON_PEGTL_NAMESPACE::position& p ) const noexcept
       {
          const char* b = begin_of_line( p );
-         return std::string_view( b, end_of_line( p ) - b );
+         return std::string_view( b, static_cast< std::size_t >( end_of_line( p ) - b ) );
       }
    };
 
    template< typename... Ts >
-   memory_input( Ts&&... )->memory_input<>;
+   memory_input( Ts&&... ) -> memory_input<>;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE