couchbase 3.0.1-universal-darwin-19 → 3.0.2-universal-darwin-19

data/ext/third_party/json/include/tao/json/external/itoa.hpp

@@ -1,149 +0,0 @@
-// This header include/tao/json/external/jeaiii.hpp contains
-// modified portions of the jeaiii/itoa library from
-//   https://github.com/jeaiii/itoa
-// which is licensed as follows:
-
-// Copyright (c) 2017 James Edward Anhalt III - https://github.com/jeaiii/itoa
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#ifndef TAO_JSON_EXTERNAL_ITOA_HPP
-#define TAO_JSON_EXTERNAL_ITOA_HPP
-
-#include <cstdint>
-#include <ostream>
-
-// form a 4.32 fixed point number: t = u * 2^32 / 10^log10(u)
-// use as much precision as possible when needed (log10(u) >= 5)
-// so shift up then down afterwards by log10(u) * log2(10) ~= 53/16
-// need to round up before and or after in some cases
-// once we have the fixed point number we can read off the digit in the upper 32 bits
-// and multiply the lower 32 bits by 10 to get the next digit and so on
-// we can do 2 digits at a time by multiplying by 100 each time
-
-// MISSING:
-// - x64 optimized version (no need to line up on 32bit boundary, so can multiply by 5 instead of 10 using lea instruction)
-// - full 64 bit LG()
-// - try splitting the number into chucks that can be processed independently
-// - try odd digit first
-// - try writing 4 chars at a time
-
-namespace tao::json::itoa
-{
-   struct pair
-   {
-      char t;
-      char o;
-   };
-
-   // clang-format off
-#define TAO_JSON_ITOA_P( T ) { T, '0' }, { T, '1' }, { T, '2' }, { T, '3' }, { T, '4' }, { T, '5' }, { T, '6' }, { T, '7' }, { T, '8' }, { T, '9' }
-   // clang-format on
-
-   static const pair s_pairs[] = { TAO_JSON_ITOA_P( '0' ),
-                                   TAO_JSON_ITOA_P( '1' ),
-                                   TAO_JSON_ITOA_P( '2' ),
-                                   TAO_JSON_ITOA_P( '3' ),
-                                   TAO_JSON_ITOA_P( '4' ),
-                                   TAO_JSON_ITOA_P( '5' ),
-                                   TAO_JSON_ITOA_P( '6' ),
-                                   TAO_JSON_ITOA_P( '7' ),
-                                   TAO_JSON_ITOA_P( '8' ),
-                                   TAO_JSON_ITOA_P( '9' ) };
-
-#define TAO_JSON_ITOA_W( N, I ) *(pair*)&b[ N ] = s_pairs[ I ]
-#define TAO_JSON_ITOA_A( N ) t = ( std::uint64_t( 1 ) << ( 32 + N / 5 * N * 53 / 16 ) ) / std::uint32_t( 1e##N ) + 1 + N / 6 - N / 8, t *= u, t >>= N / 5 * N * 53 / 16, t += N / 6 * 4, TAO_JSON_ITOA_W( 0, t >> 32 )
-#define TAO_JSON_ITOA_S( N ) b[ N ] = char( std::uint64_t( 10 ) * std::uint32_t( t ) >> 32 ) + '0'
-#define TAO_JSON_ITOA_D( N ) t = std::uint64_t( 100 ) * std::uint32_t( t ), TAO_JSON_ITOA_W( N, t >> 32 )
-
-#define TAO_JSON_ITOA_L0 b[ 0 ] = char( u ) + '0'
-#define TAO_JSON_ITOA_L1 TAO_JSON_ITOA_W( 0, u )
-#define TAO_JSON_ITOA_L2 TAO_JSON_ITOA_A( 1 ), TAO_JSON_ITOA_S( 2 )
-#define TAO_JSON_ITOA_L3 TAO_JSON_ITOA_A( 2 ), TAO_JSON_ITOA_D( 2 )
-#define TAO_JSON_ITOA_L4 TAO_JSON_ITOA_A( 3 ), TAO_JSON_ITOA_D( 2 ), TAO_JSON_ITOA_S( 4 )
-#define TAO_JSON_ITOA_L5 TAO_JSON_ITOA_A( 4 ), TAO_JSON_ITOA_D( 2 ), TAO_JSON_ITOA_D( 4 )
-#define TAO_JSON_ITOA_L6 TAO_JSON_ITOA_A( 5 ), TAO_JSON_ITOA_D( 2 ), TAO_JSON_ITOA_D( 4 ), TAO_JSON_ITOA_S( 6 )
-#define TAO_JSON_ITOA_L7 TAO_JSON_ITOA_A( 6 ), TAO_JSON_ITOA_D( 2 ), TAO_JSON_ITOA_D( 4 ), TAO_JSON_ITOA_D( 6 )
-#define TAO_JSON_ITOA_L8 TAO_JSON_ITOA_A( 7 ), TAO_JSON_ITOA_D( 2 ), TAO_JSON_ITOA_D( 4 ), TAO_JSON_ITOA_D( 6 ), TAO_JSON_ITOA_S( 8 )
-#define TAO_JSON_ITOA_L9 TAO_JSON_ITOA_A( 8 ), TAO_JSON_ITOA_D( 2 ), TAO_JSON_ITOA_D( 4 ), TAO_JSON_ITOA_D( 6 ), TAO_JSON_ITOA_D( 8 )
-
-#define TAO_JSON_ITOA_LN( N ) ( TAO_JSON_ITOA_L##N, b += N + 1 )
-
-#define TAO_JSON_ITOA_LG( F ) ( u < 100 ? u < 10 ? F( 0 ) : F( 1 ) : u < 1000000 ? u < 10000 ? u < 1000 ? F( 2 ) : F( 3 ) : u < 100000 ? F( 4 ) : F( 5 ) : u < 100000000 ? u < 10000000 ? F( 6 ) : F( 7 ) : u < 1000000000 ? F( 8 ) : F( 9 ) )
-
-   inline char* u32toa( const std::uint32_t u, char* b )
-   {
-      std::uint64_t t;
-      return TAO_JSON_ITOA_LG( TAO_JSON_ITOA_LN );
-   }
-
-   inline char* i32toa( const std::int32_t i, char* b )
-   {
-      const std::uint32_t u = i < 0 ? ( *b++ = '-', 0 - std::uint32_t( i ) ) : i;
-      std::uint64_t t;
-      return TAO_JSON_ITOA_LG( TAO_JSON_ITOA_LN );
-   }
-
-   inline char* u64toa( const std::uint64_t n, char* b )
-   {
-      std::uint32_t u;
-      std::uint64_t t;
-
-      if( std::uint32_t( n >> 32 ) == 0 ) {
-         return u = std::uint32_t( n ), TAO_JSON_ITOA_LG( TAO_JSON_ITOA_LN );
-      }
-      std::uint64_t a = n / 100000000;
-
-      if( std::uint32_t( a >> 32 ) == 0 ) {
-         u = std::uint32_t( a );
-         TAO_JSON_ITOA_LG( TAO_JSON_ITOA_LN );
-      }
-      else {
-         u = std::uint32_t( a / 100000000 );
-         TAO_JSON_ITOA_LG( TAO_JSON_ITOA_LN );
-         u = a % 100000000;
-         TAO_JSON_ITOA_LN( 7 );
-      }
-      u = n % 100000000;
-      return TAO_JSON_ITOA_LN( 7 );
-   }
-
-   inline char* i64toa( const std::int64_t i, char* b )
-   {
-      const std::uint64_t n = i < 0 ? ( *b++ = '-', 0 - std::uint64_t( i ) ) : i;
-      return u64toa( n, b );
-   }
-
-   inline void i64tos( std::ostream& o, const std::int64_t i )
-   {
-      char b[ 24 ];
-      const auto* s = i64toa( i, b );
-      o.write( b, s - b );
-   }
-
-   inline void u64tos( std::ostream& o, const std::uint64_t i )
-   {
-      char b[ 24 ];
-      const auto* s = u64toa( i, b );
-      o.write( b, s - b );
-   }
-
-}  // namespace tao::json::itoa
-
-#endif

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

