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

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

@@ -0,0 +1,227 @@
+// 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_TRACE_HPP
+#define TAO_JSON_PEGTL_CONTRIB_TRACE_HPP
+
+#include <cstddef>
+#include <iomanip>
+#include <iostream>
+#include <string_view>
+#include <tuple>
+
+#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"
+
+namespace TAO_JSON_PEGTL_NAMESPACE
+{
+   template< bool HideInternal = false, bool UseColor = true, std::size_t IndentIncrement = 2, std::size_t InitialIndent = 8 >
+   struct tracer_traits
+   {
+      template< typename Rule >
+      static constexpr bool enable = ( HideInternal ? normal< Rule >::enable : true );
+
+      static constexpr std::size_t initial_indent = InitialIndent;
+      static constexpr std::size_t indent_increment = IndentIncrement;
+
+      static constexpr std::string_view ansi_reset = UseColor ? "\033[m" : "";
+      static constexpr std::string_view ansi_rule = UseColor ? "\033[36m" : "";
+      static constexpr std::string_view ansi_hide = UseColor ? "\033[37m" : "";
+
+      static constexpr std::string_view ansi_position = UseColor ? "\033[1;34m" : "";
+      static constexpr std::string_view ansi_success = UseColor ? "\033[32m" : "";
+      static constexpr std::string_view ansi_failure = UseColor ? "\033[31m" : "";
+      static constexpr std::string_view ansi_raise = UseColor ? "\033[1;31m" : "";
+      static constexpr std::string_view ansi_unwind = UseColor ? "\033[31m" : "";
+      static constexpr std::string_view ansi_apply = UseColor ? "\033[1;36m" : "";
+   };
+
+   using standard_tracer_traits = tracer_traits< true >;
+   using complete_tracer_traits = tracer_traits< false >;
+
+   template< typename TracerTraits >
+   struct tracer
+   {
+      const std::ios_base::fmtflags m_flags;
+      std::size_t m_count = 0;
+      std::vector< std::size_t > m_stack;
+      position m_position;
+
+      template< typename Rule >
+      static constexpr bool enable = TracerTraits::template enable< Rule >;
+
+      template< typename ParseInput >
+      explicit tracer( const ParseInput& in )
+         : m_flags( std::cerr.flags() ),
+           m_position( in.position() )
+      {
+         std::cerr << std::left;
+         print_position();
+      }
+
+      tracer( const tracer& ) = delete;
+      tracer( tracer&& ) = delete;
+
+      ~tracer()
+      {
+         std::cerr.flags( m_flags );
+      }
+
+      tracer& operator=( const tracer& ) = delete;
+      tracer& operator=( tracer&& ) = delete;
+
+      [[nodiscard]] std::size_t indent() const noexcept
+      {
+         return TracerTraits::initial_indent + TracerTraits::indent_increment * m_stack.size();
+      }
+
+      void print_position() const
+      {
+         std::cerr << std::setw( indent() ) << ' ' << TracerTraits::ansi_position << "position" << TracerTraits::ansi_reset << ' ' << m_position << '\n';
+      }
+
+      void update_position( const position& p )
+      {
+         if( m_position != p ) {
+            m_position = p;
+            print_position();
+         }
+      }
+
+      template< typename Rule, typename ParseInput, typename... States >
+      void start( const ParseInput& /*unused*/, States&&... /*unused*/ )
+      {
+         std::cerr << '#' << std::setw( indent() - 1 ) << ++m_count << TracerTraits::ansi_rule << demangle< Rule >() << TracerTraits::ansi_reset << '\n';
+         m_stack.push_back( m_count );
+      }
+
+      template< typename Rule, typename ParseInput, typename... States >
+      void success( const ParseInput& in, States&&... /*unused*/ )
+      {
+         const auto prev = m_stack.back();
+         m_stack.pop_back();
+         std::cerr << std::setw( indent() ) << ' ' << TracerTraits::ansi_success << "success" << TracerTraits::ansi_reset;
+         if( m_count != prev ) {
+            std::cerr << " #" << prev << ' ' << TracerTraits::ansi_hide << demangle< Rule >() << TracerTraits::ansi_reset;
+         }
+         std::cerr << '\n';
+         update_position( in.position() );
+      }
+
+      template< typename Rule, typename ParseInput, typename... States >
+      void failure( const ParseInput& in, States&&... /*unused*/ )
+      {
+         const auto prev = m_stack.back();
+         m_stack.pop_back();
+         std::cerr << std::setw( indent() ) << ' ' << TracerTraits::ansi_failure << "failure" << TracerTraits::ansi_reset;
+         if( m_count != prev ) {
+            std::cerr << " #" << prev << ' ' << TracerTraits::ansi_hide << demangle< Rule >() << TracerTraits::ansi_reset;
+         }
+         std::cerr << '\n';
+         update_position( in.position() );
+      }
+
+      template< typename Rule, typename ParseInput, typename... States >
+      void raise( const ParseInput& /*unused*/, States&&... /*unused*/ )
+      {
+         std::cerr << std::setw( indent() ) << ' ' << TracerTraits::ansi_raise << "raise" << TracerTraits::ansi_reset << ' ' << TracerTraits::ansi_rule << demangle< Rule >() << TracerTraits::ansi_reset << '\n';
+      }
+
+      template< typename Rule, typename ParseInput, typename... States >
+      void unwind( const ParseInput& in, States&&... /*unused*/ )
+      {
+         const auto prev = m_stack.back();
+         m_stack.pop_back();
+         std::cerr << std::setw( indent() ) << ' ' << TracerTraits::ansi_unwind << "unwind" << TracerTraits::ansi_reset;
+         if( m_count != prev ) {
+            std::cerr << " #" << prev << ' ' << TracerTraits::ansi_hide << demangle< Rule >() << TracerTraits::ansi_reset;
+         }
+         std::cerr << '\n';
+         update_position( in.position() );
+      }
+
+      template< typename Rule, typename ParseInput, typename... States >
+      void apply( const ParseInput& /*unused*/, States&&... /*unused*/ )
+      {
+         std::cerr << std::setw( static_cast< int >( indent() - TracerTraits::indent_increment ) ) << ' ' << TracerTraits::ansi_apply << "apply" << TracerTraits::ansi_reset << '\n';
+      }
+
+      template< typename Rule, typename ParseInput, typename... States >
+      void apply0( const ParseInput& /*unused*/, States&&... /*unused*/ )
+      {
+         std::cerr << std::setw( static_cast< int >( indent() - TracerTraits::indent_increment ) ) << ' ' << TracerTraits::ansi_apply << "apply0" << TracerTraits::ansi_reset << '\n';
+      }
+
+      template< typename Rule,
+                template< typename... > class Action = nothing,
+                template< typename... > class Control = normal,
+                typename ParseInput,
+                typename... States >
+      bool parse( ParseInput&& in, States&&... st )
+      {
+         return TAO_JSON_PEGTL_NAMESPACE::parse< Rule, Action, state_control< Control >::template type >( in, st..., *this );
+      }
+   };
+
+   template< typename Rule,
+             template< typename... > class Action = nothing,
+             template< typename... > class Control = normal,
+             typename ParseInput,
+             typename... States >
+   bool standard_trace( ParseInput&& in, States&&... st )
+   {
+      tracer< standard_tracer_traits > tr( in );
+      return tr.parse< Rule, Action, Control >( in, st... );
+   }
+
+   template< typename Rule,
+             template< typename... > class Action = nothing,
+             template< typename... > class Control = normal,
+             typename ParseInput,
+             typename... States >
+   bool complete_trace( ParseInput&& in, States&&... st )
+   {
+      tracer< complete_tracer_traits > tr( in );
+      return tr.parse< Rule, Action, Control >( in, st... );
+   }
+
+   template< typename Tracer >
+   struct trace
+      : 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( sizeof...( st ) == 0 ) {
+            return TAO_JSON_PEGTL_NAMESPACE::match< Rule, A, M, Action, state_control< Control >::template type >( in, st..., Tracer( in ) );
+         }
+         else if constexpr( !std::is_same_v< std::tuple_element_t< sizeof...( st ) - 1, std::tuple< States... > >, Tracer& > ) {
+            return TAO_JSON_PEGTL_NAMESPACE::match< Rule, A, M, Action, state_control< Control >::template type >( in, st..., Tracer( in ) );
+         }
+         else {
+            return TAO_JSON_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
+         }
+      }
+   };
+
+   using trace_standard = trace< tracer< standard_tracer_traits > >;
+   using trace_complete = trace< tracer< complete_tracer_traits > >;
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE
+
+#endif

