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

data/ext/third_party/json/include/tao/json/external/pegtl/contrib/control_action.hpp

@@ -0,0 +1,77 @@
+// Copyright (c) 2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_JSON_PEGTL_CONTRIB_CONTROL_ACTION_HPP
+#define TAO_JSON_PEGTL_CONTRIB_CONTROL_ACTION_HPP
+
+#include <utility>
+
+#include "../config.hpp"
+#include "../match.hpp"
+#include "../nothing.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE
+{
+   namespace internal
+   {
+      template< typename, typename Rule, template< typename... > class Action, typename ParseInput, typename... States >
+      inline constexpr bool action_has_unwind = false;
+
+      template< typename Rule, template< typename... > class Action, typename ParseInput, typename... States >
+      inline constexpr bool action_has_unwind< decltype( (void)Action< Rule >::unwind( std::declval< const ParseInput& >(), std::declval< States&& >()... ) ), Rule, Action, ParseInput, States... > = true;
+
+   }  // namespace internal
+
+   struct control_action
+      : maybe_nothing
+   {
+      template< typename Rule,
+                apply_mode A,
+                rewind_mode M,
+                template< typename... >
+                class Action,
+                template< typename... >
+                class Control,
+                typename ParseInput,
+                typename... States >
+      [[nodiscard]] static bool match( ParseInput& in, States&&... st )
+      {
+         if constexpr( internal::action_has_unwind< void, Rule, Action, ParseInput, States... > ) {
+            try {
+               return control_action::match_impl< Rule, A, M, Action, Control >( in, st... );
+            }
+            catch( ... ) {
+               Action< Rule >::unwind( const_cast< const ParseInput& >( in ), st... );
+               throw;
+            }
+         }
+         else {
+            return control_action::match_impl< Rule, A, M, Action, Control >( in, st... );
+         }
+      }
+
+   private:
+      template< typename Rule,
+                apply_mode A,
+                rewind_mode M,
+                template< typename... >
+                class Action,
+                template< typename... >
+                class Control,
+                typename ParseInput,
+                typename... States >
+      [[nodiscard]] static bool match_impl( ParseInput& in, States&&... st )
+      {
+         Action< Rule >::start( const_cast< const ParseInput& >( in ), st... );
+         if( TAO_JSON_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... ) ) {
+            Action< Rule >::success( const_cast< const ParseInput& >( in ), st... );
+            return true;
+         }
+         Action< Rule >::failure( const_cast< const ParseInput& >( in ), st... );
+         return false;
+      }
+   };
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE
+
+#endif

data/ext/third_party/json/include/tao/json/external/pegtl/contrib/coverage.hpp

