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

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

@@ -1,199 +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_CONTRIB_UNESCAPE_HPP
-#define TAO_JSON_PEGTL_CONTRIB_UNESCAPE_HPP
-
-#include <cassert>
-#include <string>
-
-#include "../ascii.hpp"
-#include "../config.hpp"
-#include "../parse_error.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE::unescape
-{
-   // Utility functions for the unescape actions.
-
-   [[nodiscard]] inline bool utf8_append_utf32( std::string& string, const unsigned utf32 )
-   {
-      if( utf32 <= 0x7f ) {
-         string += char( utf32 & 0xff );
-         return true;
-      }
-      if( utf32 <= 0x7ff ) {
-         char tmp[] = { char( ( ( utf32 & 0x7c0 ) >> 6 ) | 0xc0 ),
-                        char( ( ( utf32 & 0x03f ) ) | 0x80 ) };
-         string.append( tmp, sizeof( tmp ) );
-         return true;
-      }
-      if( utf32 <= 0xffff ) {
-         if( utf32 >= 0xd800 && utf32 <= 0xdfff ) {
-            // nope, this is a UTF-16 surrogate
-            return false;
-         }
-         char tmp[] = { char( ( ( utf32 & 0xf000 ) >> 12 ) | 0xe0 ),
-                        char( ( ( utf32 & 0x0fc0 ) >> 6 ) | 0x80 ),
-                        char( ( ( utf32 & 0x003f ) ) | 0x80 ) };
-         string.append( tmp, sizeof( tmp ) );
-         return true;
-      }
-      if( utf32 <= 0x10ffff ) {
-         char tmp[] = { char( ( ( utf32 & 0x1c0000 ) >> 18 ) | 0xf0 ),
-                        char( ( ( utf32 & 0x03f000 ) >> 12 ) | 0x80 ),
-                        char( ( ( utf32 & 0x000fc0 ) >> 6 ) | 0x80 ),
-                        char( ( ( utf32 & 0x00003f ) ) | 0x80 ) };
-         string.append( tmp, sizeof( tmp ) );
-         return true;
-      }
-      return false;
-   }
-
-   // This function MUST only be called for characters matching TAO_JSON_PEGTL_NAMESPACE::ascii::xdigit!
-   template< typename I >
-   [[nodiscard]] I unhex_char( const char c )
-   {
-      switch( c ) {
-         case '0':
-         case '1':
-         case '2':
-         case '3':
-         case '4':
-         case '5':
-         case '6':
-         case '7':
-         case '8':
-         case '9':
-            return I( c - '0' );
-         case 'a':
-         case 'b':
-         case 'c':
-         case 'd':
-         case 'e':
-         case 'f':
-            return I( c - 'a' + 10 );
-         case 'A':
-         case 'B':
-         case 'C':
-         case 'D':
-         case 'E':
-         case 'F':
-            return I( c - 'A' + 10 );
-         default:                                                      // LCOV_EXCL_LINE
-            throw std::runtime_error( "invalid character in unhex" );  // LCOV_EXCL_LINE
-      }
-   }
-
-   template< typename I >
-   [[nodiscard]] I unhex_string( const char* begin, const char* end )
-   {
-      I r = 0;
-      while( begin != end ) {
-         r <<= 4;
-         r += unhex_char< I >( *begin++ );
-      }
-      return r;
-   }
-
-   // Actions for common unescape situations.
-
-   struct append_all
-   {
-      template< typename Input >
-      static void apply( const Input& in, std::string& s )
-      {
-         s.append( in.begin(), in.size() );
-      }
-   };
-
-   // This action MUST be called for a character matching T which MUST be TAO_JSON_PEGTL_NAMESPACE::one< ... >.
-   template< typename T, char... Rs >
-   struct unescape_c
-   {
-      template< typename Input >
-      static void apply( const Input& 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*/ )
-      {
-         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 )
-      {
-         const char c = *in.begin();
-         for( std::size_t i = 0; i < q.size(); ++i ) {
-            if( *( q.begin() + i ) == c ) {
-               return *( r.begin() + i );
-            }
-         }
-         throw parse_error( "invalid character in unescape", in );  // LCOV_EXCL_LINE
-      }
-   };
-
-   // See src/example/pegtl/unescape.cpp for why the following two actions
-   // skip the first input character. They also MUST be called
-   // with non-empty matched inputs!
-
-   struct unescape_u
-   {
-      template< typename Input >
-      static void apply( const Input& 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() ) ) ) {
-            throw parse_error( "invalid escaped unicode code point", in );
-         }
-      }
-   };
-
-   struct unescape_x
-   {
-      template< typename Input >
-      static void apply( const Input& in, std::string& s )
-      {
-         assert( !in.empty() );  // First character MUST be present, usually 'x'.
-         s += unhex_string< char >( in.begin() + 1, in.end() );
-      }
-   };
-
-   // The unescape_j action is similar to unescape_u, however unlike
-   // unescape_u it
-   // (a) assumes exactly 4 hexdigits per escape sequence,
-   // (b) accepts multiple consecutive escaped 16-bit values.
-   // When applied to more than one escape sequence, unescape_j
-   // translates UTF-16 surrogate pairs in the input into a single
-   // UTF-8 sequence in s, as required for JSON by RFC 8259.
-
-   struct unescape_j
-   {
-      template< typename Input >
-      static void apply( const Input& 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 ) {
-            const auto c = unhex_string< unsigned >( b, b + 4 );
-            if( ( 0xd800 <= c ) && ( c <= 0xdbff ) && ( b + 6 < in.end() ) ) {
-               const auto d = unhex_string< unsigned >( b + 6, b + 10 );
-               if( ( 0xdc00 <= d ) && ( d <= 0xdfff ) ) {
-                  b += 6;
-                  (void)utf8_append_utf32( s, ( ( ( c & 0x03ff ) << 10 ) | ( d & 0x03ff ) ) + 0x10000 );
-                  continue;
-               }
-            }
-            if( !utf8_append_utf32( s, c ) ) {
-               throw parse_error( "invalid escaped unicode code point", in );
-            }
-         }
-      }
-   };
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE::unescape
-
-#endif

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