data/ext/third_party/json/include/tao/json/external/pegtl/{uint16.hpp → contrib/uint16.hpp}

@@ -1,15 +1,15 @@
 // Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
 // Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
 
-#ifndef TAO_JSON_PEGTL_UINT16_HPP
-#define TAO_JSON_PEGTL_UINT16_HPP
+#ifndef TAO_JSON_PEGTL_CONTRIB_UINT16_HPP
+#define TAO_JSON_PEGTL_CONTRIB_UINT16_HPP
 
-#include "config.hpp"
+#include "../config.hpp"
+#include "../internal/result_on_found.hpp"
+#include "../internal/rules.hpp"
 
 #include "internal/peek_mask_uint.hpp"
 #include "internal/peek_uint.hpp"
-#include "internal/result_on_found.hpp"
-#include "internal/rules.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE
 {

data/ext/third_party/json/include/tao/json/external/pegtl/{uint32.hpp → contrib/uint32.hpp}

@@ -1,15 +1,15 @@
 // Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
 // Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
 
-#ifndef TAO_JSON_PEGTL_UINT32_HPP
-#define TAO_JSON_PEGTL_UINT32_HPP
+#ifndef TAO_JSON_PEGTL_CONTRIB_UINT32_HPP
+#define TAO_JSON_PEGTL_CONTRIB_UINT32_HPP
 
-#include "config.hpp"
+#include "../config.hpp"
+#include "../internal/result_on_found.hpp"
+#include "../internal/rules.hpp"
 
 #include "internal/peek_mask_uint.hpp"
 #include "internal/peek_uint.hpp"
-#include "internal/result_on_found.hpp"
-#include "internal/rules.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE
 {

data/ext/third_party/json/include/tao/json/external/pegtl/{uint64.hpp → contrib/uint64.hpp}

@@ -1,15 +1,15 @@
 // Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
 // Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
 
-#ifndef TAO_JSON_PEGTL_UINT64_HPP
-#define TAO_JSON_PEGTL_UINT64_HPP
+#ifndef TAO_JSON_PEGTL_CONTRIB_UINT64_HPP
+#define TAO_JSON_PEGTL_CONTRIB_UINT64_HPP
 
-#include "config.hpp"
+#include "../config.hpp"
+#include "../internal/result_on_found.hpp"
+#include "../internal/rules.hpp"
 
 #include "internal/peek_mask_uint.hpp"
 #include "internal/peek_uint.hpp"
-#include "internal/result_on_found.hpp"
-#include "internal/rules.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE
 {

data/ext/third_party/json/include/tao/json/external/pegtl/{uint8.hpp → contrib/uint8.hpp}

@@ -1,15 +1,15 @@
 // Copyright (c) 2018-2020 Dr. Colin Hirsch and Daniel Frey
 // Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
 
-#ifndef TAO_JSON_PEGTL_UINT8_HPP
-#define TAO_JSON_PEGTL_UINT8_HPP
+#ifndef TAO_JSON_PEGTL_CONTRIB_UINT8_HPP
+#define TAO_JSON_PEGTL_CONTRIB_UINT8_HPP
 
-#include "config.hpp"
+#include "../config.hpp"
+#include "../internal/result_on_found.hpp"
+#include "../internal/rules.hpp"
 
 #include "internal/peek_mask_uint8.hpp"
 #include "internal/peek_uint8.hpp"
-#include "internal/result_on_found.hpp"
-#include "internal/rules.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE::uint8
 {

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

@@ -99,8 +99,8 @@ namespace TAO_JSON_PEGTL_NAMESPACE::unescape
 
    struct append_all
    {
-      template< typename Input >
-      static void apply( const Input& in, std::string& s )
+      template< typename ActionInput >
+      static void apply( const ActionInput& in, std::string& s )
       {
          s.append( in.begin(), in.size() );
       }
@@ -110,22 +110,22 @@ namespace TAO_JSON_PEGTL_NAMESPACE::unescape
    template< typename T, char... Rs >
    struct unescape_c
    {
-      template< typename Input >
-      static void apply( const Input& in, std::string& s )
+      template< typename ActionInput >
+      static void apply( const ActionInput& in, std::string& s )
       {
          assert( in.size() == 1 );
          s += apply_one( in, static_cast< const T* >( nullptr ) );
       }
 
-      template< typename Input, char... Qs >
-      [[nodiscard]] static char apply_one( const Input& in, const one< Qs... >* /*unused*/ )
+      template< typename ActionInput, char... Qs >
+      [[nodiscard]] static char apply_one( const ActionInput& in, const one< Qs... >* /*unused*/ )
       {
          static_assert( sizeof...( Qs ) == sizeof...( Rs ), "size mismatch between escaped characters and their mappings" );
          return apply_two( in, { Qs... }, { Rs... } );
       }
 
-      template< typename Input >
-      [[nodiscard]] static char apply_two( const Input& in, const std::initializer_list< char >& q, const std::initializer_list< char >& r )
+      template< typename ActionInput >
+      [[nodiscard]] static char apply_two( const ActionInput& in, const std::initializer_list< char >& q, const std::initializer_list< char >& r )
       {
          const char c = *in.begin();
          for( std::size_t i = 0; i < q.size(); ++i ) {
@@ -143,8 +143,8 @@ namespace TAO_JSON_PEGTL_NAMESPACE::unescape
 
    struct unescape_u
    {
-      template< typename Input >
-      static void apply( const Input& in, std::string& s )
+      template< typename ActionInput >
+      static void apply( const ActionInput& in, std::string& s )
       {
          assert( !in.empty() );  // First character MUST be present, usually 'u' or 'U'.
          if( !utf8_append_utf32( s, unhex_string< unsigned >( in.begin() + 1, in.end() ) ) ) {
@@ -155,8 +155,8 @@ namespace TAO_JSON_PEGTL_NAMESPACE::unescape
 
    struct unescape_x
    {
-      template< typename Input >
-      static void apply( const Input& in, std::string& s )
+      template< typename ActionInput >
+      static void apply( const ActionInput& in, std::string& s )
       {
          assert( !in.empty() );  // First character MUST be present, usually 'x'.
          s += unhex_string< char >( in.begin() + 1, in.end() );
@@ -173,8 +173,8 @@ namespace TAO_JSON_PEGTL_NAMESPACE::unescape
 
    struct unescape_j
    {
-      template< typename Input >
-      static void apply( const Input& in, std::string& s )
+      template< typename ActionInput >
+      static void apply( const ActionInput& in, std::string& s )
       {
          assert( ( ( in.size() + 1 ) % 6 ) == 0 );  // Expects multiple "\\u1234", starting with the first "u".
          for( const char* b = in.begin() + 1; b < in.end(); b += 6 ) {

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

@@ -28,7 +28,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE::uri
    using colon = one< ':' >;
 
    // clang-format off
-   struct dec_octet : integer::maximum_rule< std::uint8_t > {};
+   struct dec_octet : maximum_rule< std::uint8_t > {};
 
    struct IPv4address : seq< dec_octet, dot, dec_octet, dot, dec_octet, dot, dec_octet > {};
 

data/ext/third_party/json/include/tao/json/external/pegtl/{utf16.hpp → contrib/utf16.hpp}

@@ -1,14 +1,14 @@
 // Copyright (c) 2015-2020 Dr. Colin Hirsch and Daniel Frey
 // Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
 
-#ifndef TAO_JSON_PEGTL_UTF16_HPP
-#define TAO_JSON_PEGTL_UTF16_HPP
+#ifndef TAO_JSON_PEGTL_CONTRIB_UTF16_HPP
+#define TAO_JSON_PEGTL_CONTRIB_UTF16_HPP
 
-#include "config.hpp"
+#include "../config.hpp"
+#include "../internal/result_on_found.hpp"
+#include "../internal/rules.hpp"
 
 #include "internal/peek_utf16.hpp"
-#include "internal/result_on_found.hpp"
-#include "internal/rules.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE
 {

data/ext/third_party/json/include/tao/json/external/pegtl/{utf32.hpp → contrib/utf32.hpp}

@@ -1,14 +1,14 @@
 // 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_UTF32_HPP
-#define TAO_JSON_PEGTL_UTF32_HPP
+#ifndef TAO_JSON_PEGTL_CONTRIB_UTF32_HPP
+#define TAO_JSON_PEGTL_CONTRIB_UTF32_HPP
 
-#include "config.hpp"
+#include "../config.hpp"
+#include "../internal/result_on_found.hpp"
+#include "../internal/rules.hpp"
 
 #include "internal/peek_utf32.hpp"
-#include "internal/result_on_found.hpp"
-#include "internal/rules.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE
 {

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

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