@@ -1,44 +0,0 @@
-// 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_HPP
-#define TAO_JSON_PEGTL_HPP
-
-#include "pegtl/config.hpp"
-#include "pegtl/parse.hpp"
-#include "pegtl/version.hpp"
-
-#include "pegtl/ascii.hpp"
-#include "pegtl/rules.hpp"
-#include "pegtl/utf8.hpp"
-
-#include "pegtl/argv_input.hpp"
-#include "pegtl/buffer_input.hpp"
-#include "pegtl/cstream_input.hpp"
-#include "pegtl/istream_input.hpp"
-#include "pegtl/memory_input.hpp"
-#include "pegtl/read_input.hpp"
-#include "pegtl/string_input.hpp"
-
-// This has to be included *after* the above inputs,
-// otherwise the amalgamated header will not work!
-#include "pegtl/file_input.hpp"
-
-#include "pegtl/change_action.hpp"
-#include "pegtl/change_action_and_state.hpp"
-#include "pegtl/change_action_and_states.hpp"
-#include "pegtl/change_control.hpp"
-#include "pegtl/change_state.hpp"
-#include "pegtl/change_states.hpp"
-
-#include "pegtl/disable_action.hpp"
-#include "pegtl/enable_action.hpp"
-
-#include "pegtl/discard_input.hpp"
-#include "pegtl/discard_input_on_failure.hpp"
-#include "pegtl/discard_input_on_success.hpp"
-
-#include "pegtl/must_if.hpp"
-#include "pegtl/visit.hpp"
-
-#endif

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