@@ -0,0 +1,151 @@
+// Copyright (c) 2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_JSON_PEGTL_CONTRIB_COVERAGE_HPP
+#define TAO_JSON_PEGTL_CONTRIB_COVERAGE_HPP
+
+#include <cstddef>
+#include <map>
+#include <string_view>
+#include <vector>
+
+#include "state_control.hpp"
+
+#include "../apply_mode.hpp"
+#include "../config.hpp"
+#include "../demangle.hpp"
+#include "../normal.hpp"
+#include "../nothing.hpp"
+#include "../parse.hpp"
+#include "../rewind_mode.hpp"
+#include "../type_list.hpp"
+#include "../visit.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE
+{
+   struct coverage_info
+   {
+      std::size_t start = 0;
+      std::size_t success = 0;
+      std::size_t failure = 0;
+      std::size_t unwind = 0;
+      std::size_t raise = 0;
+   };
+
+   struct coverage_entry
+      : coverage_info
+   {
+      std::map< std::string_view, coverage_info > branches;
+   };
+
+   using coverage_result = std::map< std::string_view, coverage_entry >;
+
+   namespace internal
+   {
+      template< typename Rule >
+      struct coverage_insert
+      {
+         static void visit( std::map< std::string_view, coverage_entry >& map )
+         {
+            visit_branches( map.try_emplace( demangle< Rule >() ).first->second.branches, typename Rule::subs_t() );
+         }
+
+         template< typename... Ts >
+         static void visit_branches( std::map< std::string_view, coverage_info >& branches, type_list< Ts... > /*unused*/ )
+         {
+            ( branches.try_emplace( demangle< Ts >() ), ... );
+         }
+      };
+
+      struct coverage_state
+      {
+         template< typename Rule >
+         static constexpr bool enable = true;
+
+         explicit coverage_state( coverage_result& in_result )
+            : result( in_result )
+         {}
+
+         coverage_result& result;
+         std::vector< std::string_view > stack;
+
+         template< typename Rule, typename ParseInput, typename... States >
+         void start( const ParseInput& /*unused*/, States&&... /*unused*/ )
+         {
+            const auto name = demangle< Rule >();
+            ++result.at( name ).start;
+            if( !stack.empty() ) {
+               ++result.at( stack.back() ).branches.at( name ).start;
+            }
+            stack.push_back( name );
+         }
+
+         template< typename Rule, typename ParseInput, typename... States >
+         void success( const ParseInput& /*unused*/, States&&... /*unused*/ )
+         {
+            stack.pop_back();
+            const auto name = demangle< Rule >();
+            ++result.at( name ).success;
+            if( !stack.empty() ) {
+               ++result.at( stack.back() ).branches.at( name ).success;
+            }
+         }
+
+         template< typename Rule, typename ParseInput, typename... States >
+         void failure( const ParseInput& /*unused*/, States&&... /*unused*/ )
+         {
+            stack.pop_back();
+            const auto name = demangle< Rule >();
+            ++result.at( name ).failure;
+            if( !stack.empty() ) {
+               ++result.at( stack.back() ).branches.at( name ).failure;
+            }
+         }
+
+         template< typename Rule, typename ParseInput, typename... States >
+         void raise( const ParseInput& /*unused*/, States&&... /*unused*/ )
+         {
+            const auto name = demangle< Rule >();
+            ++result.at( name ).raise;
+            if( !stack.empty() ) {
+               ++result.at( stack.back() ).branches.at( name ).raise;
+            }
+         }
+
+         template< typename Rule, typename ParseInput, typename... States >
+         void unwind( const ParseInput& /*unused*/, States&&... /*unused*/ )
+         {
+            stack.pop_back();
+            const auto name = demangle< Rule >();
+            ++result.at( name ).unwind;
+            if( !stack.empty() ) {
+               ++result.at( stack.back() ).branches.at( name ).unwind;
+            }
+         }
+
+         template< typename Rule, typename ParseInput, typename... States >
+         void apply( const ParseInput& /*unused*/, States&&... /*unused*/ ) noexcept
+         {}
+
+         template< typename Rule, typename ParseInput, typename... States >
+         void apply0( const ParseInput& /*unused*/, States&&... /*unused*/ ) noexcept
+         {}
+      };
+
+   }  // namespace internal
+
+   template< typename Rule,
+             template< typename... > class Action = nothing,
+             template< typename... > class Control = normal,
+             typename ParseInput,
+             typename... States >
+   bool coverage( ParseInput&& in, coverage_result& result, States&&... st )
+   {
+      internal::coverage_state state( result );
+      visit< Rule, internal::coverage_insert >( state.result );  // Fill map with all sub-rules of the grammar.
+      return parse< Rule, Action, state_control< Control >::template type >( in, st..., state );
+   }
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE
+
+#endif

data/ext/third_party/json/include/tao/json/external/pegtl/contrib/forward.hpp

@@ -0,0 +1,16 @@
+// Copyright (c) 2020 Dr. Colin Hirsch and Daniel Frey
+// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
+
+#ifndef TAO_JSON_PEGTL_CONTRIB_FORWARD_HPP
+#define TAO_JSON_PEGTL_CONTRIB_FORWARD_HPP
+
+#include "../config.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE
+{
+   template< typename Name, typename Rule, typename = void >
+   struct analyze_traits;
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE
+
+#endif

data/ext/third_party/json/include/tao/json/external/pegtl/contrib/http.hpp

@@ -11,6 +11,7 @@
 #include "../utf8.hpp"
 
 #include "abnf.hpp"
+#include "forward.hpp"
 #include "remove_first_state.hpp"
 #include "uri.hpp"
 
@@ -125,7 +126,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE::http
    // clang-format on
    struct chunk_size
    {
-      using analyze_t = plus< abnf::HEXDIG >::analyze_t;
+      using rule_t = plus< abnf::HEXDIG >::rule_t;
 
       template< apply_mode A,
                 rewind_mode M,
@@ -133,9 +134,9 @@ namespace TAO_JSON_PEGTL_NAMESPACE::http
                 class Action,
                 template< typename... >
                 class Control,
-                typename Input,
+                typename ParseInput,
                 typename... States >
-      [[nodiscard]] static bool match( Input& in, std::size_t& size, States&&... /*unused*/ )
+      [[nodiscard]] static bool match( ParseInput& in, std::size_t& size, States&&... /*unused*/ )
       {
          size = 0;
          std::size_t i = 0;
@@ -174,7 +175,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE::http
    // clang-format on
    struct chunk_data
    {
-      using analyze_t = star< abnf::OCTET >::analyze_t;
+      using rule_t = star< abnf::OCTET >::rule_t;
 
       template< apply_mode A,
                 rewind_mode M,
@@ -182,9 +183,9 @@ namespace TAO_JSON_PEGTL_NAMESPACE::http
                 class Action,
                 template< typename... >
                 class Control,
-                typename Input,
+                typename ParseInput,
                 typename... States >
-      [[nodiscard]] static bool match( Input& in, const std::size_t size, States&&... /*unused*/ )
+      [[nodiscard]] static bool match( ParseInput& in, const std::size_t size, States&&... /*unused*/ )
       {
          if( in.size( size ) >= size ) {
             in.bump( size );
@@ -196,26 +197,43 @@ namespace TAO_JSON_PEGTL_NAMESPACE::http
 
    namespace internal::chunk_helper
    {
-      template< typename Rule, template< typename... > class Control >
-      struct control
-         : remove_self_and_first_state< Rule, Control >
-      {};
+      template< typename Base >
+      struct control;
+
+      template< template< typename... > class Control, typename Rule >
+      struct control< Control< Rule > >
+         : Control< Rule >
+      {
+         template< apply_mode A,
+                   rewind_mode M,
+                   template< typename... >
+                   class Action,
+                   template< typename... >
+                   class,
+                   typename ParseInput,
+                   typename State,
+                   typename... States >
+         [[nodiscard]] static bool match( ParseInput& in, State&& /*unused*/, States&&... st )
+         {
+            return Control< Rule >::template match< A, M, Action, Control >( in, st... );
+         }
+      };
 
       template< template< typename... > class Control >
-      struct control< chunk_size, Control >
-         : remove_first_state_after_match< chunk_size, Control >
+      struct control< Control< chunk_size > >
+         : remove_first_state< Control< chunk_size > >
       {};
 
       template< template< typename... > class Control >
-      struct control< chunk_data, Control >
-         : remove_first_state_after_match< chunk_data, Control >
+      struct control< Control< chunk_data > >
+         : remove_first_state< Control< chunk_data > >
       {};
 
       template< template< typename... > class Control >
       struct bind
       {
          template< typename Rule >
-         using type = control< Rule, Control >;
+         using type = control< Control< Rule > >;
       };
 
    }  // namespace internal::chunk_helper
@@ -223,7 +241,8 @@ namespace TAO_JSON_PEGTL_NAMESPACE::http
    struct chunk
    {
       using impl = seq< chunk_size, chunk_ext, abnf::CRLF, chunk_data, abnf::CRLF >;
-      using analyze_t = impl::analyze_t;
+
+      using rule_t = impl::rule_t;
 
       template< apply_mode A,
                 rewind_mode M,
@@ -231,9 +250,9 @@ namespace TAO_JSON_PEGTL_NAMESPACE::http
                 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 )
       {
          std::size_t size{};
          return impl::template match< A, M, Action, internal::chunk_helper::bind< Control >::template type >( in, size, st... );

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

@@ -7,9 +7,9 @@
 #include <unicode/uchar.h>
 
 #include "../../config.hpp"
+#include "../../type_list.hpp"
 
-#include "../../analysis/generic.hpp"
-#include "../../internal/skip_control.hpp"
+#include "../../internal/enable_control.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE::internal
 {
@@ -18,17 +18,16 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
       template< typename Peek, UProperty P, bool V = true >
       struct binary_property
       {
-         using analyze_t = analysis::generic< analysis::rule_type::any >;
+         using rule_t = binary_property;
+         using subs_t = empty_list;
 
-         template< typename Input >
-         [[nodiscard]] static bool match( Input& in ) noexcept( noexcept( in.size( Peek::max_input_size ) ) )
+         template< typename ParseInput >
+         [[nodiscard]] static bool match( ParseInput& in ) noexcept( noexcept( Peek::peek( in ) ) )
          {
-            if( const std::size_t s = in.size( Peek::max_input_size ); s >= Peek::min_input_size ) {
-               if( const auto r = Peek::peek( in, s ) ) {
-                  if( u_hasBinaryProperty( r.data, P ) == V ) {
-                     in.bump( r.size );
-                     return true;
-                  }
+            if( const auto r = Peek::peek( in ) ) {
+               if( u_hasBinaryProperty( r.data, P ) == V ) {
+                  in.bump( r.size );
+                  return true;
                }
             }
             return false;
@@ -38,17 +37,16 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
       template< typename Peek, UProperty P, int V >
       struct property_value
       {
-         using analyze_t = analysis::generic< analysis::rule_type::any >;
+         using rule_t = property_value;
+         using subs_t = empty_list;
 
-         template< typename Input >
-         [[nodiscard]] static bool match( Input& in ) noexcept( noexcept( in.size( Peek::max_input_size ) ) )
+         template< typename ParseInput >
+         [[nodiscard]] static bool match( ParseInput& in ) noexcept( noexcept( Peek::peek( in ) ) )
          {
-            if( const std::size_t s = in.size( Peek::max_input_size ); s >= Peek::min_input_size ) {
-               if( const auto r = Peek::peek( in, s ) ) {
-                  if( u_getIntPropertyValue( r.data, P ) == V ) {
-                     in.bump( r.size );
-                     return true;
-                  }
+            if( const auto r = Peek::peek( in ) ) {
+               if( u_getIntPropertyValue( r.data, P ) == V ) {
+                  in.bump( r.size );
+                  return true;
                }
             }
             return false;
@@ -58,10 +56,10 @@ namespace TAO_JSON_PEGTL_NAMESPACE::internal
    }  // namespace icu
 
    template< typename Peek, UProperty P, bool V >
-   inline constexpr bool skip_control< icu::binary_property< Peek, P, V > > = true;
+   inline constexpr bool enable_control< icu::binary_property< Peek, P, V > > = false;
 
    template< typename Peek, UProperty P, int V >
-   inline constexpr bool skip_control< icu::property_value< Peek, P, V > > = true;
+   inline constexpr bool enable_control< icu::property_value< Peek, P, V > > = false;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
 

data/ext/third_party/json/include/tao/json/external/pegtl/contrib/icu/utf16.hpp

@@ -7,9 +7,9 @@
 #include "internal.hpp"
 
 #include "../../config.hpp"
-#include "../../utf16.hpp"
+#include "../utf16.hpp"
 
-#include "../../internal/peek_utf16.hpp"
+#include "../internal/peek_utf16.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE
 {
@@ -18,14 +18,12 @@ namespace TAO_JSON_PEGTL_NAMESPACE
       template< UProperty P, bool V = true >
       struct binary_property
          : internal::icu::binary_property< internal::peek_utf16_be, P, V >
-      {
-      };
+      {};
 
       template< UProperty P, int V >
       struct property_value
          : internal::icu::property_value< internal::peek_utf16_be, P, V >
-      {
-      };
+      {};
 
       // clang-format off
       struct alphabetic : binary_property< UCHAR_ALPHABETIC > {};
@@ -109,14 +107,12 @@ namespace TAO_JSON_PEGTL_NAMESPACE
       template< UProperty P, bool V = true >
       struct binary_property
          : internal::icu::binary_property< internal::peek_utf16_le, P, V >
-      {
-      };
+      {};
 
       template< UProperty P, int V >
       struct property_value
          : internal::icu::property_value< internal::peek_utf16_le, P, V >
-      {
-      };
+      {};
 
       // clang-format off
       struct alphabetic : binary_property< UCHAR_ALPHABETIC > {};