couchbase 3.0.0.alpha.5-x86_64-linux → 3.5.1-x86_64-linux

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/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

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

@@ -1,25 +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_RULES_HPP
-#define TAO_JSON_PEGTL_ANALYSIS_INSERT_RULES_HPP
-
-#include "../config.hpp"
-
-#include "grammar_info.hpp"
-#include "rule_info.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE::analysis
-{
-   template< typename... Rules >
-   struct insert_rules
-   {
-      static void insert( grammar_info& g, rule_info& r )
-      {
-         ( r.rules.emplace_back( Rules::analyze_t::template insert< Rules >( g ) ), ... );
-      }
-   };
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE::analysis
-
-#endif

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

@@ -1,29 +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_RULE_INFO_HPP
-#define TAO_JSON_PEGTL_ANALYSIS_RULE_INFO_HPP
-
-#include <string>
-#include <vector>
-
-#include "../config.hpp"
-
-#include "rule_type.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE::analysis
-{
-   struct rule_info
-   {
-      explicit rule_info( const rule_type in_type ) noexcept
-         : type( in_type )
-      {
-      }
-
-      rule_type type;
-      std::vector< std::string > rules;
-   };
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE::analysis
-
-#endif

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

@@ -1,21 +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_RULE_TYPE_HPP
-#define TAO_JSON_PEGTL_ANALYSIS_RULE_TYPE_HPP
-
-#include "../config.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE::analysis
-{
-   enum class rule_type : char
-   {
-      any,  // Consumption-on-success is always true; assumes bounded repetition of conjunction of sub-rules.
-      opt,  // Consumption-on-success not necessarily true; assumes bounded repetition of conjunction of sub-rules.
-      seq,  // Consumption-on-success depends on consumption of (non-zero bounded repetition of) conjunction of sub-rules.
-      sor   // Consumption-on-success depends on consumption of (non-zero bounded repetition of) disjunction of sub-rules.
-   };
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE::analysis
-
-#endif

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

@@ -1,21 +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_ANALYZE_HPP
-#define TAO_JSON_PEGTL_ANALYZE_HPP
-
-#include "config.hpp"
-
-#include "analysis/analyze_cycles.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE
-{
-   template< typename Rule >
-   [[nodiscard]] std::size_t analyze( const bool verbose = true )
-   {
-      return analysis::analyze_cycles< Rule >( verbose ).problems();
-   }
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE
-
-#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,51 +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,67 +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 "eol.hpp"
-
-#include "internal/always_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::alnum {};
-      struct alpha : internal::alpha {};
-      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< '.', '.', '.' > {};
-      struct eolf : internal::eolf {};
-      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 > > {};
-      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::if_must< false, 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
-
-      template<>
-      struct keyword<>
-      {
-         template< typename Input >
-         [[nodiscard]] static bool match( Input& /*unused*/ ) noexcept
-         {
-            static_assert( internal::always_false< Input >::value, "empty keywords not allowed" );
-            return false;
-         }
-      };
-
-   }  // namespace ascii
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE
-
-#include "internal/pegtl_string.hpp"
-
-#endif