@@ -1,19 +0,0 @@
-// 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_APPLY_MODE_HPP
-#define TAO_JSON_PEGTL_APPLY_MODE_HPP
-
-#include "config.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE
-{
-   enum class apply_mode : bool
-   {
-      action = true,
-      nothing = false
-   };
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE
-
-#endif

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

@@ -1,49 +0,0 @@
-// Copyright (c) 2017-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
-
-#ifndef TAO_JSON_PEGTL_ARGV_INPUT_HPP
-#define TAO_JSON_PEGTL_ARGV_INPUT_HPP
-
-#include <cstddef>
-#include <sstream>
-#include <string>
-#include <utility>
-
-#include "config.hpp"
-#include "eol.hpp"
-#include "memory_input.hpp"
-#include "tracking_mode.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE
-{
-   namespace internal
-   {
-      [[nodiscard]] inline std::string make_argv_source( const std::size_t argn )
-      {
-         std::ostringstream os;
-         os << "argv[" << argn << ']';
-         return os.str();
-      }
-
-   }  // namespace internal
-
-   template< tracking_mode P = tracking_mode::eager, typename Eol = eol::lf_crlf >
-   struct argv_input
-      : memory_input< P, Eol >
-   {
-      template< typename T >
-      argv_input( char** argv, const std::size_t argn, T&& in_source )
-         : memory_input< P, Eol >( static_cast< const char* >( argv[ argn ] ), std::forward< T >( in_source ) )
-      {}
-
-      argv_input( char** argv, const std::size_t argn )
-         : argv_input( argv, argn, internal::make_argv_source( argn ) )
-      {}
-   };
-
-   template< typename... Ts >
-   argv_input( Ts&&... ) -> argv_input<>;
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE
-
-#endif

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

@@ -1,54 +0,0 @@
-// 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_ASCII_HPP
-#define TAO_JSON_PEGTL_ASCII_HPP
-
-#include "config.hpp"
-
-#include "internal/dependent_false.hpp"
-#include "internal/result_on_found.hpp"
-#include "internal/rules.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE
-{
-   inline namespace ascii
-   {
-      // clang-format off
-      struct alnum : internal::ranges< internal::peek_char, 'a', 'z', 'A', 'Z', '0', '9' > {};
-      struct alpha : internal::ranges< internal::peek_char, 'a', 'z', 'A', 'Z' > {};
-      struct any : internal::any< internal::peek_char > {};
-      struct blank : internal::one< internal::result_on_found::success, internal::peek_char, ' ', '\t' > {};
-      struct digit : internal::range< internal::result_on_found::success, internal::peek_char, '0', '9' > {};
-      struct ellipsis : internal::string< '.', '.', '.' > {};
-      template< char... Cs > struct forty_two : internal::rep< 42, internal::one< internal::result_on_found::success, internal::peek_char, Cs... > > {};
-      struct identifier_first : internal::identifier_first {};
-      struct identifier_other : internal::identifier_other {};
-      struct identifier : internal::identifier {};
-      template< char... Cs > struct istring : internal::istring< Cs... > {};
-      template< char... Cs > struct keyword : internal::seq< internal::string< Cs... >, internal::not_at< internal::identifier_other > > { static_assert( sizeof...( Cs ) > 0 ); };
-      struct lower : internal::range< internal::result_on_found::success, internal::peek_char, 'a', 'z' > {};
-      template< char... Cs > struct not_one : internal::one< internal::result_on_found::failure, internal::peek_char, Cs... > {};
-      template< char Lo, char Hi > struct not_range : internal::range< internal::result_on_found::failure, internal::peek_char, Lo, Hi > {};
-      struct nul : internal::one< internal::result_on_found::success, internal::peek_char, char( 0 ) > {};
-      template< char... Cs > struct one : internal::one< internal::result_on_found::success, internal::peek_char, Cs... > {};
-      struct print : internal::range< internal::result_on_found::success, internal::peek_char, char( 32 ), char( 126 ) > {};
-      template< char Lo, char Hi > struct range : internal::range< internal::result_on_found::success, internal::peek_char, Lo, Hi > {};
-      template< char... Cs > struct ranges : internal::ranges< internal::peek_char, Cs... > {};
-      struct seven : internal::range< internal::result_on_found::success, internal::peek_char, char( 0 ), char( 127 ) > {};
-      struct shebang : internal::seq< internal::string< '#', '!' >, internal::until< internal::eolf > > {};
-      struct space : internal::one< internal::result_on_found::success, internal::peek_char, ' ', '\n', '\r', '\t', '\v', '\f' > {};
-      template< char... Cs > struct string : internal::string< Cs... > {};
-      template< char C > struct three : internal::string< C, C, C > {};
-      template< char C > struct two : internal::string< C, C > {};
-      struct upper : internal::range< internal::result_on_found::success, internal::peek_char, 'A', 'Z' > {};
-      struct xdigit : internal::ranges< internal::peek_char, '0', '9', 'a', 'f', 'A', 'F' > {};
-      // clang-format on
-
-   }  // namespace ascii
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE
-
-#include "internal/pegtl_string.hpp"
-
-#endif

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

@@ -1,212 +0,0 @@
-// Copyright (c) 2016-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
-
-#ifndef TAO_JSON_PEGTL_BUFFER_INPUT_HPP
-#define TAO_JSON_PEGTL_BUFFER_INPUT_HPP
-
-#include <algorithm>
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <memory>
-#include <stdexcept>
-#include <string>
-
-#include "config.hpp"
-#include "eol.hpp"
-#include "memory_input.hpp"
-#include "position.hpp"
-#include "tracking_mode.hpp"
-
-#include "internal/action_input.hpp"
-#include "internal/bump.hpp"
-#include "internal/iterator.hpp"
-#include "internal/marker.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE
-{
-   template< typename Reader, typename Eol = eol::lf_crlf, typename Source = std::string, std::size_t Chunk = 64 >
-   class buffer_input
-   {
-   public:
-      using reader_t = Reader;
-
-      using eol_t = Eol;
-      using source_t = Source;
-
-      using iterator_t = internal::iterator;
-
-      using action_t = internal::action_input< buffer_input >;
-
-      static constexpr std::size_t chunk_size = Chunk;
-      static constexpr tracking_mode tracking_mode_v = tracking_mode::eager;
-
-      template< typename T, typename... As >
-      buffer_input( T&& in_source, const std::size_t maximum, As&&... as )
-         : m_reader( std::forward< As >( as )... ),
-           m_maximum( maximum + Chunk ),
-           m_buffer( new char[ maximum + Chunk ] ),
-           m_current( m_buffer.get() ),
-           m_end( m_buffer.get() ),
-           m_source( std::forward< T >( in_source ) )
-      {
-         static_assert( Chunk, "zero chunk size not implemented" );
-         assert( m_maximum > maximum );  // Catches overflow; change to >= when zero chunk size is implemented.
-      }
-
-      buffer_input( const buffer_input& ) = delete;
-      buffer_input( buffer_input&& ) = delete;
-
-      ~buffer_input() = default;
-
-      void operator=( const buffer_input& ) = delete;
-      void operator=( buffer_input&& ) = delete;
-
-      [[nodiscard]] bool empty()
-      {
-         require( 1 );
-         return m_current.data == m_end;
-      }
-
-      [[nodiscard]] std::size_t size( const std::size_t amount )
-      {
-         require( amount );
-         return buffer_occupied();
-      }
-
-      [[nodiscard]] const char* current() const noexcept
-      {
-         return m_current.data;
-      }
-
-      [[nodiscard]] const char* end( const std::size_t amount )
-      {
-         require( amount );
-         return m_end;
-      }
-
-      [[nodiscard]] std::size_t byte() const noexcept
-      {
-         return m_current.byte;
-      }
-
-      [[nodiscard]] std::size_t line() const noexcept
-      {
-         return m_current.line;
-      }
-
-      [[nodiscard]] std::size_t column() const noexcept
-      {
-         return m_current.column;
-      }
-
-      [[nodiscard]] const Source& source() const noexcept
-      {
-         return m_source;
-      }
-
-      [[nodiscard]] char peek_char( const std::size_t offset = 0 ) const noexcept
-      {
-         return m_current.data[ offset ];
-      }
-
-      [[nodiscard]] std::uint8_t peek_uint8( const std::size_t offset = 0 ) const noexcept
-      {
-         return static_cast< std::uint8_t >( peek_char( offset ) );
-      }
-
-      void bump( const std::size_t in_count = 1 ) noexcept
-      {
-         internal::bump( m_current, in_count, Eol::ch );
-      }
-
-      void bump_in_this_line( const std::size_t in_count = 1 ) noexcept
-      {
-         internal::bump_in_this_line( m_current, in_count );
-      }
-
-      void bump_to_next_line( const std::size_t in_count = 1 ) noexcept
-      {
-         internal::bump_to_next_line( m_current, in_count );
-      }
-
-      void discard() noexcept
-      {
-         if( m_current.data > m_buffer.get() + Chunk ) {
-            const auto s = m_end - m_current.data;
-            std::memmove( m_buffer.get(), m_current.data, s );
-            m_current.data = m_buffer.get();
-            m_end = m_buffer.get() + s;
-         }
-      }
-
-      void require( const std::size_t amount )
-      {
-         if( m_current.data + amount <= m_end ) {
-            return;
-         }
-         if( m_current.data + amount > m_buffer.get() + m_maximum ) {
-            throw std::overflow_error( "require beyond end of buffer" );
-         }
-         if( const auto r = m_reader( m_end, ( std::min )( buffer_free_after_end(), ( std::max )( amount - buffer_occupied(), Chunk ) ) ) ) {
-            m_end += r;
-         }
-      }
-
-      template< rewind_mode M >
-      [[nodiscard]] internal::marker< iterator_t, M > mark() noexcept
-      {
-         return internal::marker< iterator_t, M >( m_current );
-      }
-
-      [[nodiscard]] TAO_JSON_PEGTL_NAMESPACE::position position( const iterator_t& it ) const
-      {
-         return TAO_JSON_PEGTL_NAMESPACE::position( it, m_source );
-      }
-
-      [[nodiscard]] TAO_JSON_PEGTL_NAMESPACE::position position() const
-      {
-         return position( m_current );
-      }
-
-      [[nodiscard]] const iterator_t& iterator() const noexcept
-      {
-         return m_current;
-      }
-
-      [[nodiscard]] std::size_t buffer_capacity() const noexcept
-      {
-         return m_maximum;
-      }
-
-      [[nodiscard]] std::size_t buffer_occupied() const noexcept
-      {
-         assert( m_end >= m_current.data );
-         return std::size_t( m_end - m_current.data );
-      }
-
-      [[nodiscard]] std::size_t buffer_free_before_current() const noexcept
-      {
-         assert( m_current.data >= m_buffer.get() );
-         return std::size_t( m_current.data - m_buffer.get() );
-      }
-
-      [[nodiscard]] std::size_t buffer_free_after_end() const noexcept
-      {
-         assert( m_buffer.get() + m_maximum >= m_end );
-         return std::size_t( m_buffer.get() + m_maximum - m_end );
-      }
-
-   private:
-      Reader m_reader;
-      std::size_t m_maximum;
-      std::unique_ptr< char[] > m_buffer;
-      iterator_t m_current;
-      char* m_end;
-      const Source m_source;
-   };
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE
-
-#endif