couchbase 3.0.0 → 3.0.1

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

@@ -26,40 +26,40 @@ namespace TAO_JSON_PEGTL_NAMESPACE::parse_tree
             if( c == '\\' ) {
                os.write( l, p - l );
                l = ++p;
-               os << "\\\\";
+               os << "\\\\\\\\";
             }
             else if( c == '"' ) {
                os.write( l, p - l );
                l = ++p;
-               os << "\\\"";
+               os << "\\\\\\\"";
             }
             else if( c < 32 ) {
                os.write( l, p - l );
                l = ++p;
                switch( c ) {
                   case '\b':
-                     os << "\\b";
+                     os << "\\\\b";
                      break;
                   case '\f':
-                     os << "\\f";
+                     os << "\\\\f";
                      break;
                   case '\n':
-                     os << "\\n";
+                     os << "\\\\n";
                      break;
                   case '\r':
-                     os << "\\r";
+                     os << "\\\\r";
                      break;
                   case '\t':
-                     os << "\\t";
+                     os << "\\\\t";
                      break;
                   default:
-                     os << "\\u00" << h[ ( c & 0xf0 ) >> 4 ] << h[ c & 0x0f ];
+                     os << "\\\\u00" << h[ ( c & 0xf0 ) >> 4 ] << h[ c & 0x0f ];
                }
             }
             else if( c == 127 ) {
                os.write( l, p - l );
                l = ++p;
-               os << "\\u007f";
+               os << "\\\\u007f";
             }
             else {
                ++p;
@@ -74,8 +74,9 @@ namespace TAO_JSON_PEGTL_NAMESPACE::parse_tree
          os << "  x" << &n << " [ label=\"";
          escape( os, s );
          if( n.has_content() ) {
-            os << "\\n";
+            os << "\\n\\\"";
             escape( os, n.string_view() );
+            os << "\\\"";
          }
          os << "\" ]\n";
          if( !n.children.empty() ) {

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

@@ -0,0 +1,75 @@
+// 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_PRINT_HPP
+#define TAO_JSON_PEGTL_CONTRIB_PRINT_HPP
+
+#include <ostream>
+
+#include "../config.hpp"
+#include "../demangle.hpp"
+#include "../type_list.hpp"
+#include "../visit.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE
+{
+   namespace internal
+   {
+      template< typename Name >
+      struct print_names
+      {
+         static void visit( std::ostream& os )
+         {
+            os << demangle< Name >() << '\n';
+         }
+      };
+
+      template< typename Name >
+      struct print_debug
+      {
+         static void visit( std::ostream& os )
+         {
+            const auto first = demangle< Name >();
+            os << first << '\n';
+
+            const auto second = demangle< typename Name::rule_t >();
+            if( first != second ) {
+               os << " (aka) " << second << '\n';
+            }
+
+            print_subs( os, typename Name::subs_t() );
+
+            os << '\n';
+         }
+
+      private:
+         template< typename... Rules >
+         static void print_subs( std::ostream& os, type_list< Rules... > /*unused*/ )
+         {
+            ( print_sub< Rules >( os ), ... );
+         }
+
+         template< typename Rule >
+         static void print_sub( std::ostream& os )
+         {
+            os << " (sub) " << demangle< Rule >() << '\n';
+         }
+      };
+
+   }  // namespace internal
+
+   template< typename Grammar >
+   void print_names( std::ostream& os )
+   {
+      visit< Grammar, internal::print_names >( os );
+   }
+
+   template< typename Grammar >
+   void print_debug( std::ostream& os )
+   {
+      visit< Grammar, internal::print_debug >( os );
+   }
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE
+
+#endif

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

@@ -0,0 +1,53 @@
+// 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_PRINT_COVERAGE_HPP
+#define TAO_JSON_PEGTL_CONTRIB_PRINT_COVERAGE_HPP
+
+#include <ostream>
+
+#include "coverage.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE
+{
+   inline std::ostream& operator<<( std::ostream& os, const coverage_result& result )
+   {
+      os << "[\n";
+      bool f = true;
+      for( const auto& [ k, v ] : result ) {
+         if( f ) {
+            f = false;
+         }
+         else {
+            os << ",\n";
+         }
+         os << "  {\n"
+            << "    \"rule\": \"" << k << "\",\n"
+            << "    \"start\": " << v.start << ", \"success\": " << v.success << ", \"failure\": " << v.failure << ", \"unwind\": " << v.unwind << ", \"raise\": " << v.raise << ",\n";
+         if( v.branches.empty() ) {
+            os << "    \"branches\": []\n";
+         }
+         else {
+            os << "    \"branches\": [\n";
+            bool f2 = true;
+            for( const auto& [ k2, v2 ] : v.branches ) {
+               if( f2 ) {
+                  f2 = false;
+               }
+               else {
+                  os << ",\n";
+               }
+               os << "      { \"branch\": \"" << k2 << "\", \"start\": " << v2.start << ", \"success\": " << v2.success << ", \"failure\": " << v2.failure << ", \"unwind\": " << v2.unwind << ", \"raise\": " << v2.raise << " }";
+            }
+            os << "\n    ]\n";
+         }
+         os << "  }";
+      }
+      os << "\n";
+      os << "]\n";
+      return os;
+   }
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE
+
+#endif

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

@@ -8,19 +8,12 @@
 #include <type_traits>
 
 #include "../apply_mode.hpp"
+#include "../ascii.hpp"
 #include "../config.hpp"
 #include "../rewind_mode.hpp"
+#include "../rules.hpp"
 
-#include "../internal/bytes.hpp"
-#include "../internal/eof.hpp"
-#include "../internal/eol.hpp"
-#include "../internal/must.hpp"
-#include "../internal/not_at.hpp"
-#include "../internal/seq.hpp"
-#include "../internal/skip_control.hpp"
-#include "../internal/star.hpp"
-
-#include "../analysis/generic.hpp"
+#include "analyze_traits.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE
 {
@@ -29,7 +22,8 @@ namespace TAO_JSON_PEGTL_NAMESPACE
       template< char Open, char Marker >
       struct raw_string_open
       {
-         using analyze_t = analysis::generic< analysis::rule_type::any >;
+         using rule_t = raw_string_open;
+         using subs_t = empty_list;
 
          template< apply_mode A,
                    rewind_mode,
@@ -37,9 +31,9 @@ namespace TAO_JSON_PEGTL_NAMESPACE
                    class Action,
                    template< typename... >
                    class Control,
-                   typename Input,
+                   typename ParseInput,
                    typename... States >
-         [[nodiscard]] static bool match( Input& in, std::size_t& marker_size, States&&... /*unused*/ ) noexcept( noexcept( in.size( 0 ) ) )
+         [[nodiscard]] static bool match( ParseInput& in, std::size_t& marker_size, States&&... /*unused*/ ) noexcept( noexcept( in.size( 0 ) ) )
          {
             if( in.empty() || ( in.peek_char( 0 ) != Open ) ) {
                return false;
@@ -62,12 +56,13 @@ namespace TAO_JSON_PEGTL_NAMESPACE
       };
 
       template< char Open, char Marker >
-      inline constexpr bool skip_control< raw_string_open< Open, Marker > > = true;
+      inline constexpr bool enable_control< raw_string_open< Open, Marker > > = false;
 
       template< char Marker, char Close >
       struct at_raw_string_close
       {
-         using analyze_t = analysis::generic< analysis::rule_type::opt >;
+         using rule_t = at_raw_string_close;
+         using subs_t = empty_list;
 
          template< apply_mode A,
                    rewind_mode,
@@ -75,9 +70,9 @@ namespace TAO_JSON_PEGTL_NAMESPACE
                    class Action,
                    template< typename... >
                    class Control,
-                   typename Input,
+                   typename ParseInput,
                    typename... States >
-         [[nodiscard]] static bool match( Input& in, const std::size_t& marker_size, States&&... /*unused*/ ) noexcept( noexcept( in.size( 0 ) ) )
+         [[nodiscard]] static bool match( ParseInput& in, const std::size_t& marker_size, States&&... /*unused*/ ) noexcept( noexcept( in.size( 0 ) ) )
          {
             if( in.size( marker_size ) < marker_size ) {
                return false;
@@ -98,15 +93,18 @@ namespace TAO_JSON_PEGTL_NAMESPACE
       };
 
       template< char Marker, char Close >
-      inline constexpr bool skip_control< at_raw_string_close< Marker, Close > > = true;
+      inline constexpr bool enable_control< at_raw_string_close< Marker, Close > > = false;
 
       template< typename Cond, typename... Rules >
-      struct raw_string_until;
+      struct raw_string_until
+         : raw_string_until< Cond, seq< Rules... > >
+      {};
 
       template< typename Cond >
       struct raw_string_until< Cond >
       {
-         using analyze_t = analysis::generic< analysis::rule_type::seq, star< not_at< Cond >, not_at< eof >, bytes< 1 > >, Cond >;
+         using rule_t = raw_string_until;
+         using subs_t = type_list< Cond >;
 
          template< apply_mode A,
                    rewind_mode M,
@@ -114,9 +112,9 @@ namespace TAO_JSON_PEGTL_NAMESPACE
                    class Action,
                    template< typename... >
                    class Control,
-                   typename Input,
+                   typename ParseInput,
                    typename... States >
-         [[nodiscard]] static bool match( Input& in, const std::size_t& marker_size, States&&... st )
+         [[nodiscard]] static bool match( ParseInput& in, const std::size_t& marker_size, States&&... st )
          {
             auto m = in.template mark< M >();
 
@@ -130,10 +128,11 @@ namespace TAO_JSON_PEGTL_NAMESPACE
          }
       };
 
-      template< typename Cond, typename... Rules >
-      struct raw_string_until
+      template< typename Cond, typename Rule >
+      struct raw_string_until< Cond, Rule >
       {
-         using analyze_t = analysis::generic< analysis::rule_type::seq, star< not_at< Cond >, not_at< eof >, Rules... >, Cond >;
+         using rule_t = raw_string_until;
+         using subs_t = type_list< Cond, Rule >;
 
          template< apply_mode A,
                    rewind_mode M,
@@ -141,15 +140,15 @@ namespace TAO_JSON_PEGTL_NAMESPACE
                    class Action,
                    template< typename... >
                    class Control,
-                   typename Input,
+                   typename ParseInput,
                    typename... States >
-         [[nodiscard]] static bool match( Input& in, const std::size_t& marker_size, States&&... st )
+         [[nodiscard]] static bool match( ParseInput& in, const std::size_t& marker_size, 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, marker_size, st... ) ) {
-               if( in.empty() || !( 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;
                }
             }
@@ -158,7 +157,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE
       };
 
       template< typename Cond, typename... Rules >
-      inline constexpr bool skip_control< raw_string_until< Cond, Rules... > > = true;
+      inline constexpr bool enable_control< raw_string_until< Cond, Rules... > > = false;
 
    }  // namespace internal
 
@@ -194,10 +193,10 @@ namespace TAO_JSON_PEGTL_NAMESPACE
       // when a raw string is not closed properly or has invalid content.
       struct content
          : internal::raw_string_until< internal::at_raw_string_close< Marker, Close >, Contents... >
-      {
-      };
+      {};
 
-      using analyze_t = typename internal::seq< internal::bytes< 1 >, content, internal::bytes< 1 > >::analyze_t;
+      using rule_t = raw_string;
+      using subs_t = empty_list;  // type_list< internal::raw_string_open< Open, Marker >, internal::must< content > >;
 
       template< apply_mode A,
                 rewind_mode M,
@@ -205,14 +204,14 @@ namespace TAO_JSON_PEGTL_NAMESPACE
                 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 marker_size;
-         if( internal::raw_string_open< Open, Marker >::template match< A, M, Action, Control >( in, marker_size, st... ) ) {
+         if( Control< internal::raw_string_open< Open, Marker > >::template match< A, M, Action, Control >( in, marker_size, st... ) ) {
             // TODO: Do not rely on must<>
-            (void)internal::must< content >::template match< A, M, Action, Control >( in, marker_size, st... );
+            (void)Control< internal::must< content > >::template match< A, M, Action, Control >( in, marker_size, st... );
             in.bump_in_this_line( marker_size );
             return true;
          }
@@ -220,6 +219,16 @@ namespace TAO_JSON_PEGTL_NAMESPACE
       }
    };
 
+   template< typename Name, char Open, char Marker, char Close >
+   struct analyze_traits< Name, raw_string< Open, Marker, Close > >
+      : analyze_any_traits<>
+   {};
+
+   template< typename Name, char Open, char Marker, char Close, typename... Contents >
+   struct analyze_traits< Name, raw_string< Open, Marker, Close, Contents... > >
+      : analyze_traits< Name, typename seq< any, star< Contents... >, any >::rule_t >
+   {};
+
 }  // namespace TAO_JSON_PEGTL_NAMESPACE
 
 #endif

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

@@ -4,80 +4,63 @@
 #ifndef TAO_JSON_PEGTL_CONTRIB_REMOVE_FIRST_STATE_HPP
 #define TAO_JSON_PEGTL_CONTRIB_REMOVE_FIRST_STATE_HPP
 
-#include "../apply_mode.hpp"
+#include <type_traits>
+
 #include "../config.hpp"
-#include "../rewind_mode.hpp"
+
+#include "../internal/has_unwind.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE
 {
-   // NOTE: The naming of the following classes might still change.
-
-   template< typename Rule, template< typename... > class Control >
-   struct remove_first_state_after_match
-      : Control< Rule >
+   // Applies to start(), success(), failure(), raise(), apply(), and apply0():
+   // The first state is removed when the call is forwarded to Base.
+   template< typename Base >
+   struct remove_first_state
+      : Base
    {
-      template< typename Input, typename State, typename... States >
-      static void start( const Input& in, State&& /*unused*/, States&&... st ) noexcept( noexcept( Control< Rule >::start( in, st... ) ) )
+      template< typename ParseInput, typename State, typename... States >
+      static void start( const ParseInput& in, State&& /*unused*/, States&&... st ) noexcept( noexcept( Base::start( in, st... ) ) )
       {
-         Control< Rule >::start( in, st... );
+         Base::start( in, st... );
       }
 
-      template< typename Input, typename State, typename... States >
-      static void success( const Input& in, State&& /*unused*/, States&&... st ) noexcept( noexcept( Control< Rule >::success( in, st... ) ) )
+      template< typename ParseInput, typename State, typename... States >
+      static void success( const ParseInput& in, State&& /*unused*/, States&&... st ) noexcept( noexcept( Base::success( in, st... ) ) )
       {
-         Control< Rule >::success( in, st... );
+         Base::success( in, st... );
       }
 
-      template< typename Input, typename State, typename... States >
-      static void failure( const Input& in, State&& /*unused*/, States&&... st ) noexcept( noexcept( Control< Rule >::failure( in, st... ) ) )
+      template< typename ParseInput, typename State, typename... States >
+      static void failure( const ParseInput& in, State&& /*unused*/, States&&... st ) noexcept( noexcept( Base::failure( in, st... ) ) )
       {
-         Control< Rule >::failure( in, st... );
+         Base::failure( in, st... );
       }
 
-      template< typename Input, typename State, typename... States >
-      static void raise( const Input& in, State&& /*unused*/, States&&... st )
+      template< typename ParseInput, typename State, typename... States >
+      [[noreturn]] static void raise( const ParseInput& in, State&& /*unused*/, States&&... st )
       {
-         Control< Rule >::raise( in, st... );
+         Base::raise( in, st... );
       }
 
-      template< template< typename... > class Action,
-                typename Iterator,
-                typename Input,
-                typename State,
-                typename... States >
-      static auto apply( const Iterator& begin, const Input& in, State&& /*unused*/, States&&... st ) noexcept( noexcept( Control< Rule >::template apply< Action >( begin, in, st... ) ) )
-         -> decltype( Control< Rule >::template apply< Action >( begin, in, st... ) )
+      template< typename ParseInput, typename State, typename... States >
+      static auto unwind( const ParseInput& in, State&& /*unused*/, States&&... st )
+         -> std::enable_if_t< internal::has_unwind< Base, void, const ParseInput&, States... > >
       {
-         return Control< Rule >::template apply< Action >( begin, in, st... );
+         Base::unwind( in, st... );
       }
 
-      template< template< typename... > class Action,
-                typename Input,
-                typename State,
-                typename... States >
-      static auto apply0( const Input& in, State&& /*unused*/, States&&... st ) noexcept( noexcept( Control< Rule >::template apply0< Action >( in, st... ) ) )
-         -> decltype( Control< Rule >::template apply0< Action >( in, st... ) )
+      template< template< typename... > class Action, typename Iterator, typename ParseInput, typename State, typename... States >
+      static auto apply( const Iterator& begin, const ParseInput& in, State&& /*unused*/, States&&... st ) noexcept( noexcept( Base::template apply< Action >( begin, in, st... ) ) )
+         -> decltype( Base::template apply< Action >( begin, in, st... ) )
       {
-         return Control< Rule >::template apply0< Action >( in, st... );
+         return Base::template apply< Action >( begin, in, st... );
       }
-   };
 
-   template< typename Rule, template< typename... > class Control >
-   struct remove_self_and_first_state
-      : Control< Rule >
-   {
-      template< apply_mode A,
-                rewind_mode M,
-                template< typename... >
-                class Action,
-                template< typename... >
-                class,
-                typename Input,
-                typename State,
-                typename... States >
-      [[nodiscard]] static bool match( Input& in, State&& /*unused*/, States&&... st )
+      template< template< typename... > class Action, typename ParseInput, typename State, typename... States >
+      static auto apply0( const ParseInput& in, State&& /*unused*/, States&&... st ) noexcept( noexcept( Base::template apply0< Action >( in, st... ) ) )
+         -> decltype( Base::template apply0< Action >( in, st... ) )
       {
-         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
+         return Base::template apply0< Action >( in, st... );
       }
    };