couchbase 3.0.0.alpha.4-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,53 +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/version.hpp"
-
-#include "pegtl/parse.hpp"
-
-#include "pegtl/ascii.hpp"
-#include "pegtl/rules.hpp"
-#include "pegtl/uint16.hpp"
-#include "pegtl/uint32.hpp"
-#include "pegtl/uint64.hpp"
-#include "pegtl/uint8.hpp"
-#include "pegtl/utf16.hpp"
-#include "pegtl/utf32.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"
-
-// The following are not included by
-// default because they include <iostream>.
-
-// #include "pegtl/analyze.hpp"
-
-#endif

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

@@ -1,127 +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_ANALYSIS_ANALYZE_CYCLES_HPP
-#define TAO_JSON_PEGTL_ANALYSIS_ANALYZE_CYCLES_HPP
-
-#include <cassert>
-
-#include <map>
-#include <set>
-#include <stdexcept>
-#include <string_view>
-
-#include <iostream>
-#include <utility>
-
-#include "../config.hpp"
-
-#include "grammar_info.hpp"
-#include "insert_guard.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE::analysis
-{
-   struct analyze_cycles_impl
-   {
-   protected:
-      explicit analyze_cycles_impl( const bool verbose ) noexcept
-         : m_verbose( verbose ),
-           m_problems( 0 )
-      {
-      }
-
-      const bool m_verbose;
-      unsigned m_problems;
-      grammar_info m_info;
-      std::set< std::string_view > m_stack;
-      std::map< std::string_view, bool > m_cache;
-      std::map< std::string_view, bool > m_results;
-
-      [[nodiscard]] std::map< std::string_view, rule_info >::const_iterator find( const std::string_view name ) const noexcept
-      {
-         const auto iter = m_info.map.find( name );
-         assert( iter != m_info.map.end() );
-         return iter;
-      }
-
-      [[nodiscard]] bool work( const std::map< std::string_view, rule_info >::const_iterator& start, const bool accum )
-      {
-         const auto j = m_cache.find( start->first );
-
-         if( j != m_cache.end() ) {
-            return j->second;
-         }
-         if( const auto g = insert_guard( m_stack, start->first ) ) {
-            switch( start->second.type ) {
-               case rule_type::any: {
-                  bool a = false;
-                  for( const auto& r : start->second.rules ) {
-                     a = a || work( find( r ), accum || a );
-                  }
-                  return m_cache[ start->first ] = true;
-               }
-               case rule_type::opt: {
-                  bool a = false;
-                  for( const auto& r : start->second.rules ) {
-                     a = a || work( find( r ), accum || a );
-                  }
-                  return m_cache[ start->first ] = false;
-               }
-               case rule_type::seq: {
-                  bool a = false;
-                  for( const auto& r : start->second.rules ) {
-                     a = a || work( find( r ), accum || a );
-                  }
-                  return m_cache[ start->first ] = a;
-               }
-               case rule_type::sor: {
-                  bool a = true;
-                  for( const auto& r : start->second.rules ) {
-                     a = a && work( find( r ), accum );
-                  }
-                  return m_cache[ start->first ] = a;
-               }
-            }
-            throw std::logic_error( "code should be unreachable: invalid rule_type value" );  // LCOV_EXCL_LINE
-         }
-         if( !accum ) {
-            ++m_problems;
-            if( m_verbose ) {
-               std::cout << "problem: cycle without progress detected at rule class " << start->first << std::endl;  // LCOV_EXCL_LINE
-            }
-         }
-         return m_cache[ start->first ] = accum;
-      }
-   };
-
-   template< typename Grammar >
-   struct analyze_cycles
-      : private analyze_cycles_impl
-   {
-      explicit analyze_cycles( const bool verbose )
-         : analyze_cycles_impl( verbose )
-      {
-         Grammar::analyze_t::template insert< Grammar >( m_info );
-      }
-
-      [[nodiscard]] std::size_t problems()
-      {
-         for( auto i = m_info.map.begin(); i != m_info.map.end(); ++i ) {
-            m_results[ i->first ] = work( i, false );
-            m_cache.clear();
-         }
-         return m_problems;
-      }
-
-      template< typename Rule >
-      [[nodiscard]] bool consumes() const noexcept
-      {
-         const auto i = m_results.find( internal::demangle< Rule >() );
-         assert( i != m_results.end() );
-         return i->second;
-      }
-   };
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE::analysis
-
-#endif

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

@@ -1,23 +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_ANALYSIS_COUNTED_HPP
-#define TAO_JSON_PEGTL_ANALYSIS_COUNTED_HPP
-
-#include "../config.hpp"
-
-#include <cstddef>
-
-#include "generic.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE::analysis
-{
-   template< rule_type Type, std::size_t Count, typename... Rules >
-   struct counted
-      : generic< ( Count != 0 ) ? Type : rule_type::opt, Rules... >
-   {
-   };
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE::analysis
-
-#endif

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

@@ -1,31 +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_ANALYSIS_GENERIC_HPP
-#define TAO_JSON_PEGTL_ANALYSIS_GENERIC_HPP
-
-#include "../config.hpp"
-
-#include "grammar_info.hpp"
-#include "insert_rules.hpp"
-#include "rule_type.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE::analysis
-{
-   template< rule_type Type, typename... Rules >
-   struct generic
-   {
-      template< typename Name >
-      static std::string_view insert( grammar_info& g )
-      {
-         const auto [ it, success ] = g.insert< Name >( Type );
-         if( success ) {
-            insert_rules< Rules... >::insert( g, it->second );
-         }
-         return it->first;
-      }
-   };
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE::analysis
-
-#endif

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

@@ -1,32 +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_ANALYSIS_GRAMMAR_INFO_HPP
-#define TAO_JSON_PEGTL_ANALYSIS_GRAMMAR_INFO_HPP
-
-#include <map>
-#include <string>
-#include <utility>
-
-#include "../config.hpp"
-#include "../internal/demangle.hpp"
-
-#include "rule_info.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE::analysis
-{
-   struct grammar_info
-   {
-      using map_t = std::map< std::string_view, rule_info >;
-      map_t map;
-
-      template< typename Name >
-      auto insert( const rule_type type )
-      {
-         return map.try_emplace( internal::demangle< Name >(), rule_info( type ) );
-      }
-   };
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE::analysis
-
-#endif

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

@@ -1,51 +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_ANALYSIS_INSERT_GUARD_HPP
-#define TAO_JSON_PEGTL_ANALYSIS_INSERT_GUARD_HPP
-
-#include <utility>
-
-#include "../config.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE::analysis
-{
-   template< typename C >
-   class insert_guard
-   {
-   public:
-      insert_guard( C& container, const typename C::value_type& value )
-         : m_i( container.insert( value ) ),
-           m_c( container )
-      {
-      }
-
-      insert_guard( const insert_guard& ) = delete;
-      insert_guard( insert_guard&& ) = delete;
-
-      ~insert_guard()
-      {
-         if( m_i.second ) {
-            m_c.erase( m_i.first );
-         }
-      }
-
-      void operator=( const insert_guard& ) = delete;
-      void operator=( insert_guard&& ) = delete;
-
-      explicit operator bool() const noexcept
-      {
-         return m_i.second;
-      }
-
-   private:
-      const std::pair< typename C::iterator, bool > m_i;
-      C& m_c;
-   };
-
-   template< typename C >
-   insert_guard( C&, const typename C::value_type& )->insert_guard< C >;
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE::analysis
-
-#endif