@@ -1,106 +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_CONTRIB_URI_HPP
-#define TAO_JSON_PEGTL_CONTRIB_URI_HPP
-
-#include <cstdint>
-
-#include "../ascii.hpp"
-#include "../config.hpp"
-#include "../rules.hpp"
-#include "../utf8.hpp"
-
-#include "abnf.hpp"
-#include "integer.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE::uri
-{
-   // URI grammar according to RFC 3986.
-
-   // This grammar is a direct PEG translation of the original URI grammar.
-   // It should be considered experimental -- in case of any issues, in particular
-   // missing rules for attached actions, please contact the developers.
-
-   // Note that this grammar has multiple top-level rules.
-
-   using dot = one< '.' >;
-   using colon = one< ':' >;
-
-   // clang-format off
-   struct dec_octet : integer::maximum_rule< std::uint8_t > {};
-
-   struct IPv4address : seq< dec_octet, dot, dec_octet, dot, dec_octet, dot, dec_octet > {};
-
-   struct h16 : rep_min_max< 1, 4, abnf::HEXDIG > {};
-   struct ls32 : sor< seq< h16, colon, h16 >, IPv4address > {};
-
-   struct dcolon : two< ':' > {};
-
-   struct IPv6address : sor< seq<                                               rep< 6, h16, colon >, ls32 >,
-                             seq<                                       dcolon, rep< 5, h16, colon >, ls32 >,
-                             seq< opt< h16                           >, dcolon, rep< 4, h16, colon >, ls32 >,
-                             seq< opt< h16,     opt<    colon, h16 > >, dcolon, rep< 3, h16, colon >, ls32 >,
-                             seq< opt< h16, rep_opt< 2, colon, h16 > >, dcolon, rep< 2, h16, colon >, ls32 >,
-                             seq< opt< h16, rep_opt< 3, colon, h16 > >, dcolon,         h16, colon,   ls32 >,
-                             seq< opt< h16, rep_opt< 4, colon, h16 > >, dcolon,                       ls32 >,
-                             seq< opt< h16, rep_opt< 5, colon, h16 > >, dcolon,                       h16  >,
-                             seq< opt< h16, rep_opt< 6, colon, h16 > >, dcolon                             > > {};
-
-   struct gen_delims : one< ':', '/', '?', '#', '[', ']', '@' > {};
-   struct sub_delims : one< '!', '$', '&', '\'', '(', ')', '*', '+', ',', ';', '=' > {};
-
-   struct unreserved : sor< abnf::ALPHA, abnf::DIGIT, one< '-', '.', '_', '~' > > {};
-   struct reserved : sor< gen_delims, sub_delims > {};
-
-   struct IPvFuture : if_must< one< 'v', 'V' >, plus< abnf::HEXDIG >, dot, plus< sor< unreserved, sub_delims, colon > > > {};
-
-   struct IP_literal : if_must< one< '[' >, sor< IPvFuture, IPv6address >, one< ']' > > {};
-
-   struct pct_encoded : if_must< one< '%' >, abnf::HEXDIG, abnf::HEXDIG > {};
-   struct pchar : sor< unreserved, pct_encoded, sub_delims, one< ':', '@' > > {};
-
-   struct query : star< sor< pchar, one< '/', '?' > > > {};
-   struct fragment : star< sor< pchar, one< '/', '?' > > > {};
-
-   struct segment : star< pchar > {};
-   struct segment_nz : plus< pchar > {};
-   struct segment_nz_nc : plus< sor< unreserved, pct_encoded, sub_delims, one< '@' > > > {}; // non-zero-length segment without any colon ":"
-
-   struct path_abempty : star< one< '/' >, segment > {};
-   struct path_absolute : seq< one< '/' >, opt< segment_nz, star< one< '/' >, segment > > > {};
-   struct path_noscheme : seq< segment_nz_nc, star< one< '/' >, segment > > {};
-   struct path_rootless : seq< segment_nz, star< one< '/' >, segment > > {};
-   struct path_empty : success {};
-
-   struct path : sor< path_noscheme,     // begins with a non-colon segment
-                      path_rootless,     // begins with a segment
-                      path_absolute,     // begins with "/" but not "//"
-                      path_abempty > {}; // begins with "/" or is empty
-
-   struct reg_name : star< sor< unreserved, pct_encoded, sub_delims > > {};
-
-   struct port : star< abnf::DIGIT > {};
-   struct host : sor< IP_literal, IPv4address, reg_name > {};
-   struct userinfo : star< sor< unreserved, pct_encoded, sub_delims, colon > > {};
-   struct opt_userinfo : opt< userinfo, one< '@' > > {};
-   struct authority : seq< opt_userinfo, host, opt< colon, port > > {};
-
-   struct scheme : seq< abnf::ALPHA, star< sor< abnf::ALPHA, abnf::DIGIT, one< '+', '-', '.' > > > > {};
-
-   using dslash = two< '/' >;
-   using opt_query = opt_must< one< '?' >, query >;
-   using opt_fragment = opt_must< one< '#' >, fragment >;
-
-   struct hier_part : sor< if_must< dslash, authority, path_abempty >, path_rootless, path_absolute, path_empty > {};
-   struct relative_part : sor< if_must< dslash, authority, path_abempty >, path_noscheme, path_absolute, path_empty > {};
-   struct relative_ref : seq< relative_part, opt_query, opt_fragment > {};
-
-   struct URI : seq< scheme, one< ':' >, hier_part, opt_query, opt_fragment > {};
-   struct URI_reference : sor< URI, relative_ref > {};
-   struct absolute_URI : seq< scheme, one< ':' >, hier_part, opt_query > {};
-   // clang-format on
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE::uri
-
-#endif

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

@@ -1,33 +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_CSTREAM_INPUT_HPP
-#define TAO_JSON_PEGTL_CSTREAM_INPUT_HPP
-
-#include <cstdio>
-
-#include "buffer_input.hpp"
-#include "config.hpp"
-#include "eol.hpp"
-
-#include "internal/cstream_reader.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE
-{
-   template< typename Eol = eol::lf_crlf, std::size_t Chunk = 64 >
-   struct cstream_input
-      : buffer_input< internal::cstream_reader, Eol, std::string, Chunk >
-   {
-      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<>;
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE
-
-#endif

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

@@ -1,35 +0,0 @@
-// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
-
-#ifndef TAO_JSON_PEGTL_DISABLE_ACTION_HPP
-#define TAO_JSON_PEGTL_DISABLE_ACTION_HPP
-
-#include "apply_mode.hpp"
-#include "config.hpp"
-#include "match.hpp"
-#include "nothing.hpp"
-#include "rewind_mode.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE
-{
-   struct disable_action
-      : maybe_nothing
-   {
-      template< typename Rule,
-                apply_mode A,
-                rewind_mode M,
-                template< typename... >
-                class Action,
-                template< typename... >
-                class Control,
-                typename Input,
-                typename... States >
-      [[nodiscard]] static bool match( Input& in, States&&... st )
-      {
-         return TAO_JSON_PEGTL_NAMESPACE::match< Rule, apply_mode::nothing, M, Action, Control >( in, st... );
-      }
-   };
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE
-
-#endif

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

@@ -1,37 +0,0 @@
-// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
-
-#ifndef TAO_JSON_PEGTL_DISCARD_INPUT_HPP
-#define TAO_JSON_PEGTL_DISCARD_INPUT_HPP
-
-#include "apply_mode.hpp"
-#include "config.hpp"
-#include "match.hpp"
-#include "nothing.hpp"
-#include "rewind_mode.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE
-{
-   struct discard_input
-      : maybe_nothing
-   {
-      template< typename Rule,
-                apply_mode A,
-                rewind_mode M,
-                template< typename... >
-                class Action,
-                template< typename... >
-                class Control,
-                typename Input,
-                typename... States >
-      [[nodiscard]] static bool match( Input& in, States&&... st )
-      {
-         const bool result = TAO_JSON_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
-         in.discard();
-         return result;
-      }
-   };
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE
-
-#endif

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

@@ -1,39 +0,0 @@
-// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
-
-#ifndef TAO_JSON_PEGTL_DISCARD_INPUT_ON_FAILURE_HPP
-#define TAO_JSON_PEGTL_DISCARD_INPUT_ON_FAILURE_HPP
-
-#include "apply_mode.hpp"
-#include "config.hpp"
-#include "match.hpp"
-#include "nothing.hpp"
-#include "rewind_mode.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE
-{
-   struct discard_input_on_failure
-      : maybe_nothing
-   {
-      template< typename Rule,
-                apply_mode A,
-                rewind_mode M,
-                template< typename... >
-                class Action,
-                template< typename... >
-                class Control,
-                typename Input,
-                typename... States >
-      [[nodiscard]] static bool match( Input& in, States&&... st )
-      {
-         const bool result = TAO_JSON_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
-         if( !result ) {
-            in.discard();
-         }
-         return result;
-      }
-   };
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE
-
-#endif

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

@@ -1,39 +0,0 @@
-// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
-
-#ifndef TAO_JSON_PEGTL_DISCARD_INPUT_ON_SUCCESS_HPP
-#define TAO_JSON_PEGTL_DISCARD_INPUT_ON_SUCCESS_HPP
-
-#include "apply_mode.hpp"
-#include "config.hpp"
-#include "match.hpp"
-#include "nothing.hpp"
-#include "rewind_mode.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE
-{
-   struct discard_input_on_success
-      : maybe_nothing
-   {
-      template< typename Rule,
-                apply_mode A,
-                rewind_mode M,
-                template< typename... >
-                class Action,
-                template< typename... >
-                class Control,
-                typename Input,
-                typename... States >
-      [[nodiscard]] static bool match( Input& in, States&&... st )
-      {
-         const bool result = TAO_JSON_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
-         if( result ) {
-            in.discard();
-         }
-         return result;
-      }
-   };
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE
-
-#endif

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

@@ -1,35 +0,0 @@
-// Copyright (c) 2019-2020 Dr. Colin Hirsch and Daniel Frey
-// Please see LICENSE for license or visit https://github.com/taocpp/PEGTL/
-
-#ifndef TAO_JSON_PEGTL_ENABLE_ACTION_HPP
-#define TAO_JSON_PEGTL_ENABLE_ACTION_HPP
-
-#include "apply_mode.hpp"
-#include "config.hpp"
-#include "match.hpp"
-#include "nothing.hpp"
-#include "rewind_mode.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE
-{
-   struct enable_action
-      : maybe_nothing
-   {
-      template< typename Rule,
-                apply_mode A,
-                rewind_mode M,
-                template< typename... >
-                class Action,
-                template< typename... >
-                class Control,
-                typename Input,
-                typename... States >
-      [[nodiscard]] static bool match( Input& in, States&&... st )
-      {
-         return TAO_JSON_PEGTL_NAMESPACE::match< Rule, apply_mode::action, M, Action, Control >( in, st... );
-      }
-   };
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE
-
-#endif

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

@@ -1,37 +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_EOL_HPP
-#define TAO_JSON_PEGTL_EOL_HPP
-
-#include "config.hpp"
-
-#include "internal/eol.hpp"
-
-#include "internal/cr_crlf_eol.hpp"
-#include "internal/cr_eol.hpp"
-#include "internal/crlf_eol.hpp"
-#include "internal/lf_crlf_eol.hpp"
-#include "internal/lf_eol.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE
-{
-   inline namespace ascii
-   {
-      // this is both a rule and a pseudo-namespace for eol::cr, ...
-      struct eol : internal::eol
-      {
-         // clang-format off
-         struct cr : internal::cr_eol {};
-         struct cr_crlf : internal::cr_crlf_eol {};
-         struct crlf : internal::crlf_eol {};
-         struct lf : internal::lf_eol {};
-         struct lf_crlf : internal::lf_crlf_eol {};
-         // clang-format on
-      };
-
-   }  // namespace ascii
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE
-
-#endif

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

@@ -1,18 +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_EOL_PAIR_HPP
-#define TAO_JSON_PEGTL_EOL_PAIR_HPP
-
-#include <cstddef>
-#include <utility>
-
-#include "config.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE
-{
-   using eol_pair = std::pair< bool, std::size_t >;
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE
-
-#endif

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

@@ -1,44 +0,0 @@
-// 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_FILE_INPUT_HPP
-#define TAO_JSON_PEGTL_FILE_INPUT_HPP
-
-#include "config.hpp"
-#include "eol.hpp"
-#include "tracking_mode.hpp"
-
-#if defined( __unix__ ) || ( defined( __APPLE__ ) && defined( __MACH__ ) )
-#include <unistd.h>  // Required for _POSIX_MAPPED_FILES
-#endif
-
-#if defined( _POSIX_MAPPED_FILES ) || defined( _WIN32 )
-#include "mmap_input.hpp"
-#else
-#include "read_input.hpp"
-#endif
-
-namespace TAO_JSON_PEGTL_NAMESPACE
-{
-#if defined( _POSIX_MAPPED_FILES ) || defined( _WIN32 )
-   template< tracking_mode P = tracking_mode::eager, typename Eol = eol::lf_crlf >
-   struct file_input
-      : mmap_input< P, Eol >
-   {
-      using mmap_input< P, Eol >::mmap_input;
-   };
-#else
-   template< tracking_mode P = tracking_mode::eager, typename Eol = eol::lf_crlf >
-   struct file_input
-      : read_input< P, Eol >
-   {
-      using read_input< P, Eol >::read_input;
-   };
-#endif
-
-   template< typename... Ts >
-   explicit file_input( Ts&&... )->file_input<>;
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE
-
-#endif

data/ext/third_party/json/include/tao/json/external/pegtl/internal/action.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_INTERNAL_ACTION_HPP
-#define TAO_JSON_PEGTL_INTERNAL_ACTION_HPP
-
-#include "../config.hpp"
-
-#include "duseltronik.hpp"
-#include "seq.hpp"
-#include "skip_control.hpp"
-
-#include "../apply_mode.hpp"
-#include "../rewind_mode.hpp"
-
-#include "../analysis/generic.hpp"
-
-namespace TAO_JSON_PEGTL_NAMESPACE::internal
-{
-   template< template< typename... > class Action, typename... Rules >
-   struct action
-   {
-      using analyze_t = analysis::generic< analysis::rule_type::seq, Rules... >;
-
-      template< apply_mode A,
-                rewind_mode M,
-                template< typename... >
-                class,
-                template< typename... >
-                class Control,
-                typename Input,
-                typename... States >
-      [[nodiscard]] static bool match( Input& in, States&&... st )
-      {
-         return duseltronik< seq< Rules... >, A, M, Action, Control >::match( in, st... );
-      }
-   };
-
-   template< template< typename... > class Action, typename... Rules >
-   inline constexpr bool skip_control< action< Action, Rules... > > = true;
-
-}  // namespace TAO_JSON_PEGTL_NAMESPACE::internal
-
-#endif