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

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

@@ -4,14 +4,16 @@
 #ifndef TAO_JSON_PEGTL_MMAP_INPUT_HPP
 #define TAO_JSON_PEGTL_MMAP_INPUT_HPP
 
+#include <filesystem>
 #include <string>
-#include <utility>
 
 #include "config.hpp"
 #include "eol.hpp"
 #include "memory_input.hpp"
 #include "tracking_mode.hpp"
 
+#include "internal/path_to_string.hpp"
+
 #if defined( __unix__ ) || ( defined( __APPLE__ ) && defined( __MACH__ ) )
 #include <unistd.h>  // Required for _POSIX_MAPPED_FILES
 #endif
@@ -29,15 +31,11 @@ namespace TAO_JSON_PEGTL_NAMESPACE
    {
       struct mmap_holder
       {
-         const std::string filename;
          const file_mapper data;
 
-         template< typename T >
-         explicit mmap_holder( T&& in_filename )
-            : filename( std::forward< T >( in_filename ) ),
-              data( filename.c_str() )
-         {
-         }
+         explicit mmap_holder( const std::filesystem::path& path )
+            : data( path )
+         {}
 
          mmap_holder( const mmap_holder& ) = delete;
          mmap_holder( mmap_holder&& ) = delete;
@@ -53,14 +51,16 @@ namespace TAO_JSON_PEGTL_NAMESPACE
    template< tracking_mode P = tracking_mode::eager, typename Eol = eol::lf_crlf >
    struct mmap_input
       : private internal::mmap_holder,
-        public memory_input< P, Eol, const char* >
+        public memory_input< P, Eol >
    {
-      template< typename T >
-      explicit mmap_input( T&& in_filename )
-         : internal::mmap_holder( std::forward< T >( in_filename ) ),
-           memory_input< P, Eol, const char* >( data.begin(), data.end(), filename.c_str() )
-      {
-      }
+      mmap_input( const std::filesystem::path& path, const std::string& source )
+         : internal::mmap_holder( path ),
+           memory_input< P, Eol >( data.begin(), data.end(), source )
+      {}
+
+      explicit mmap_input( const std::filesystem::path& path )
+         : mmap_input( path, internal::path_to_string( path ) )
+      {}
 
       mmap_input( const mmap_input& ) = delete;
       mmap_input( mmap_input&& ) = delete;
@@ -72,7 +72,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE
    };
 
    template< typename... Ts >
-   explicit mmap_input( Ts&&... )->mmap_input<>;
+   explicit mmap_input( Ts&&... ) -> mmap_input<>;
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE
 

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

@@ -0,0 +1,64 @@
+// 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_MUST_IF_HPP
+#define TAO_JSON_PEGTL_MUST_IF_HPP
+
+#include <type_traits>
+
+#include "config.hpp"
+#include "normal.hpp"
+
+namespace TAO_JSON_PEGTL_NAMESPACE
+{
+   namespace internal
+   {
+      template< typename Errors, typename Rule, typename = void >
+      inline constexpr bool raise_on_failure = ( Errors::template message< Rule > != nullptr );
+
+      template< typename Errors, typename Rule >
+      inline constexpr bool raise_on_failure< Errors, Rule, std::void_t< decltype( Errors::template raise_on_failure< Rule > ) > > = Errors::template raise_on_failure< Rule >;
+
+   }  // namespace internal
+
+   template< typename Errors, template< typename... > class Base = normal, bool RequireMessage = true >
+   struct must_if
+   {
+      template< typename Rule >
+      struct control
+         : Base< Rule >
+      {
+         template< typename ParseInput, typename... States >
+         static void failure( const ParseInput& in, States&&... st ) noexcept( noexcept( Base< Rule >::failure( in, st... ) ) && !internal::raise_on_failure< Errors, Rule > )
+         {
+            if constexpr( internal::raise_on_failure< Errors, Rule > ) {
+               raise( in, st... );
+            }
+            else {
+               Base< Rule >::failure( in, st... );
+            }
+         }
+
+         template< typename ParseInput, typename... States >
+         [[noreturn]] static void raise( const ParseInput& in, [[maybe_unused]] States&&... st )
+         {
+            if constexpr( RequireMessage ) {
+               static_assert( Errors::template message< Rule > != nullptr );
+            }
+            if constexpr( Errors::template message< Rule > != nullptr ) {
+               constexpr const char* p = Errors::template message< Rule >;
+               throw parse_error( p, in );
+#if defined( _MSC_VER )
+               ( (void)st, ... );
+#endif
+            }
+            else {
+               Base< Rule >::raise( in, st... );
+            }
+         }
+      };
+   };
+
+}  // namespace TAO_JSON_PEGTL_NAMESPACE
+
+#endif

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

@@ -10,11 +10,12 @@
 
 #include "apply_mode.hpp"
 #include "config.hpp"
+#include "demangle.hpp"
 #include "match.hpp"
 #include "parse_error.hpp"
 #include "rewind_mode.hpp"
 
-#include "internal/demangle.hpp"
+#include "internal/enable_control.hpp"
 #include "internal/has_match.hpp"
 
 namespace TAO_JSON_PEGTL_NAMESPACE
@@ -22,42 +23,41 @@ namespace TAO_JSON_PEGTL_NAMESPACE
    template< typename Rule >
    struct normal
    {
-      template< typename Input, typename... States >
-      static void start( const Input& /*unused*/, States&&... /*unused*/ ) noexcept
-      {
-      }
+      static constexpr bool enable = internal::enable_control< Rule >;
 
-      template< typename Input, typename... States >
-      static void success( const Input& /*unused*/, States&&... /*unused*/ ) noexcept
-      {
-      }
+      template< typename ParseInput, typename... States >
+      static void start( const ParseInput& /*unused*/, States&&... /*unused*/ ) noexcept
+      {}
 
-      template< typename Input, typename... States >
-      static void failure( const Input& /*unused*/, States&&... /*unused*/ ) noexcept
-      {
-      }
+      template< typename ParseInput, typename... States >
+      static void success( const ParseInput& /*unused*/, States&&... /*unused*/ ) noexcept
+      {}
+
+      template< typename ParseInput, typename... States >
+      static void failure( const ParseInput& /*unused*/, States&&... /*unused*/ ) noexcept
+      {}
 
-      template< typename Input, typename... States >
-      static void raise( const Input& in, States&&... /*unused*/ )
+      template< typename ParseInput, typename... States >
+      [[noreturn]] static void raise( const ParseInput& in, States&&... /*unused*/ )
       {
-         throw parse_error( "parse error matching " + std::string( internal::demangle< Rule >() ), in );
+         throw parse_error( "parse error matching " + std::string( demangle< Rule >() ), in );
       }
 
       template< template< typename... > class Action,
                 typename Iterator,
-                typename Input,
+                typename ParseInput,
                 typename... States >
-      static auto apply( const Iterator& begin, const Input& in, States&&... st ) noexcept( noexcept( Action< Rule >::apply( std::declval< const typename Input::action_t& >(), st... ) ) )
-         -> decltype( Action< Rule >::apply( std::declval< const typename Input::action_t& >(), st... ) )
+      static auto apply( const Iterator& begin, const ParseInput& in, States&&... st ) noexcept( noexcept( Action< Rule >::apply( std::declval< const typename ParseInput::action_t& >(), st... ) ) )
+         -> decltype( Action< Rule >::apply( std::declval< const typename ParseInput::action_t& >(), st... ) )
       {
-         const typename Input::action_t action_input( begin, in );
+         const typename ParseInput::action_t action_input( begin, in );
          return Action< Rule >::apply( action_input, st... );
       }
 
       template< template< typename... > class Action,
-                typename Input,
+                typename ParseInput,
                 typename... States >
-      static auto apply0( const Input& /*unused*/, States&&... st ) noexcept( noexcept( Action< Rule >::apply0( st... ) ) )
+      static auto apply0( const ParseInput& /*unused*/, States&&... st ) noexcept( noexcept( Action< Rule >::apply0( st... ) ) )
          -> decltype( Action< Rule >::apply0( st... ) )
       {
          return Action< Rule >::apply0( st... );
@@ -69,11 +69,11 @@ 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 )
       {
-         if constexpr( internal::has_match_v< Rule, A, M, Action, Control, Input, States... > ) {
+         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
             return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
          }
          else {

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

@@ -10,8 +10,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE
 {
    template< typename Rule >
    struct nothing
-   {
-   };
+   {};
 
    using maybe_nothing = nothing< void >;
 

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

@@ -13,8 +13,6 @@
 #include "parse_error.hpp"
 #include "rewind_mode.hpp"
 
-#include "internal/action_input.hpp"
-
 namespace TAO_JSON_PEGTL_NAMESPACE
 {
    template< typename Rule,
@@ -22,9 +20,9 @@ namespace TAO_JSON_PEGTL_NAMESPACE
              template< typename... > class Control = normal,
              apply_mode A = apply_mode::action,
              rewind_mode M = rewind_mode::required,
-             typename Input,
+             typename ParseInput,
              typename... States >
-   bool parse( Input&& in, States&&... st )
+   auto parse( ParseInput&& in, States&&... st )
    {
       return Control< Rule >::template match< A, M, Action, Control >( in, st... );
    }
@@ -34,16 +32,16 @@ namespace TAO_JSON_PEGTL_NAMESPACE
              template< typename... > class Control = normal,
              apply_mode A = apply_mode::action,
              rewind_mode M = rewind_mode::required,
-             typename Outer,
-             typename Input,
+             typename OuterInput,
+             typename ParseInput,
              typename... States >
-   bool parse_nested( const Outer& oi, Input&& in, States&&... st )
+   auto parse_nested( const OuterInput& oi, ParseInput&& in, States&&... st )
    {
       try {
          return parse< Rule, Action, Control, A, M >( in, st... );
       }
       catch( parse_error& e ) {
-         e.positions.push_back( oi.position() );
+         e.add_position( oi.position() );
          throw;
       }
    }

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

@@ -4,10 +4,11 @@
 #ifndef TAO_JSON_PEGTL_PARSE_ERROR_HPP
 #define TAO_JSON_PEGTL_PARSE_ERROR_HPP
 
-#include <ostream>
-#include <sstream>
+#include <cstddef>
+#include <memory>
 #include <stdexcept>
 #include <string>
+#include <string_view>
 #include <utility>
 #include <vector>
 
@@ -16,53 +17,97 @@
 
 namespace TAO_JSON_PEGTL_NAMESPACE
 {
-   struct parse_error
-      : std::runtime_error
+   namespace internal
    {
-      template< typename Msg >
-      parse_error( Msg&& msg, std::vector< position > in_positions )
-         : std::runtime_error( std::forward< Msg >( msg ) ),
-           positions( std::move( in_positions ) )
+      class parse_error
       {
-      }
+      private:
+         std::string m_msg;
+         std::size_t m_prefix = 0;
+         std::vector< position > m_positions;
+
+      public:
+         explicit parse_error( const char* msg )
+            : m_msg( msg )
+         {}
+
+         [[nodiscard]] const char* what() const noexcept
+         {
+            return m_msg.c_str();
+         }
+
+         [[nodiscard]] std::string_view message() const noexcept
+         {
+            return { m_msg.data() + m_prefix, m_msg.size() - m_prefix };
+         }
+
+         [[nodiscard]] const std::vector< position >& positions() const noexcept
+         {
+            return m_positions;
+         }
 
-      template< typename Msg >
-      parse_error( Msg&& msg, const position& pos )
-         : std::runtime_error( std::forward< Msg >( msg ) ),
-           positions( 1, pos )
+         void add_position( position&& p )
+         {
+            const auto prefix = to_string( p );
+            m_msg = prefix + ": " + m_msg;
+            m_prefix += prefix.size() + 2;
+            m_positions.emplace_back( std::move( p ) );
+         }
+      };
+
+   }  // namespace internal
+
+   class parse_error
+      : public std::runtime_error
+   {
+   private:
+      std::shared_ptr< internal::parse_error > m_impl;
+
+   public:
+      parse_error( const char* msg, position p )
+         : std::runtime_error( msg ),
+           m_impl( std::make_shared< internal::parse_error >( msg ) )
       {
+         m_impl->add_position( std::move( p ) );
       }
 
-      template< typename Msg >
-      parse_error( Msg&& msg, position&& pos )
-         : std::runtime_error( std::forward< Msg >( msg ) )
+      parse_error( const std::string& msg, position p )
+         : parse_error( msg.c_str(), std::move( p ) )
+      {}
+
+      template< typename ParseInput >
+      parse_error( const char* msg, const ParseInput& in )
+         : parse_error( msg, in.position() )
+      {}
+
+      template< typename ParseInput >
+      parse_error( const std::string& msg, const ParseInput& in )
+         : parse_error( msg.c_str(), in.position() )
+      {}
+
+      [[nodiscard]] const char* what() const noexcept override
       {
-         positions.emplace_back( std::move( pos ) );
+         return m_impl->what();
       }
 
-      template< typename Msg, typename Input >
-      parse_error( Msg&& msg, const Input& in )
-         : parse_error( std::forward< Msg >( msg ), in.position() )
+      [[nodiscard]] std::string_view message() const noexcept
       {
+         return m_impl->message();
       }
 
-      std::vector< position > positions;
-   };
-
-   inline std::ostream& operator<<( std::ostream& o, const parse_error& e )
-   {
-      for( auto it = e.positions.rbegin(); it != e.positions.rend(); ++it ) {
-         o << *it << ": ";
+      [[nodiscard]] const std::vector< position >& positions() const noexcept
+      {
+         return m_impl->positions();
       }
-      return o << e.what();
-   }
 
-   [[nodiscard]] inline std::string to_string( const parse_error& e )
-   {
-      std::ostringstream o;
-      o << e;
-      return o.str();
-   }
+      void add_position( position&& p )
+      {
+         if( m_impl.use_count() > 1 ) {
+            m_impl = std::make_shared< internal::parse_error >( *m_impl );
+         }
+         m_impl->add_position( std::move( p ) );
+      }
+   };
 
 }  // namespace TAO_JSON_PEGTL_NAMESPACE
 

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

@@ -23,10 +23,9 @@ namespace TAO_JSON_PEGTL_NAMESPACE
       position( position&& p ) noexcept
          : byte( p.byte ),
            line( p.line ),
-           byte_in_line( p.byte_in_line ),
+           column( p.column ),
            source( std::move( p.source ) )
-      {
-      }
+      {}
 
       position( const position& ) = default;
 
@@ -34,7 +33,7 @@ namespace TAO_JSON_PEGTL_NAMESPACE
       {
          byte = p.byte;
          line = p.line;
-         byte_in_line = p.byte_in_line;
+         column = p.column;
          source = std::move( p.source );
          return *this;
       }
@@ -45,22 +44,31 @@ namespace TAO_JSON_PEGTL_NAMESPACE
       position( const internal::iterator& in_iter, T&& in_source )
          : byte( in_iter.byte ),
            line( in_iter.line ),
-           byte_in_line( in_iter.byte_in_line ),
+           column( in_iter.column ),
            source( std::forward< T >( in_source ) )
-      {
-      }
+      {}
 
       ~position() = default;
 
       std::size_t byte;
       std::size_t line;
-      std::size_t byte_in_line;
+      std::size_t column;
       std::string source;
    };
 
-   inline std::ostream& operator<<( std::ostream& o, const position& p )
+   inline bool operator==( const position& lhs, const position& rhs ) noexcept
+   {
+      return ( lhs.byte == rhs.byte ) && ( lhs.source == rhs.source );
+   }
+
+   inline bool operator!=( const position& lhs, const position& rhs ) noexcept
+   {
+      return !( lhs == rhs );
+   }
+
+   inline std::ostream& operator<<( std::ostream& os, const position& p )
    {
-      return o << p.source << ':' << p.line << ':' << p.byte_in_line << '(' << p.byte << ')';
+      return os << p.source << ':' << p.line << ':' << p.column;
    }
 
    [[nodiscard]] inline std::string to_string( const position& p )